@kody-ade/kody-engine-lite 0.1.150 → 0.1.152

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aharon Yair Cohen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -16,30 +16,9 @@ Kody wraps Claude Code with a 7-stage autonomous pipeline — classify, plan, bu
 
 [Why Kody? →](docs/ABOUT.md) · [Full comparison →](docs/COMPARISON.md)
 
-```
-@kody on issue
-    │
-    ▼
-① TASKIFY ─── classify, scope, detect complexity, ask questions
-    │
-    ▼
-② PLAN ────── TDD implementation plan (deep reasoning)
-    │          🛑 HIGH risk? Pause for human approval
-    ▼
-③ BUILD ───── implement via Claude Code tools
-    │
-    ▼
-④ VERIFY ──── run your quality commands (typecheck, tests, lint)
-    │          ✗ fail → AI diagnosis → autofix → retry
-    ▼
-⑤ REVIEW ──── AI code review (fresh session, no build bias)
-    │
-    ▼
-⑥ REVIEW-FIX ─ fix Critical and Major findings
-    │
-    ▼
-⑦ SHIP ────── push branch, create PR with Closes #N
-```
+<p align="center">
+  <img src="assets/pipeline.svg" alt="Kody 7-stage pipeline: Taskify → Plan → Build → Verify → Review → Review-Fix → Ship" width="600">
+</p>
 
 ## Quick Start
 
@@ -89,10 +68,36 @@ Comment on any GitHub issue:
 @kody
 ```
 
-Kody picks up the issue and works through the pipeline autonomously. You'll see:
-- Labels updating in real-time: `kody:planning` → `kody:building` → `kody:review` → `kody:done`
-- Progress comments on the issue at each stage
-- A PR with a rich description, passing quality checks, and `Closes #N`
+Kody picks up the issue and works through the pipeline autonomously:
+
+<div align="center">
+  <picture>
+    <img src="assets/screenshots/kody-trigger.png" alt="GitHub issue showing @kody trigger, pipeline started comment, and complexity detection" width="680">
+  </picture>
+  <br><sub>▲ Comment <code>@kody</code> on an issue — pipeline starts automatically</sub>
+</div>
+
+<br>
+
+You'll see labels updating in real-time, progress comments at each stage, and a pipeline summary when done:
+
+<div align="center">
+  <picture>
+    <img src="assets/screenshots/kody-summary.png" alt="Pipeline summary table showing all stages completed with duration and retries" width="680">
+  </picture>
+  <br><sub>▲ Pipeline summary — all stages completed with duration and retries</sub>
+</div>
+
+<br>
+
+The result is a PR with a rich description, passing quality checks, and `Closes #N`:
+
+<div align="center">
+  <picture>
+    <img src="assets/screenshots/kody-pr.png" alt="Pull request created by Kody with description, scope, verify status, and Closes link" width="680">
+  </picture>
+  <br><sub>▲ PR created by Kody — description, scope, verify status, Closes #N</sub>
+</div>
 
 If the task is HIGH-risk, Kody pauses after planning and asks for approval before writing code.
 
@@ -110,11 +115,45 @@ ANTHROPIC_COMPATIBLE_API_KEY=your-key-here
 
 Kody auto-starts the LiteLLM proxy. [Full LiteLLM guide →](docs/LITELLM.md)
 
+## Which command should I use?
+
+```mermaid
+flowchart TD
+    Start(("What do you\nneed to do?")):::start
+
+    Start --> NewIssue{"New issue\n→ PR?"}
+    Start --> ExistingPR{"Existing\nPR?"}
+    Start --> Setup{"Setup /\nOnboarding?"}
+
+    NewIssue -->|"Simple/medium"| Kody["**@kody**\nFull pipeline: taskify → plan →\nbuild → verify → review → ship"]:::cmd
+    NewIssue -->|"Complex multi-area"| Decompose["**@kody decompose**\nParallel sub-tasks: analyze →\nsplit → parallel build → merge → ship"]:::cmd
+
+    ExistingPR --> PRWhat{"What's wrong?"}
+
+    PRWhat -->|"Need a code review"| Review["**@kody review**\nStandalone PR review with\nstructured findings + verdict"]:::cmd
+    PRWhat -->|"Human gave feedback"| Fix["**@kody fix**\nRe-run from build with\nPR feedback as context"]:::cmd
+    PRWhat -->|"CI is failing"| FixCI["**@kody fix-ci**\nFetch CI logs, diagnose,\nand push a fix"]:::cmd
+    PRWhat -->|"Merge conflicts"| Resolve["**@kody resolve**\nMerge default branch,\nAI-resolve conflicts, verify"]:::cmd
+    PRWhat -->|"Previous run failed\nor was paused"| Rerun["**@kody rerun**\nResume from failed/paused stage\n*--from stage* to pick stage"]:::cmd
+
+    Setup -->|"First time"| Init["**kody-engine-lite init**\nGenerate workflow + config"]:::setup
+    Init --> Bootstrap
+    Setup -->|"After major refactor"| Bootstrap["**@kody bootstrap**\nRegenerate memory +\nstep files + labels"]:::setup
+
+    Kody -.->|"Paused with\nquestions or\nrisk gate?"| Approve["**@kody approve**\nResume after pause"]:::cmd
+
+    classDef start fill:#1a1a2e,stroke:#e94560,color:#fff,stroke-width:2px
+    classDef cmd fill:#0f3460,stroke:#53d8fb,color:#fff,stroke-width:1px
+    classDef setup fill:#1a1a2e,stroke:#e9b44c,color:#fff,stroke-width:1px
+```
+
 ## Commands
 
 | Command | What it does |
 |---------|-------------|
 | `@kody` | Run full pipeline on an issue |
+| `@kody decompose` | Parallel sub-tasks for complex issues — analyze, split, build in parallel, merge, verify, review, ship ([details](docs/DECOMPOSE.md)) |
+| `@kody compose` | Retry merge + verify + review + ship after a decompose build succeeded |
 | `@kody review` | Review any PR — structured findings + GitHub approve/request-changes (falls back to comment if self-review blocked) |
 | `@kody fix` | Re-run from build with human PR feedback + Kody's review as context |
 | `@kody fix-ci` | Fix failing CI checks (auto-triggered with loop guard) |
@@ -133,6 +172,8 @@ kody-engine-lite review --pr-number 42   # Standalone PR review
 kody-engine-lite fix --issue-number 42 --feedback "Use middleware pattern"
 kody-engine-lite fix-ci --pr-number 42
 kody-engine-lite resolve --pr-number 42   # Merge + resolve conflicts
+kody-engine-lite decompose --issue-number 42  # Parallel sub-tasks for complex issues
+kody-engine-lite compose --task-id <id>  # Retry compose after decompose
 kody-engine-lite rerun --issue-number 42 --from verify
 kody-engine-lite watch [--dry-run]       # Run health monitoring locally
 ```
@@ -148,6 +189,7 @@ kody-engine-lite watch [--dry-run]       # Run health monitoring locally
 - **AI Failure Diagnosis** — classifies errors as fixable/infrastructure/pre-existing/abort before retry ([details](docs/FEATURES.md#ai-powered-failure-diagnosis))
 - **Question Gates** — asks product/architecture questions when the task is unclear ([details](docs/FEATURES.md#question-gates))
 - **Auto Fix-CI** — CI fails on a PR? Kody fetches logs, diagnoses, and pushes a fix ([details](docs/FEATURES.md#auto-fix-ci))
+- **Parallel Decomposition** — complex tasks auto-split into independent sub-tasks that build in parallel, then merge and verify ([details](docs/DECOMPOSE.md))
 - **Pattern Discovery** — searches for existing patterns before proposing new ones ([details](docs/FEATURES.md#pattern-discovery))
 - **Decision Memory** — architectural decisions extracted from reviews persist across tasks ([details](docs/FEATURES.md#decision-memory))
 - **Auto-Learning** — extracts coding conventions from each successful run ([details](docs/FEATURES.md#auto-learning-memory))
@@ -155,14 +197,126 @@ kody-engine-lite watch [--dry-run]       # Run health monitoring locally
 - **Kody Watch** — periodic health monitoring: pipeline health, security scanning, config validation every 30 min ([setup guide](docs/WATCH.md))
 - **Anthropic-Compatible Models** — route through LiteLLM to use other providers like MiniMax, Gemini, etc. ([setup guide](docs/LITELLM.md) · [model test results](docs/model-compatibility.md))
 
+## Architecture
+
+<details>
+<summary>System overview (click to expand)</summary>
+
+```mermaid
+flowchart TB
+    subgraph trigger ["Trigger"]
+        direction LR
+        Comment["@kody comment\non GitHub issue"]
+        Dispatch["workflow_dispatch\n(manual)"]
+        CLI["kody-engine-lite run\n(local CLI)"]
+    end
+
+    subgraph ci ["GitHub Actions"]
+        direction LR
+        Parse["**parse**\nValidate author\nExtract mode + task ID"]
+        Orchestrate["**orchestrate**\nCheckout, install deps,\nstart LiteLLM proxy"]
+        Parse --> Orchestrate
+    end
+
+    Entry["**entry.ts**\nPreflight checks → fetch issue →\ncreate runners → build context"]
+
+    subgraph pipeline ["Pipeline  (pipeline.ts)"]
+        direction TB
+
+        subgraph explore ["Session: explore"]
+            direction LR
+            Taskify["**1 Taskify**\nClassify, scope,\ndetect complexity\n*→ task.json*"]
+            Plan["**2 Plan**\nTDD plan with\ndeep reasoning\n*→ plan.md*"]
+            Taskify --> Plan
+        end
+
+        subgraph build_session ["Session: build"]
+            direction LR
+            Build["**3 Build**\nImplement via\nClaude Code tools"]
+            Autofix["**Autofix**\nAI-diagnosed\nerror fixes"]
+            ReviewFix["**6 Review-Fix**\nFix Critical +\nMajor findings"]
+        end
+
+        subgraph verify_loop ["Quality Gate"]
+            Verify["**4 Verify**\ntypecheck + tests + lint"]
+            Diagnose{"Fail?"}
+            Verify --> Diagnose
+            Diagnose -->|"fixable"| Autofix
+            Autofix --> Verify
+            Diagnose -->|"infra/pre-existing"| Skip["Skip\n(mark passed)"]
+            Diagnose -->|"abort"| Abort["Stop pipeline"]
+        end
+
+        subgraph review_session ["Session: review  (fresh — no build bias)"]
+            Review["**5 Review**\nPASS/FAIL verdict\n+ findings\n*→ review.md*"]
+        end
+
+        Ship["**7 Ship**\nPush branch → create PR\n→ comment on issue"]
+
+        explore --> build_session
+        Build --> verify_loop
+        Skip --> review_session
+        Diagnose -->|"pass"| review_session
+        review_session -->|"FAIL"| ReviewFix
+        ReviewFix -->|"retry review\n(max 2)"| review_session
+        review_session -->|"PASS"| Ship
+    end
+
+    subgraph support ["Support Systems"]
+        direction LR
+        Memory["**.kody/memory/**\narchitecture.md\nconventions.md\nobserver-log.jsonl"]
+        Steps["**.kody/steps/**\nRepo-customized\nprompts per stage"]
+        State["**status.json**\nStage states +\nsession IDs"]
+    end
+
+    subgraph outputs ["Outputs"]
+        direction LR
+        PR["Pull Request\nwith Closes #N"]
+        Labels["GitHub Labels\nkody:planning → kody:done"]
+        Artifacts["Task Artifacts\n.kody/tasks/id/"]
+        Learn["Auto-Learn\n+ Retrospective"]
+    end
+
+    QuestionGate{"Questions?\nPause for\nhuman input"}
+    RiskGate{"HIGH risk?\nPause for\napproval"}
+
+    Comment --> ci
+    Dispatch --> Orchestrate
+    CLI --> Entry
+    Orchestrate --> Entry
+    Entry --> pipeline
+
+    Taskify -.-> QuestionGate
+    Plan -.-> RiskGate
+    QuestionGate -.->|"@kody approve"| Plan
+    RiskGate -.->|"@kody approve"| Build
+
+    pipeline <-..-> support
+    Ship --> outputs
+```
+
+</details>
+
+[Full architecture docs →](docs/ARCHITECTURE.md)
+
 ## Documentation
 
 **Understand Kody:** [About](docs/ABOUT.md) · [Architecture](docs/ARCHITECTURE.md) · [Tech Stack](docs/TECH-STACK.md) · [Features](docs/FEATURES.md) · [Pipeline](docs/PIPELINE.md) · [Comparison](docs/COMPARISON.md)
 
-**Set up & use:** [CLI](docs/CLI.md) · [Configuration](docs/CONFIGURATION.md) · [Bootstrap](docs/BOOTSTRAP.md) · [Tools](docs/TOOLS.md) · [Watch](docs/WATCH.md) · [LiteLLM](docs/LITELLM.md)
+**Set up & use:** [CLI](docs/CLI.md) · [Configuration](docs/CONFIGURATION.md) · [Bootstrap](docs/BOOTSTRAP.md) · [Decompose](docs/DECOMPOSE.md) · [Tools](docs/TOOLS.md) · [Watch](docs/WATCH.md) · [LiteLLM](docs/LITELLM.md)
 
 **Reference:** [FAQ](docs/FAQ.md) · [Model Compatibility](docs/model-compatibility.md)
 
+## Generating Demo GIFs
+
+Demo GIFs can be generated using [VHS](https://github.com/charmbracelet/vhs). Tape files are in `assets/tapes/`:
+
+```bash
+brew install vhs            # install VHS
+vhs assets/tapes/init.tape  # → assets/demo-init.gif
+vhs assets/tapes/run-local.tape  # → assets/demo-run.gif (runs a real pipeline)
+```
+
 ## License
 
 MIT

package/dist/bin/cli.js

@@ -5622,6 +5622,7 @@ async function executeAgentStage(ctx, def) {
     return { outcome: "completed", retries: 0 };
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
+  const promptTokens = estimateTokens(prompt);
   let currentModelTier = def.modelTier;
   if (ctx.input.feedback && def.name === "build") {
     logger.info(`  feedback: ${ctx.input.feedback.slice(0, 200)}${ctx.input.feedback.length > 200 ? "..." : ""}`);
@@ -5653,14 +5654,8 @@ async function executeAgentStage(ctx, def) {
   if (ds && devServerStages.includes(def.name) && taskHasUI(ctx.taskDir)) {
     logger.info(`  Starting dev server: ${ds.command}`);
     const envVars = {};
-    if (ds.env && ds.env.length > 0) {
-      for (const varName of ds.env) {
-        if (process.env[varName]) envVars[varName] = process.env[varName];
-      }
-    } else {
-      for (const [k, v] of Object.entries(process.env)) {
-        if (v !== void 0) envVars[k] = v;
-      }
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== void 0) envVars[k] = v;
     }
     devServerHandle = await startDevServer({
       command: ds.command,
@@ -5710,7 +5705,7 @@ async function executeAgentStage(ctx, def) {
     logger.info(`  Dev server stopped`);
   }
   if (lastResult.outcome !== "completed") {
-    return { outcome: lastResult.outcome, error: lastResult.error, retries };
+    return { outcome: lastResult.outcome, error: lastResult.error, retries, promptTokens };
   }
   const result2 = lastResult;
   if (def.outputFile && result2.output) {
@@ -5772,7 +5767,7 @@ async function executeAgentStage(ctx, def) {
     }
   }
   appendStageContext(ctx.taskDir, def.name, result2.output);
-  return { outcome: "completed", outputFile: def.outputFile, retries };
+  return { outcome: "completed", outputFile: def.outputFile, retries, promptTokens };
 }
 function appendStageContext(taskDir, stageName, output) {
   const contextPath = path23.join(taskDir, "context.md");
@@ -5795,6 +5790,7 @@ var init_agent = __esm({
   "src/stages/agent.ts"() {
     "use strict";
     init_context();
+    init_context_tiers();
     init_validators();
     init_config();
     init_mcp_config();
@@ -6968,8 +6964,9 @@ function collectRunContext(ctx, state, pipelineStartTime) {
     const s = state.stages[def.name];
     const duration = computeStageDuration(s);
     const durationStr = duration != null ? `, ${duration}ms` : "";
+    const tokenStr = s.promptTokens != null ? `, ~${s.promptTokens} prompt tokens` : "";
     const errorStr = s.error ? ` \u2014 ${s.error}` : "";
-    lines.push(`${def.name}: ${s.state} (${s.retries} retries${durationStr})${errorStr}`);
+    lines.push(`${def.name}: ${s.state} (${s.retries} retries${durationStr}${tokenStr})${errorStr}`);
     if (s.state === "failed" || s.state === "timeout") {
       failedStage = def.name;
     }
@@ -7034,6 +7031,23 @@ function appendRetrospectiveEntry(projectDir, entry) {
   }
   fs34.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
+function computeTokenStats(state, projectDir) {
+  const perStage = {};
+  let totalPromptTokens = 0;
+  let hasAny = false;
+  for (const def of STAGES) {
+    const s = state.stages[def.name];
+    if (s.promptTokens != null) {
+      perStage[def.name] = s.promptTokens;
+      totalPromptTokens += s.promptTokens;
+      hasAny = true;
+    }
+  }
+  if (!hasAny) return void 0;
+  const memory = readProjectMemory(projectDir);
+  const memoryTokens = memory ? estimateTokens(memory) : 0;
+  return { totalPromptTokens, memoryTokens, perStage };
+}
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
   try {
@@ -7094,6 +7108,7 @@ ${previousText}
         failedStage = def.name;
       }
     }
+    const tokenStats = computeTokenStats(state, ctx.projectDir);
     const entry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       taskId: state.taskId,
@@ -7104,7 +7119,8 @@ ${previousText}
       observation,
       patternMatch,
       suggestion,
-      pipelineFlaw
+      pipelineFlaw,
+      tokenStats
     };
     appendRetrospectiveEntry(ctx.projectDir, entry);
     logger.info(`Retrospective: ${observation.slice(0, 120)}`);
@@ -7120,6 +7136,8 @@ var init_retrospective = __esm({
     init_context();
     init_config();
     init_runner_selection();
+    init_memory();
+    init_context_tiers();
     init_logger();
     RETROSPECTIVE_PROMPT = `You are a pipeline retrospective analyst. You observe automated software development pipeline runs and identify flaws, patterns, and improvement opportunities.
 
@@ -7449,7 +7467,8 @@ async function runPipelineInner(ctx) {
         state: "completed",
         completedAt: (/* @__PURE__ */ new Date()).toISOString(),
         retries: result2.retries,
-        outputFile: result2.outputFile
+        outputFile: result2.outputFile,
+        promptTokens: result2.promptTokens
       };
       logger.info(`[${def.name}] \u2713 completed`);
       const detected = autoDetectComplexity(ctx, def);
@@ -7467,7 +7486,8 @@ async function runPipelineInner(ctx) {
       state.stages[def.name] = {
         state: isTimeout ? "timeout" : "failed",
         retries: result2.retries,
-        error: isTimeout ? "Stage timed out" : result2.error ?? "Stage failed"
+        error: isTimeout ? "Stage timed out" : result2.error ?? "Stage failed",
+        promptTokens: result2.promptTokens
       };
       state.state = "failed";
       state.sessions = ctx.sessions;

package/kody.config.schema.json

@@ -263,11 +263,6 @@
             "readyTimeout": {
               "type": "number",
               "description": "Seconds to wait for the server to be ready. Default: 180"
-            },
-            "env": {
-              "type": "array",
-              "items": { "type": "string" },
-              "description": "List of GitHub secret names to forward as environment variables for the dev server process (e.g., ['BLOB_READ_WRITE_TOKEN', 'DATABASE_URL']). These are injected into the workflow env block during 'kody init'."
             }
           },
           "required": ["command", "url"]
@@ -295,11 +290,6 @@
         "readyTimeout": {
           "type": "number",
           "description": "Seconds to wait for the server to be ready. Default: 180"
-        },
-        "env": {
-          "type": "array",
-          "items": { "type": "string" },
-          "description": "List of GitHub secret names to forward as environment variables for the dev server process (e.g., ['BLOB_READ_WRITE_TOKEN', 'DATABASE_URL']). These are injected into the workflow env block during 'kody init'."
         }
       },
       "required": ["command", "url"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.150",
+  "version": "0.1.152",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",

package/prompts/taskify.md

@@ -32,8 +32,8 @@ Required JSON format:
 
 Risk level heuristics:
 - low: single file change, no breaking changes, docs, config, isolated scripts, test additions, style changes
-- medium: multiple files, possible side effects, API changes, new dependencies, refactoring existing logic
-- high: core business logic, data migrations, security, authentication, payment processing, database schema changes
+- medium: 2-3 files, possible side effects, API changes, new dependencies, refactoring existing logic, adding a new utility/middleware with tests
+- high: 4+ files across multiple directories, core business logic, data migrations, security, authentication, payment processing, database schema changes, cross-cutting concerns, system redesigns
 
 existing_patterns rules:
 - List patterns found in the codebase that are relevant to this task

package/templates/kody-watch.yml

@@ -35,11 +35,23 @@ jobs:
       - name: Install Kody Engine
         run: npm install -g @kody-ade/kody-engine-lite
 
+      - name: Export project secrets
+        env:
+          ALL_SECRETS: ${{ toJSON(secrets) }}
+        run: |
+          echo "$ALL_SECRETS" | jq -r 'to_entries[] | select(.key | test("^(GITHUB_TOKEN)$") | not) | @json' | while IFS= read -r entry; do
+            KEY=$(echo "$entry" | jq -r '.key')
+            VALUE=$(echo "$entry" | jq -r '.value')
+            DELIM="KODY_EOF_${KEY}"
+            echo "${KEY}<<${DELIM}" >> $GITHUB_ENV
+            echo "${VALUE}" >> $GITHUB_ENV
+            echo "${DELIM}" >> $GITHUB_ENV
+          done
+
       - name: Run Kody Watch
         env:
           GH_TOKEN: ${{ github.token }}
           REPO: ${{ github.repository }}
           WATCH_DIGEST_ISSUE: ${{ vars.WATCH_DIGEST_ISSUE }}
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           DRY_RUN: ${{ inputs.dry_run || 'false' }}
         run: npx kody-engine-lite watch ${{ inputs.dry_run == 'true' && '--dry-run' || '' }}

package/dist/agent-runner.d.ts

@@ -1,4 +0,0 @@
-import type { AgentRunner } from "./types.js";
-import type { KodyConfig } from "./config.js";
-export declare function createClaudeCodeRunner(): AgentRunner;
-export declare function createRunners(config: KodyConfig): Record<string, AgentRunner>;

package/dist/agent-runner.js

@@ -1,122 +0,0 @@
-import { spawn, execFileSync } from "child_process";
-const SIGKILL_GRACE_MS = 5000;
-const STDERR_TAIL_CHARS = 500;
-function writeStdin(child, prompt) {
-    return new Promise((resolve, reject) => {
-        if (!child.stdin) {
-            resolve();
-            return;
-        }
-        child.stdin.write(prompt, (err) => {
-            if (err)
-                reject(err);
-            else {
-                child.stdin.end();
-                resolve();
-            }
-        });
-    });
-}
-function waitForProcess(child, timeout) {
-    return new Promise((resolve) => {
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-        const timer = setTimeout(() => {
-            child.kill("SIGTERM");
-            setTimeout(() => {
-                if (!child.killed)
-                    child.kill("SIGKILL");
-            }, SIGKILL_GRACE_MS);
-        }, timeout);
-        child.on("exit", (code) => {
-            clearTimeout(timer);
-            resolve({
-                code,
-                stdout: Buffer.concat(stdoutChunks).toString(),
-                stderr: Buffer.concat(stderrChunks).toString(),
-            });
-        });
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            resolve({ code: -1, stdout: "", stderr: err.message });
-        });
-    });
-}
-async function runSubprocess(command, args, prompt, timeout, options) {
-    const child = spawn(command, args, {
-        cwd: options?.cwd ?? process.cwd(),
-        env: {
-            ...process.env,
-            SKIP_BUILD: "1",
-            SKIP_HOOKS: "1",
-            ...options?.env,
-        },
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    try {
-        await writeStdin(child, prompt);
-    }
-    catch (err) {
-        return {
-            outcome: "failed",
-            error: `Failed to send prompt: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    const { code, stdout, stderr } = await waitForProcess(child, timeout);
-    if (code === 0) {
-        return { outcome: "completed", output: stdout };
-    }
-    return {
-        outcome: code === null ? "timed_out" : "failed",
-        error: `Exit code ${code}\n${stderr.slice(-STDERR_TAIL_CHARS)}`,
-    };
-}
-function checkCommand(command, args) {
-    try {
-        execFileSync(command, args, { timeout: 10_000, stdio: "pipe" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ─── Claude Code Runner ──────────────────────────────────────────────────────
-export function createClaudeCodeRunner() {
-    return {
-        async run(_stageName, prompt, model, timeout, _taskDir, options) {
-            return runSubprocess("claude", [
-                "--print",
-                "--model", model,
-                "--dangerously-skip-permissions",
-                "--allowedTools", "Bash,Edit,Read,Write,Glob,Grep",
-            ], prompt, timeout, options);
-        },
-        async healthCheck() {
-            return checkCommand("claude", ["--version"]);
-        },
-    };
-}
-// ─── Runner Factory ──────────────────────────────────────────────────────────
-const RUNNER_FACTORIES = {
-    "claude-code": createClaudeCodeRunner,
-};
-export function createRunners(config) {
-    // New multi-runner config
-    if (config.agent.runners && Object.keys(config.agent.runners).length > 0) {
-        const runners = {};
-        for (const [name, runnerConfig] of Object.entries(config.agent.runners)) {
-            const factory = RUNNER_FACTORIES[runnerConfig.type];
-            if (factory) {
-                runners[name] = factory();
-            }
-        }
-        return runners;
-    }
-    // Legacy single-runner fallback
-    const runnerType = config.agent.runner ?? "claude-code";
-    const factory = RUNNER_FACTORIES[runnerType];
-    const defaultName = config.agent.defaultRunner ?? "claude";
-    return { [defaultName]: factory ? factory() : createClaudeCodeRunner() };
-}

package/dist/ci/parse-inputs.d.ts

@@ -1,6 +0,0 @@
-/**
- * Parses @kody / /kody comment body into structured inputs.
- * Run by the parse job in GitHub Actions.
- * Reads from env, writes to $GITHUB_OUTPUT.
- */
-export {};