karajan-code 2.17.1 → 2.18.1

package/src/plan/plan-store.js

@@ -7,7 +7,35 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
+import { writeJsonAtomic } from "../utils/atomic-write.js";
 import { generatePlanId, normaliseAlias } from "./plan-id.js";
+
+/**
+ * A plan JSON file failed to parse — typically an interrupted write
+ * leaves it truncated. Previously every read site swallowed this with
+ * a silent catch and the plan vanished from `kj plan list` and
+ * `kj plan load` as if it had never existed.
+ *
+ * Now: warn loudly so the user knows their plan is corrupt, and rename
+ * the file to `<name>.corrupt-<ts>` so it stops blocking subsequent
+ * reads of the same alias / planId (without destroying evidence).
+ * Best-effort: if the rename itself fails (read-only FS, permissions),
+ * we log and move on — never escalate to a throw, that would block the
+ * caller from reading the rest of the directory.
+ */
+async function handleCorruptPlanFile(filePath, error) {
+  const corruptPath = `${filePath}.corrupt-${Date.now()}`;
+  // eslint-disable-next-line no-console
+  console.warn(`[plan-store] Corrupt plan JSON at ${filePath}: ${error.message}`);
+  try {
+    await fs.rename(filePath, corruptPath);
+    // eslint-disable-next-line no-console
+    console.warn(`[plan-store] Renamed to ${path.basename(corruptPath)} so it stops blocking subsequent reads.`);
+  } catch (renameErr) {
+    // eslint-disable-next-line no-console
+    console.warn(`[plan-store] Could not rename ${filePath}: ${renameErr.message}`);
+  }
+}
 import { isPlanV2, migratePlanV1toV2 } from "./plan-schema.js";
 
 // Per-process tmp dir for VITEST runs that forget to set KJ_HOME. We
@@ -83,7 +111,7 @@ export async function savePlan(projectDir, planResult) {
     if (!planResult.alias && planResult.name) {
       planResult.alias = await resolveUniqueAlias(dir, planResult.planId, normaliseAlias(planResult.name));
     }
-    await fs.writeFile(filePath, JSON.stringify(planResult, null, 2), "utf8");
+    await writeJsonAtomic(filePath, planResult);
     return planResult.planId;
   }
 
@@ -100,7 +128,7 @@ export async function savePlan(projectDir, planResult) {
   };
 
   const filePath = path.join(dir, `${planId}.json`);
-  await fs.writeFile(filePath, JSON.stringify(record, null, 2), "utf8");
+  await writeJsonAtomic(filePath, record);
   return planId;
 }
 
@@ -119,11 +147,14 @@ async function resolveUniqueAlias(dir, ownPlanId, base) {
   const taken = new Set();
   for (const f of files) {
     if (!f.endsWith(".json")) continue;
+    const filePath = path.join(dir, f);
     try {
-      const record = JSON.parse(await fs.readFile(path.join(dir, f), "utf8"));
+      const record = JSON.parse(await fs.readFile(filePath, "utf8"));
       if (record.planId === ownPlanId) continue;
       if (record.alias) taken.add(record.alias);
-    } catch { /* skip corrupt */ }
+    } catch (err) {
+      if (err.code !== "ENOENT") await handleCorruptPlanFile(filePath, err);
+    }
   }
   if (!taken.has(base)) return base;
   for (let i = 2; i < 1000; i += 1) {
@@ -151,19 +182,28 @@ export async function loadPlan(projectDir, ref) {
     const plan = JSON.parse(data);
     if (!isPlanV2(plan)) return migratePlanV1toV2(plan);
     return plan;
-  } catch { /* fall through to alias scan */ }
+  } catch (err) {
+    // ENOENT is expected (caller may have passed an alias, not a planId)
+    // → fall through to the alias scan. Anything else means the file is
+    // there but unreadable / corrupt; surface it instead of silently
+    // hiding the plan.
+    if (err.code !== "ENOENT") await handleCorruptPlanFile(direct, err);
+  }
   // 2. Escaneo del dir por alias. Coste O(N) pero N suele ser <10.
   let files;
   try { files = await fs.readdir(dir); } catch { return null; }
   for (const f of files) {
     if (!f.endsWith(".json")) continue;
+    const filePath = path.join(dir, f);
     try {
-      const record = JSON.parse(await fs.readFile(path.join(dir, f), "utf8"));
+      const record = JSON.parse(await fs.readFile(filePath, "utf8"));
       if (record.alias === ref || record.planId === ref) {
         if (!isPlanV2(record)) return migratePlanV1toV2(record);
         return record;
       }
-    } catch { /* skip corrupt */ }
+    } catch (err) {
+      if (err.code !== "ENOENT") await handleCorruptPlanFile(filePath, err);
+    }
   }
   return null;
 }
@@ -197,8 +237,10 @@ export async function listPlans(projectDir) {
   const plans = [];
   for (const file of files) {
     if (!file.endsWith(".json")) continue;
+    if (file.includes(".corrupt-")) continue; // own renamed-aside files
+    const filePath = path.join(dir, file);
     try {
-      const data = await fs.readFile(path.join(dir, file), "utf8");
+      const data = await fs.readFile(filePath, "utf8");
       const record = JSON.parse(data);
       plans.push({
         planId: record.planId,
@@ -210,7 +252,9 @@ export async function listPlans(projectDir) {
         huCount: Array.isArray(record.hus) ? record.hus.length : 0,
         createdAt: record.createdAt
       });
-    } catch { /* skip corrupt */ }
+    } catch (err) {
+      if (err.code !== "ENOENT") await handleCorruptPlanFile(filePath, err);
+    }
   }
 
   plans.sort((a, b) => (b.createdAt || "").localeCompare(a.createdAt || ""));

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/agent-role.js

@@ -17,6 +17,19 @@ import { BaseRole } from "./base-role.js";
 import { createAgent as defaultCreateAgent } from "../agents/index.js";
 import { withBrainRecovery } from "../brain/with-brain-recovery.js";
 
+/**
+ * Silence timeout (ms) for an agent subprocess, from
+ * config.session.max_agent_silence_minutes. runCommand kills a child
+ * that produces no output for this long — without it a hung coder /
+ * reviewer leaves `kj run` waiting forever. Returns null when unset.
+ * @param {object} config
+ * @returns {number|null}
+ */
+export function resolveAgentSilenceTimeoutMs(config) {
+  const minutes = Number(config?.session?.max_agent_silence_minutes);
+  return Number.isFinite(minutes) && minutes > 0 ? Math.round(minutes * 60 * 1000) : null;
+}
+
 export class AgentRole extends BaseRole {
   constructor({ name, config, logger, emitter = null, createAgentFn = null }) {
     super({ name, config, logger, emitter });
@@ -116,6 +129,11 @@ export class AgentRole extends BaseRole {
 
     const runArgs = { prompt, role: this.name };
     if (onOutput) runArgs.onOutput = onOutput;
+    // Kill a hung agent: without a silence timeout a coder / reviewer
+    // that stalls with no output left `kj run` waiting indefinitely.
+    // PlannerRole set this itself; every other role was unprotected.
+    const silenceTimeoutMs = resolveAgentSilenceTimeoutMs(this.config);
+    if (silenceTimeoutMs) runArgs.silenceTimeoutMs = silenceTimeoutMs;
 
     // KJC-TSK-0413 step B: TODAS las roles que heredan de AgentRole pasan
     // por Brain Recovery aquí — cubre AuditRole, SecurityRole, HuReviewerRole,
@@ -130,13 +148,18 @@ export class AgentRole extends BaseRole {
       provider,
       emitter: this.emitter,
       logger: this.logger,
+      // KJC: sessionState lets withBrainRecovery persist a hibernating run
+      // to ~/.kj/standby/ so it can be resumed. Without it a quota-exhausted
+      // run had nothing to resume from. Caller (coder-stage etc.) passes it
+      // through the input object; extractInput forwards it via `...input`.
+      sessionState: extracted.sessionState || this.context?.sessionState || null,
     });
 
     if (!result.ok) {
       const recoveryNote = result.recovery?.class ? ` [${result.recovery.class}]` : "";
       return {
         ok: false,
-        result: { error: result.error || result.output || `${this.name} failed${recoveryNote}`, provider, recovery: result.recovery, action: result.action },
+        result: { error: result.error || result.output || `${this.name} failed${recoveryNote}`, provider, recovery: result.recovery, action: result.action, standbyFile: result.standbyFile || null },
         summary: `${this.name} failed${recoveryNote}: ${result.recovery?.message || result.error || "unknown error"}`,
         usage: result.usage
       };

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 };

package/src/roles/triage-role.js

@@ -61,20 +61,39 @@ export class TriageRole extends AgentRole {
   }
 
   handleParseNull(agentResult, provider) {
-    return {
-      ok: true,
-      result: { ...FALLBACK_RESULT, reasoning: "Unstructured output, using safe defaults.", provider, raw: agentResult.output },
-      summary: "Triage complete (fallback defaults)",
-      usage: agentResult.usage
-    };
+    return this.degradedTriageResult({
+      agentResult, provider,
+      reason: "parse-null",
+      reasoning: "Unstructured output, using safe defaults.",
+      message: "[triage] LLM output was unstructured — falling back to defaults; the pipeline may skip optional roles.",
+    });
+  }
+
+  handleParseError(err, agentResult, provider) {
+    return this.degradedTriageResult({
+      agentResult, provider,
+      reason: "parse-error",
+      reasoning: `Failed to parse triage output (${err?.message || "unknown error"}), using safe defaults.`,
+      message: `[triage] Could not parse LLM output — falling back to defaults: ${err?.message || "unknown"}.`,
+    });
   }
 
-  handleParseError(_err, agentResult, provider) {
+  // Triage degradation is what made a complex task quietly run as
+  // `level: "medium", roles: ["reviewer"]` — researcher / architect /
+  // security / tester silently skipped. The fallback is preserved so
+  // the pipeline still moves, but the user (and any board / kj-tail
+  // listener) now learns it happened. result.degraded = true lets
+  // downstream code react if it wants.
+  // Same shape as before so downstream cost / event accounting is
+  // byte-identical; the only change is the loud logger.warn, which is
+  // what makes the silent degradation visible to the user / kj-tail.
+  degradedTriageResult({ agentResult, provider, reason: _reason, reasoning, message }) {
+    this.logger?.warn?.(message);
     return {
       ok: true,
-      result: { ...FALLBACK_RESULT, reasoning: "Failed to parse triage output, using safe defaults.", provider, raw: agentResult.output },
+      result: { ...FALLBACK_RESULT, reasoning, provider, raw: agentResult.output },
       summary: "Triage complete (fallback defaults)",
-      usage: agentResult.usage
+      usage: agentResult.usage,
     };
   }
 }

package/src/session/store.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { ensureDir, exists } from "../utils/fs.js";
 import { getSessionRoot } from "../utils/paths.js";
+import { writeJsonAtomic } from "../utils/atomic-write.js";
 
 const SESSION_ROOT = getSessionRoot();
 
@@ -31,7 +32,7 @@ export async function saveSession(session) {
   const dir = path.join(SESSION_ROOT, session.id);
   await ensureDir(dir);
   session.updated_at = new Date().toISOString();
-  await fs.writeFile(path.join(dir, "session.json"), JSON.stringify(session, null, 2), "utf8");
+  await writeJsonAtomic(path.join(dir, "session.json"), session);
 }
 
 export async function loadSession(sessionId) {

package/src/utils/atomic-write.js

@@ -0,0 +1,43 @@
+// Atomic JSON writes for persistent state (resilience audit, Phase 2).
+//
+// A plain `writeFile(path, JSON.stringify(...))` truncates the live file
+// before the new content lands. If the process is killed mid-write
+// (SIGKILL, crash, power loss) the file is left truncated and the only
+// good copy is already gone — the plan / session / standby JSON
+// silently corrupts.
+//
+// write-temp + rename fixes it: `rename` is atomic on the same
+// filesystem, so a reader sees either the old file or the complete new
+// one, never a half-written one. The temp file sits next to the target
+// (same dir → same FS) and is uniquely named so concurrent writers do
+// not clobber each other's temp. A crash before the rename leaves an
+// orphan `.tmp` but never a corrupt target.
+
+import { writeFileSync, renameSync } from "node:fs";
+import { writeFile, rename } from "node:fs/promises";
+
+function tempPath(target) {
+  return `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+}
+
+/**
+ * Atomically write `obj` as pretty JSON to `target` (synchronous).
+ * @param {string} target - destination path; its directory must exist
+ * @param {unknown} obj
+ */
+export function writeJsonAtomicSync(target, obj) {
+  const tmp = tempPath(target);
+  writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf-8");
+  renameSync(tmp, target);
+}
+
+/**
+ * Atomically write `obj` as pretty JSON to `target` (async).
+ * @param {string} target - destination path; its directory must exist
+ * @param {unknown} obj
+ */
+export async function writeJsonAtomic(target, obj) {
+  const tmp = tempPath(target);
+  await writeFile(tmp, JSON.stringify(obj, null, 2), "utf-8");
+  await rename(tmp, target);
+}

package/src/utils/display/resume-hint.js

@@ -0,0 +1,41 @@
+/**
+ * Prints — as the LAST line of a stopped `kj run` / `kj plan` — the exact
+ * command to resume it. A halted run that never tells you how to restart
+ * it is the resilience gap this closes (resilience audit, Phase 1).
+ *
+ *   Quota hibernation → `kj standby resume <id>`
+ *   Solomon pause     → `kj resume <id> --answer "..."`
+ *   Stopped / failed  → `kj resume <id>`
+ *   Success           → nothing.
+ *
+ * @param {object} result          - the flow / command result
+ * @param {object} [opts]
+ * @param {(line:string)=>void} [opts.print] - sink, default console.log
+ */
+export function printResumeHint(result, { print = console.log } = {}) {
+  if (!result || typeof result !== "object") return;
+  const id = result.sessionId || result.session?.id || null;
+
+  if (result.hibernated === true) {
+    print("");
+    print("⏸  Run hibernated — provider quota exhausted.");
+    print(`   Resume when the quota resets:  kj standby resume ${id || "<session-id>"}`);
+    if (!id) print("   (run `kj standby list` to find the id)");
+    return;
+  }
+
+  if (result.paused === true && id) {
+    print("");
+    print("⏸  Run paused — waiting for your input.");
+    print(`   Resume:  kj resume ${id} --answer "<your answer>"`);
+    return;
+  }
+
+  // Stopped / failed / aborted but with a session on record → resumable.
+  // A successful run has approved === true and prints nothing.
+  if (id && result.approved !== true && result.paused !== true) {
+    print("");
+    print("✗  Run stopped before finishing.");
+    print(`   Resume:  kj resume ${id}`);
+  }
+}

package/src/utils/process.js

@@ -152,6 +152,24 @@ export async function runCommand(command, args = [], options = {}) {
 function enrichResult(result, stdoutAccum, _stderrAccum) {
   if (result.timedOut) return result;
 
+  // execa with reject:false RESOLVES (does not throw) on a spawn
+  // failure — ENOENT (binary not in PATH), EACCES, etc. The result
+  // then carries exitCode null/undefined, an empty stderr, and the
+  // real cause only in `code` / `shortMessage`. Surface it: a missing
+  // agent CLI used to fail with a completely empty error message,
+  // leaving the user with "coder failed" and no idea what to install.
+  if (result.failed && result.exitCode == null && !result.signal) {
+    const reason = result.shortMessage || result.message
+      || `spawn failed${result.code ? ` (${result.code})` : ""}`;
+    return {
+      ...result,
+      exitCode: 1,
+      stdout: result.stdout || stdoutAccum,
+      stderr: result.stderr || reason,
+      spawnError: result.code || true,
+    };
+  }
+
   const killed = result.killed || !!result.signal;
   const signal = result.signal || null;
 

package/src/utils/rate-limit-detector.js

@@ -39,6 +39,26 @@ export function parseCooldown(message) {
     }
   }
 
+  // 5. Claude Code session / weekly limit: "resets 10:10pm" / "resets 4am"
+  //    (12-hour clock, no date). Resolve to the next wall-clock occurrence
+  //    of that time in the machine's local timezone. Claude Code reports
+  //    the reset in the user's local TZ and kj runs on the same machine,
+  //    so the parenthesised "(Europe/Madrid)" hint is ignored on purpose.
+  const ampmMatch = /reset(?:s|ting)?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*([ap]m)\b/i.exec(
+    message
+  );
+  if (ampmMatch) {
+    let hour = Number.parseInt(ampmMatch[1], 10) % 12;
+    if (/pm/i.test(ampmMatch[3])) hour += 12;
+    const minute = ampmMatch[2] ? Number.parseInt(ampmMatch[2], 10) : 0;
+    if (hour < 24 && minute < 60) {
+      const target = new Date();
+      target.setHours(hour, minute, 0, 0);
+      if (target.getTime() <= Date.now()) target.setDate(target.getDate() + 1);
+      return { cooldownUntil: target.toISOString(), cooldownMs: target.getTime() - Date.now() };
+    }
+  }
+
   // 2. Relative seconds: "retry after 120 seconds" / "retry in 120s" / "Retry-After: 120"
   const secMatch = /(?:retry[\s-]*after|retry\s+in|wait)\s*:?\s*(\d+)\s*(?:seconds?|secs?|s\b)/i.exec(
     message
@@ -69,6 +89,8 @@ const RATE_LIMIT_PATTERNS = [
   { pattern: /usage limit/i, agent: "claude" },
   { pattern: /plan's usage limit/i, agent: "claude" },
   { pattern: /Claude Pro usage limit/i, agent: "claude" },
+  { pattern: /session limit/i, agent: "claude" },
+  { pattern: /weekly limit/i, agent: "claude" },
 
   // OpenAI / Codex CLI
   { pattern: /exceeded your current quota/i, agent: "codex" },

package/src/utils/run-registry.js

@@ -20,6 +20,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { writeJsonAtomicSync } from "./atomic-write.js";
 
 /**
  * Directorio raíz donde viven los registros de run.
@@ -54,7 +55,7 @@ export function registerRun(info = {}) {
       source: info.source || "cli",
       startedAt: new Date().toISOString(),
     };
-    fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf8");
+    writeJsonAtomicSync(filePath, entry);
     return runId;
   } catch {
     return null;