@kody-ade/kody-engine-lite 0.1.19 → 0.1.21

package/README.md

@@ -1,401 +1,270 @@
 # Kody Engine Lite
 
-Autonomous SDLC pipeline — runs a 7-stage pipeline (taskify → plan → build → verify → review → review-fix → ship) on your codebase using Claude Code as the execution engine.
+Autonomous SDLC pipeline. Comment `@kody` on a GitHub issue → Kody classifies, plans, builds, tests, reviews, fixes, and ships a PR. Zero human intervention required.
 
 ## How it works
 
 ```
-@kody full <task-id>  (comment on a GitHub issue)
-     ↓
-GitHub Actions workflow triggers
-     ↓
-Kody Engine Lite (npm package)
-     ↓
+@kody  (comment on a GitHub issue)
+  ↓
+GitHub Actions workflow
+  ↓
 7-stage pipeline:
-  1. taskify  — classify the task (haiku)
-  2. plan     — create implementation plan (sonnet)
-  3. build    — implement code changes (opus)
-  4. verify   — run typecheck + tests + lint
-  5. review   — code review (sonnet)
-  6. review-fix — fix review issues (opus)
-  7. ship     — push branch + create PR
-     ↓
-PR created on your repo
+  1. taskify  — classify task, detect complexity, ask questions if unclear
+  2. plan     — TDD implementation plan (opus — deep reasoning)
+  3. build    — implement code changes (sonnet — tool use via Claude Code)
+  4. verify   — typecheck + tests + lint (auto-fix on failure)
+  5. review   — code review with severity levels (opus)
+  6. review-fix — fix Critical/Major findings (sonnet)
+  7. ship     — push branch + create PR with Closes #N
+  ↓
+PR created with What/Scope/Changes description
 ```
 
 ## Quick Start
 
-### 1. Install
-
 ```bash
+# Install
 npm install -g @kody-ade/kody-engine-lite
-```
-
-### 2. Init (run in your project root)
 
-```bash
+# Init (in your project root) — auto-detects everything
 cd your-project
 kody-engine-lite init
-```
-
-This will:
-- Copy `.github/workflows/kody.yml` to your repo
-- Create `kody.config.json` (edit this)
-- Create `.kody/memory/architecture.md` (auto-detected)
-- Create `.kody/memory/conventions.md` (seed)
-- Add `.tasks/` to `.gitignore`
-- Run health checks (prerequisites, GitHub auth, secrets)
-
-### 3. Configure
-
-Edit `kody.config.json`:
-
-```json
-{
-  "quality": {
-    "typecheck": "pnpm tsc --noEmit",
-    "lint": "pnpm lint",
-    "lintFix": "pnpm lint:fix",
-    "format": "",
-    "formatFix": "",
-    "testUnit": "pnpm test"
-  },
-  "git": {
-    "defaultBranch": "main"
-  },
-  "github": {
-    "owner": "your-org",
-    "repo": "your-repo"
-  },
-  "paths": {
-    "taskDir": ".tasks"
-  },
-  "agent": {
-    "runner": "claude-code",
-    "modelMap": {
-      "cheap": "haiku",
-      "mid": "sonnet",
-      "strong": "opus"
-    }
-  }
-}
-```
-
-### 4. GitHub Setup
-
-#### Required Secret
-
-Add `ANTHROPIC_API_KEY` to your repo secrets:
-
-```bash
-gh secret set ANTHROPIC_API_KEY --repo owner/repo
-```
-
-#### Required Permissions
-
-Go to **Settings → Actions → General → Workflow permissions**:
 
-1. Select **"Read and write permissions"**
-2. Check **"Allow GitHub Actions to create and approve pull requests"**
-3. Save
-
-Without this, the ship stage cannot create PRs.
-
-### 5. Push and Use
-
-```bash
+# Push and use
 git add .github/workflows/kody.yml kody.config.json .kody/
 git commit -m "chore: add kody engine"
 git push
-```
-
-Then comment on any issue:
 
-```
+# Comment on any issue
 @kody
 ```
 
-## CLI Usage
-
-### Run locally
-
-```bash
-# Run against current directory
-kody-engine-lite run --task "Add a sum function to src/math.ts with tests"
-
-# Run against a different project
-kody-engine-lite run --task "Add feature X" --cwd /path/to/project
-
-# Run from a GitHub issue (fetches issue body as task)
-kody-engine-lite run --issue-number 1 --cwd /path/to/project
-
-# Dry run (no agent calls)
-kody-engine-lite run --task "Test" --dry-run
-
-# Resume from a failed/paused stage (auto-detects which stage)
-kody-engine-lite rerun --issue-number 1
+### What `init` does
 
-# Fix — rerun from build stage (skip taskify/plan)
-kody-engine-lite fix --issue-number 1
-
-# Fix with feedback
-kody-engine-lite fix --issue-number 1 --feedback "Use middleware pattern instead"
-
-# Check pipeline status
-kody-engine-lite status --task-id my-task
-```
+Spawns Claude Code to analyze your project and auto-generates:
+- `.github/workflows/kody.yml` — full CI/CD workflow
+- `kody.config.json` — quality commands auto-detected from `package.json`
+- `.kody/memory/architecture.md` — project-specific tech stack and structure
+- `.kody/memory/conventions.md` — coding patterns, references to existing docs
+- 14 GitHub labels — lifecycle, complexity, and type labels
+- Health checks — CLI tools, GitHub auth, secrets, config validation
 
-### Init a new project
+### GitHub Setup
 
+**Required secret:**
 ```bash
-cd your-project
-kody-engine-lite init          # setup workflow, config, memory
-kody-engine-lite init --force  # overwrite existing workflow
+gh secret set ANTHROPIC_API_KEY --repo owner/repo
 ```
 
-### GitHub Comment Triggers
-
-Comment on any issue:
-
-```
-@kody                                     # Run full pipeline (auto-generates task-id)
-@kody full <task-id>                      # Run with specific task-id
-@kody rerun                               # Resume latest task (auto-detects stage)
-@kody rerun --from <stage>                # Resume from specific stage
-@kody fix                                 # Re-build from build stage (skip taskify/plan)
-@kody fix --feedback "Use X instead of Y" # Fix with specific guidance
-@kody approve                             # Approve + provide answers to questions
-@kody status <task-id>                    # Check status
-```
+**Required permission:**
+Settings → Actions → General → "Allow GitHub Actions to create and approve pull requests"
 
-### Approve Flow (Question Gate)
+## Commands
 
-When Kody encounters unclear requirements or architecture decisions, it pauses and posts questions:
+### GitHub Comments
 
 ```
-Kody: 🤔 Kody has questions before proceeding:
-      1. Should the search be case-sensitive?
-      2. Which users should have access?
-
-      Reply with @kody approve and your answers in the comment body.
+@kody                         Run full pipeline (auto-generates task-id)
+@kody approve                 Answer questions and resume paused pipeline
+@kody fix                     Re-build from build stage (on issues or PRs)
+@kody fix                     Comment body = feedback for the fix
+  fix the auth middleware
+  to return 401 not 500
+@kody rerun                   Resume from failed/paused stage
+@kody rerun --from <stage>    Resume from specific stage
 ```
 
-You reply:
-
-```
-@kody approve
+### CLI
 
-1. Yes, case-sensitive
-2. Only admin users
+```bash
+kody-engine-lite run --task "Add feature X" --cwd /path/to/project
+kody-engine-lite run --issue-number 42 --cwd /path/to/project
+kody-engine-lite fix --issue-number 42 --feedback "Use middleware pattern"
+kody-engine-lite rerun --issue-number 42
+kody-engine-lite status --task-id <id>
+kody-engine-lite init [--force]
 ```
 
-Kody resumes automatically from where it paused, with your answers injected as context.
-
 ## Pipeline Stages
 
 | Stage | Model | What it does |
 |-------|-------|-------------|
-| taskify | haiku | Classifies task from issue body → `task.json` |
-| plan | opus | Deep reasoning: creates TDD implementation plan → `plan.md` |
-| build | sonnet | Implements code changes (Claude Code tools handle execution) |
-| verify | — | Runs typecheck + tests + lint (from `kody.config.json`) |
-| review | opus | Thorough code review → `review.md` (PASS/FAIL + findings) |
-| review-fix | sonnet | Applies known fixes from review findings |
-| ship | — | Pushes branch + creates PR + comments on issue |
+| taskify | haiku | Classify task → `task.json` (type, scope, risk, questions) |
+| plan | opus | Create TDD plan → `plan.md` (deep reasoning) |
+| build | sonnet | Implement code using Claude Code tools (Read/Write/Edit/Bash) |
+| verify | — | Run typecheck + tests + lint from `kody.config.json` |
+| review | opus | Code review → `review.md` (PASS/FAIL + Critical/Major/Minor) |
+| review-fix | sonnet | Fix Critical and Major findings |
+| ship | — | Push branch, create PR, comment on issue |
 
-### Branch Syncing
-
-On every run/rerun/fix, Kody automatically:
-1. Checks out (or creates) the feature branch
-2. Pulls latest from the default branch and merges into the feature branch
-3. If there's a merge conflict, skips the sync and warns
+## Key Features
 
-This ensures the feature branch is always up-to-date before building.
+### Question Gates
 
-### Automatic Loops
+Kody asks before building if something is unclear:
 
-- **Verify + autofix**: If verify fails, runs lint-fix + format-fix + autofix agent, retries up to 2 times
-- **Review + fix**: If review verdict is FAIL, runs review-fix agent then re-reviews
+- **Taskify** asks product/requirements questions ("Should search be case-sensitive?")
+- **Plan** asks architecture/technical questions ("Recommend middleware pattern — approve?")
+- Pipeline pauses with `kody:waiting` label
+- Resume with `@kody approve` + your answers in the comment body
 
-## Memory System
+### Complexity-Based Stage Skipping
 
-Kody maintains project memory in `.kody/memory/`:
+Auto-detected from taskify's risk assessment, or override with `--complexity`:
 
-- **`architecture.md`** — auto-detected on `init` (framework, language, testing, directory structure)
-- **`conventions.md`** — auto-learned after each successful pipeline run
+| Complexity | Runs | Skips |
+|-----------|------|-------|
+| low | taskify → build → verify → ship | plan, review, review-fix |
+| medium | taskify → plan → build → verify → review → ship | review-fix |
+| high | all 7 stages | nothing |
 
-Memory is prepended to every agent prompt, giving Claude Code project context.
+### Branch Syncing
 
-## Configuration Reference
+Every run merges latest from the default branch into the feature branch before building.
 
-### `kody.config.json`
+### Verify + Autofix Loop
 
-| Field | Description | Default |
-|-------|-------------|---------|
-| `quality.typecheck` | Typecheck command | `pnpm -s tsc --noEmit` |
-| `quality.lint` | Lint command | `pnpm -s lint` |
-| `quality.lintFix` | Lint fix command | `pnpm lint:fix` |
-| `quality.format` | Format check command | `""` |
-| `quality.formatFix` | Format fix command | `""` |
-| `quality.testUnit` | Test command | `pnpm -s test` |
-| `git.defaultBranch` | Default branch | `dev` |
-| `github.owner` | GitHub org/user | `""` |
-| `github.repo` | GitHub repo name | `""` |
-| `paths.taskDir` | Task artifacts directory | `.tasks` |
-| `agent.modelMap.cheap` | Model for taskify | `haiku` |
-| `agent.modelMap.mid` | Model for build/review-fix/autofix | `sonnet` |
-| `agent.modelMap.strong` | Model for plan/review (deep reasoning) | `opus` |
+If verify fails: runs lint-fix → format-fix → autofix agent → retries (up to 2 attempts).
 
-### Environment Variables
+### Review + Fix Loop
 
-| Variable | Required | Description |
-|----------|----------|-------------|
-| `ANTHROPIC_API_KEY` | Yes | Claude API key (set as repo secret) |
-| `GH_TOKEN` | Auto | GitHub token (provided by Actions) |
-| `GH_PAT` | No | Personal access token (preferred over GH_TOKEN) |
-| `LOG_LEVEL` | No | `debug`, `info`, `warn`, `error` (default: `info`) |
-| `LITELLM_BASE_URL` | No | LiteLLM proxy URL for model routing |
+If review verdict is FAIL: runs review-fix agent → re-reviews.
 
-## Multi-Runner Support
+### Rich PR Description
 
-Use different agent runners per stage. For example, use OpenCode (MiniMax) for reasoning and Claude Code for code execution:
+```markdown
+## What
+Add authentication middleware to 8 unprotected API routes
 
-```json
-{
-  "agent": {
-    "defaultRunner": "claude",
-    "runners": {
-      "claude": { "type": "claude-code" },
-      "opencode": { "type": "opencode" }
-    },
-    "stageRunners": {
-      "taskify": "opencode",
-      "plan": "opencode",
-      "build": "claude",
-      "review": "opencode",
-      "review-fix": "claude",
-      "autofix": "claude"
-    }
-  }
-}
-```
+## Scope
+- `src/middleware/auth.ts`
+- `src/app/api/cron/route.ts`
 
-Available runner types:
-- `claude-code` — Claude Code CLI (`claude --print`). Supports tool use (Read, Write, Edit, Bash).
-- `opencode` — OpenCode CLI (`opencode github run`). Supports MiniMax, OpenAI, Anthropic, Gemini.
+**Type:** bugfix | **Risk:** high
 
-If no `runners`/`stageRunners` config, defaults to Claude Code for all stages.
+## Changes
+Added auth middleware to all cron routes and copilotkit endpoint.
 
-## Complexity-Based Stage Skipping
+**Review:** ✅ PASS
+**Verify:** ✅ typecheck + tests + lint passed
 
-Skip stages based on task complexity to save time and cost:
+<details><summary>📋 Implementation plan</summary>
+...
+</details>
 
-```bash
-# Simple fix — skip plan and review
-kody-engine-lite run --task-id fix-typo --task "Fix typo in README" --complexity low
+Closes #42
+```
 
-# Standard feature — skip review-fix
-kody-engine-lite run --task-id add-feature --task "Add search" --complexity medium
+### Labels
 
-# Complex task — run all stages (default)
-kody-engine-lite run --task-id refactor --task "Refactor auth" --complexity high
-```
+`init` creates 14 labels:
+- **Lifecycle:** `kody:planning`, `kody:building`, `kody:review`, `kody:done`, `kody:failed`, `kody:waiting`
+- **Complexity:** `kody:low`, `kody:medium`, `kody:high`
+- **Type:** `kody:feature`, `kody:bugfix`, `kody:refactor`, `kody:docs`, `kody:chore`
 
-| Complexity | Stages | Skipped |
-|-----------|--------|---------|
-| low | taskify → build → verify → ship | plan, review, review-fix |
-| medium | taskify → plan → build → verify → review → ship | review-fix |
-| high | taskify → plan → build → verify → review → review-fix → ship | none |
+### Memory System
 
-If `--complexity` is not provided, it's auto-detected from the taskify stage's `risk_level` output. A complexity label (`kody:low`, `kody:medium`, `kody:high`) is set on the issue.
+`.kody/memory/` files are prepended to every agent prompt:
+- `architecture.md` — auto-generated by `init`
+- `conventions.md` — auto-learned after each successful run
 
-## LiteLLM (Optional)
+## Using Non-Anthropic Models (LiteLLM)
 
-For multi-provider model routing with fallback:
+Claude Code can use **any model** through a LiteLLM proxy. Tested with MiniMax (full tool use: Write, Read, Edit, Bash, Grep).
 
 ```bash
-pip install litellm[proxy]
-litellm --config litellm-config.yaml --port 4000
+# Start LiteLLM proxy
+docker run -d -p 4000:4000 \
+  -e MINIMAX_API_KEY=your-key \
+  -v config.yaml:/app/config.yaml \
+  ghcr.io/berriai/litellm:main-latest --config /app/config.yaml
 ```
 
-Then set in `kody.config.json`:
+```yaml
+# config.yaml
+model_list:
+  - model_name: minimax
+    litellm_params:
+      model: minimax/MiniMax-M2.7-highspeed
+      api_key: os.environ/MINIMAX_API_KEY
+```
 
 ```json
+// kody.config.json
 {
   "agent": {
     "litellmUrl": "http://localhost:4000",
-    "modelMap": { "cheap": "cheap", "mid": "mid", "strong": "strong" }
+    "modelMap": { "cheap": "minimax", "mid": "minimax", "strong": "minimax" }
   }
 }
 ```
 
-## Task Artifacts
+LiteLLM translates Anthropic's tool-use protocol to the target provider's format. No code changes needed.
 
-Each pipeline run creates artifacts in `.tasks/<task-id>/`:
+## Configuration
 
-| File | Created by | Content |
-|------|-----------|---------|
-| `task.md` | entry / issue fetch | Task description |
-| `task.json` | taskify stage | Structured classification |
-| `plan.md` | plan stage | Implementation steps |
-| `verify.md` | verify stage | Quality gate results |
-| `review.md` | review stage | Code review + verdict |
-| `ship.md` | ship stage | PR URL |
-| `status.json` | state machine | Pipeline state (per-stage) |
+### `kody.config.json`
 
-## Architecture
+| Field | Description | Default |
+|-------|-------------|---------|
+| `quality.typecheck` | Typecheck command | `pnpm -s tsc --noEmit` |
+| `quality.lint` | Lint command | `""` |
+| `quality.lintFix` | Auto-fix lint | `""` |
+| `quality.testUnit` | Unit test command | `pnpm -s test` |
+| `git.defaultBranch` | Default branch | `dev` |
+| `github.owner` | GitHub org/user | auto-detected |
+| `github.repo` | Repository name | auto-detected |
+| `agent.modelMap.cheap` | Taskify model | `haiku` |
+| `agent.modelMap.mid` | Build/fix model | `sonnet` |
+| `agent.modelMap.strong` | Plan/review model | `opus` |
+| `agent.litellmUrl` | LiteLLM proxy URL | — |
 
-```
-@kody-ade/kody-engine-lite (npm package)
-├── dist/bin/cli.js      — CLI entry point
-├── prompts/             — Stage prompt templates
-│   ├── taskify.md
-│   ├── plan.md
-│   ├── build.md
-│   ├── review.md
-│   ├── review-fix.md
-│   └── autofix.md
-└── templates/
-    └── kody.yml         — GitHub Actions workflow template
-```
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ANTHROPIC_API_KEY` | Yes | Claude API key (repo secret) |
+| `GH_TOKEN` | Auto | GitHub token (provided by Actions) |
+| `LOG_LEVEL` | No | `debug`, `info`, `warn`, `error` |
 
-Source files (in this repo):
+## Architecture
 
 ```
 src/
-├── entry.ts          — CLI argument parsing, pipeline dispatch
+├── entry.ts          — CLI: run/rerun/fix/status, arg parsing, CI mode
+├── state-machine.ts  — Pipeline loop, stage dispatch, question gates, complexity
+├── agent-runner.ts   — Claude Code subprocess wrapper (thin — spawn, pipe, timeout)
+├── context.ts        — Prompt assembly + memory + task context injection
+├── definitions.ts    — 7-stage pipeline config
 ├── types.ts          — TypeScript interfaces
-├── definitions.ts    — 7-stage pipeline configuration
-├── state-machine.ts  — Pipeline orchestration loop
-├── agent-runner.ts   — Claude Code subprocess wrapper
-├── context.ts        — Prompt assembly + task context injection
-├── memory.ts         — Project memory reader
-├── config.ts         — Config loading (kody.config.json)
-├── logger.ts         — Structured logging
-├── preflight.ts      — Startup checks
-├── validators.ts     — Output validation
+├── config.ts         — kody.config.json loader + constants
+├── git-utils.ts      — Branch, commit, push, sync, diff
+├── github-api.ts     — Issues, labels, PRs, comments via gh CLI
 ├── verify-runner.ts  — Quality gate execution
+├── validators.ts     — Output validation (task.json, plan.md, review.md)
+├── memory.ts         — .kody/memory/ reader
+├── logger.ts         — Structured logging with CI groups
+├── preflight.ts      — Startup health checks
 ├── kody-utils.ts     — Task directory utilities
-├── git-utils.ts      — Git operations
-├── github-api.ts     — GitHub API via gh CLI
-└── bin/cli.ts        — Package CLI (init, run, version)
+└── bin/cli.ts        — Package CLI: init (LLM-powered), run, version
 ```
 
 ## Development
 
 ```bash
-# Install deps
-pnpm install
+pnpm install          # Install deps
+pnpm typecheck        # Type check
+pnpm test             # 125 tests (16 files)
+pnpm build            # Build npm package
+pnpm kody run ...     # Dev mode (tsx)
+npm publish --access public  # Publish
+```
 
-# Type check
-pnpm typecheck
+## Security
 
-# Run locally (dev mode)
-pnpm kody run --task-id test --task "Add feature" --cwd /path/to/project
+Only GitHub collaborators (COLLABORATOR, MEMBER, OWNER) can trigger `@kody`. External contributors cannot.
 
-# Build package
-pnpm build
+## License
 
-# Publish
-npm publish --access public
-```
+MIT

package/dist/bin/cli.js

@@ -107,26 +107,6 @@ function createClaudeCodeRunner() {
     }
   };
 }
-function createOpenCodeRunner() {
-  return {
-    async run(stageName, prompt, model, timeout, _taskDir, options) {
-      const args2 = ["run", "--agent", "build"];
-      if (model) {
-        args2.push("--model", model);
-      }
-      return runSubprocess(
-        "opencode",
-        args2,
-        prompt,
-        timeout,
-        options
-      );
-    },
-    async healthCheck() {
-      return checkCommand("opencode", ["--version"]);
-    }
-  };
-}
 function createRunners(config) {
   if (config.agent.runners && Object.keys(config.agent.runners).length > 0) {
     const runners = {};
@@ -150,8 +130,7 @@ var init_agent_runner = __esm({
     SIGKILL_GRACE_MS = 5e3;
     STDERR_TAIL_CHARS = 500;
     RUNNER_FACTORIES = {
-      "claude-code": createClaudeCodeRunner,
-      "opencode": createOpenCodeRunner
+      "claude-code": createClaudeCodeRunner
     };
   }
 });
@@ -552,11 +531,20 @@ function getCurrentBranch(cwd) {
 }
 function ensureFeatureBranch(issueNumber, title, cwd) {
   const current = getCurrentBranch(cwd);
-  if (!BASE_BRANCHES.includes(current) && current !== "") {
+  const branchName = deriveBranchName(issueNumber, title);
+  if (current === branchName || current.startsWith(`${issueNumber}-`)) {
     logger.info(`  Already on feature branch: ${current}`);
     return current;
   }
-  const branchName = deriveBranchName(issueNumber, title);
+  if (!BASE_BRANCHES.includes(current) && current !== "") {
+    const defaultBranch2 = getDefaultBranch(cwd);
+    logger.info(`  Switching from ${current} to ${defaultBranch2} before creating ${branchName}`);
+    try {
+      git(["checkout", defaultBranch2], { cwd });
+    } catch {
+      logger.warn(`  Failed to checkout ${defaultBranch2}`);
+    }
+  }
   try {
     git(["fetch", "origin"], { cwd, timeout: 3e4 });
   } catch {
@@ -1711,6 +1699,60 @@ function parseArgs() {
     complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY
   };
 }
+async function checkLitellmHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function tryStartLitellm(url, projectDir) {
+  const configPath = path5.join(projectDir, "litellm-config.yaml");
+  if (!fs6.existsSync(configPath)) {
+    logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
+    return null;
+  }
+  const portMatch = url.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "4000";
+  try {
+    execFileSync7("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+  } catch {
+    try {
+      execFileSync7("python3", ["-m", "litellm", "--version"], { timeout: 5e3, stdio: "pipe" });
+    } catch {
+      logger.warn("litellm not installed (pip install 'litellm[proxy]')");
+      return null;
+    }
+  }
+  logger.info(`Starting LiteLLM proxy on port ${port}...`);
+  let cmd;
+  let args2;
+  try {
+    execFileSync7("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+    cmd = "litellm";
+    args2 = ["--config", configPath, "--port", port];
+  } catch {
+    cmd = "python3";
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  const child = spawn2(cmd, args2, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: process.env
+  });
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (await checkLitellmHealth(url)) {
+      logger.info(`LiteLLM proxy ready at ${url}`);
+      return child;
+    }
+  }
+  logger.warn("LiteLLM proxy failed to start within 60s");
+  child.kill();
+  return null;
+}
 function findLatestTaskForIssue(issueNumber, projectDir) {
   const tasksDir = path5.join(projectDir, ".tasks");
   if (!fs6.existsSync(tasksDir)) return null;
@@ -1838,11 +1880,31 @@ ${issue.body ?? ""}`;
         process.exit(1);
       }
     } else {
-      console.error("--from <stage> is required for rerun (no status.json found)");
-      process.exit(1);
+      logger.info("No status.json found \u2014 running full pipeline with feedback");
+      input.command = "run";
     }
   }
   const config = getProjectConfig();
+  let litellmProcess = null;
+  const cleanupLitellm = () => {
+    if (litellmProcess) {
+      litellmProcess.kill();
+      litellmProcess = null;
+    }
+  };
+  process.on("exit", cleanupLitellm);
+  if (config.agent.litellmUrl) {
+    const proxyRunning = await checkLitellmHealth(config.agent.litellmUrl);
+    if (!proxyRunning) {
+      litellmProcess = await tryStartLitellm(config.agent.litellmUrl, projectDir);
+      if (!litellmProcess) {
+        logger.warn("LiteLLM not available \u2014 falling back to Anthropic models");
+        config.agent.litellmUrl = void 0;
+      }
+    } else {
+      logger.info(`LiteLLM proxy already running at ${config.agent.litellmUrl}`);
+    }
+  }
   const runners = createRunners(config);
   const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
   const defaultRunner = runners[defaultRunnerName];
@@ -2139,8 +2201,7 @@ function detectBasicConfig(cwd) {
     }
   } catch {
   }
-  const hasOpenCode = fs7.existsSync(path6.join(cwd, "opencode.json"));
-  return { defaultBranch, owner, repo, pm, hasOpenCode };
+  return { defaultBranch, owner, repo, pm };
 }
 function smartInit(cwd) {
   const basic = detectBasicConfig(cwd);
@@ -2190,14 +2251,14 @@ ${srcDirs.join(", ")}
   } catch {
   }
   const existingFiles = [];
-  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "opencode.json", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
+  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
     if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
 
 `;
-  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}, opencode=${basic.hasOpenCode}
+  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}
 `;
   const prompt = `You are analyzing a project to configure Kody (an autonomous SDLC pipeline).
 
@@ -2217,8 +2278,8 @@ Given this project context, output ONLY a JSON object with EXACTLY this structur
     "github": { "owner": "${basic.owner}", "repo": "${basic.repo}" },
     "paths": { "taskDir": ".tasks" },
     "agent": {
-      "runner": "${basic.hasOpenCode ? "opencode" : "claude-code"}",
-      "defaultRunner": "${basic.hasOpenCode ? "opencode" : "claude"}",
+      "runner": "${"claude-code"}",
+      "defaultRunner": "${"claude"}",
       "modelMap": { "cheap": "haiku", "mid": "sonnet", "strong": "opus" }
     }
   },
@@ -2269,12 +2330,13 @@ ${context}`;
     if (!config.github) config.github = {};
     if (!config.paths) config.paths = {};
     if (!config.agent) config.agent = {};
+    config["$schema"] = "https://raw.githubusercontent.com/aharonyaircohen/Kody-Engine-Lite/main/kody.config.schema.json";
     config.git.defaultBranch = config.git.defaultBranch || basic.defaultBranch;
     config.github.owner = config.github.owner || basic.owner;
     config.github.repo = config.github.repo || basic.repo;
     config.paths.taskDir = config.paths.taskDir || ".tasks";
-    config.agent.runner = config.agent.runner || (basic.hasOpenCode ? "opencode" : "claude-code");
-    config.agent.defaultRunner = config.agent.defaultRunner || (basic.hasOpenCode ? "opencode" : "claude");
+    config.agent.runner = config.agent.runner || "claude-code";
+    config.agent.defaultRunner = config.agent.defaultRunner || "claude";
     if (!config.agent.modelMap) {
       config.agent.modelMap = { cheap: "haiku", mid: "sonnet", strong: "opus" };
     }
@@ -2343,6 +2405,7 @@ function buildFallbackConfig(cwd, basic) {
     return "";
   };
   return {
+    "$schema": "https://raw.githubusercontent.com/aharonyaircohen/Kody-Engine-Lite/main/kody.config.schema.json",
     quality: {
       typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
       lint: find("lint"),
@@ -2355,8 +2418,8 @@ function buildFallbackConfig(cwd, basic) {
     github: { owner: basic.owner, repo: basic.repo },
     paths: { taskDir: ".tasks" },
     agent: {
-      runner: basic.hasOpenCode ? "opencode" : "claude-code",
-      defaultRunner: basic.hasOpenCode ? "opencode" : "claude",
+      runner: "claude-code",
+      defaultRunner: "claude",
       modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
     }
   };

package/kody.config.schema.json

@@ -0,0 +1,170 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Kody Engine Lite Configuration",
+  "description": "Configuration for the Kody autonomous SDLC pipeline. See https://github.com/aharonyaircohen/Kody-Engine-Lite",
+  "type": "object",
+  "properties": {
+    "quality": {
+      "type": "object",
+      "description": "Quality gate commands run during the verify stage. Leave empty string to skip.",
+      "properties": {
+        "typecheck": {
+          "type": "string",
+          "description": "TypeScript type checking command (e.g., 'pnpm typecheck', 'pnpm tsc --noEmit')",
+          "default": "pnpm -s tsc --noEmit"
+        },
+        "lint": {
+          "type": "string",
+          "description": "Lint command (e.g., 'pnpm lint'). Empty to skip.",
+          "default": ""
+        },
+        "lintFix": {
+          "type": "string",
+          "description": "Auto-fix lint command, run when verify fails (e.g., 'pnpm lint:fix')",
+          "default": ""
+        },
+        "format": {
+          "type": "string",
+          "description": "Format check command (e.g., 'pnpm format:check'). Empty to skip.",
+          "default": ""
+        },
+        "formatFix": {
+          "type": "string",
+          "description": "Auto-fix format command, run when verify fails (e.g., 'pnpm format')",
+          "default": ""
+        },
+        "testUnit": {
+          "type": "string",
+          "description": "Unit test command. Use test:unit to exclude integration/e2e tests (e.g., 'pnpm test:unit')",
+          "default": "pnpm -s test"
+        }
+      },
+      "additionalProperties": false
+    },
+    "git": {
+      "type": "object",
+      "description": "Git configuration",
+      "properties": {
+        "defaultBranch": {
+          "type": "string",
+          "description": "Default branch for PR base and branch syncing (e.g., 'main', 'dev')",
+          "default": "dev"
+        },
+        "userEmail": {
+          "type": "string",
+          "description": "Git user email for CI commits (optional, defaults to github-actions bot)"
+        },
+        "userName": {
+          "type": "string",
+          "description": "Git user name for CI commits (optional, defaults to github-actions bot)"
+        }
+      },
+      "additionalProperties": false
+    },
+    "github": {
+      "type": "object",
+      "description": "GitHub repository settings. Auto-detected from git remote by init.",
+      "properties": {
+        "owner": {
+          "type": "string",
+          "description": "GitHub organization or username (e.g., 'my-org')"
+        },
+        "repo": {
+          "type": "string",
+          "description": "GitHub repository name (e.g., 'my-repo')"
+        }
+      },
+      "additionalProperties": false
+    },
+    "paths": {
+      "type": "object",
+      "description": "File path configuration",
+      "properties": {
+        "taskDir": {
+          "type": "string",
+          "description": "Directory for pipeline artifacts and state (gitignored)",
+          "default": ".tasks"
+        }
+      },
+      "additionalProperties": false
+    },
+    "agent": {
+      "type": "object",
+      "description": "Agent execution configuration",
+      "properties": {
+        "runner": {
+          "type": "string",
+          "description": "Agent runner type",
+          "enum": ["claude-code"],
+          "default": "claude-code"
+        },
+        "defaultRunner": {
+          "type": "string",
+          "description": "Name of the default runner to use",
+          "default": "claude"
+        },
+        "modelMap": {
+          "type": "object",
+          "description": "Maps model tiers to actual model names. Use LiteLLM aliases when litellmUrl is set.",
+          "properties": {
+            "cheap": {
+              "type": "string",
+              "description": "Fast/cheap model for taskify stage (e.g., 'haiku' or LiteLLM alias)",
+              "default": "haiku"
+            },
+            "mid": {
+              "type": "string",
+              "description": "Mid-tier model for build, review-fix, autofix (e.g., 'sonnet' or LiteLLM alias)",
+              "default": "sonnet"
+            },
+            "strong": {
+              "type": "string",
+              "description": "Strongest model for plan, review — deep reasoning (e.g., 'opus' or LiteLLM alias)",
+              "default": "opus"
+            }
+          },
+          "additionalProperties": false
+        },
+        "litellmUrl": {
+          "type": "string",
+          "description": "LiteLLM proxy URL for using non-Anthropic models (e.g., 'http://localhost:4000'). Sets ANTHROPIC_BASE_URL for Claude Code.",
+          "examples": ["http://localhost:4000"]
+        },
+        "usePerStageRouting": {
+          "type": "boolean",
+          "description": "When true, uses stage name as the LiteLLM model alias instead of modelMap tier",
+          "default": false
+        },
+        "runners": {
+          "type": "object",
+          "description": "Named runner definitions (advanced)",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["claude-code"]
+              }
+            },
+            "required": ["type"]
+          }
+        },
+        "stageRunners": {
+          "type": "object",
+          "description": "Per-stage runner assignment (advanced). Maps stage name to runner name.",
+          "properties": {
+            "taskify": { "type": "string" },
+            "plan": { "type": "string" },
+            "build": { "type": "string" },
+            "autofix": { "type": "string" },
+            "review": { "type": "string" },
+            "review-fix": { "type": "string" }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",
@@ -10,7 +10,8 @@
   "files": [
     "dist",
     "prompts",
-    "templates"
+    "templates",
+    "kody.config.schema.json"
   ],
   "scripts": {
     "kody": "tsx src/entry.ts",