@wrongstack/tools 0.295.0 → 0.295.1

package/dist/auto-proceed-loop-guard.d.ts

@@ -86,6 +86,27 @@ export interface RepetitionSignal {
      */
     shouldHalt: boolean;
 }
+/**
+ * Steer text appended (once) to a grounded todo continuation when the board
+ * has not moved between two consecutive automatic turns. Grounded prompts are
+ * synthesized from durable todo state, so an identical re-feed means the whole
+ * previous turn produced zero board movement — usually the model worked but
+ * forgot to update the board. One explicit steer fixes that far more often
+ * than halting; the halt only fires if the board stays frozen AFTER the steer.
+ */
+export declare const GROUNDED_NO_PROGRESS_STEER: string;
+export type GroundedRepetitionAction = 'feed' | 'steer' | 'halt';
+export interface GroundedRepetitionSignal extends RepetitionSignal {
+    /**
+     * What the caller should do with this grounded (todo-sourced) prompt:
+     *   - `feed`  — no repetition; feed the prompt as-is.
+     *   - `steer` — first repetition; feed the prompt with
+     *     {@link GROUNDED_NO_PROGRESS_STEER} appended instead of halting.
+     *   - `halt`  — the board stayed frozen even after a steer; break the loop
+     *     exactly like a `shouldHalt` from {@link AutoProceedLoopGuard.record}.
+     */
+    action: GroundedRepetitionAction;
+}
 export interface AutoProceedLoopGuard {
     /**
      * Record a prompt that is about to be auto-fed. Returns the repetition
@@ -94,6 +115,16 @@ export interface AutoProceedLoopGuard {
      * the loop must be broken instead.
      */
     record(prompt: string): RepetitionSignal;
+    /**
+     * Record a GROUNDED prompt — one synthesized from durable state (the todo
+     * board) rather than echoed from model output. Repetition of a grounded
+     * prompt is a "no board progress" signal, not necessarily an echo loop, so
+     * the first repetition asks the caller to steer (append
+     * {@link GROUNDED_NO_PROGRESS_STEER} to the fed text) and only a repetition
+     * that survives the steer halts. The steer state resets whenever a
+     * different prompt is recorded (board moved) or on {@link reset}.
+     */
+    recordGrounded(prompt: string): GroundedRepetitionSignal;
     /**
      * Drop the history. Call this on any manual user input so a fresh run
      * starts with no memory of the prior cycle.

package/dist/auto-proceed-loop-guard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-proceed-loop-guard.d.ts","sourceRoot":"","sources":["../src/auto-proceed-loop-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACzC;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IACd;;;;OAIG;IACH,OAAO,IAAI,SAAS,MAAM,EAAE,CAAC;IAC7B;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,gBAAqB,GAAG,oBAAoB,CAmD/F"}
+{"version":3,"file":"auto-proceed-loop-guard.d.ts","sourceRoot":"","sources":["../src/auto-proceed-loop-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,QAO3B,CAAC;AAEb,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAChE;;;;;;;OAOG;IACH,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACzC;;;;;;;;OAQG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAAC;IACzD;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IACd;;;;OAIG;IACH,OAAO,IAAI,SAAS,MAAM,EAAE,CAAC;IAC7B;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,gBAAqB,GAAG,oBAAoB,CAqE/F"}

package/dist/auto-proceed-loop-guard.js

@@ -2,6 +2,14 @@
 function normalizeForRepetition(prompt) {
   return prompt.replace(/\s+/g, " ").trim().toLowerCase();
 }
+var GROUNDED_NO_PROGRESS_STEER = [
+  "NOTE: The todo board has not changed since the previous automatic continuation \u2014 this exact instruction is being repeated.",
+  "Before anything else, bring the board up to date so the loop stays grounded:",
+  "- mark work that is actually finished as completed,",
+  "- split the current item into smaller concrete sub-items if it needs more than one turn,",
+  "- remove or reword items that no longer apply.",
+  "Then continue the work. If you are blocked, state exactly what is blocking you instead of repeating the same turn."
+].join("\n");
 function createAutoProceedLoopGuard(options = {}) {
   const safeIntegerOption = (value, fallback) => {
     if (value === void 0) return fallback;
@@ -11,6 +19,7 @@ function createAutoProceedLoopGuard(options = {}) {
   const repeatThreshold = Math.max(2, safeIntegerOption(options.repeatThreshold, 2));
   const windowSize = Math.max(repeatThreshold, safeIntegerOption(options.windowSize, 3));
   let buffer = [];
+  let steeredFor = null;
   function record(prompt) {
     const normalized = normalizeForRepetition(prompt);
     buffer.push(normalized);
@@ -28,8 +37,21 @@ function createAutoProceedLoopGuard(options = {}) {
       shouldHalt: runLength >= repeatThreshold
     };
   }
+  function recordGrounded(prompt) {
+    const signal = record(prompt);
+    if (!signal.shouldHalt) {
+      steeredFor = null;
+      return { ...signal, shouldHalt: false, action: "feed" };
+    }
+    if (steeredFor === signal.normalized) {
+      return { ...signal, action: "halt" };
+    }
+    steeredFor = signal.normalized;
+    return { ...signal, shouldHalt: false, action: "steer" };
+  }
   function reset() {
     buffer = [];
+    steeredFor = null;
   }
   function history() {
     return buffer.slice();
@@ -37,9 +59,10 @@ function createAutoProceedLoopGuard(options = {}) {
   function size() {
     return buffer.length;
   }
-  return { record, reset, history, size };
+  return { record, recordGrounded, reset, history, size };
 }
 export {
+  GROUNDED_NO_PROGRESS_STEER,
   createAutoProceedLoopGuard,
   normalizeForRepetition
 };

package/dist/auto-proceed-loop-guard.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/auto-proceed-loop-guard.ts"],
-  "sourcesContent": ["/**\n * Auto-proceed loop guard.\n *\n * ## Problem\n *\n * The REPL and TUI both implement an \"auto\" autonomy mode that, after every\n * completed agent turn, feeds the next suggestion (or top auto=\"true\" item)\n * back as a fresh prompt. When the agent emits the same `<nextsteps>` block\n * on every reply \u2014 which happens whenever the model's output is stable but\n * autonomy treats the next step as \"still actionable\" \u2014 the loop self-feeds\n * the same instruction 2\u20133 times in a row before the longer\n * `autoProceedMaxIterations` cap (default 50) trips.\n *\n * The user reports the visible symptom: the same response, including the same\n * `<nextsteps>` block, repeats. Manual input from the user is the only thing\n * that breaks out. They suspect the next-steps mechanism is the source.\n *\n * The 50-iteration cap is intentionally loose \u2014 it is a runaway safety net,\n * not a UX signal. By the time it trips, the user has already watched the\n * same response 50 times.\n *\n * ## Approach\n *\n * A small, pure, browser-safe stateful helper that records the last few\n * prompts fed through the auto-proceed / auto-submit path. It normalizes\n * prompts (whitespace, casing) so trivial rewordings are not collapsed, but\n * identical re-feeds are. When the same normalized prompt is fed\n * `repeatThreshold` (default 2) times in a row, the guard returns\n * `{ shouldHalt: true }`.\n *\n * Callers are expected to:\n *   1. Call `record(prompt)` immediately before each auto-feed.\n *   2. If `shouldHalt` is true, clear the suggestion + auto-suggestion store,\n *      cancel any pending countdown, and surface a \"we detected a loop\"\n *      message asking the user what's happening. Do NOT feed the prompt.\n *   3. Call `reset()` whenever the user types anything manually (REPL manual\n *      input or any user-driven submit) so the next auto-feed starts clean.\n *\n * The default `repeatThreshold` is 2 \u2014 i.e. the second consecutive identical\n * feed (the first re-feed of an already-seen prompt) halts the loop. That\n * matches the user's report (\"receiving the same prompt 2-3 times in a row\n * causes the system to enter a loop\"). Setting it to 2 catches the loop on\n * the first identical re-feed rather than after the 50-iteration runaway cap trips.\n *\n * The window size is intentionally small (default 3). The loop we care about\n * is the immediate repetition \u2014 a longer history would misfire on legitimate\n * \"do X, then do Y, then do X\" sequences the model occasionally returns to.\n *\n * This module is BROWSER-SAFE \u2014 no Node-only imports \u2014 so it can be imported\n * from Vite-bundled WebUI as well as Node-based CLI/TUI.\n */\n\n/**\n * Normalize a prompt for repetition comparison. Whitespace is collapsed and\n * trimmed; case is folded to lowercase. Nothing semantic is removed, so two\n * prompts that differ in any meaningful way (extra word, different code,\n * different file path) compare as distinct. Two prompts that differ only by\n * leading/trailing whitespace and casing are treated as identical.\n */\nexport function normalizeForRepetition(prompt: string): string {\n  return prompt.replace(/\\s+/g, ' ').trim().toLowerCase();\n}\n\nexport interface LoopGuardOptions {\n  /**\n   * How many consecutive identical prompts (after normalization) trigger a\n   * halt. Default 2 \u2014 i.e. the second consecutive identical feed (the first\n   * re-feed of an already-seen prompt) halts the loop. Clamped to >= 2.\n   */\n  repeatThreshold?: number;\n  /**\n   * How many of the most recent feeds to retain for comparison. The window\n   * is searched from newest to oldest; the guard cares about the run of\n   * identical entries ending at the most recent one, not about identical\n   * entries anywhere in history. Default 3.\n   */\n  windowSize?: number;\n}\n\nexport interface RepetitionSignal {\n  /** The normalized prompt that just got recorded. */\n  normalized: string;\n  /**\n   * Number of consecutive identical feeds ending at the most recent feed,\n   * including this one. Always >= 1.\n   */\n  runLength: number;\n  /**\n   * True when the run length has crossed `repeatThreshold`. Callers must\n   * stop feeding and surface a user prompt instead.\n   */\n  shouldHalt: boolean;\n}\n\nexport interface AutoProceedLoopGuard {\n  /**\n   * Record a prompt that is about to be auto-fed. Returns the repetition\n   * signal for that prompt. When `shouldHalt` is true the caller MUST NOT\n   * feed the prompt \u2014 it has been recorded for post-mortem inspection, but\n   * the loop must be broken instead.\n   */\n  record(prompt: string): RepetitionSignal;\n  /**\n   * Drop the history. Call this on any manual user input so a fresh run\n   * starts with no memory of the prior cycle.\n   */\n  reset(): void;\n  /**\n   * Read-only view of the most recent normalized prompts (newest last).\n   * Useful for diagnostics and for the message shown to the user when the\n   * guard halts the loop.\n   */\n  history(): readonly string[];\n  /**\n   * How many entries the guard is currently retaining.\n   */\n  size(): number;\n}\n\n/**\n * Build a fresh loop guard. Defaults: `repeatThreshold = 2`, `windowSize = 3`.\n *\n * @example\n *   const guard = createAutoProceedLoopGuard();\n *   for (const prompt of candidates) {\n *     const signal = guard.record(prompt);\n *     if (signal.shouldHalt) {\n *       haltAutoProceedAndAskUser(signal);\n *       break;\n *     }\n *     feedPrompt(prompt);\n *   }\n */\nexport function createAutoProceedLoopGuard(options: LoopGuardOptions = {}): AutoProceedLoopGuard {\n  // Validate options defensively. Non-finite values (NaN, Infinity) MUST\n  // fall back to the documented default \u2014 a guard that silently disables\n  // itself is worse than no guard at all. Specifically:\n  //   - `repeatThreshold: NaN` would cause `Math.floor(NaN) = NaN`,\n  //     `Math.max(2, NaN) = NaN`, and `runLength >= NaN` is always false,\n  //     making the guard permanent no-op.\n  //   - `windowSize: NaN` / `Infinity` would skip the trim branch entirely\n  //     (`buffer.length > NaN` and `buffer.length > Infinity` are both\n  //     false), so the buffer would grow without bound.\n  const safeIntegerOption = (value: number | undefined, fallback: number): number => {\n    if (value === undefined) return fallback;\n    if (!Number.isFinite(value)) return fallback;\n    return Math.floor(value);\n  };\n  const repeatThreshold = Math.max(2, safeIntegerOption(options.repeatThreshold, 2));\n  const windowSize = Math.max(repeatThreshold, safeIntegerOption(options.windowSize, 3));\n  let buffer: string[] = [];\n\n  function record(prompt: string): RepetitionSignal {\n    const normalized = normalizeForRepetition(prompt);\n    buffer.push(normalized);\n    if (buffer.length > windowSize) {\n      buffer = buffer.slice(buffer.length - windowSize);\n    }\n    // Count the trailing run of identical normalized prompts.\n    let runLength = 0;\n    for (let i = buffer.length - 1; i >= 0; i--) {\n      if (buffer[i] === normalized) runLength++;\n      else break;\n    }\n    return {\n      normalized,\n      runLength,\n      shouldHalt: runLength >= repeatThreshold,\n    };\n  }\n\n  function reset(): void {\n    buffer = [];\n  }\n\n  function history(): readonly string[] {\n    return buffer.slice();\n  }\n\n  function size(): number {\n    return buffer.length;\n  }\n\n  return { record, reset, history, size };\n}\n"],
-  "mappings": ";AA2DO,SAAS,uBAAuB,QAAwB;AAC7D,SAAO,OAAO,QAAQ,QAAQ,GAAG,EAAE,KAAK,EAAE,YAAY;AACxD;AAwEO,SAAS,2BAA2B,UAA4B,CAAC,GAAyB;AAU/F,QAAM,oBAAoB,CAAC,OAA2B,aAA6B;AACjF,QAAI,UAAU,OAAW,QAAO;AAChC,QAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB;AACA,QAAM,kBAAkB,KAAK,IAAI,GAAG,kBAAkB,QAAQ,iBAAiB,CAAC,CAAC;AACjF,QAAM,aAAa,KAAK,IAAI,iBAAiB,kBAAkB,QAAQ,YAAY,CAAC,CAAC;AACrF,MAAI,SAAmB,CAAC;AAExB,WAAS,OAAO,QAAkC;AAChD,UAAM,aAAa,uBAAuB,MAAM;AAChD,WAAO,KAAK,UAAU;AACtB,QAAI,OAAO,SAAS,YAAY;AAC9B,eAAS,OAAO,MAAM,OAAO,SAAS,UAAU;AAAA,IAClD;AAEA,QAAI,YAAY;AAChB,aAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,UAAI,OAAO,CAAC,MAAM,WAAY;AAAA,UACzB;AAAA,IACP;AACA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,YAAY,aAAa;AAAA,IAC3B;AAAA,EACF;AAEA,WAAS,QAAc;AACrB,aAAS,CAAC;AAAA,EACZ;AAEA,WAAS,UAA6B;AACpC,WAAO,OAAO,MAAM;AAAA,EACtB;AAEA,WAAS,OAAe;AACtB,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,EAAE,QAAQ,OAAO,SAAS,KAAK;AACxC;",
+  "sourcesContent": ["/**\n * Auto-proceed loop guard.\n *\n * ## Problem\n *\n * The REPL and TUI both implement an \"auto\" autonomy mode that, after every\n * completed agent turn, feeds the next suggestion (or top auto=\"true\" item)\n * back as a fresh prompt. When the agent emits the same `<nextsteps>` block\n * on every reply \u2014 which happens whenever the model's output is stable but\n * autonomy treats the next step as \"still actionable\" \u2014 the loop self-feeds\n * the same instruction 2\u20133 times in a row before the longer\n * `autoProceedMaxIterations` cap (default 50) trips.\n *\n * The user reports the visible symptom: the same response, including the same\n * `<nextsteps>` block, repeats. Manual input from the user is the only thing\n * that breaks out. They suspect the next-steps mechanism is the source.\n *\n * The 50-iteration cap is intentionally loose \u2014 it is a runaway safety net,\n * not a UX signal. By the time it trips, the user has already watched the\n * same response 50 times.\n *\n * ## Approach\n *\n * A small, pure, browser-safe stateful helper that records the last few\n * prompts fed through the auto-proceed / auto-submit path. It normalizes\n * prompts (whitespace, casing) so trivial rewordings are not collapsed, but\n * identical re-feeds are. When the same normalized prompt is fed\n * `repeatThreshold` (default 2) times in a row, the guard returns\n * `{ shouldHalt: true }`.\n *\n * Callers are expected to:\n *   1. Call `record(prompt)` immediately before each auto-feed.\n *   2. If `shouldHalt` is true, clear the suggestion + auto-suggestion store,\n *      cancel any pending countdown, and surface a \"we detected a loop\"\n *      message asking the user what's happening. Do NOT feed the prompt.\n *   3. Call `reset()` whenever the user types anything manually (REPL manual\n *      input or any user-driven submit) so the next auto-feed starts clean.\n *\n * The default `repeatThreshold` is 2 \u2014 i.e. the second consecutive identical\n * feed (the first re-feed of an already-seen prompt) halts the loop. That\n * matches the user's report (\"receiving the same prompt 2-3 times in a row\n * causes the system to enter a loop\"). Setting it to 2 catches the loop on\n * the first identical re-feed rather than after the 50-iteration runaway cap trips.\n *\n * The window size is intentionally small (default 3). The loop we care about\n * is the immediate repetition \u2014 a longer history would misfire on legitimate\n * \"do X, then do Y, then do X\" sequences the model occasionally returns to.\n *\n * This module is BROWSER-SAFE \u2014 no Node-only imports \u2014 so it can be imported\n * from Vite-bundled WebUI as well as Node-based CLI/TUI.\n */\n\n/**\n * Normalize a prompt for repetition comparison. Whitespace is collapsed and\n * trimmed; case is folded to lowercase. Nothing semantic is removed, so two\n * prompts that differ in any meaningful way (extra word, different code,\n * different file path) compare as distinct. Two prompts that differ only by\n * leading/trailing whitespace and casing are treated as identical.\n */\nexport function normalizeForRepetition(prompt: string): string {\n  return prompt.replace(/\\s+/g, ' ').trim().toLowerCase();\n}\n\nexport interface LoopGuardOptions {\n  /**\n   * How many consecutive identical prompts (after normalization) trigger a\n   * halt. Default 2 \u2014 i.e. the second consecutive identical feed (the first\n   * re-feed of an already-seen prompt) halts the loop. Clamped to >= 2.\n   */\n  repeatThreshold?: number;\n  /**\n   * How many of the most recent feeds to retain for comparison. The window\n   * is searched from newest to oldest; the guard cares about the run of\n   * identical entries ending at the most recent one, not about identical\n   * entries anywhere in history. Default 3.\n   */\n  windowSize?: number;\n}\n\nexport interface RepetitionSignal {\n  /** The normalized prompt that just got recorded. */\n  normalized: string;\n  /**\n   * Number of consecutive identical feeds ending at the most recent feed,\n   * including this one. Always >= 1.\n   */\n  runLength: number;\n  /**\n   * True when the run length has crossed `repeatThreshold`. Callers must\n   * stop feeding and surface a user prompt instead.\n   */\n  shouldHalt: boolean;\n}\n\n/**\n * Steer text appended (once) to a grounded todo continuation when the board\n * has not moved between two consecutive automatic turns. Grounded prompts are\n * synthesized from durable todo state, so an identical re-feed means the whole\n * previous turn produced zero board movement \u2014 usually the model worked but\n * forgot to update the board. One explicit steer fixes that far more often\n * than halting; the halt only fires if the board stays frozen AFTER the steer.\n */\nexport const GROUNDED_NO_PROGRESS_STEER = [\n  'NOTE: The todo board has not changed since the previous automatic continuation \u2014 this exact instruction is being repeated.',\n  'Before anything else, bring the board up to date so the loop stays grounded:',\n  '- mark work that is actually finished as completed,',\n  '- split the current item into smaller concrete sub-items if it needs more than one turn,',\n  '- remove or reword items that no longer apply.',\n  'Then continue the work. If you are blocked, state exactly what is blocking you instead of repeating the same turn.',\n].join('\\n');\n\nexport type GroundedRepetitionAction = 'feed' | 'steer' | 'halt';\n\nexport interface GroundedRepetitionSignal extends RepetitionSignal {\n  /**\n   * What the caller should do with this grounded (todo-sourced) prompt:\n   *   - `feed`  \u2014 no repetition; feed the prompt as-is.\n   *   - `steer` \u2014 first repetition; feed the prompt with\n   *     {@link GROUNDED_NO_PROGRESS_STEER} appended instead of halting.\n   *   - `halt`  \u2014 the board stayed frozen even after a steer; break the loop\n   *     exactly like a `shouldHalt` from {@link AutoProceedLoopGuard.record}.\n   */\n  action: GroundedRepetitionAction;\n}\n\nexport interface AutoProceedLoopGuard {\n  /**\n   * Record a prompt that is about to be auto-fed. Returns the repetition\n   * signal for that prompt. When `shouldHalt` is true the caller MUST NOT\n   * feed the prompt \u2014 it has been recorded for post-mortem inspection, but\n   * the loop must be broken instead.\n   */\n  record(prompt: string): RepetitionSignal;\n  /**\n   * Record a GROUNDED prompt \u2014 one synthesized from durable state (the todo\n   * board) rather than echoed from model output. Repetition of a grounded\n   * prompt is a \"no board progress\" signal, not necessarily an echo loop, so\n   * the first repetition asks the caller to steer (append\n   * {@link GROUNDED_NO_PROGRESS_STEER} to the fed text) and only a repetition\n   * that survives the steer halts. The steer state resets whenever a\n   * different prompt is recorded (board moved) or on {@link reset}.\n   */\n  recordGrounded(prompt: string): GroundedRepetitionSignal;\n  /**\n   * Drop the history. Call this on any manual user input so a fresh run\n   * starts with no memory of the prior cycle.\n   */\n  reset(): void;\n  /**\n   * Read-only view of the most recent normalized prompts (newest last).\n   * Useful for diagnostics and for the message shown to the user when the\n   * guard halts the loop.\n   */\n  history(): readonly string[];\n  /**\n   * How many entries the guard is currently retaining.\n   */\n  size(): number;\n}\n\n/**\n * Build a fresh loop guard. Defaults: `repeatThreshold = 2`, `windowSize = 3`.\n *\n * @example\n *   const guard = createAutoProceedLoopGuard();\n *   for (const prompt of candidates) {\n *     const signal = guard.record(prompt);\n *     if (signal.shouldHalt) {\n *       haltAutoProceedAndAskUser(signal);\n *       break;\n *     }\n *     feedPrompt(prompt);\n *   }\n */\nexport function createAutoProceedLoopGuard(options: LoopGuardOptions = {}): AutoProceedLoopGuard {\n  // Validate options defensively. Non-finite values (NaN, Infinity) MUST\n  // fall back to the documented default \u2014 a guard that silently disables\n  // itself is worse than no guard at all. Specifically:\n  //   - `repeatThreshold: NaN` would cause `Math.floor(NaN) = NaN`,\n  //     `Math.max(2, NaN) = NaN`, and `runLength >= NaN` is always false,\n  //     making the guard permanent no-op.\n  //   - `windowSize: NaN` / `Infinity` would skip the trim branch entirely\n  //     (`buffer.length > NaN` and `buffer.length > Infinity` are both\n  //     false), so the buffer would grow without bound.\n  const safeIntegerOption = (value: number | undefined, fallback: number): number => {\n    if (value === undefined) return fallback;\n    if (!Number.isFinite(value)) return fallback;\n    return Math.floor(value);\n  };\n  const repeatThreshold = Math.max(2, safeIntegerOption(options.repeatThreshold, 2));\n  const windowSize = Math.max(repeatThreshold, safeIntegerOption(options.windowSize, 3));\n  let buffer: string[] = [];\n  // Normalized grounded prompt we already steered for; a halt only fires for\n  // a grounded prompt that repeats again AFTER its steer.\n  let steeredFor: string | null = null;\n\n  function record(prompt: string): RepetitionSignal {\n    const normalized = normalizeForRepetition(prompt);\n    buffer.push(normalized);\n    if (buffer.length > windowSize) {\n      buffer = buffer.slice(buffer.length - windowSize);\n    }\n    // Count the trailing run of identical normalized prompts.\n    let runLength = 0;\n    for (let i = buffer.length - 1; i >= 0; i--) {\n      if (buffer[i] === normalized) runLength++;\n      else break;\n    }\n    return {\n      normalized,\n      runLength,\n      shouldHalt: runLength >= repeatThreshold,\n    };\n  }\n\n  function recordGrounded(prompt: string): GroundedRepetitionSignal {\n    const signal = record(prompt);\n    if (!signal.shouldHalt) {\n      // The board moved (different prompt) \u2014 clear any pending steer state.\n      steeredFor = null;\n      return { ...signal, shouldHalt: false, action: 'feed' };\n    }\n    if (steeredFor === signal.normalized) {\n      return { ...signal, action: 'halt' };\n    }\n    steeredFor = signal.normalized;\n    return { ...signal, shouldHalt: false, action: 'steer' };\n  }\n\n  function reset(): void {\n    buffer = [];\n    steeredFor = null;\n  }\n\n  function history(): readonly string[] {\n    return buffer.slice();\n  }\n\n  function size(): number {\n    return buffer.length;\n  }\n\n  return { record, recordGrounded, reset, history, size };\n}\n"],
+  "mappings": ";AA2DO,SAAS,uBAAuB,QAAwB;AAC7D,SAAO,OAAO,QAAQ,QAAQ,GAAG,EAAE,KAAK,EAAE,YAAY;AACxD;AAyCO,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAiEJ,SAAS,2BAA2B,UAA4B,CAAC,GAAyB;AAU/F,QAAM,oBAAoB,CAAC,OAA2B,aAA6B;AACjF,QAAI,UAAU,OAAW,QAAO;AAChC,QAAI,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACpC,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB;AACA,QAAM,kBAAkB,KAAK,IAAI,GAAG,kBAAkB,QAAQ,iBAAiB,CAAC,CAAC;AACjF,QAAM,aAAa,KAAK,IAAI,iBAAiB,kBAAkB,QAAQ,YAAY,CAAC,CAAC;AACrF,MAAI,SAAmB,CAAC;AAGxB,MAAI,aAA4B;AAEhC,WAAS,OAAO,QAAkC;AAChD,UAAM,aAAa,uBAAuB,MAAM;AAChD,WAAO,KAAK,UAAU;AACtB,QAAI,OAAO,SAAS,YAAY;AAC9B,eAAS,OAAO,MAAM,OAAO,SAAS,UAAU;AAAA,IAClD;AAEA,QAAI,YAAY;AAChB,aAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,UAAI,OAAO,CAAC,MAAM,WAAY;AAAA,UACzB;AAAA,IACP;AACA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,YAAY,aAAa;AAAA,IAC3B;AAAA,EACF;AAEA,WAAS,eAAe,QAA0C;AAChE,UAAM,SAAS,OAAO,MAAM;AAC5B,QAAI,CAAC,OAAO,YAAY;AAEtB,mBAAa;AACb,aAAO,EAAE,GAAG,QAAQ,YAAY,OAAO,QAAQ,OAAO;AAAA,IACxD;AACA,QAAI,eAAe,OAAO,YAAY;AACpC,aAAO,EAAE,GAAG,QAAQ,QAAQ,OAAO;AAAA,IACrC;AACA,iBAAa,OAAO;AACpB,WAAO,EAAE,GAAG,QAAQ,YAAY,OAAO,QAAQ,QAAQ;AAAA,EACzD;AAEA,WAAS,QAAc;AACrB,aAAS,CAAC;AACV,iBAAa;AAAA,EACf;AAEA,WAAS,UAA6B;AACpC,WAAO,OAAO,MAAM;AAAA,EACtB;AAEA,WAAS,OAAe;AACtB,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,EAAE,QAAQ,gBAAgB,OAAO,SAAS,KAAK;AACxD;",
   "names": []
 }

package/dist/bash.js

@@ -825,6 +825,7 @@ function emitStructuredLog(level, event, message, error) {
 }
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_THRESHOLD_MS = 3e4;
+var LOCK_STALE_MS = 3e4;
 var LOCKFILE = ".process-registry.lock";
 function generateInstanceId() {
   const hostname2 = os2.hostname();
@@ -853,21 +854,26 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
         try {
           const content = await fs.readFile(lockfilePath, "utf-8");
           const parts = content.split(":");
-          const lockPidStr = parts[0] ?? "0";
-          const lockPid = parseInt(lockPidStr, 10);
-          if (process.platform !== "win32") {
+          const lockPid = parseInt(parts[0] ?? "0", 10);
+          const lockTs = Number(parts[parts.length - 1]);
+          const staleByAge = Number.isFinite(lockTs) && Date.now() - lockTs > LOCK_STALE_MS;
+          let holderDead = false;
+          if (process.platform !== "win32" && Number.isFinite(lockPid) && lockPid > 0) {
             try {
               process.kill(lockPid, 0);
             } catch {
-              await fs.unlink(lockfilePath);
-              continue;
+              holderDead = true;
             }
           }
-        } catch {
-          try {
-            await fs.unlink(lockfilePath);
-          } catch {
+          if (holderDead || staleByAge) {
+            await fs.unlink(lockfilePath).catch(() => {
+            });
+            continue;
           }
+        } catch {
+          await fs.unlink(lockfilePath).catch(() => {
+          });
+          continue;
         }
         await new Promise((r) => setTimeout(r, 100));
         continue;
@@ -877,25 +883,35 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
   }
   throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
 }
+function freshRegistryData() {
+  return {
+    version: 1,
+    instances: /* @__PURE__ */ new Map(),
+    protectedPatterns: ["wrongstack", "node"],
+    lastCleanup: Date.now()
+  };
+}
 async function readRegistryFile(filePath) {
+  let content;
   try {
-    const content = await fs.readFile(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed.instances && Array.isArray(parsed.instances)) {
-      parsed.instances = new Map(parsed.instances);
-    }
-    return parsed;
+    content = await fs.readFile(filePath, "utf-8");
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
-      return {
-        version: 1,
-        instances: /* @__PURE__ */ new Map(),
-        protectedPatterns: ["wrongstack", "node"],
-        lastCleanup: Date.now()
-      };
-    }
+    if (isNodeError(err) && err.code === "ENOENT") return freshRegistryData();
     throw err;
   }
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object") return freshRegistryData();
+    const base = freshRegistryData();
+    return {
+      version: 1,
+      instances: Array.isArray(parsed.instances) ? new Map(parsed.instances) : base.instances,
+      protectedPatterns: Array.isArray(parsed.protectedPatterns) ? parsed.protectedPatterns : base.protectedPatterns,
+      lastCleanup: typeof parsed.lastCleanup === "number" ? parsed.lastCleanup : base.lastCleanup
+    };
+  } catch {
+    return freshRegistryData();
+  }
 }
 async function writeRegistryFile(filePath, data) {
   const tmpPath = `${filePath}.tmp.${process.pid}`;