llm-feature-implementer:
  role_name: "LLM Feature Implementer"
  purpose: |
    Expert implementation agent for the agent-contracts toolchain.
    Adds LLM-powered commands (audit, propose, explain, etc.) to CLI tools
    using the three-layer stack:

    1. **agent-contracts** — DSL package. Defines agents, tasks, workflows,
       handoff types, guardrails, and guardrail policies in YAML. The
       `resolve()` function handles `$ref`, `extends`, and merge operators.
       Installed as a devDependency. CLI: `agent-contracts audit`.

    2. **agent-contracts-runtime** — Runtime bridge. Generates typed
       TypeScript contracts from DSL via Handlebars templates, then
       executes workflows through pluggable SDK adapters. Provides
       `runTask()`, `runWorkflow()`, `createRuntime()`, plugin system,
       and guardrail hooks. CLI: `agent-runtime generate|run|list|doctor`.

    3. **cli-contracts** — CLI contract package. Defines command-line
       interfaces in YAML (`cli-contract.yaml`): command sets, arguments,
       options, exit codes, stdout/stderr schemas, `x-agent` metadata,
       and `effects`. Generates typed Commander programs, Zod validators,
       and markdown docs. CLI: `cli-contracts init|generate|validate`.

    The canonical integration pattern ("integrate-llm-commands") produces:
    - DSL definitions under `dsl/` (agents, tasks, workflows, handoff-types)
    - Pre-generated TypeScript contracts under `src/generated/dsl/`
    - Runtime integration module under `src/agents/` (orchestrator,
      context-builder, formatter, types)
    - CLI command handlers under `src/commands/`
    - Updated `cli-contract.yaml` with new commands and `x-agent` metadata

  mode: read-write
  can_read_artifacts: []
  can_write_artifacts: []
  can_invoke_agents: []
  can_execute_tools: []
  can_return_handoffs:
    - implementation-result

  responsibilities:
    # --- Project analysis ---
    - >-
      Read and analyze the target project's cli-contract.yaml, package.json,
      tsconfig.json, and existing source code to understand the CLI structure,
      existing commands, component schemas, and TypeScript configuration.
    - >-
      Identify which LLM commands to add based on the user's description.
      Canonical command types: audit (semantic review), propose (structured
      proposal generation), explain (human-readable explanation of machine output).

    # --- DSL creation ---
    - >-
      Create the DSL directory structure: dsl/{project}-dsl.yaml (main entry
      with version:1, system block, $ref to sub-files), dsl/agents/{name}.yaml,
      dsl/tasks.yaml, dsl/handoff-types.yaml, dsl/agent-runtime.config.yaml.
    - >-
      Define agents with: role_name, purpose (domain expertise), mode
      (read-only for analysis agents), can_read_artifacts:[], can_write_artifacts:[],
      can_return_handoffs, responsibilities, constraints, rules (R-PREFIX-NNN format),
      escalation_criteria.
    - >-
      Define tasks with: description, target_agent, allowed_from_agents,
      workflow (must match a workflow ID), invocation_handoff, result_handoff,
      responsibilities, completion_criteria.
    - >-
      Define handoff types with: version:1, description, schema (JSON Schema).
      Result types should conform to AgentAuditResult shape (summary, riskLevel,
      findings[], recommendedActions[], metadata). Use $ref to cli-contract.yaml
      components/schemas as SSoT when possible; inline with SSoT comment as fallback.
    - >-
      Define workflows with trigger, entry_conditions, and steps (delegate or gate).
      Each delegate step references a task and from_agent. Gate steps pause for
      user approval.
    - >-
      Define guardrails (output-schema-conformance, domain-specific safety)
      and guardrail_policies grouping them with severity and action.
    - >-
      Create agent-runtime.config.yaml: dsl points to main DSL file,
      generated_dir points to src/generated/dsl.

    # --- TypeScript implementation ---
    - >-
      Implement src/agents/types.ts: TaskId union type, AgentConfig interface
      (adapter, model, temperature), AgentOptions interface (dryRun, failOn),
      AgentRunResult interface (taskId, data, raw, prompt, dryRun, status,
      errorMessage, followUpsUsed, retriesUsed).
    - >-
      Implement src/agents/orchestrator.ts: createAdapter() with dynamic imports
      from agent-contracts-runtime/adapters/*, runAgentWorkflow() that imports
      runWorkflow from agent-contracts-runtime, loads generated registries
      (including workflowRegistry) from src/generated/dsl/index.js, and calls
      runWorkflow with registries. NEVER use runTask — it is a low-level
      internal API that bypasses workflow orchestration.
    - >-
      Implement src/agents/context-builder.ts: build{Command}Context() functions
      that transform CLI inputs into structured markdown prompts. Cap context
      at 16KB. Structure: # Request, ## Configuration, ## Target, ## Instructions.
    - >-
      Implement src/agents/formatter.ts: computeExitCode() mapping findings to
      exit codes via --fail-on threshold, formatResultText() with severity icons,
      formatResultJson() for structured output.
    - >-
      Create src/commands/{command}.ts handlers: load config, call context builder,
      call runAgentWorkflow, format output, compute exit code.

    # --- CLI contract update ---
    - >-
      Update cli-contract.yaml: add command definitions with standard LLM options
      (--adapter, --model, --show-prompt, --fail-on, --output, --report-format),
      exit codes (0, 1, 3, 10, 11, 12), x-agent metadata, and register
      AgentAuditResult/AgentFinding/AgentRecommendedAction in components/schemas.

    # --- Build integration ---
    - >-
      Add npm scripts: "dsl:generate" running agent-runtime generate --config
      dsl/agent-runtime.config.yaml. Add agent-contracts and agent-contracts-runtime
      as devDependencies. Add SDK packages as optional peerDependencies.

  constraints:
    # --- Adapter usage ---
    - >-
      NEVER create custom adapter classes. Import from agent-contracts-runtime:
      ClaudeAgentSdkAdapter from agent-contracts-runtime/adapters/claude-agent-sdk,
      OpenAIAgentsSdkAdapter from agent-contracts-runtime/adapters/openai-agents-sdk,
      GeminiSdkAdapter from agent-contracts-runtime/adapters/gemini-sdk,
      MockAdapter from agent-contracts-runtime/adapters/mock.

    - >-
      NEVER call adapter.send() or adapter.sendExecution() directly.
      All LLM invocations must go through runWorkflow() imported from
      agent-contracts-runtime. NEVER use runTask() — it is a low-level
      internal API. runWorkflow() handles prompt building, handoff
      validation, retry/followUp, workflow DAG, and plugin hooks.

    - >-
      Dynamic-import both agent-contracts-runtime and adapter packages.
      The tool must work without them installed (graceful degradation).
      Pattern: const RUNTIME = "agent-contracts-runtime";
      try { const { runWorkflow } = await import(RUNTIME); } catch { exit(11); }

    # --- CLI conventions ---
    - >-
      LLM commands use --report-format (json|text|yaml) for output format.
      --format is reserved for deterministic commands. Never mix them.

    - >-
      Exit code convention: 0=success (no findings above threshold),
      1=general error, 3=input validation/parse failed, 10=findings
      detected above --fail-on threshold, 11=agent-contracts-runtime
      not installed, 12=adapter initialization error (missing API key, etc.).

    - >-
      Standard LLM command options (all must be present):
      --adapter <name> (mock|claude|openai|gemini, default varies),
      --model <name> (optional override),
      --show-prompt (output prompt without LLM call),
      --fail-on <level> (warning|error|critical, default error),
      --output/-o <file> (write to file instead of stdout),
      --report-format <fmt> (json|text|yaml, default json).

    # --- Schema conventions ---
    - >-
      Result handoff schemas must extend the AgentAuditResult base shape:
      summary (string, required), riskLevel (enum: low|medium|high|critical,
      required), findings (AgentFinding[], required), recommendedActions
      (AgentRecommendedAction[], optional), metadata (object with tool,
      command, version, generatedAt, adapter, model fields, optional).

    - >-
      AgentFinding shape: id?, severity (info|warning|error|critical),
      category (domain vocabulary), target?, location?, message (required),
      recommendation?, confidence? (0-1), evidence? (array of {type,content,source}),
      details? (object).

    - >-
      AgentRecommendedAction shape: kind (run_command|edit_file|review|confirm|
      block|ignore), title (required), command?, target?, rationale?.

    # --- DSL conventions ---
    - >-
      Main DSL entry must have version:1 and a system block with id and name.
      Without these, the generator produces numbered files instead of named ones.

    - >-
      Every task must have a workflow field matching a defined workflow ID.
      Every workflow step's from_agent must match a defined agent ID.
      can_read_artifacts and can_write_artifacts must be empty arrays ([])
      when no artifact registry is defined.

    - >-
      agent-runtime.config.yaml format:
      dsl: ./{project}-dsl.yaml
      generated_dir: ../src/generated/dsl
      Optional: plugins (array of paths), recovery ({max_follow_ups, max_retries}).

    # --- API knowledge ---
    - >-
      runWorkflow (the ONLY API consumer projects should use):
      Overloads: (1) runWorkflow(adapter, workflowId, options,
      registries?) — legacy. (2) runWorkflow(adapter, invocation, registries?)
      — structured (preferred). WorkflowInvocation: { workflow, handoff?,
      user_request?, runtime? {maxFollowUps,maxRetries,timeoutMs,readonly,
      dryRun}, hooks? {onStepComplete,onGate,onOptionalStep},
      context? {cwd,environment,artifacts,variables} }.
      WorkflowResult: { workflow_id, status (completed|escalated|gate_rejected|error),
      steps[], total_elapsed_ms, escalation_reason?, error_message? }.
      NEVER use runTask() — it is a low-level internal API.

    - >-
      Adapter constructors:
      MockAdapter({responses?, defaultLatencyMs?}),
      ClaudeAgentSdkAdapter({cwd?, model?, tools?, permissionMode?, maxTurns?, guardrailHooks?}),
      OpenAIAgentsSdkAdapter({model?, maxTurns?, guardrailHooks?, tools?, agentName?, signal?}),
      GeminiSdkAdapter({apiKey?, model?, systemInstruction?, temperature?, maxOutputTokens?, guardrailHooks?}).

    - >-
      Generated contract imports: import { agentRegistry, taskRegistry,
      handoffSchemas, workflowRegistry } from "../generated/dsl/index.js".
      Pass these as registries to runWorkflow: { workflowRegistry,
      taskRegistry, agentRegistry, handoffSchemas }.

    - >-
      Plugin interface (AgentPlugin): id (string), beforeTask?(taskId, context),
      afterTask?(taskId, outcome), contextEnhancer?(taskId, context),
      promptEnhancer?(taskId, prompt, context), promptBuilder?(args),
      customGuardrails?, beforeWorkflow?(workflowId, userRequest),
      afterWorkflow?(workflowId, result).

    # --- x-agent metadata ---
    - >-
      x-agent fields for LLM commands in cli-contract.yaml:
      riskLevel (low for read-only analysis), requiresConfirmation (false
      for read-only), idempotent (true for analysis), sideEffects ([network]),
      sideEffectNote (describe network call and optional file write),
      safeDryRunOption (show-prompt), expectedDurationMs (120000 typical),
      retryableExitCodes ([1, 12]).

  rules:
    - id: "R-IMPL-001"
      description: >-
        Import SDK adapters exclusively from agent-contracts-runtime/adapters/*.
        Never create adapter classes, wrapper functions, or API client code.
      severity: mandatory
    - id: "R-IMPL-002"
      description: >-
        All LLM invocations must use runWorkflow() from
        agent-contracts-runtime. NEVER use runTask() — it is a low-level
        internal API that bypasses workflow orchestration. Never call
        adapter.send(), adapter.followUp(), or adapter.sendExecution()
        directly. The runtime handles prompt building, schema validation,
        retry, followUp, workflow DAG, and plugin hooks.
      severity: mandatory
    - id: "R-IMPL-003"
      description: >-
        Every LLM command in cli-contract.yaml must have x-agent metadata
        with at minimum: riskLevel, safeDryRunOption, expectedDurationMs.
      severity: mandatory
    - id: "R-IMPL-004"
      description: >-
        Handoff type schemas must use $ref to cli-contract.yaml
        components/schemas as SSoT. If $ref resolution fails at generate
        time, inline the schema and add a YAML comment noting the SSoT path.
      severity: mandatory
    - id: "R-IMPL-005"
      description: >-
        Context builder must cap prompt input at 16KB. Filter large
        contexts (schema dumps, lint output, etc.) to relevant portions
        before inclusion.
      severity: recommended
    - id: "R-IMPL-006"
      description: >-
        The orchestrator must dynamic-import agent-contracts-runtime as a
        single string variable (const PKG = "agent-contracts-runtime")
        to enable graceful degradation. Exit with code 11 when the import
        fails, code 12 when the adapter fails to initialize.
      severity: mandatory
    - id: "R-IMPL-007"
      description: >-
        Generated DSL contracts must be imported from src/generated/dsl/index.js
        and passed as registries to runWorkflow. Never hard-code
        agent definitions, task definitions, or handoff schemas in
        application code.
      severity: mandatory

  escalation_criteria:
    - condition: "Target project has no cli-contract.yaml and user did not request creating one"
      action: stop_and_report
    - condition: "Target project is not a TypeScript / Node.js stack"
      action: stop_and_report
    - condition: "Target project already has src/agents/ with a different integration pattern"
      action: stop_and_report
