@nathapp/nax 0.18.1

package/nax/features/plugin-integration/US-007-VERIFICATION.md

@@ -0,0 +1,259 @@
+# US-007: Read plugin config entries from nax config.json
+
+## Verification Report
+
+**Date**: 2026-02-26
+**Status**: ✅ COMPLETE (Already Implemented)
+**Test Results**: 10/10 tests passing
+
+---
+
+## Implementation Summary
+
+US-007 functionality was already fully implemented. This verification confirms all acceptance criteria are met with comprehensive test coverage.
+
+### Architecture
+
+The implementation follows this flow:
+
+```
+config.json (plugins[])
+  → loadConfig() (src/config/loader.ts)
+  → runner/CLI extracts config.plugins
+  → loadPlugins(globalDir, projectDir, configPlugins, projectRoot)
+  → resolveModulePath() for each plugin
+  → loadAndValidatePlugin(resolvedPath, config)
+  → plugin.setup(config)
+```
+
+---
+
+## Acceptance Criteria Verification
+
+### ✅ AC1: plugins[] from config.json passed to loadPlugins()
+
+**Implementation:**
+- `src/execution/runner.ts:201-202`
+- `src/execution/run-lifecycle.ts:88-89`
+- `src/cli/plugins.ts:22-23`
+
+**Code:**
+```typescript
+const configPlugins = config.plugins || [];
+const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir);
+```
+
+**Tests:** 2 tests in `config-resolution.test.ts`
+
+---
+
+### ✅ AC2: Relative module paths resolved relative to project root
+
+**Implementation:** `src/plugins/loader.ts:173-186`
+
+**Code:**
+```typescript
+function resolveModulePath(modulePath: string, projectRoot?: string): string {
+  // Absolute paths and npm packages work as-is
+  if (path.isAbsolute(modulePath) || (!modulePath.startsWith("./") && !modulePath.startsWith("../"))) {
+    return modulePath;
+  }
+
+  // Relative paths resolved relative to project root
+  if (projectRoot) {
+    return path.resolve(projectRoot, modulePath);
+  }
+
+  return path.resolve(modulePath);
+}
+```
+
+**Tests:** 2 tests in `config-resolution.test.ts`
+- `./relative/path` resolution
+- `../parent/path` resolution
+
+---
+
+### ✅ AC3: Absolute paths and npm package names work as-is
+
+**Implementation:** `src/plugins/loader.ts:175-176`
+
+**Logic:**
+- Absolute paths: `path.isAbsolute(modulePath)` → return as-is
+- npm packages: No `./` or `../` prefix → return as-is
+
+**Tests:** 2 tests in `config-resolution.test.ts`
+- Absolute path loading
+- npm package name handling
+
+---
+
+### ✅ AC4: Clear error message when plugin module not found
+
+**Implementation:** `src/plugins/loader.ts:230-235`
+
+**Code:**
+```typescript
+if (errorMsg.includes("Cannot find module") || errorMsg.includes("ENOENT")) {
+  console.error(`[nax] Failed to load plugin module '${displayPath}'`);
+  console.error(`[nax] Attempted path: ${modulePath}`);
+  console.error(
+    "[nax] Ensure the module exists and the path is correct (relative paths are resolved from project root)",
+  );
+}
+```
+
+**Error Output Example:**
+```
+[nax] Failed to load plugin module './nonexistent/plugin.ts'
+[nax] Attempted path: /project/root/nonexistent/plugin.ts
+[nax] Ensure the module exists and the path is correct (relative paths are resolved from project root)
+```
+
+**Tests:** 2 tests in `config-resolution.test.ts`
+
+---
+
+### ✅ AC5: Plugin-specific config passed to setup() function
+
+**Implementation:** `src/plugins/loader.ts:93, 215-221`
+
+**Code:**
+```typescript
+// Extract config from entry
+const validated = await loadAndValidatePlugin(resolvedModule, entry.config ?? {}, entry.module);
+
+// Inside loadAndValidatePlugin:
+if (validated.setup) {
+  try {
+    await validated.setup(config);
+  } catch (error) {
+    console.error(`[nax] Plugin '${validated.name}' setup failed:`, error);
+    return null;
+  }
+}
+```
+
+**Tests:** 2 tests in `config-resolution.test.ts`
+- Config passed correctly
+- Empty config when undefined
+
+---
+
+## Test Coverage
+
+### Unit Tests: `test/integration/plugins/config-resolution.test.ts`
+
+```
+✅ AC1: plugins[] from config.json passed to loadPlugins
+  ✅ loads plugins from config array
+  ✅ loads multiple plugins from config array
+
+✅ AC2: Relative module paths resolved relative to project root
+  ✅ resolves ./relative/path from project root
+  ✅ resolves ../relative/path from project root
+
+✅ AC3: Absolute paths and npm packages work as-is
+  ✅ loads plugin with absolute path
+  ✅ treats non-relative paths as npm packages (doesn't crash)
+
+✅ AC4: Clear error message when plugin module not found
+  ✅ logs helpful error for missing relative path
+  ✅ logs helpful error for missing absolute path
+
+✅ AC5: Plugin-specific config passed to setup()
+  ✅ passes config object to plugin setup function
+  ✅ passes empty config object when config is undefined
+
+Total: 10 tests, 10 passing, 0 failing
+```
+
+### Integration Test: `test/integration/plugins/config-integration.test.ts`
+
+```
+✅ realistic scenario: project with relative plugin paths in config
+  - Creates project with custom-plugins/ directory
+  - Loads multiple plugins with relative paths
+  - Verifies configs passed to each plugin's setup()
+
+Total: 1 test, 1 passing, 0 failing
+```
+
+### Overall Plugin Test Suite
+
+```
+✅ 102 plugin-related tests pass
+✅ 0 failures
+✅ 177 expect() calls
+```
+
+---
+
+## Example Usage
+
+### Config Format
+
+```json
+{
+  "version": 1,
+  "plugins": [
+    {
+      "module": "./custom-plugins/my-plugin.ts",
+      "config": {
+        "apiKey": "key-123",
+        "enabled": true
+      }
+    },
+    {
+      "module": "/absolute/path/to/plugin.js",
+      "config": {
+        "timeout": 5000
+      }
+    },
+    {
+      "module": "@org/nax-plugin-package"
+    }
+  ]
+}
+```
+
+### Path Resolution Examples
+
+| Config Path | Project Root | Resolved Path |
+|------------|--------------|---------------|
+| `./plugins/foo.ts` | `/home/user/project` | `/home/user/project/plugins/foo.ts` |
+| `../shared/bar.ts` | `/home/user/project` | `/home/user/shared/bar.ts` |
+| `/abs/path/baz.ts` | `/home/user/project` | `/abs/path/baz.ts` |
+| `@org/plugin` | `/home/user/project` | `@org/plugin` |
+
+---
+
+## Files Involved
+
+### Implementation
+- `src/config/schema.ts` - PluginConfigEntry type definition
+- `src/config/loader.ts` - Config loading with plugins[] array
+- `src/plugins/loader.ts` - Plugin loading and path resolution
+- `src/execution/runner.ts` - Runner integration
+- `src/execution/run-lifecycle.ts` - Lifecycle integration
+- `src/cli/plugins.ts` - CLI command integration
+
+### Tests
+- `test/integration/plugins/config-resolution.test.ts` - AC verification (10 tests)
+- `test/integration/plugins/config-integration.test.ts` - E2E test (1 test)
+- `test/integration/cli-plugins.test.ts` - CLI integration (9 tests)
+
+---
+
+## Conclusion
+
+✅ **US-007 is fully implemented and verified**
+
+All acceptance criteria are met with comprehensive test coverage. The implementation correctly:
+1. Reads plugins[] from config.json
+2. Resolves relative paths against project root
+3. Handles absolute paths and npm packages
+4. Provides clear error messages
+5. Passes plugin-specific config to setup()
+
+**No code changes required.** Implementation was completed in prior stories.

package/nax/features/plugin-integration/prd.json

@@ -0,0 +1,208 @@
+{
+  "project": "nax",
+  "feature": "plugin-integration",
+  "branchName": "feat/plugin-integration",
+  "createdAt": "2026-02-26T22:00:00Z",
+  "updatedAt": "2026-02-28T06:34:45Z",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Wire plugin loading into the runner startup",
+      "description": "The runner (src/execution/runner.ts) should call loadPlugins() at startup and store the resulting PluginRegistry in the pipeline context. Currently loadPlugins() exists in src/plugins/loader.ts but is never called. The runner should: 1) resolve global dir (~/.nax/plugins), project dir (<workdir>/nax/plugins), and config.plugins[] entries, 2) call loadPlugins(), 3) store the registry on the RunContext or pass it through the pipeline. On teardown (run end), call registry.teardownAll().",
+      "acceptanceCriteria": [
+        "Runner calls loadPlugins() during initialization before story loop starts",
+        "PluginRegistry is accessible from pipeline context (RunContext or similar)",
+        "registry.teardownAll() is called on both success and failure paths",
+        "If no plugins are found, an empty registry is used (no error)",
+        "Plugin loading errors are logged but do not abort the run"
+      ],
+      "dependencies": [],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 1,
+      "escalations": [],
+      "priorErrors": []
+    },
+    {
+      "id": "US-002",
+      "title": "Context providers inject into agent prompts",
+      "description": "Before agent execution in the pipeline, call all registered context providers (registry.getContextProviders()) for the current story. Each provider returns {content, estimatedTokens, label}. Append provider content to the agent prompt under labeled sections, respecting a configurable token budget (default 2000 tokens total for all providers). If a provider throws, log warning and skip it. Add contextProviderTokenBudget to ExecutionConfig.",
+      "acceptanceCriteria": [
+        "All registered context providers are called before agent execution",
+        "Provider content is appended to the prompt under a markdown section with the provider's label",
+        "Total injected tokens respect the token budget (providers are added in order until budget exhausted)",
+        "Provider errors are caught, logged, and skipped without failing the story",
+        "Token budget is configurable via execution.contextProviderTokenBudget in config"
+      ],
+      "dependencies": [
+        "US-001"
+      ],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 2,
+      "escalations": [],
+      "priorErrors": [
+        "Implemented directly with Claude outside nax. Marked passed on cleanup 2026-02-28."
+      ],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: security-critical, strategy:lite"
+      }
+    },
+    {
+      "id": "US-003",
+      "title": "Review plugins run after built-in verification",
+      "description": "After the built-in review checks (typecheck/lint/test) pass in the pipeline's review stage (src/pipeline/stages/), call all registered reviewer plugins (registry.getReviewers()). Each reviewer's check(workdir, changedFiles) returns {passed, output, exitCode?}. If any reviewer fails, treat it the same as a built-in check failure (triggers retry/escalation). Include reviewer output in the story result for debugging.",
+      "acceptanceCriteria": [
+        "Plugin reviewers run after built-in checks pass",
+        "Each reviewer receives the workdir and list of changed files",
+        "Reviewer failure triggers the same retry/escalation as built-in check failures",
+        "Reviewer output is included in the story execution result",
+        "If a reviewer throws an exception, it counts as a failure with the exception message as output",
+        "Multiple reviewers run sequentially; first failure short-circuits remaining reviewers"
+      ],
+      "dependencies": [
+        "US-001"
+      ],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 2,
+      "escalations": [],
+      "priorErrors": [
+        "Implemented directly with Claude outside nax. Marked passed on cleanup 2026-02-28."
+      ],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: strategy:lite"
+      }
+    },
+    {
+      "id": "US-004",
+      "title": "Reporter plugins receive lifecycle events",
+      "description": "Fire reporter events at the appropriate points in the runner loop: onRunStart when the run begins, onStoryComplete after each story finishes (success or failure), onRunEnd when the run completes. All reporter calls are fire-and-forget (errors logged, never block pipeline). Build event objects from existing run state (RunStartEvent, StoryCompleteEvent, RunEndEvent as defined in src/plugins/types.ts).",
+      "acceptanceCriteria": [
+        "onRunStart fires once at run start with runId, feature, totalStories, startTime",
+        "onStoryComplete fires after each story with storyId, status, durationMs, cost, tier, testStrategy",
+        "onRunEnd fires once at run end with runId, totalDurationMs, totalCost, storySummary counts",
+        "Reporter errors are caught and logged but never block execution",
+        "Multiple reporters all receive events (not short-circuited on error)",
+        "Events fire even when the run fails or is aborted (onRunEnd still fires)"
+      ],
+      "dependencies": [
+        "US-001"
+      ],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 1,
+      "escalations": [],
+      "priorErrors": [
+        "Implemented directly with Claude outside nax. Marked passed on cleanup 2026-02-28."
+      ],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: strategy:lite"
+      }
+    },
+    {
+      "id": "US-005",
+      "title": "Plugin routing strategies integrate into router chain",
+      "description": "Insert plugin routing strategies (registry.getRouters()) before the built-in router in the routing chain (src/routing/). When routing a story, iterate plugin routers first; if any returns a routing decision, use it. If all plugin routers return null/undefined, fall back to the built-in strategy. This allows plugins to override routing for specific stories (e.g., always route security-tagged stories to premium).",
+      "acceptanceCriteria": [
+        "Plugin routers are tried before the built-in routing strategy",
+        "First plugin router that returns a non-null result wins",
+        "If all plugin routers return null, built-in strategy is used as fallback",
+        "Plugin routers receive the same story context as built-in routers",
+        "Router errors are caught and logged; fallback to next router in chain"
+      ],
+      "dependencies": [
+        "US-001"
+      ],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 2,
+      "escalations": [],
+      "priorErrors": [
+        "Implemented directly with Claude outside nax. Marked passed on cleanup 2026-02-28."
+      ]
+    },
+    {
+      "id": "US-006",
+      "title": "CLI 'nax plugins list' command",
+      "description": "Add a 'plugins' subcommand to the CLI (src/cli/) with a 'list' action. It should: 1) load plugins from global + project + config sources (reuse loadPlugins), 2) display a table with name, version, provides[], and source (global/project/config), 3) exit cleanly. If no plugins found, print a helpful message pointing to docs.",
+      "acceptanceCriteria": [
+        "Running 'nax plugins list' prints a formatted table of installed plugins",
+        "Each row shows: plugin name, version, extension types provided, source location",
+        "If no plugins found, prints 'No plugins installed' with help text",
+        "Works in both project directory and outside (global-only scan outside project)",
+        "Exit code 0 on success"
+      ],
+      "dependencies": [],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 1,
+      "escalations": [],
+      "priorErrors": []
+    },
+    {
+      "id": "US-007",
+      "title": "Read plugin config entries from nax config.json",
+      "description": "The config loader (src/config/loader.ts) already supports a plugins[] array in the schema. Ensure that when config is loaded, the plugins[] entries are passed to loadPlugins() as the configPlugins parameter. Each entry has {module, config?}. Validate that module paths resolve correctly (relative to project root). Add a helpful error message if a configured plugin module cannot be found.",
+      "acceptanceCriteria": [
+        "plugins[] from config.json are passed to loadPlugins() as configPlugins parameter",
+        "Relative module paths in plugins[].module are resolved relative to project root",
+        "Absolute module paths and npm package names work as-is",
+        "If a plugin module cannot be found, a clear error message is logged with the path tried",
+        "Plugin-specific config (plugins[].config) is passed to the plugin's setup() function"
+      ],
+      "dependencies": [],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 1,
+      "escalations": [],
+      "priorErrors": []
+    },
+    {
+      "id": "US-008",
+      "title": "Sample console reporter plugin with tests",
+      "description": "Create a sample reporter plugin at examples/plugins/console-reporter/ that demonstrates the plugin API. It should: 1) implement IReporter with onRunStart (print banner), onStoryComplete (print status line), onRunEnd (print summary table), 2) have a setup() that reads config.verbose for detail level, 3) include unit tests in the same directory. This serves as both documentation and a smoke test for the plugin system.",
+      "acceptanceCriteria": [
+        "Plugin exports a valid NaxPlugin with provides: ['reporter']",
+        "onRunStart prints a run banner with feature name and story count",
+        "onStoryComplete prints a status line (\u2713/\u2717) with story ID, tier, duration, cost",
+        "onRunEnd prints a summary table with total stories, pass/fail counts, total cost, total duration",
+        "setup() reads config.verbose (boolean, default false) for extra detail",
+        "Plugin passes validatePlugin() from src/plugins/validator.ts",
+        "Unit tests verify all three event handlers produce expected output"
+      ],
+      "dependencies": [
+        "US-004",
+        "US-007"
+      ],
+      "tags": [],
+      "status": "passed",
+      "passes": true,
+      "attempts": 1,
+      "escalations": [],
+      "priorErrors": [
+        "Implemented directly with Claude outside nax. Marked passed on cleanup 2026-02-28."
+      ]
+    }
+  ],
+  "analyzeConfig": {
+    "maxStories": 15,
+    "granularity": "medium"
+  }
+}

package/nax/features/plugin-integration/progress.txt

@@ -0,0 +1,5 @@
+[2026-02-26T16:06:18.213Z] US-001 — FAILED — Wire plugin loading into the runner startup — All tiers exhausted
+[2026-02-26T16:18:45.006Z] US-006 — FAILED — CLI 'nax plugins list' command — All tiers exhausted
+[2026-02-26T16:27:59.795Z] US-007 — FAILED — Read plugin config entries from nax config.json — All tiers exhausted
+[2026-02-26T17:26:43.751Z] US-002 — FAILED — Context providers inject into agent prompts — All tiers exhausted
+[2026-02-26T17:27:52.898Z] US-003 — FAILED — Review plugins run after built-in verification — All tiers exhausted

package/nax/features/precheck/prd.json

@@ -0,0 +1,205 @@
+{
+  "project": "nax",
+  "feature": "precheck",
+  "branchName": "feat/precheck",
+  "createdAt": "2026-02-27T10:00:00Z",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Precheck types and check implementations",
+      "description": "Create src/precheck/types.ts with PrecheckResult, CheckStatus, CheckTier types. Create src/precheck/checks.ts with individual check implementations. Tier 1 blockers: git repo exists, working tree clean, no stale lock (>2h), PRD valid (required fields: id, title, description), Claude CLI available, dependencies installed (detect node_modules/target/venv/vendor), test/lint/typecheck commands work (from config, skip if not configured), git user configured. Tier 2 warnings: CLAUDE.md exists, disk space >1GB, pending stories exist, missing optional commands. Each check returns {name, tier, passed, message}. Tier 2 warning: .gitignore exists and covers nax runtime files (nax.lock, nax/features/*/runs/, test/tmp/).",
+      "acceptanceCriteria": [
+        "PrecheckResult type includes blockers[] and warnings[] arrays",
+        "Git repo check uses git rev-parse --git-dir",
+        "Working tree check uses git status --porcelain",
+        "Stale lock detection: nax.lock older than 2 hours",
+        "PRD validation checks id, title, description per story",
+        "PRD auto-defaults missing optional fields in-memory (tags=[], status=pending, storyPoints=1)",
+        "Claude CLI check runs claude --version",
+        "Dependency detection is language-aware (node_modules, target, venv, vendor)",
+        "Test/lint/typecheck commands read from config.execution",
+        "Commands set to null/false are skipped silently",
+        "Disk space warning triggers below 1GB",
+        ".gitignore warning if missing or does not cover nax.lock, runs/, test/tmp/"
+      ],
+      "dependencies": [],
+      "tags": [
+        "precheck",
+        "types"
+      ],
+      "status": "passed",
+      "attempts": 2,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced",
+        "Attempt 2 failed with model tier: balanced",
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": [],
+      "routing": {
+        "complexity": "complex",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: complexity:complex, strategy:lite"
+      }
+    },
+    {
+      "id": "US-002",
+      "title": "Precheck orchestrator with formatted output",
+      "description": "Create src/precheck/index.ts. Runs all checks from checks.ts in order. Stops on first Tier 1 blocker (fail-fast). Collects all Tier 2 warnings. Formats human-readable output with emoji indicators (checkmark/cross/warning). Supports --json flag for machine-readable output. Returns summary with counts (checks, passed, failed, warnings).",
+      "acceptanceCriteria": [
+        "Runs Tier 1 checks first, stops on first failure",
+        "Runs all Tier 2 checks even if some warn",
+        "Human output shows emoji per check result",
+        "JSON output matches spec schema (passed, blockers, warnings, summary, feature)",
+        "Exit code 0 for pass, 1 for blocker, 2 for invalid PRD",
+        "Summary line shows total checks/passed/failed/warnings"
+      ],
+      "dependencies": [
+        "US-001"
+      ],
+      "tags": [
+        "precheck",
+        "orchestrator"
+      ],
+      "status": "passed",
+      "attempts": 1,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": []
+    },
+    {
+      "id": "US-003",
+      "title": "CLI nax precheck command with --json flag",
+      "description": "Create src/commands/precheck.ts, register in CLI (bin/nax.ts). Uses resolveProject() from US-001 of v0.12.0. Supports -f <feature>, -d <dir>, --json flags. Runs precheck orchestrator and displays results. Uses same project resolver as nax status/logs.",
+      "acceptanceCriteria": [
+        "Registered as nax precheck subcommand",
+        "Uses resolveProject() for directory resolution",
+        "-f flag specifies feature to validate",
+        "-d flag specifies working directory",
+        "--json flag outputs machine-readable JSON",
+        "Without --json shows human-friendly formatted output",
+        "Exit codes: 0=pass, 1=blocker, 2=invalid PRD"
+      ],
+      "dependencies": [
+        "US-002"
+      ],
+      "tags": [
+        "cli",
+        "precheck"
+      ],
+      "status": "passed",
+      "attempts": 2,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced",
+        "Attempt 2 failed with model tier: balanced",
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": [],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: strategy:lite"
+      },
+      "passes": true
+    },
+    {
+      "id": "US-004",
+      "title": "Integrate precheck into nax run",
+      "description": "Modify src/execution/runner.ts to run precheck before story execution loop. If precheck fails (any Tier 1 blocker), abort run with clear error message pointing to nax precheck for details. Warnings are logged but execution continues. Add --skip-precheck flag to bypass (for advanced users).",
+      "acceptanceCriteria": [
+        "Precheck runs automatically before first story",
+        "Tier 1 blocker aborts run with descriptive error",
+        "Tier 2 warnings logged but don't block execution",
+        "--skip-precheck flag bypasses all checks",
+        "Precheck results included in run JSONL log",
+        "Failed precheck updates status.json with precheck-failed status"
+      ],
+      "dependencies": [
+        "US-002"
+      ],
+      "tags": [
+        "runner",
+        "integration"
+      ],
+      "status": "passed",
+      "attempts": 1,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": [],
+      "passes": true
+    },
+    {
+      "id": "US-005",
+      "title": "Config-driven review commands replacing hardcoded lint",
+      "description": "Modify src/pipeline/stages/review/runner.ts to use config-driven command resolution instead of hardcoded 'bun run lint'. Resolution order: 1) explicit config.execution.lintCommand, 2) package.json has 'lint' script -> 'bun run lint', 3) not found -> skip with warning. Same for typecheckCommand. Setting to null explicitly disables. This fixes BUG-005.",
+      "acceptanceCriteria": [
+        "Review stage reads lintCommand from config.execution",
+        "Review stage reads typecheckCommand from config.execution",
+        "Resolution order: config -> package.json -> skip",
+        "Setting command to null/false explicitly disables it",
+        "Missing command logs warning instead of failing",
+        "Config schema updated with lintCommand and typecheckCommand fields",
+        "BUG-005 (hardcoded bun run lint) is resolved"
+      ],
+      "dependencies": [],
+      "tags": [
+        "review",
+        "config"
+      ],
+      "status": "passed",
+      "attempts": 2,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced",
+        "Attempt 2 failed with model tier: balanced",
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": [],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: strategy:lite"
+      }
+    },
+    {
+      "id": "US-006",
+      "title": "PRD auto-default and router tags fix",
+      "description": "Fix src/routing/router.ts line ~277 to use tags ?? [] as defensive fallback (prevents crash on missing tags). During precheck and run initialization, auto-default missing optional PRD fields in-memory: tags->[], status->pending, storyPoints->1, acceptanceCriteria->[]. Do not modify the PRD file on disk. This fixes BUG-004 properly at the source.",
+      "acceptanceCriteria": [
+        "Router uses tags ?? [] for spread operations",
+        "PRD loader auto-defaults tags=[] when missing",
+        "PRD loader auto-defaults status=pending when missing",
+        "PRD loader auto-defaults storyPoints=1 when missing",
+        "PRD file on disk is not modified",
+        "Existing values are preserved (only fills missing)"
+      ],
+      "dependencies": [],
+      "tags": [
+        "fix",
+        "prd"
+      ],
+      "status": "passed",
+      "attempts": 2,
+      "priorErrors": [
+        "Attempt 1 failed with model tier: balanced",
+        "Attempt 2 failed with model tier: balanced",
+        "Attempt 1 failed with model tier: balanced"
+      ],
+      "escalations": [],
+      "routing": {
+        "complexity": "medium",
+        "modelTier": "powerful",
+        "testStrategy": "three-session-tdd-lite",
+        "reasoning": "three-session-tdd-lite: strategy:lite"
+      }
+    }
+  ],
+  "analyzeConfig": {
+    "maxStories": 15,
+    "granularity": "medium"
+  },
+  "updatedAt": "2026-02-27T14:10:37.423Z"
+}