karajan-code 2.18.0 → 2.18.1

package/README.md

@@ -23,7 +23,9 @@
 
 ---
 
-> **v2.18.0 released** — Minor. Closes the **resilience audit** triggered by the public launch: 15 PRs across 5 phases hardening Karajan against the silent-failure family of bugs — *the problem is not that something fails, the problem is failing without telling the user why.* **Phase 1 — hibernation end to end** (#756–#759): a quota cap is classified as a recoverable quota class (incl. Claude Code's `"You've hit your session limit · resets 10:10pm"`); `withBrainRecovery` persists a standby JSON; the orchestrator consumes `action:"hibernate"`, seals the session `hibernated` (resumable) instead of `failed`; the last line printed is the exact resume command (`kj standby resume <id>`). **Phase 2 — don't lie** (#761–#763): `runCommand` surfaces ENOENT so a missing agent CLI gets an actionable error (not an empty one); `silenceTimeoutMs` is forwarded to every role so a hung agent is killed, not waited on forever; all 6 state-file writers go through `writeJsonAtomic` (write-temp + rename) — interrupted writes can no longer truncate plans, sessions, standby snapshots. **Phase 3 — don't lose or block** (#764–#767): a corrupt plan JSON is renamed aside with a loud warn (was silently dropped from `kj plan list`); `kj.config.yml` parse errors throw `Invalid YAML in <path>` (used to brick every kj command including `kj doctor`); `injectLoadedPlan` reconciles HUs left in `coding`/`reviewing`/`running` by a killed `kj run` (cross-checked against the run-registry); board SQLite gets `busy_timeout`, a `user_version` schema gate and corruption recovery. **Phase 4 — don't degrade silently** (#768–#769): `TriageRole` warns loudly when LLM output is unparseable (used to skip researcher/architect/security/tester with a chirpy "fallback defaults" summary); `verifyCoderOutput` distinguishes a git failure from "the coder did nothing" (`gitError` + `retryStrategy: null`) — no more iterations blaming the agent for infra. **Phase 5 — safety net** (#770): a `tests/resilience/` suite indexes every silent-failure mode and pins each one with a test, plus an end-to-end tripwire for the whole quota → hibernate → resume flow. Plus CI runs the `packages/hu-board` suite on every PR (#755). 4 959/4 959 tests passing across 416 files. Safe upgrade from 2.17.2.
+> **v2.18.1 released** — Patch. Six user-feedback follow-ups to v2.18.0: **`kj-tail` after `kj resume`** (#772, was silent because `resume.js` skipped `withCliRunLog`); **standby waits in-process instead of exiting on a short cooldown** (#773, kj stays alive for waits ≤ 12 h and retries on its own; Ctrl+C during the wait prints `kj standby resume <id>`); **closed KJC-BUG-0040 — SEA linux binaries** (#774, was a race between `gh release create` and softprops, not `better-sqlite3` as the memory said — 60 s poll fix + `make_latest:false`); **stack bias — Python repos no longer get vitest** (#775 + #776 + #777, `detectProjectStack` finally cabled into the coder prompt, the HU auto-generator templates by language, and the synthesizer + `auto-hu-batch` take the stack from the filesystem). 4 971/4 971 tests passing across 416 files. Safe upgrade from 2.18.0.
+>
+> **v2.18.0** — Minor. Closes the **resilience audit** triggered by the public launch: 15 PRs across 5 phases hardening Karajan against the silent-failure family of bugs — *the problem is not that something fails, the problem is failing without telling the user why.* **Phase 1 — hibernation end to end** (#756–#759): a quota cap is classified as a recoverable quota class (incl. Claude Code's `"You've hit your session limit · resets 10:10pm"`); `withBrainRecovery` persists a standby JSON; the orchestrator consumes `action:"hibernate"`, seals the session `hibernated` (resumable) instead of `failed`; the last line printed is the exact resume command (`kj standby resume <id>`). **Phase 2 — don't lie** (#761–#763): `runCommand` surfaces ENOENT so a missing agent CLI gets an actionable error (not an empty one); `silenceTimeoutMs` is forwarded to every role so a hung agent is killed, not waited on forever; all 6 state-file writers go through `writeJsonAtomic` (write-temp + rename) — interrupted writes can no longer truncate plans, sessions, standby snapshots. **Phase 3 — don't lose or block** (#764–#767): a corrupt plan JSON is renamed aside with a loud warn (was silently dropped from `kj plan list`); `kj.config.yml` parse errors throw `Invalid YAML in <path>` (used to brick every kj command including `kj doctor`); `injectLoadedPlan` reconciles HUs left in `coding`/`reviewing`/`running` by a killed `kj run` (cross-checked against the run-registry); board SQLite gets `busy_timeout`, a `user_version` schema gate and corruption recovery. **Phase 4 — don't degrade silently** (#768–#769): `TriageRole` warns loudly when LLM output is unparseable (used to skip researcher/architect/security/tester with a chirpy "fallback defaults" summary); `verifyCoderOutput` distinguishes a git failure from "the coder did nothing" (`gitError` + `retryStrategy: null`) — no more iterations blaming the agent for infra. **Phase 5 — safety net** (#770): a `tests/resilience/` suite indexes every silent-failure mode and pins each one with a test, plus an end-to-end tripwire for the whole quota → hibernate → resume flow. Plus CI runs the `packages/hu-board` suite on every PR (#755). 4 959/4 959 tests passing across 416 files. Safe upgrade from 2.17.2.
 >
 > **v2.17.2** — Patch. Wires quota-exhaustion **hibernation end to end**. A `kj run` / `kj plan` that hits a provider session or usage cap used to abort the task with an opaque `UNKNOWN_FATAL`; now it suspends and tells you how to resume. **Session-limit classification (#756)**: `"You've hit your session limit · resets 10:10pm"` matched no rate-limit pattern → `session limit`/`weekly limit` added, and `parseCooldown` learns the 12-hour `resets 10:10pm` clock. **Hibernation persists (#757)**: `withBrainRecovery` only wrote `~/.kj/standby/<id>.json` with a `sessionState`, which no caller passed — new `buildStandbyState()` assembles it with an allowlisted env subset (never the full `process.env`). **Orchestrator consumes `action:"hibernate"` (#758)**: no code checked for it, so a hibernation sealed the HU `failed`; the coder/refactorer stages now stop cleanly and the session is sealed `hibernated` (resumable). **Resume hint (#759)**: a stopped run's last line is now the exact command — `kj standby resume <id>` for a hibernation, `kj resume <id>` otherwise. Plus CI now runs the `packages/hu-board` suite (#755). 4 931/4 931 tests passing across 410 files. Safe upgrade from 2.17.1.
 >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "2.18.0",
+  "version": "2.18.1",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",

package/src/brain/with-brain-recovery.js

@@ -7,7 +7,7 @@
 // puede ignorarlo (fallback a long standby capped) hasta que llegue 0414.
 
 import { classifyAgentError, ERROR_CLASS } from "./agent-error-classifier.js";
-import { persistStandby } from "./standby-store.js";
+import { persistStandby, markStandbyDone } from "./standby-store.js";
 
 const ONE_MIN = 60 * 1000;
 
@@ -20,6 +20,13 @@ export const DEFAULT_RECOVERY_POLICY = Object.freeze({
   // KJC-TSK-0415: threshold de fallback. Si retryAfter > esto Y el role
   // tiene fallback configurado → switch provider en vez de hibernar.
   fallbackWaitHoursDefault: DEFAULT_FALLBACK_WAIT_HOURS,
+  // Standby-in-process: when the cooldown is short enough we keep the
+  // process alive and `await sleepFn(retryAfter)`, then retry the
+  // agent. The user sees nothing terminal — kj just pauses. A SIGINT /
+  // SIGTERM during the wait prints `kj standby resume <id>` and exits
+  // cleanly. For waits longer than this the process exits straight
+  // away (a multi-day weekly cap is not worth keeping kj running).
+  standbyWaitHoursMax: DEFAULT_FALLBACK_WAIT_HOURS,
   classes: {
     [ERROR_CLASS.RATE_LIMIT_SHORT]: { mode: "standby", maxRetries: 3 },
     [ERROR_CLASS.QUOTA_EXHAUSTED_DAILY]: { mode: "hibernate", maxRetries: 1, fallbackEligible: true },
@@ -132,10 +139,15 @@ export async function withBrainRecovery({
       }
     }
 
-    // HIBERNATE: persistir + signal action=hibernate al caller.
-    // Si el caller pasó `sessionState` (TSK-0414 PR2), persistimos el JSON
-    // automáticamente en ~/.kj/standby/<sessionId>.json. Caller decide qué
-    // hacer con action=hibernate (típicamente exit 0 para liberar memoria).
+    // HIBERNATE: the cooldown is too long for a short standby. Persist
+    // the snapshot first so a SIGINT / SIGTERM during the wait leaves a
+    // recoverable session on disk. Then either:
+    //   (a) wait in-process until cooldownUntil and retry (the common
+    //       case — daily quotas reset in a few hours), or
+    //   (b) when the wait would exceed `standbyWaitHoursMax`, return
+    //       action="hibernate" so the caller exits and the user
+    //       resumes later with `kj standby resume <id>` (weekly /
+    //       monthly caps).
     if (classPolicy.mode === "hibernate" && cls.retryAfter && cls.retryAfter > policy.hibernateThresholdMs) {
       let standbyFile = null;
       if (sessionState && sessionState.sessionId) {
@@ -147,13 +159,58 @@ export async function withBrainRecovery({
             role, provider: effectiveProvider,
             classifierMessage: cls.message,
           });
-          logger?.info?.(`[brain] hibernated session ${sessionState.sessionId} → ${standbyFile} (resume at ${cls.retryUntil})`);
         } catch (err) {
           logger?.warn?.(`[brain] failed to persist standby: ${err.message}`);
         }
       }
-      emit(emitter, "brain:hibernate-request", eventBase, { role, class: cls.class, retryUntil: cls.retryUntil, retryAfter: cls.retryAfter, standbyFile });
-      return { ok: false, action: "hibernate", recovery: cls, standbyFile };
+
+      const maxWaitMs = (policy.standbyWaitHoursMax ?? DEFAULT_FALLBACK_WAIT_HOURS) * ONE_HOUR;
+      const tooLongToWait = cls.retryAfter > maxWaitMs;
+
+      if (tooLongToWait) {
+        logger?.info?.(`[brain] hibernated session ${sessionState?.sessionId ?? "(no id)"} → ${standbyFile} (resume at ${cls.retryUntil}; wait > ${Math.round(maxWaitMs/ONE_HOUR)}h, exiting)`);
+        emit(emitter, "brain:hibernate-request", eventBase, { role, class: cls.class, retryUntil: cls.retryUntil, retryAfter: cls.retryAfter, standbyFile });
+        return { ok: false, action: "hibernate", recovery: cls, standbyFile };
+      }
+
+      // Standby-in-process: keep kj alive, sleep until the cooldown,
+      // then retry. A SIGINT / SIGTERM during the wait prints the
+      // resume command and exits — the standby JSON is already on
+      // disk so the user can pick it up later.
+      const sid = sessionState?.sessionId ?? null;
+      const onSignal = (signal) => {
+        // eslint-disable-next-line no-console
+        console.log(`\n⏸  Standby interrupted (${signal}). Resume with:`);
+        // eslint-disable-next-line no-console
+        if (sid) console.log(`     kj standby resume ${sid}`);
+        // eslint-disable-next-line no-console
+        else console.log(`     kj standby list   (no session id was assigned)`);
+        process.exit(signal === "SIGINT" ? 130 : 143);
+      };
+      const detach = () => {
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+      };
+      process.once("SIGINT", onSignal);
+      process.once("SIGTERM", onSignal);
+
+      const hours = Math.round((cls.retryAfter / ONE_HOUR) * 10) / 10;
+      logger?.info?.(`[brain] ${role}: standby for ~${hours}h until ${cls.retryUntil} (Ctrl+C to detach; will resume with 'kj standby resume ${sid}').`);
+      emit(emitter, "brain:standby-wait", eventBase, { role, class: cls.class, waitMs: cls.retryAfter, retryUntil: cls.retryUntil, standbyFile });
+
+      try {
+        await sleepFn(cls.retryAfter);
+      } finally {
+        detach();
+      }
+
+      // Wait finished without an interrupt — mark the standby JSON
+      // done so it does not auto-resume from disk later.
+      if (sid) {
+        try { markStandbyDone(sid); } catch { /* ignore */ }
+      }
+      emit(emitter, "brain:standby-resumed", eventBase, { role, class: cls.class });
+      continue;
     }
 
     // STANDBY: espera hasta cooldownUntil (capado por longStandbyCapMs).

package/src/commands/resume.js

@@ -3,6 +3,8 @@ import readline from "node:readline";
 import { resumeFlow } from "../orchestrator.js";
 import { createActivityLog } from "../activity-log.js";
 import { printEvent } from "../utils/display/event-handlers.js";
+import { withCliRunLog } from "../utils/cli-run-log.js";
+import { registerRun, unregisterRun } from "../utils/run-registry.js";
 
 function createCliAskQuestion(opts = {}) {
   const { sessionId = null } = opts;
@@ -51,36 +53,55 @@ export async function resumeCommand({ sessionId, answer, config, logger, flags }
   const jsonMode = flags?.json;
   const quietMode = config.output?.quiet !== false;
 
-  const emitter = new EventEmitter();
-  let activityLog = null;
+  // Same wrapper as every other CLI command — without it `.kj/run.log`
+  // is never opened during the resume and `kj-tail` stays silent
+  // (every line of the resumed run goes only to the per-session
+  // activity log + the local console). Also registers the run so the
+  // HU Board shows it as live and can offer its Stop button.
+  return withCliRunLog("resume", { projectDir: config?.projectDir, logger }, async ({ forwardProgress }) => {
+    const runId = registerRun({
+      pid: process.pid,
+      planId: flags?.plan || null,
+      huIds: null,
+      projectDir: config?.projectDir || process.cwd(),
+      source: "cli-resume",
+    });
+    const cleanupRegistry = () => { if (runId) unregisterRun(runId); };
+    process.once("exit", cleanupRegistry);
+    process.once("SIGTERM", () => { cleanupRegistry(); process.exit(143); });
+    process.once("SIGINT", () => { cleanupRegistry(); process.exit(130); });
 
-  emitter.on("progress", (event) => {
-    if (!activityLog && event.sessionId) {
-      activityLog = createActivityLog(event.sessionId);
-      logger.onLog((entry) => activityLog.write(entry));
-    }
+    const emitter = new EventEmitter();
+    let activityLog = null;
+    forwardProgress(emitter);
 
-    if (activityLog) {
-      activityLog.writeEvent(event);
-    }
+    emitter.on("progress", (event) => {
+      if (!activityLog && event.sessionId) {
+        activityLog = createActivityLog(event.sessionId);
+        logger.onLog((entry) => activityLog.write(entry));
+      }
+      if (activityLog) {
+        activityLog.writeEvent(event);
+      }
+      if (!jsonMode) {
+        printEvent(event, { quiet: quietMode });
+      }
+    });
 
-    if (!jsonMode) {
-      printEvent(event, { quiet: quietMode });
-    }
-  });
+    const askQuestion = createCliAskQuestion();
+    const result = await resumeFlow({
+      sessionId,
+      answer: answer || null,
+      config,
+      logger,
+      flags: flags || {},
+      emitter,
+      askQuestion
+    });
 
-  const askQuestion = createCliAskQuestion();
-  const result = await resumeFlow({
-    sessionId,
-    answer: answer || null,
-    config,
-    logger,
-    flags: flags || {},
-    emitter,
-    askQuestion
+    if (jsonMode || !answer) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return result;
   });
-
-  if (jsonMode || !answer) {
-    console.log(JSON.stringify(result, null, 2));
-  }
 }

package/src/hu/auto-generator.js

@@ -66,64 +66,191 @@ export function needsSetupHu({ isNewProject = false, stackHints = [], subtasks =
   return subtasks.some(s => setupKeywords.test(s));
 }
 
+// Stack-hint keyword sets. Used by filterConflictingHints (drop hints
+// from other ecosystems once one is detected) and by
+// resolveLanguageFromHints (pick the canonical language for setup +
+// acceptance_tests templates).
+const HINT_NODE = new Set(["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces"]);
+const HINT_PYTHON = new Set(["pytest", "flask", "fastapi", "django", "numpy", "pandas"]);
+const HINT_GO = new Set(["gin", "fiber", "go"]);
+const HINT_RUST = new Set(["cargo", "rust"]);
+
 /**
- * Filter conflicting stack hints. When Node.js ecosystem keywords are present,
- * remove Go/Rust/Python keywords that were detected from gitignore patterns
- * but aren't actually part of the task.
+ * Drop hints from OTHER ecosystems when one is clearly the project's.
+ * Symmetric: previously only node-vs-go was filtered, so a Python
+ * project that also had "vitest" in a stale gitignore would still
+ * receive vitest in its setup HU.
  */
 function filterConflictingHints(hints) {
   if (!hints || hints.length === 0) return hints;
-  const nodeEcosystem = new Set(["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces"]);
-  const goKeywords = new Set(["gin", "fiber", "go"]);
-  const hasNode = hints.some(h => nodeEcosystem.has(h));
-  if (!hasNode) return hints;
-  return hints.filter(h => !goKeywords.has(h));
+  const setForEachLang = [
+    ["python", HINT_PYTHON],
+    ["go", HINT_GO],
+    ["rust", HINT_RUST],
+    ["node", HINT_NODE],
+  ];
+  const present = setForEachLang.filter(([, set]) => hints.some((h) => set.has(h)));
+  if (present.length <= 1) return hints;
+  // First ecosystem found in the original hints order wins. We keep
+  // ambiguous keywords (those not in any set) and the winner's own
+  // keywords; we drop the explicit losers from competing ecosystems.
+  const winnerSet = present[0][1];
+  const losers = present.slice(1).flatMap(([, s]) => [...s]);
+  return hints.filter((h) => winnerSet.has(h) || !losers.includes(h));
+}
+
+/**
+ * Pick the canonical language for setup + acceptance_test templates
+ * based on the (already filtered) stack hints. Falls back to
+ * javascript so existing Node-centric runs keep their previous shape.
+ * @param {string[]} hints
+ * @returns {"python"|"go"|"rust"|"javascript"}
+ */
+export function resolveLanguageFromHints(hints) {
+  if (!hints || hints.length === 0) return "javascript";
+  if (hints.some((h) => HINT_PYTHON.has(h))) return "python";
+  if (hints.some((h) => HINT_GO.has(h))) return "go";
+  if (hints.some((h) => HINT_RUST.has(h))) return "rust";
+  return "javascript";
+}
+
+// HU templates per language. The JS template is the legacy default;
+// the others were missing — every autogenerated HU got vitest /
+// npm-install hardcoded acceptance_tests regardless of stack.
+const HU_TEMPLATES = {
+  javascript: {
+    pkgManager: "npm",
+    setupBullets: [
+      "- Create package.json (with workspaces if monorepo detected from stack hints)",
+      "- Install all runtime + dev dependencies listed in stack hints",
+      "- Install test framework WITH coverage reporter (e.g. vitest + @vitest/coverage-v8)",
+      "- Configure vitest.config.js with coverage.enabled = true",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "npm install succeeds without errors",
+      "npm test runs without error",
+      "npm run test:coverage runs without error",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "npm install --ignore-scripts 2>&1 && echo PASS || echo FAIL",
+      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
+    ],
+  },
+  python: {
+    pkgManager: "pip",
+    setupBullets: [
+      "- Create pyproject.toml (preferred) or requirements.txt",
+      "- Create a virtual env: python -m venv .venv",
+      "- Install runtime + dev dependencies (pip install -e . or pip install -r requirements.txt)",
+      "- Install pytest with coverage (pip install pytest pytest-cov)",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "Project metadata file exists (pyproject.toml or requirements.txt)",
+      "pytest runs without error",
+      "pytest --cov reports a total",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "(test -f pyproject.toml || test -f requirements.txt) && echo PASS || echo FAIL",
+      "python -m pytest 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "python -m pytest --cov 2>&1 | grep -q 'TOTAL\\|coverage' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "python -m pytest 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "python -m pytest --cov 2>&1 | grep -q 'TOTAL\\|coverage' && echo PASS || echo FAIL",
+    ],
+  },
+  go: {
+    pkgManager: "go",
+    setupBullets: [
+      "- Create go.mod with `go mod init <module>`",
+      "- Install dependencies with `go get` per import",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "go.mod exists",
+      "go test ./... runs without error",
+      "go test -cover reports coverage",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "test -f go.mod && echo PASS || echo FAIL",
+      "go test ./... 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "go test -cover ./... 2>&1 | grep -q 'coverage:' && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "go test ./... 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+    ],
+  },
+  rust: {
+    pkgManager: "cargo",
+    setupBullets: [
+      "- Initialise the crate with `cargo init`",
+      "- Add dependencies with `cargo add`",
+      "- Create .env.example with placeholder variables",
+    ],
+    setupCriteria: [
+      "Cargo.toml exists",
+      "cargo test runs without error",
+      ".env.example exists",
+    ],
+    setupTests: [
+      "test -f Cargo.toml && echo PASS || echo FAIL",
+      "cargo test 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+      "test -f .env.example && echo PASS || echo FAIL",
+    ],
+    taskTests: [
+      "cargo test 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
+    ],
+  },
+};
+
+function templateFor(language) {
+  return HU_TEMPLATES[language] || HU_TEMPLATES.javascript;
 }
 
 /**
  * Build a MINIMAL setup HU — project structure + deps only.
  * NEVER includes the full original task. The coder must only do setup.
  */
-function buildSetupHu({ stackHints }) {
+function buildSetupHu({ stackHints, language = "javascript" }) {
+  const tpl = templateFor(language);
   const deps = stackHints.length > 0
     ? stackHints.map(h => `- ${h}`).join("\n")
     : "- (auto-detect from subsequent HUs)";
   const certifiedText = [
-    "**Setup: initialize project structure and install dependencies.**",
+    `**Setup: initialise the ${language} project + install dependencies (package manager: ${tpl.pkgManager}).**`,
     "",
     "SCOPE (do ONLY this, nothing else):",
-    "- Create package.json (with workspaces if monorepo detected from stack hints)",
-    "- Install all runtime + dev dependencies listed in stack hints",
-    "- Install test framework WITH coverage reporter (e.g. vitest + @vitest/coverage-v8)",
-    "- Configure vitest.config.js with coverage.enabled = true",
-    "- Create .env.example with placeholder variables",
+    ...tpl.setupBullets,
     "- Verify by running each acceptance_test command below",
     "",
     "DO NOT implement any business logic, API routes, components, or features.",
     "This HU is ONLY project scaffolding.",
     "",
     "Stack hints:",
-    deps
+    deps,
   ].join("\n");
   return {
     id: "HU-01",
-    title: "Setup: project structure + dependencies",
+    title: `Setup: ${language} project structure + dependencies`,
     task_type: "infra",
     status: "certified",
     blocked_by: [],
     certified: { text: certifiedText },
-    acceptance_criteria: [
-      "npm install succeeds without errors",
-      "npm test runs without error",
-      "npm run test:coverage runs without error",
-      ".env.example exists"
-    ],
-    acceptance_tests: [
-      "npm install --ignore-scripts 2>&1 && echo PASS || echo FAIL",
-      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
-      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL",
-      "test -f .env.example && echo PASS || echo FAIL"
-    ]
+    acceptance_criteria: tpl.setupCriteria,
+    acceptance_tests: tpl.setupTests,
   };
 }
 
@@ -131,8 +258,9 @@ function buildSetupHu({ stackHints }) {
  * Build a MINIMAL task HU — one specific, focused piece of work.
  * Includes a short goal reference (max 80 chars) NOT the full task.
  */
-function buildTaskHu({ id, subtask, projectName, blockedBy }) {
+function buildTaskHu({ id, subtask, projectName, blockedBy, language = "javascript" }) {
   const taskType = classifyTaskType(subtask);
+  const tpl = templateFor(language);
   const certifiedText = [
     `**${subtask}**`,
     "",
@@ -143,7 +271,7 @@ function buildTaskHu({ id, subtask, projectName, blockedBy }) {
     "- Add unit tests for the new code",
     "- Run ALL acceptance_tests listed below and ensure they pass",
     "- Do NOT touch code outside this subtask's scope",
-    "- Target: <200 lines changed (like an atomic PR)"
+    "- Target: <200 lines changed (like an atomic PR)",
   ].join("\n");
   return {
     id,
@@ -155,12 +283,9 @@ function buildTaskHu({ id, subtask, projectName, blockedBy }) {
     acceptance_criteria: [
       `${subtask} is implemented and working`,
       "Unit tests cover the new code",
-      "All acceptance_tests pass"
+      "All acceptance_tests pass",
     ],
-    acceptance_tests: [
-      "npx vitest run 2>&1; test $? -eq 0 && echo PASS || echo FAIL",
-      "npx vitest run --coverage 2>&1 | grep -q 'All files\\|% Stmts' && echo PASS || echo FAIL"
-    ]
+    acceptance_tests: tpl.taskTests,
   };
 }
 
@@ -182,7 +307,8 @@ export function generateHuBatch({
   stackHints = [],
   isNewProject = false,
   researcherContext = null,
-  architectContext = null
+  architectContext = null,
+  language = null,
 }) {
   if (!originalTask || typeof originalTask !== "string") {
     throw new Error("generateHuBatch: originalTask is required");
@@ -194,12 +320,17 @@ export function generateHuBatch({
   const stories = [];
   const filteredHints = filterConflictingHints(stackHints);
   const needsSetup = needsSetupHu({ isNewProject, stackHints: filteredHints, subtasks });
+  // Caller may pass a language explicitly (when it has a real
+  // detectProjectStack result from the filesystem); otherwise fall
+  // back to inferring from the hint keywords. Default 'javascript'
+  // matches the previous behaviour for Node-centric runs.
+  const resolvedLanguage = language || resolveLanguageFromHints(filteredHints);
   let nextId = 1;
 
   const projectName = deriveProjectName(originalTask);
 
   if (needsSetup) {
-    stories.push(buildSetupHu({ stackHints: filteredHints }));
+    stories.push(buildSetupHu({ stackHints: filteredHints, language: resolvedLanguage }));
     nextId = 2;
   }
 
@@ -211,7 +342,7 @@ export function generateHuBatch({
     const blockedBy = [];
     if (setupId) blockedBy.push(setupId);
     if (previousId && previousId !== setupId) blockedBy.push(previousId);
-    stories.push(buildTaskHu({ id, subtask, projectName, blockedBy }));
+    stories.push(buildTaskHu({ id, subtask, projectName, blockedBy, language: resolvedLanguage }));
     previousId = id;
     nextId += 1;
   }

package/src/orchestrator/drivers/pre-loop-phases/auto-hu-batch.js

@@ -16,6 +16,7 @@
  */
 
 import { emitProgress, makeEvent } from "#utils/events.js";
+import { detectProjectStack } from "#utils/stack-detect.js";
 
 export async function maybeGenerateAutoHuBatch({
   flags, stageResults, task, logger, emitter, eventBase, projectDir, session,
@@ -40,19 +41,38 @@ export async function maybeGenerateAutoHuBatch({
     isNewProject = relevant.length === 0;
   } catch { /* ignore */ }
 
-  // Extract stack hints from planner + architect output
+  // Stack hints from planner + architect text. Now multi-ecosystem
+  // (was 13/16 JS keywords — Python/Go/Rust barely existed). Combined
+  // with `detectProjectStack(projectDir)` below to override the text
+  // heuristic with the actual filesystem reality when available.
   const stackHints = [];
   const combined = `${stageResults.planner?.plan || ""} ${stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : ""} ${task}`.toLowerCase();
-  const stackKeywords = ["express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "fastapi", "django", "spring", "gin", "nestjs", "monorepo", "workspaces"];
+  const stackKeywords = [
+    "express", "vite", "vitest", "jest", "next", "astro", "react", "vue", "svelte", "nestjs", "monorepo", "workspaces",
+    "pytest", "flask", "fastapi", "django", "numpy", "pandas",
+    "gin", "fiber", "go",
+    "cargo", "rust",
+    "spring",
+  ];
   for (const kw of stackKeywords) {
     if (combined.includes(kw)) stackHints.push(kw);
   }
 
+  // Filesystem trumps text. detectProjectStack inspects package.json /
+  // pyproject.toml / go.mod / Cargo.toml, so a pure-python repo gets
+  // `language: "python"` regardless of what the task text says.
+  let detectedLanguage = null;
+  try {
+    const fsStack = await detectProjectStack(projectDir);
+    if (fsStack?.language) detectedLanguage = fsStack.language;
+  } catch { /* best-effort */ }
+
   const batch = generateHuBatch({
     originalTask: task,
     subtasks,
     stackHints,
     isNewProject,
+    language: detectedLanguage,
     researcherContext: stageResults.researcher?.summary || null,
     architectContext: stageResults.architect?.architecture ? JSON.stringify(stageResults.architect.architecture) : null
   });

package/src/plan/tests-synthesizer.js

@@ -33,7 +33,7 @@ import { withBrainRecovery } from "../brain/with-brain-recovery.js";
  * @param {Array<{ id: string, title?: string, scope?: string }>} args.husNeedingTests
  * @returns {string}
  */
-export function buildSynthesizerPrompt({ task, husNeedingTests }) {
+export function buildSynthesizerPrompt({ task, husNeedingTests, stack = null, testFramework = null }) {
   const lines = [
     "You previously generated an implementation plan for the task below, but some HUs were left without acceptance_tests.",
     "Your ONLY job in this call is to fill that gap.",
@@ -59,12 +59,22 @@ export function buildSynthesizerPrompt({ task, husNeedingTests }) {
     "- Tests must be writable BEFORE the HU is implemented (they should fail until done).",
     "- Return ONLY the JSON — no prose, no markdown fences around it.",
     "",
-    "## Task",
-    task,
-    "",
-    "## HUs that need acceptance_tests",
-    "",
   ];
+  // Stack-aware hint: tell the LLM what test framework / language to
+  // emit shell commands for. Without this it defaulted to vitest /
+  // npm even on Python / Go / Rust projects (sesgo-de-stack audit).
+  if (stack || testFramework) {
+    lines.push("## Project Stack — generate shell tests for THIS stack, not generic JS");
+    if (stack?.language) lines.push(`- Language: **${stack.language}**`);
+    if (stack?.frameworks?.length) lines.push(`- Frameworks: ${stack.frameworks.join(", ")}`);
+    if (testFramework?.hasTests && testFramework?.framework) {
+      lines.push(`- Test framework already in use: **${testFramework.framework}** — use it for the shell commands.`);
+    } else if (stack?.language && stack.language !== "javascript" && stack.language !== "typescript") {
+      lines.push(`- Use the canonical test runner for ${stack.language} (pytest / go test / cargo test / rspec). Do NOT emit vitest, jest, or npm commands.`);
+    }
+    lines.push("");
+  }
+  lines.push("## Task", task, "", "## HUs that need acceptance_tests", "");
   for (const hu of husNeedingTests) {
     lines.push(`### ${hu.id}: ${hu.title || ""}`);
     lines.push(hu.scope ? `Scope: ${hu.scope}` : "(no scope)");

package/src/prompts/coder.js

@@ -158,7 +158,28 @@ function renderReviewerFindingsSection(findings, huId) {
   ].join("\n");
 }
 
-export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en", provider = null, acceptanceTests = null, adrs = null, specSection = null, reviewerFindings = null, huId = null }) {
+// KJC sesgo-de-stack: Karajan used to default every prompt to JS/TS
+// (vitest, npm install, console.log, JSDoc, httpOnly cookies). When
+// the project is Python / Go / Rust / Ruby, that produced absurd
+// outputs (e.g. installing vitest in a pure-python repo to satisfy a
+// hardcoded `npx vitest run` acceptance test). When we know the
+// stack we tell the coder explicitly so it stops assuming.
+function buildStackSection({ stack, testFramework }) {
+  if (!stack && !testFramework) return null;
+  const lines = ["## Project Stack — match this, don't assume JavaScript"];
+  if (stack?.language) lines.push(`- Language: **${stack.language}**`);
+  if (stack?.frameworks?.length) lines.push(`- Frameworks: ${stack.frameworks.join(", ")}`);
+  if (testFramework?.hasTests && testFramework?.framework) {
+    lines.push(`- Test framework already in use: **${testFramework.framework}** (${testFramework.language || stack?.language || "unknown"}). Use it for new tests; do NOT add a JS test framework on top.`);
+  } else if (stack?.language && stack.language !== "javascript" && stack.language !== "typescript") {
+    lines.push(`- No test framework detected yet. Pick the canonical one for ${stack.language} (e.g. pytest for python, \`go test\` for go, \`cargo test\` for rust, rspec for ruby). Do NOT use vitest / jest / \`npm install\` in a non-JS project.`);
+  }
+  lines.push("");
+  lines.push("If an acceptance_test command on this HU points at a foreign framework (e.g. `npx vitest run` on a python project), REPLACE the command with the equivalent for the project's actual stack and use that to verify your work.");
+  return lines.join("\n");
+}
+
+export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSummary = null, coderRules = null, methodology = "tdd", serenaEnabled = false, rtkAvailable = false, deferredContext = null, productContext = null, domainContext = null, plan = null, projectDir = null, language = "en", provider = null, acceptanceTests = null, adrs = null, specSection = null, reviewerFindings = null, huId = null, stack = null, testFramework = null }) {
   const langInstruction = getLanguageInstruction(language);
   // KJC-BUG-0032 (PR-I): hard rule about file paths. Real bug: a HU
   // titled "Initialize project skeleton: create assistant/ directory…"
@@ -190,10 +211,12 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
     "Keep changes minimal and production-ready.",
     "Follow SOLID principles. Write small, focused functions (< 30 lines).",
     "Make atomic commits: 1 logical change = 1 commit. Keep PRs small and reviewable.",
-    "Security: use httpOnly cookies for auth tokens, validate all input, parameterize queries, never expose secrets.",
-    "No console.log — use a structured logger. No 'any' types — use JSDoc annotations.",
+    "Security: validate all input, parameterize queries, never expose secrets. Use the auth pattern that matches the stack (e.g. httpOnly cookies for web sessions).",
+    "Use the project's standard logger and type system (no console.log when a structured logger exists; use the project's type idiom — TS types, JSDoc, Python type hints, Go interfaces…).",
     SUBPROCESS_CONSTRAINTS
   ];
+  const stackRule = buildStackSection({ stack, testFramework });
+  if (stackRule) sections.push(stackRule);
   if (projectDirRule) sections.push(projectDirRule);
 
   if (serenaEnabled) {
@@ -268,7 +291,7 @@ export async function buildCoderPrompt({ task, reviewerFeedback = null, sonarSum
       "1. Find the relevant file(s) in the project",
       "2. Make the specific code change needed to resolve the issue",
       "3. If tests are missing, write them",
-      "4. If dependencies are needed, install them (npm install)",
+      "4. If dependencies are needed, install them with the project's package manager (npm install / pip install / go get / cargo add — pick the one that matches the stack above)",
       "5. Do NOT skip any issue — all must be resolved"
     );
   }

package/src/roles/coder-role.js

@@ -2,6 +2,8 @@ import { AgentRole } from "./agent-role.js";
 import { buildCoderPrompt } from "../prompts/coder.js";
 import { isHostAgent } from "../utils/agent-detect.js";
 import { HostAgent } from "../agents/host-agent.js";
+import { detectProjectStack } from "../utils/stack-detect.js";
+import { detectTestFramework } from "../utils/project-detect.js";
 
 export class CoderRole extends AgentRole {
   constructor(opts) {
@@ -54,6 +56,16 @@ export class CoderRole extends AgentRole {
   }
 
   async buildPrompt({ task, reviewerFeedback, sonarSummary, deferredContext, acceptanceTests, adrs, specSection, reviewerFindings, huId }) {
+    const projectDir = this.config?.projectDir || null;
+    // KJC sesgo-de-stack: pasar stack/testFramework al prompt para que
+    // el coder no asuma JS/vitest en proyectos Python / Go / Rust /
+    // Ruby. audit-role.js y tester-role.js ya lo hacen así.
+    let stack = null;
+    let testFramework = null;
+    if (projectDir) {
+      try { stack = await detectProjectStack(projectDir); } catch { /* best-effort */ }
+      try { testFramework = await detectTestFramework(projectDir); } catch { /* best-effort */ }
+    }
     const prompt = await buildCoderPrompt({
       task, reviewerFeedback, sonarSummary, deferredContext, acceptanceTests,
       adrs, specSection, reviewerFindings, huId,
@@ -63,7 +75,8 @@ export class CoderRole extends AgentRole {
       rtkAvailable: Boolean(this.config?.rtk?.available),
       productContext: this.config?.productContext || null,
       domainContext: this.config?.domainContext || null,
-      projectDir: this.config?.projectDir || null,
+      projectDir,
+      stack, testFramework,
       provider: this._resolvedProvider || (typeof this.resolveProvider === "function" ? this.resolveProvider() : null)
     });
     return { prompt };