@humwick/runner 0.130.5 → 0.130.6

package/src/busy-reconciler.ts

@@ -8,16 +8,16 @@ const BUSY_RECONCILE_IDLE_CONFIRM = 8;
 const BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY = 15;
 const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
 const PROVIDER_TURN_CLEAR_TIMEOUT_MS = 60_000;
-// #1980 U2 — how many consecutive reconcile ticks a live turn may be HELD (never force-cleared,
+// U2 — how many consecutive reconcile ticks a live turn may be HELD (never force-cleared,
 // because there is no positive end-evidence) before the backstop escalates a NOTIFY-ONLY
 // watchdog. At the 4s poll this is ~20 min. The escalation NEVER cancels the turn (a 44-min gate
 // is legitimate); it only surfaces "this turn has been held a long time" to the coordinator, so a
 // genuinely wedged-but-active agent (a frozen `busy`, or a pane-scrape-only long tool the runner
 // cannot prove idle) is seen instead of silently cancelled. One-shot per turn (reset on arm/disarm).
 //
-// #2010 INVARIANT: this interval (BUSY_RECONCILE_WATCHDOG_TICKS * BUSY_RECONCILE_POLL_MS, ~20
+// INVARIANT: this interval (BUSY_RECONCILE_WATCHDOG_TICKS * BUSY_RECONCILE_POLL_MS, ~20
 // min) must stay >= the server's STUCK_BUSY_PROVIDER_TURN_MS threshold (src/config.ts, default
-// 15 min but operator-configurable via AGENT_RELAY_STUCK_BUSY_PROVIDER_TURN_MS). The server-side
+// 15 min but operator-configurable via HUMWICK_STUCK_BUSY_PROVIDER_TURN_MS). The server-side
 // gate in auditProviderTurnWatchdog (src/services/turn-reconcile-audit.ts) only wakes the
 // coordinator once staleForMs (time since real last progress) reaches that threshold. If an
 // operator raises the server threshold ABOVE this interval, a genuinely dead-from-the-start turn
@@ -34,18 +34,18 @@ interface BusyReconcilerDeps {
   hasProviderTurn(): boolean;
   canProbeActivity(): boolean;
   probeActivity(): Promise<ProviderActivity> | undefined;
-  // #769 P1-A / #1656: optional independent pane-busy read. `busy` vetoes a clear; `not-busy`
+  // P1-A: optional independent pane-busy read. `busy` vetoes a clear; `not-busy`
   // is the positive corroboration every counted idle tick requires; anything else is unknown
   // and holds the turn. Omitted entirely by providers with no pane to read.
   probePaneBusy?(): Promise<PaneBusyReading> | undefined;
   clearProviderTurn(reason: string): void;
-  // #1980 U2 — escalate a NOTIFY-ONLY watchdog for a live turn the backstop has HELD past the
+  // U2 — escalate a NOTIFY-ONLY watchdog for a live turn the backstop has HELD past the
   // prolonged-hold threshold (a frozen-active `busy`, or a pane-scrape-only long tool that can
   // never be positively proven idle — probeActivity reads `unknown`, not `idle`, so the clear
   // paths are never reached). The runner turns this into a coordinator notification; it MUST NOT
   // cancel the turn. Optional: providers/tests without a watchdog simply hold silently.
   escalateWatchdog?(reason: string): void;
-  /** Every no-provider-turn edge (#2984: a pending effort change applies here). */
+  /** Every no-provider-turn edge (a pending effort change applies here). */
   turnCleared?(): void;
   sessionDebug(message: string): void;
 }
@@ -54,12 +54,12 @@ export class BusyReconciler {
   private idleStreak = 0;
   private timer?: ReturnType<typeof setInterval>;
   private sawBusy = false;
-  // #1980 U2 — consecutive reconcile ticks this live turn has been held without ending, and the
+  // U2 — consecutive reconcile ticks this live turn has been held without ending, and the
   // one-shot guard so the prolonged-hold watchdog notifies at most once per turn. Both reset on
   // arm/disarm (a new turn starts a fresh hold budget).
   private heldTicks = 0;
   private watchdogEscalated = false;
-  // #1838 row 14 — the activity probe now runs OFF the runner's event loop (async tmux
+  // row 14 — the activity probe now runs OFF the runner's event loop (async tmux
   // subprocess + probe reads), so a single reconcile can outlast the 4s poll interval when a
   // tmux socket is slow. This guard drops any timer tick that fires while the previous
   // reconcile is still in flight, so slow probes can never stack N concurrent reads on one
@@ -67,7 +67,7 @@ export class BusyReconciler {
   // directly and await it to completion are unaffected — the flag is always clear by the next
   // call.
   private reconcileInFlight = false;
-  // #1838 round-3 HIGH — a monotonic generation, the same await-fence the turn watcher uses.
+  // round-3 HIGH — a monotonic generation, the same await-fence the turn watcher uses.
   // Captured at the start of a reconcile and re-checked after EVERY await before any streak
   // mutation or clearProviderTurn: a disarm / re-arm / turn clear that happens while an off-loop
   // probe is in flight means the verdict describes a STALE turn, so it must not clear a
@@ -98,7 +98,7 @@ export class BusyReconciler {
     this.watchdogEscalated = false;
   }
 
-  // #1838 round-3 HIGH — true when an in-flight reconcile that started at `gen` must abandon
+  // round-3 HIGH — true when an in-flight reconcile that started at `gen` must abandon
   // without mutating streak state or clearing: the generation moved (arm/disarm/turn clear), or
   // the turn/process/lifecycle preconditions it verified BEFORE its await no longer hold. Cheap,
   // synchronous, re-evaluated after each await.
@@ -123,7 +123,7 @@ export class BusyReconciler {
   // durable timeline event during teardown. Catch at this boundary so an expected race cannot
   // become Bun's process-fatal unhandled rejection; retain the error in the session log.
   private runInBackground(): void {
-    // #1838 row 14 — skip this tick if the previous off-loop reconcile is still running.
+    // row 14 — skip this tick if the previous off-loop reconcile is still running.
     if (this.reconcileInFlight) {
       this.deps.sessionDebug("busy reconcile skipped: previous probe still in flight");
       return;
@@ -149,7 +149,7 @@ export class BusyReconciler {
     const probe = this.deps.probeActivity();
     let activity: ProviderActivity = "unknown";
     try { if (probe) activity = await probe; } catch { return; }
-    // #1838 round-3 HIGH: re-check after the probe await. Turn A was interrupted, its probe
+    // round-3 HIGH: re-check after the probe await. Turn A was interrupted, its probe
     // stalled, A ended and Turn B began — A's stale `idle` must NOT clear B. `stale(gen)` catches
     // the disarm/re-arm/turn-clear (via generation) AND a status/turn that moved out from under us.
     if (this.stale(gen)) return;
@@ -175,7 +175,7 @@ export class BusyReconciler {
   }
 
   providerTurnCleared(): void {
-    // #1838 round-3 HIGH — a turn clear/replacement invalidates any in-flight reconcile that was
+    // round-3 HIGH — a turn clear/replacement invalidates any in-flight reconcile that was
     // judging the turn that just ended. Bump BEFORE the waiter-fan-out and the hasProviderTurn
     // guard: this method is only invoked by the runner on a no-provider-turn edge, so it never
     // fires during a legitimate active reconcile.
@@ -200,15 +200,15 @@ export class BusyReconciler {
       this.disarm();
       return;
     }
-    // #1656: a probe we could not read is `unknown`, not `idle`. It breaks the streak
+    // a probe we could not read is `unknown`, not `idle`. It breaks the streak
     // exactly like any other non-idle reading — it must never be silently skipped past.
     let activity: ProviderActivity;
     try { activity = await probe; } catch { activity = "unknown"; }
-    // #1838 round-3 HIGH: re-check after the (off-loop) probe await, BEFORE touching sawBusy /
+    // round-3 HIGH: re-check after the (off-loop) probe await, BEFORE touching sawBusy /
     // idleStreak. A disarm/re-arm or turn clear while the probe was in flight means this verdict
     // is for a stale turn — abandon rather than mutate the successor's streak.
     if (this.stale(gen)) return;
-    // #1980 U2 — this tick observed a still-live, still-busy provider turn that did not end. A
+    // U2 — this tick observed a still-live, still-busy provider turn that did not end. A
     // turn that is genuinely wedged-but-active never reaches a force-clear at all: a frozen
     // foreground tool keeps reading `busy`, and a pane-scrape-only long tool reads `unknown` (not
     // `idle`, so its streak never accumulates). Count the hold so such a turn is escalated to a
@@ -221,14 +221,14 @@ export class BusyReconciler {
       this.deps.sessionDebug(`reconcile probe=${activity} sawBusy=${this.sawBusy} streak=${this.idleStreak}`);
       return;
     }
-    // #769 P1-A / #1656: the probe alone does not get to end a turn. An independent pane read
+    // P1-A: the probe alone does not get to end a turn. An independent pane read
     // runs on EVERY idle tick — not just once at the force-clear moment — and the streak counts
-    // only ticks where it positively reported `not-busy`. That is the substance of #1656: the
+    // only ticks where it positively reported `not-busy`. That is the substance: the
     // old counter measured "how long since I last saw busy", which a pane that cannot be read at
     // all satisfies perfectly. It now measures accumulated positive evidence that the turn ended,
     // and any tick that fails to produce such evidence resets it to zero.
     const pane = await this.readPaneBusy();
-    // #1838 round-3 HIGH: re-check after the pane await too — this is the tick that can call
+    // round-3 HIGH: re-check after the pane await too — this is the tick that can call
     // clearProviderTurn, so a turn that was replaced during the pane read must not be cleared.
     if (this.stale(gen)) return;
     if (pane === "busy") {
@@ -246,10 +246,10 @@ export class BusyReconciler {
     const confirm = this.sawBusy ? BUSY_RECONCILE_IDLE_CONFIRM : BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY;
     this.deps.sessionDebug(`reconcile not-busy pane=${pane ?? "none"} sawBusy=${this.sawBusy} streak=${this.idleStreak}/${confirm}`);
     if (this.idleStreak < confirm) return;
-    // #1980 U2 — reaching here means POSITIVE end-evidence: the activity read is `idle`, which for
+    // U2 — reaching here means POSITIVE end-evidence: the activity read is `idle`, which for
     // a probe-capable Claude session comes only from the provider's own idle assertion or a
     // busy-verdict a real interrupt / trust-window decay turned idle — NOT from pane silence. A
-    // long foreground tool the runner cannot see now reads `unknown` (probeActivity, #1980 U2),
+    // long foreground tool the runner cannot see now reads `unknown`,
     // whose streak resets above, so the `no-busy-observed` force-cancel that lost the 44-min gate
     // is no longer reachable from silence. Genuine ends still clear here, with their reason +
     // notification (the interrupted-turn audit downstream).
@@ -261,7 +261,7 @@ export class BusyReconciler {
     this.deps.clearProviderTurn(reason);
   }
 
-  // #1980 U2 — fire the notify-only watchdog at most once per turn. The reconciler NEVER cancels
+  // U2 — fire the notify-only watchdog at most once per turn. The reconciler NEVER cancels
   // the turn on this path; it only asks the runner to tell the coordinator the turn is being held.
   private emitWatchdog(reason: string): void {
     if (this.watchdogEscalated) return;

package/src/claim-tracker.ts

@@ -17,7 +17,7 @@ interface WorkRecord {
   role?: string;
   parentId?: string;
   metadata?: Record<string, unknown>;
-  // OS pids of the underlying process(es) this work tracks (#650). When present,
+  // OS pids of the underlying process(es) this work tracks. When present,
   // a periodic liveness reconcile clears the record once every pid is dead — so a
   // tracked process killed out-of-band (no exit event) can't strand the agent busy.
   pids?: number[];
@@ -112,7 +112,7 @@ export class ClaimTracker {
     return [...this.work.values()];
   }
 
-  /** True iff any active work carries pids the liveness reconcile can check (#650). */
+  /** True iff any active work carries pids the liveness reconcile can check. */
   hasLivenessTrackedWork(): boolean {
     for (const item of this.work.values()) {
       if (item.pids && item.pids.length > 0) return true;
@@ -121,7 +121,7 @@ export class ClaimTracker {
   }
 
   /**
-   * Reconcile pid-bearing work against actual process liveness (#650): drop any
+   * Reconcile pid-bearing work against actual process liveness: drop any
    * record whose tracked pids are ALL dead — its underlying process died out-of-band
    * (killed/crashed/orphaned) with no exit event to clear the busy marker. Records
    * with no pids are never touched (no liveness signal to act on). Returns the removed

package/src/claude-settings.ts

@@ -1,7 +1,7 @@
 import { projectClaudePermissionRules } from "./provider-integration";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import type { ProvisioningHookSet, ToolGeneration } from "@humwick/sdk";
+import type { ProvisioningHookSet } from "@humwick/sdk";
 import { mergeClaudeRelayPermissions } from "./provisioning";
 import { shellQuote } from "@humwick/sdk/shell-utils";
 
@@ -14,7 +14,7 @@ export interface ClaudeSettingsResolution {
   suppressedHookNames: string[];
 }
 
-// #3187 — Claude Code's own defaults append "Generated with Claude Code" / Co-Authored-By.
+// Claude Code's own defaults append "Generated with Claude Code" / Co-Authored-By.
 // `attribution` is the current key; `includeCoAuthoredBy` is its deprecated predecessor.
 export const CLAUDE_NO_ATTRIBUTION_SETTINGS = { attribution: { commit: "", pr: "" }, includeCoAuthoredBy: false } as const;
 export const CLAUDE_NO_ATTRIBUTION_RULE =
@@ -31,14 +31,14 @@ export function claudeSettingsArgs(
   hookNames: string[],
   includeStatusLine: boolean,
   nativeMemorySettings: Record<string, unknown>,
-  launch: { cwd: string; model?: string; generation?: ToolGeneration },
+  launch: { cwd: string; model?: string },
   ...argLists: string[][]
 ): ClaudeSettingsResolution {
   const relaySettings: Record<string, unknown> = {
     ...projectSettings,
     ...(Object.keys(provisionedHooks).length ? { hooks: provisionedHooks } : {}),
     ...(includeStatusLine ? relayStatusLineSettings() : {}),
-    // #1565 P5.7 — LAST, so a project `.claude/settings.json` cannot quietly re-enable a
+    // P5.7 — LAST, so a project `.claude/settings.json` cannot quietly re-enable a
     // profile's native memory. (Claude's own env predicate outranks all of this either way.)
     ...nativeMemorySettings,
     ...CLAUDE_NO_ATTRIBUTION_SETTINGS,
@@ -47,14 +47,14 @@ export function claudeSettingsArgs(
   const caller = extractCallerSettings(argLists, launch.cwd);
   if (!caller) {
     return {
-      args: Object.keys(relaySettings).length ? ["--settings", JSON.stringify(projectClaudePermissionRules(relaySettings, launch.generation ?? "relay"))] : [],
+      args: Object.keys(relaySettings).length ? ["--settings", JSON.stringify(projectClaudePermissionRules(relaySettings))] : [],
       callerSettingsConsumed: false, statusLineApplied: includeStatusLine,
       suppressedHookNames: [],
     };
   }
   if (caller.settings) {
     const merged = mergeClaudeSettings(caller.settings, relaySettings, launch.model);
-    return { args: ["--settings", JSON.stringify(projectClaudePermissionRules(merged, launch.generation ?? "relay"))], callerSettingsConsumed: true, statusLineApplied: includeStatusLine && merged.statusLine === relaySettings.statusLine, suppressedHookNames: [] };
+    return { args: ["--settings", JSON.stringify(projectClaudePermissionRules(merged))], callerSettingsConsumed: true, statusLineApplied: includeStatusLine && merged.statusLine === relaySettings.statusLine, suppressedHookNames: [] };
   }
   throw new Error("Claude --settings must be a JSON object or a readable JSON settings file (idleCompaction must be disabled)");
 }
@@ -132,7 +132,7 @@ function isHookSet(value: unknown): value is ProvisioningHookSet {
 
 // Strip every `--settings <json>` / `--settings=<json>` occurrence from a provider arg list. The
 // adapter applies this to the caller args once the assembler has folded them into its own merged
-// `--settings` (callerSettingsConsumed), so exactly one `--settings` reaches the launch (#1096).
+// `--settings` (callerSettingsConsumed), so exactly one `--settings` reaches the launch.
 export function stripSettingsArgs(args: string[]): string[] {
   const result: string[] = [];
   for (let i = 0; i < args.length; i += 1) {
@@ -149,7 +149,7 @@ export function hasSettingsArg(args: string[]): boolean {
 }
 
 // Claude relay status-line + readable-thinking settings, injected only when no caller
-// --settings is already present (caller wins). Relocated from claude.ts (#557).
+// --settings is already present (caller wins). Relocated from claude.ts.
 export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[] {
   if (argLists.some(hasSettingsArg)) return [];
   return ["--settings", JSON.stringify(relayStatusLineSettings())];

package/src/claude-system-prompt.ts

@@ -9,7 +9,7 @@ import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 
 const APPEND_FLAGS = ["--append-system-prompt", "--append-system-prompt-file"];
 
-// #3830 — caller/default appends share the same file channel as Relay context.
+// caller/default appends share the same file channel as Relay context.
 export function claudeCallerAppends(args: string[]): { args: string[]; appends: Array<{ value: string; file: boolean }> } {
   const remaining: string[] = [];
   const appends: Array<{ value: string; file: boolean }> = [];

package/src/claude-workspace-trust.ts

@@ -1,4 +1,4 @@
-// #2254 — Claude folder-trust seeding for EVERY launch, host-base included.
+// Claude folder-trust seeding for EVERY launch, host-base included.
 //
 // THE BUG: relay seeded `projects[cwd].hasTrustDialogAccepted` only into an ISOLATED
 // `CLAUDE_CONFIG_DIR` (profile-home's `ensureClaudeConfigSeed`). Host-base profiles and