@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/development/frontend/ui-primitives/cli/scaffold-ui-primitives/index.ts

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * cli:scaffold-ui-primitives — Scaffold theme-compliant UI primitives.
+ *
+ * Idempotent: skips writes if existing file content matches; honors
+ * `/* @customised *\/` (or `// @customised`) marker at the top of the file.
+ * For JSON locale files, deep-merges the `entityLookup.*` namespace into
+ * existing content so siblings (auth.*, nav.*, …) are preserved.
+ */
+import { parseArgs } from 'node:util';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { validate } from './validate.js';
+import { generate } from './generate.js';
+import { generateEnvelope, failGenerate, printEnvelope } from '../../../../../lib/output.js';
+
+const COMMAND = 'scaffold-ui-primitives';
+
+function isCustomised(source: string): boolean {
+  const head = source.trimStart().slice(0, 100);
+  return head.startsWith('/* @customised') || head.startsWith('// @customised');
+}
+
+/**
+ * Recursively merge `patch` on top of `base`. Objects are merged key-by-key,
+ * arrays and primitives in `patch` replace those in `base`. Used for locale
+ * JSON so we override only the `entityLookup.*` namespace and never wipe
+ * sibling namespaces (auth.*, nav.*, …).
+ */
+function deepMerge(base: unknown, patch: unknown): unknown {
+  if (
+    base !== null && typeof base === 'object' && !Array.isArray(base) &&
+    patch !== null && typeof patch === 'object' && !Array.isArray(patch)
+  ) {
+    const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };
+    for (const [k, v] of Object.entries(patch as Record<string, unknown>)) {
+      out[k] = deepMerge(out[k], v);
+    }
+    return out;
+  }
+  return patch;
+}
+
+function main(): void {
+  const { values } = parseArgs({
+    options: {
+      spec: { type: 'string' },
+      dry_run: { type: 'boolean', default: false },
+    },
+    strict: true,
+  });
+
+  if (!values.spec) {
+    printEnvelope(failGenerate(COMMAND, ['--spec is required']));
+    process.exit(1);
+  }
+
+  let raw: unknown;
+  try {
+    raw = JSON.parse(values.spec);
+  } catch {
+    printEnvelope(failGenerate(COMMAND, ['Invalid JSON in --spec']));
+    process.exit(1);
+  }
+
+  const validation = validate(raw);
+  if (!validation.valid || !validation.spec) {
+    printEnvelope(failGenerate(COMMAND, validation.errors));
+    process.exit(1);
+  }
+
+  const spec = validation.spec;
+  const files = generate(spec);
+
+  if (values.dry_run) {
+    printEnvelope(generateEnvelope(COMMAND, {
+      data: { dryRun: true, files: files.map((f) => f.path) },
+      warnings: validation.warnings,
+    }));
+    process.exit(0);
+  }
+
+  const filesCreated: string[] = [];
+  const filesModified: string[] = [];
+  const skipped: string[] = [];
+
+  for (const file of files) {
+    const abs = resolve(join(spec.projectPath, file.path));
+    const exists = existsSync(abs);
+
+    if (exists && file.strategy === 'overwrite') {
+      const existing = readFileSync(abs, 'utf-8');
+      if (isCustomised(existing)) { skipped.push(file.path); continue; }
+      if (!spec.force && existing === file.content) continue;
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, file.content, 'utf-8');
+      filesModified.push(abs);
+    } else if (exists && file.strategy === 'deep-merge-json') {
+      let existingJson: unknown = {};
+      try {
+        existingJson = JSON.parse(readFileSync(abs, 'utf-8'));
+      } catch {
+        // Malformed JSON — overwrite with the canonical patch rather than fail.
+        existingJson = {};
+      }
+      const patch = JSON.parse(file.content);
+      const merged = deepMerge(existingJson, patch);
+      const out = JSON.stringify(merged, null, 2) + '\n';
+      const current = readFileSync(abs, 'utf-8');
+      if (!spec.force && current === out) continue;
+      writeFileSync(abs, out, 'utf-8');
+      filesModified.push(abs);
+    } else {
+      mkdirSync(dirname(abs), { recursive: true });
+      // For new locale files we still write the patch verbatim (it's already
+      // a complete JSON document with just our namespace).
+      writeFileSync(abs, file.content, 'utf-8');
+      filesCreated.push(abs);
+    }
+  }
+
+  const nextSteps: string[] = [];
+  if (skipped.length > 0) {
+    nextSteps.push(`Skipped ${skipped.length} customised file(s): ${skipped.join(', ')}. Remove the @customised marker to allow overwrites.`);
+  }
+  if (filesCreated.length === 0 && filesModified.length === 0 && skipped.length === 0) {
+    nextSteps.push('UI primitives already up-to-date — no changes needed.');
+  }
+  if (filesCreated.length > 0) {
+    nextSteps.push('scaffold-component now resolves @/components/ui/EntityLookup for FK fields. Re-run audit-dev-frontend to clear DEV-UI-022.');
+  }
+
+  printEnvelope(generateEnvelope(COMMAND, {
+    data: { fileCount: filesCreated.length + filesModified.length, skipped: skipped.length },
+    filesCreated,
+    filesModified,
+    warnings: validation.warnings,
+    nextSteps,
+  }));
+}
+
+main();

package/templates/skills/development/frontend/ui-primitives/cli/scaffold-ui-primitives/types.ts

@@ -0,0 +1,27 @@
+/**
+ * scaffold-ui-primitives/types.ts — Input contract + generated file shape.
+ *
+ * Today only EntityLookup is emitted; the schema stays narrow so adding new
+ * primitives (EnumSelect, DateInput) means extending GeneratedFile output only.
+ */
+import { z } from 'zod';
+
+export const ScaffoldUiPrimitivesInputSchema = z.object({
+  projectPath: z.string().min(1),
+  appCode: z.string().min(1),
+  force: z.boolean().default(false),
+});
+
+export type ScaffoldUiPrimitivesInput = z.infer<typeof ScaffoldUiPrimitivesInputSchema>;
+
+export interface GeneratedFile {
+  path: string;
+  content: string;
+  /**
+   * 'overwrite' — replace the file verbatim (used for the primitive .tsx).
+   * 'deep-merge-json' — read existing JSON, merge `content` (parsed) on top
+   *  preserving sibling keys (used for locale files so we don't clobber other
+   *  namespaces like `auth.*` or `nav.*`).
+   */
+  strategy: 'overwrite' | 'deep-merge-json';
+}

package/templates/skills/development/frontend/ui-primitives/cli/scaffold-ui-primitives/validate.ts

@@ -0,0 +1,37 @@
+/**
+ * scaffold-ui-primitives/validate.ts — Args validation.
+ */
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { ScaffoldUiPrimitivesInputSchema, type ScaffoldUiPrimitivesInput } from './types.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  spec: ScaffoldUiPrimitivesInput | null;
+  errors: string[];
+  warnings: string[];
+}
+
+export function validate(raw: unknown): ValidationResult {
+  const parsed = ScaffoldUiPrimitivesInputSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      spec: null,
+      errors: parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`),
+      warnings: [],
+    };
+  }
+  const spec = parsed.data;
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  const abs = path.resolve(spec.projectPath);
+  if (!existsSync(abs)) errors.push(`projectPath does not exist: ${abs}`);
+  else if (!statSync(abs).isDirectory()) errors.push(`projectPath is not a directory: ${abs}`);
+  else if (!existsSync(path.join(abs, 'src'))) {
+    warnings.push(`projectPath has no "src" folder yet — it will be created.`);
+  }
+
+  return { valid: errors.length === 0, spec, errors, warnings };
+}

package/templates/skills/development/run/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: run
+description: Kill orphans + launch backend + frontend, auto-retry on failure
+group: RUN
+recommended_model: haiku
+allowed-tools: [Read, Glob, Grep, Bash]  # Bash: process management
+---
+
+# Skill: Run — Launch backend + frontend with auto-retry
+
+## Role
+
+You are a launcher agent. Your job is to **start the SmartStack stack** (backend .NET
+then frontend Vite) in the current worktree. You don't analyze, you don't redesign —
+you **kill stale processes, start, check, retry**. If you cannot make it work after 3
+loops, you escalate to `development/debug/{backend,frontend}/SKILL.md` (Opus territory).
+
+## Order of operations
+
+1. **Backend** first (frontend proxies API calls → needs backend ready)
+2. **Frontend** second
+
+For each side: run the corresponding sub-skill.
+
+## Sub-skills
+
+| Side | Skill |
+|------|-------|
+| backend | `@backend/SKILL.md` |
+| frontend | `@frontend/SKILL.md` |
+
+## Loop budget
+
+- **3 attempts per side** maximum
+- Each attempt: kill orphans → launch → wait → health-check
+- If all 3 attempts fail: stop, summarize the errors, suggest switching to `debug/` skill
+
+## Output format
+
+Short, structured. Examples:
+
+```
+[backend] attempt 1: OK (port 5142, /health HTTP 200 in 6.3s)
+[frontend] attempt 1: port 3000 already in use → killed PID 12345 → attempt 2: OK (port 3000, Vite ready)
+✓ Stack running — backend: http://localhost:5142 | frontend: http://localhost:3000
+```
+
+```
+[backend] attempt 1: build failed (CS0246 in UserService.cs:42)
+[backend] attempt 2: same error — NOT transient
+✗ Backend failed to launch after 3 attempts. Escalate with: claude -p "@.claude/skills/development/debug/backend/SKILL.md"
+```
+
+## Rules
+
+- **Never** modify source files (that's `debug/`'s job)
+- **Always** kill before launch — stale processes lock DLLs (MSB3026) and ports
+- **Always** verify reality (curl the URL, don't trust "Application started")
+- **Always** check DB connectivity before declaring backend OK (port binding ≠ application healthy). A 401/403 on `/api/navigation/menu` proves routing + DB are up.
+- **Always** check `VITE_API_URL` is reachable before declaring frontend OK. Vite returns 200 on `/` even when its API backend is dead.
+- **Fail fast**: if the same error repeats 2x, stop retrying

package/templates/skills/development/run/backend/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: run-backend
+description: Kill stale .Api processes, launch dotnet run, verify /health — retry loop
+group: RUN
+recommended_model: haiku
+allowed-tools: [Read, Glob, Grep, Bash]  # Bash: process management
+---
+
+# Skill: Run Backend — kill → launch → verify → retry
+
+## Inputs
+
+- Worktree cwd (you're already there)
+- AppCode: read from `src/*.Api.csproj` filename, or from `.smartstack/config.json`
+- Expected port: `--urls` arg OR 5142 default
+
+## Loop (max 3 attempts)
+
+```
+attempt = 1
+LOOP:
+  # ── 1. Kill stale processes ────────────────────
+  Get-Process | Where-Object { $_.Name -like '*.Api' -and $_.Path -like '*{worktree}*' } | Stop-Process -Force
+  # OR on Unix: pkill -f "{AppCode}.Api"
+  # OR generic: npx fkill-cli "{AppCode}.Api.exe" 2>/dev/null
+  Free port: netstat -ano | findstr :5142 → taskkill /PID <pid> /F
+
+  # ── 2. Build (fail fast) ───────────────────────
+  dotnet build --nologo --verbosity minimal src/{AppCode}.Api
+  IF exit != 0:
+    capture last 20 lines → stderr_summary
+    IF stderr_summary == prev_stderr_summary: break (non-transient, escalate)
+    attempt++ → CONTINUE LOOP
+  END
+
+  # ── 3. Launch ──────────────────────────────────
+  Spawn: dotnet run --no-build --no-launch-profile --urls http://localhost:5142 --project src/{AppCode}.Api
+  (spawn in background, capture stdout/stderr)
+
+  # ── 4. Wait + verify ──────────────────────────
+  FOR i in 1..15:   # 15 * 2s = 30s max
+    sleep 2s
+    response = curl -fsS http://localhost:5142/health || curl -fsS http://localhost:5142/
+    IF HTTP 2xx/4xx:
+      # ── 4b. DB connectivity check (port OK ≠ DB OK) ──
+      # Parse /health body for a DB/SqlServer entry. If the health payload
+      # exposes database status, require it to be "Healthy" before SUCCESS.
+      # If /health returns plain 200 with no body, probe an endpoint that
+      # requires DB (e.g. /api/navigation/menu returning 401 Unauthorized
+      # proves routing + DB up; 500 or ECONNREFUSED means DB dead).
+      nav_response = curl -s -o /dev/null -w "%{http_code}" http://localhost:5142/api/navigation/menu
+      IF nav_response in (200, 401, 403): return SUCCESS
+      IF nav_response == 500: continue (DB still warming up)
+    END
+  END
+
+  # ── 5. Post-mortem before retry ───────────────
+  Check if process still alive
+    IF dead: read last 30 lines of stdout → note the error
+    IF alive but port refused: Kestrel bound elsewhere → check logs for "Now listening on:"
+  attempt++
+END LOOP
+
+IF attempt > 3: FAIL with summary of what was tried
+```
+
+## Recognized transient errors (auto-retry, no escalation)
+
+- `MSB3026: Impossible de copier ... locked by ...` → orphan not killed yet, wait 2s + retry
+- `bind: address already in use` → port conflict, kill occupant + retry
+- `A connection attempt failed because the connected party did not properly respond` (flaky SQL) → wait 3s + retry
+
+## Non-transient errors (stop + escalate)
+
+- `error CS\d+` with same code 2x in a row → compile error, escalate to `debug/backend`
+- `Microsoft.Data.SqlClient.SqlException: Login failed` → config issue, escalate
+- `System.Reflection.TargetInvocationException` → DI, escalate
+- `Unable to find package` → dependency problem, escalate
+
+## Output format (Haiku-friendly, concise)
+
+Success:
+```
+[backend] ✓ OK (port 5142, HTTP 200 in 6.2s, attempt 1)
+```
+
+Transient retry:
+```
+[backend] attempt 1: MSB3026 (DLLs locked), killed PID 7841
+[backend] attempt 2: ✓ OK (port 5142, attempt 2)
+```
+
+Escalation needed:
+```
+[backend] attempt 1: error CS0246 in UserService.cs:42 'IUserRepository' not found
+[backend] attempt 2: same CS0246 — non-transient
+[backend] ✗ FAIL. Run: claude -p "@.claude/skills/development/debug/backend/SKILL.md"
+```
+
+## Rules
+
+- **Kill before launch, always** — `--no-build` fails if DLLs are locked by orphans
+- **One command per step** — no shell piping spaghetti
+- **Report reality** — `curl` the URL, don't trust "Application started"
+- **No source modification** — escalate to debug for that
+- **Max 3 attempts** — budget strictly enforced

package/templates/skills/development/run/frontend/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: run-frontend
+description: Kill stale Vite, npm run dev, verify /, retry loop
+group: RUN
+recommended_model: haiku
+allowed-tools: [Read, Glob, Grep, Bash]  # Bash: process management
+---
+
+# Skill: Run Frontend — kill → launch → verify → retry
+
+## Inputs
+
+- Worktree cwd (you're there)
+- Web dir: `web/{appcode}-web/` (lowercase AppCode)
+- Expected port: from `vite.config.ts` server.port OR 3000 default
+- Expected API URL: from env `VITE_API_URL` OR http://localhost:5142
+
+## Loop (max 3 attempts)
+
+```
+attempt = 1
+LOOP:
+  cd web/{appcode}-web
+
+  # ── 1. Kill stale vite/node ──────────────────
+  Get-Process | Where-Object { $_.CommandLine -like '*vite*' -and $_.Path -like '*{worktree}*' } | Stop-Process -Force
+  # OR Unix: pkill -f "vite.*{worktree}"
+  Free port: netstat -ano | findstr :3000 → taskkill /PID <pid> /F
+
+  # ── 2. Ensure deps ───────────────────────────
+  IF NOT exists node_modules/:
+    npm install --silent
+    IF exit != 0: ESCALATE (npm install failed)
+  END
+
+  # ── 3. Ensure scaffold ───────────────────────
+  IF NOT exists index.html: ESCALATE (index.html missing, needs debug/frontend)
+  IF NOT exists src/main.tsx: ESCALATE (main.tsx missing)
+
+  # ── 4. Launch ────────────────────────────────
+  # Validate VITE_API_URL points to a reachable backend BEFORE launching Vite,
+  # otherwise the UI will load but every API call will fail silently (500s).
+  VITE_API_URL ?= http://localhost:5142
+  api_probe = curl -s -o /dev/null -w "%{http_code}" $VITE_API_URL/health
+  IF api_probe not in (200, 204, 404):
+    WARN: "VITE_API_URL=$VITE_API_URL is unreachable (code $api_probe). Launching Vite anyway — expect broken UI."
+  END
+
+  Spawn: npm run dev -- --port 3000 --host localhost
+  Export VITE_API_URL=$VITE_API_URL in the env
+
+  # ── 5. Wait for "Local: http://localhost:PORT/" in stdout (max 20s) ──
+  FOR i in 1..10:
+    sleep 2s
+    grep "Local:\s*https?://localhost:\d+" stdout
+    IF match: real_port = extracted port → break loop
+    IF "ready in" AND no "Local:": real_port = 3000 (best guess) → break
+  END
+
+  IF no Vite ready after 20s:
+    capture stderr last 20 lines
+    IF same_as_prev: break (non-transient)
+    attempt++ → CONTINUE
+  END
+
+  # ── 6. Verify HTTP 200 on / ──────────────────
+  curl -fsS http://localhost:{real_port}/ > /dev/null
+  IF HTTP 200: return SUCCESS with port=real_port
+  IF HTTP 404:
+    Check: does index.html exist at root? → if not, ESCALATE
+    Check: does vite.config.ts have base != '/'? → report in output
+  IF ECONNREFUSED: retry (port probably still binding)
+END LOOP
+
+IF attempt > 3: FAIL with summary
+```
+
+## Recognized transient errors (auto-retry)
+
+- `Port 3000 is in use, trying another one...` → Vite auto-bumps, accept real_port from logs
+- `ECONNREFUSED` on first curl → Vite still binding, wait 2s + retry
+- `Cannot find module 'vite'` right after fresh clone → node_modules corrupted, `rm -rf node_modules && npm install`
+
+## Non-transient (escalate)
+
+- `index.html` missing at web root → `debug/frontend` can auto-repair
+- `SyntaxError` in main.tsx → config error, `debug/frontend`
+- `useLocation() may be used only...` → missing BrowserRouter, `debug/frontend`
+- `Cannot read properties of undefined (reading 'extensions')` → missing config prop, `debug/frontend`
+- `Failed to resolve import "..."` → missing dep, `debug/frontend`
+
+## Output format (concise)
+
+Success:
+```
+[frontend] ✓ OK (port 3000, HTTP 200, Vite ready in 680ms, attempt 1)
+```
+
+Port bump:
+```
+[frontend] attempt 1: port 3000 busy, Vite picked 3001 → ✓ OK on 3001
+```
+
+Escalation:
+```
+[frontend] attempt 1: index.html missing at web root
+[frontend] ✗ Non-transient. Run: claude -p "@.claude/skills/development/debug/frontend/SKILL.md"
+```
+
+## Rules
+
+- **Kill stale node processes** whose cwd matches the worktree (don't kill user's other Vite instances)
+- **Never touch index.html or main.tsx** — that's debug/'s job, escalate instead
+- **Read the real port from Vite's "Local:" line** — don't assume it's the one we requested
+- **VITE_API_URL matters** — pass it as env, don't put it in CLI args
+- Max 3 attempts — escalate after

package/templates/skills/development/smoke-test/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: smoke-test
+description: >
+  Runtime smoke-test for a freshly-generated SmartStack.app project. Starts
+  the backend (`dotnet run`) and the frontend (`npm run dev`) in the
+  background, waits for both to become reachable, then probes every page
+  route and every API endpoint scaffolded by the pipeline. Fails the run
+  if ANY endpoint returns a 4xx/5xx status code or if any page is missing
+  from disk. Designed to be the final gate of `ba-develop`
+  so cross-stack drift surfaces in CI rather than at the user's first
+  manual `npm run dev`.
+group: development
+cli: run-smoke
+mode: execute
+allowed-tools: [Read, Glob, Grep, Bash]  # Bash: CLI invocation
+---
+
+# smoke-test — Runtime gate for freshly-scaffolded projects
+
+## Why this skill exists
+
+`/ba-develop` currently builds (`dotnet build` + `npm run
+type-check`) and runs unit tests, but **never starts the application**.
+Static audits (`audit-dev-frontend`, `audit-pre-dev`) grep the generated
+sources for patterns ; they cannot tell you whether the running app
+serves the routes the frontend believes exist.
+
+The ba-002 (Budgets, 2026-05-10) regression exhibited four runtime
+failures that every existing gate missed :
+
+- `404 GET /api/budgets/dashboard/alerts` — frontend hook emitted, backend
+  endpoint not scaffolded (cross-stack drift)
+- `404 GET /api/budgets/dashboard/consolidated` — same drift
+- `405 POST /api/budgets/dashboard/budgets/{id}/export` — wrong verb on
+  the controller side
+- `400 GET /api/user/preferences/for-tenant/{guid}` — platform endpoint
+  contract drift, hidden by the absence of a runtime probe
+
+A single end-to-end smoke probe catches all four classes.
+
+## What this skill does
+
+It is invoked as the **last step** of `ba-develop`, after all
+scaffolders + audits have completed and before the orchestrator emits
+its « done » signal :
+
+1. Spawns the backend (`dotnet run --project <api-csproj>`) in the
+   background, waits for `GET /health` (or `/swagger/index.html` as
+   fallback) to return 200.
+2. Spawns the frontend (`npm run dev` — Vite) in the background, waits
+   for `GET /` to return 200 on the configured port (default `3000`).
+3. **Page probe** : for each `pageSpec.filePath` in the PRD slice,
+   derives the expected URL (`/{appCode}/{module}/{section}/...`) and
+   issues a `GET`. Fail if status ≠ 200.
+4. **API probe** : extracts every URL referenced inside the generated
+   `src/services/api/*.ts` and `src/hooks/use*.ts` files (the canonical
+   set of endpoints the frontend will hit). Issues a `GET` (with
+   sensible header defaults) and fails on any 4xx/5xx.
+5. Tears down both processes ; emits the standard `executeEnvelope`
+   with a structured `report` summarising probed routes, statuses,
+   and timings.
+
+## How to invoke
+
+```
+npx tsx skills/development/smoke-test/cli/run-smoke/index.ts \
+  --project-path <path-to-feature-folder> \
+  --prd-slice <path-to-prd-slice.frontend.json> \
+  [--backend-port 5000] [--frontend-port 3000] [--timeout-ms 60000]
+```
+
+The CLI exits with a non-zero status (and emits `success=false` in the
+envelope) on the FIRST endpoint that fails its probe, after best-effort
+teardown of the two background processes.
+
+## What it does NOT do (v1 scope)
+
+- **No browser test** (Playwright / headless Chromium) — the v1 probes
+  HTTP only. The v2 milestone adds a browser navigation pass that
+  captures `console.error` events.
+- **No load test** — single GET per endpoint, no concurrency.
+- **No auth flow** — uses anonymous probing ; endpoints requiring login
+  are flagged as `skipped` in the report (not failed). v2 may inject
+  a test JWT.
+- **No data assertion** — only status codes are checked. The aim is to
+  catch missing endpoints (404), wrong verbs (405) and broken contracts
+  (400/500) — not to validate response shapes.
+
+## Wiring as the final gate of ba-develop
+
+The orchestrator MUST invoke this skill as its last step. If the smoke
+test fails, the orchestrator **must not signal « done »** ; instead it
+should surface the failing endpoints to the user and route to the
+relevant fix-skill (controller for 404 on a missing backend endpoint,
+frontend-component for a misnamed hook URL, etc.).
+
+The skill's envelope `report.failures[]` carries enough metadata
+(`endpoint`, `verb`, `status`, `expectedBy`) for a programmatic
+dispatcher to fan out the corrections without re-asking Claude.