instar 1.3.749 → 1.3.751

package/dist/core/VetoedKillBackoff.d.ts

@@ -0,0 +1,130 @@
+/**
+ * VetoedKillBackoff — a per-session veto-backoff ledger for the SessionManager
+ * kill branches (the age-gate AND the bound-idle zombie killer).
+ *
+ * SessionManager.monitorTick runs every 5 seconds. When it decides a session is
+ * killable (past its max age, or idle-at-prompt past its bound-idle threshold) it
+ * requests a kill via terminateSession → ReapGuard. If the §P2 KEEP-guard vetoes
+ * that kill (a recent user message, an open commitment, a live subagent, …), the
+ * session correctly survives — but a naive caller re-requests the SAME kill every
+ * 5 seconds forever (720 attempts/hour/session → the 2026-06-05 17,503-line log
+ * flood, and the 2026-07-03 132MB reap-log idle-zombie hot-spin).
+ *
+ * This ledger makes the kill branch RESPECT the guard's verdict: after a veto it
+ * suppresses re-requests for `backoffMs` (so a kept session is re-checked on a slow
+ * cadence, not every tick). It changes only how OFTEN a vetoed kill is retried —
+ * never WHICH sessions are killed (the KEEP-guard remains the sole authority). A
+ * genuinely-idle-abandoned session has no keep-reason, so its first request returns
+ * terminated:true and it dies exactly as before.
+ *
+ * Generalized from the shipped `AgeKillBackoff` (#863): a superset that adds a
+ * reason-KEY-aware stale-reprieve (a changed protection re-checks now, doesn't wait
+ * out the window), an episode counter (feeds the P19 breaker), and a once-per-episode
+ * log gate (`recordVeto` returns `firstOfEpisode`) — all folded into the ledger value
+ * so no parallel Set is needed. The class is not persisted; there is no on-disk value
+ * to migrate.
+ *
+ * Pure logic, injectable clock, bounded memory — unit-testable in isolation.
+ */
+export interface VetoedKillBackoffOptions {
+    /** Suppress kill re-requests for this long after a veto. 0 = no cooldown window
+     *  (still tracks episodes + log-once + breaker; NOT a disable — the disable path
+     *  is never constructing the instance). */
+    backoffMs: number;
+    /** Hard cap on distinct sessions tracked (memory bound; oldest-evicted). */
+    maxTracked: number;
+}
+export declare const DEFAULT_VETOED_KILL_BACKOFF: VetoedKillBackoffOptions;
+/** Back-compat aliases for the shipped age-gate name. */
+export type AgeKillBackoffOptions = VetoedKillBackoffOptions;
+export declare const DEFAULT_AGE_KILL_BACKOFF: VetoedKillBackoffOptions;
+/**
+ * Map a ReapGuard blockedReason result (or a bare reason string) to the STABLE
+ * ledger key. The `reason` field ReapGuard returns is already a stable enum key
+ * (`open-commitment`, `recent-user-message`, …), NOT free-form/interpolated text,
+ * so it is safe to use verbatim as the ledger key (R3-2). The human-readable string
+ * (if any interpolation ever existed) is used only for WARN/attention wording; only
+ * this stable key crosses into the ledger.
+ *
+ * Returns null when there is no usable reason string — the "unkeyable, fail-open"
+ * case: the caller re-evaluates this tick rather than minting a fabricated key.
+ */
+export declare function normalizeReasonKey(blocked: {
+    reason?: string;
+} | string | null | undefined): string | null;
+/**
+ * Every keep-reason `ReapGuard.blockedReason()` can currently return (source of
+ * truth: src/core/ReapGuard.ts evaluate()). Used by the exhaustive normalization
+ * test — each maps to its OWN distinct key, and no two materially-different keep
+ * reasons collapse onto one another.
+ */
+export declare const KNOWN_REAP_KEEP_REASONS: readonly ["protected", "spawn-grace", "recovery-in-flight", "pending-injection", "relay-lease", "recent-user-message", "open-commitment", "active-subagent", "structural-long-work", "active-process", "process-uninspectable", "main-process-active", "guard-error"];
+/**
+ * The subset of skip reasons whose PERSISTENCE is a genuine "this session is STUCK
+ * and should be investigated" signal — i.e. the ones the Fix A′ P19 breaker may
+ * escalate on (spec §Fix A′: "likely a stuck open-commitment or a resume-loop").
+ *
+ * DELIBERATELY EXCLUDED (second-pass review, point 9 — the multi-machine standby
+ * escalation gap the converged spec did not cover):
+ *  - Authority/CAS skips `terminateSession` returns BEFORE the keep-guard runs —
+ *    `not-lease-holder` (a STANDBY machine returns this every tick for every idle
+ *    session — escalating it as "vetoed from cleanup" is false), `in-flight`,
+ *    `not-found`, `already-completed`/`already-killed`/`already-*`. These are not
+ *    keep-reasons at all.
+ *  - Intentional / transient keep-reasons that are NOT a stuck anomaly:
+ *    `protected` (operator-configured permanent keep), `spawn-grace` (startup),
+ *    `recovery-in-flight` (a bounded recovery window), `guard-error` (a transient
+ *    inspect failure that resolves itself).
+ *
+ * A skip reason OUTSIDE this set still COOLS DOWN (recordVeto → the flood-stop
+ * benefit applies universally, incl. the standby `not-lease-holder` flood) — it
+ * simply never raises the "stuck session" attention item.
+ */
+export declare const IDLE_ZOMBIE_ESCALATION_REASONS: ReadonlySet<string>;
+export declare class VetoedKillBackoff {
+    private readonly backoffMs;
+    private readonly maxTracked;
+    /** sessionId -> ledger entry (insertion-ordered for oldest-eviction). */
+    private readonly entries;
+    constructor(opts?: Partial<VetoedKillBackoffOptions>);
+    /**
+     * Whether the kill branch may request a kill for this session right now.
+     *
+     * - backoffMs === 0 → always true (no cooldown gate).
+     * - no entry → true (never vetoed / already cleared).
+     * - STALE-REPRIEVE (R3-2): a stored key AND a supplied key that DIFFER means the
+     *   protection changed → invalidate the entry and allow one fresh evaluation now.
+     * - else → true once `nowMs >= entry.until`.
+     *
+     * Back-compat: `reasonKey` omitted (age-gate 2-arg callsites) ⇒ treated as null
+     * ⇒ no stale-reprieve, today's behavior.
+     */
+    shouldRequest(sessionId: string, nowMs: number, reasonKey?: string | null): boolean;
+    /**
+     * Record that the guard KEPT this session (kill vetoed) — back off re-requests.
+     * Returns `firstOfEpisode`: true exactly once per (session, reasonKey) episode so
+     * the caller logs the WARN once, not every tick.
+     *
+     * With backoffMs === 0 (no cooldown) the entry is STILL recorded — episode
+     * counting, the once-per-episode log gate, and the P19 breaker all still work
+     * (R4-5: cooldownMs:0 is enabled-but-no-cooldown, NOT a disable).
+     */
+    recordVeto(sessionId: string, nowMs: number, reasonKey?: string | null): boolean;
+    /** Consecutive veto episodes recorded for this session (0 if none). */
+    episodeCount(sessionId: string): number;
+    /** The session was actually killed — drop its state (episode ends). */
+    recordKilled(sessionId: string): void;
+    /** Session is gone (cleanup on removal). */
+    clear(sessionId: string): void;
+    /** A session's state changed materially (e.g. it resumed work) — drop the
+     *  back-off so it is re-evaluated at the next tick rather than staying suppressed. */
+    reset(sessionId: string): void;
+    /** Test/inspection seam — ms remaining in the back-off window (0 if not
+     *  suppressed). Reads `.until`, never the whole object (L1). */
+    remainingMs(sessionId: string, nowMs: number): number;
+    /** Test/inspection seam. */
+    get trackedCount(): number;
+    /** Drop the oldest entry while over the cap (insertion-ordered Map). */
+    private evictIfNeeded;
+}
+//# sourceMappingURL=VetoedKillBackoff.d.ts.map

package/dist/core/VetoedKillBackoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VetoedKillBackoff.d.ts","sourceRoot":"","sources":["../../src/core/VetoedKillBackoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,wBAAwB;IACvC;;+CAE2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,2BAA2B,EAAE,wBAGzC,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAC7D,eAAO,MAAM,wBAAwB,EAAE,wBAAsD,CAAC;AAwB9F;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GACvD,MAAM,GAAG,IAAI,CAIf;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,uQAc1B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,8BAA8B,EAAE,WAAW,CAAC,MAAM,CAU7D,CAAC;AAEH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;gBAE/C,IAAI,GAAE,OAAO,CAAC,wBAAwB,CAAM;IAOxD;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;IAYnF;;;;;;;;OAQG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;IA4BhF,uEAAuE;IACvE,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIvC,uEAAuE;IACvE,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC,4CAA4C;IAC5C,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B;0FACsF;IACtF,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B;oEACgE;IAChE,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAKrD,4BAA4B;IAC5B,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,wEAAwE;IACxE,OAAO,CAAC,aAAa;CAOtB"}

package/dist/core/VetoedKillBackoff.js

@@ -0,0 +1,221 @@
+/**
+ * VetoedKillBackoff — a per-session veto-backoff ledger for the SessionManager
+ * kill branches (the age-gate AND the bound-idle zombie killer).
+ *
+ * SessionManager.monitorTick runs every 5 seconds. When it decides a session is
+ * killable (past its max age, or idle-at-prompt past its bound-idle threshold) it
+ * requests a kill via terminateSession → ReapGuard. If the §P2 KEEP-guard vetoes
+ * that kill (a recent user message, an open commitment, a live subagent, …), the
+ * session correctly survives — but a naive caller re-requests the SAME kill every
+ * 5 seconds forever (720 attempts/hour/session → the 2026-06-05 17,503-line log
+ * flood, and the 2026-07-03 132MB reap-log idle-zombie hot-spin).
+ *
+ * This ledger makes the kill branch RESPECT the guard's verdict: after a veto it
+ * suppresses re-requests for `backoffMs` (so a kept session is re-checked on a slow
+ * cadence, not every tick). It changes only how OFTEN a vetoed kill is retried —
+ * never WHICH sessions are killed (the KEEP-guard remains the sole authority). A
+ * genuinely-idle-abandoned session has no keep-reason, so its first request returns
+ * terminated:true and it dies exactly as before.
+ *
+ * Generalized from the shipped `AgeKillBackoff` (#863): a superset that adds a
+ * reason-KEY-aware stale-reprieve (a changed protection re-checks now, doesn't wait
+ * out the window), an episode counter (feeds the P19 breaker), and a once-per-episode
+ * log gate (`recordVeto` returns `firstOfEpisode`) — all folded into the ledger value
+ * so no parallel Set is needed. The class is not persisted; there is no on-disk value
+ * to migrate.
+ *
+ * Pure logic, injectable clock, bounded memory — unit-testable in isolation.
+ */
+export const DEFAULT_VETOED_KILL_BACKOFF = {
+    backoffMs: 10 * 60 * 1000, // 10 minutes → 6 attempts/hr (was 720/hr)
+    maxTracked: 1024,
+};
+export const DEFAULT_AGE_KILL_BACKOFF = DEFAULT_VETOED_KILL_BACKOFF;
+function coerceNonNegInt(v, fallback) {
+    const n = typeof v === 'number' ? v : NaN;
+    if (!Number.isFinite(n) || n < 0)
+        return fallback;
+    return Math.floor(n);
+}
+/**
+ * Map a ReapGuard blockedReason result (or a bare reason string) to the STABLE
+ * ledger key. The `reason` field ReapGuard returns is already a stable enum key
+ * (`open-commitment`, `recent-user-message`, …), NOT free-form/interpolated text,
+ * so it is safe to use verbatim as the ledger key (R3-2). The human-readable string
+ * (if any interpolation ever existed) is used only for WARN/attention wording; only
+ * this stable key crosses into the ledger.
+ *
+ * Returns null when there is no usable reason string — the "unkeyable, fail-open"
+ * case: the caller re-evaluates this tick rather than minting a fabricated key.
+ */
+export function normalizeReasonKey(blocked) {
+    if (!blocked)
+        return null;
+    const reason = typeof blocked === 'string' ? blocked : blocked.reason;
+    return typeof reason === 'string' && reason.length > 0 ? reason : null;
+}
+/**
+ * Every keep-reason `ReapGuard.blockedReason()` can currently return (source of
+ * truth: src/core/ReapGuard.ts evaluate()). Used by the exhaustive normalization
+ * test — each maps to its OWN distinct key, and no two materially-different keep
+ * reasons collapse onto one another.
+ */
+export const KNOWN_REAP_KEEP_REASONS = [
+    'protected',
+    'spawn-grace',
+    'recovery-in-flight',
+    'pending-injection',
+    'relay-lease',
+    'recent-user-message',
+    'open-commitment',
+    'active-subagent',
+    'structural-long-work',
+    'active-process',
+    'process-uninspectable',
+    'main-process-active',
+    'guard-error',
+];
+/**
+ * The subset of skip reasons whose PERSISTENCE is a genuine "this session is STUCK
+ * and should be investigated" signal — i.e. the ones the Fix A′ P19 breaker may
+ * escalate on (spec §Fix A′: "likely a stuck open-commitment or a resume-loop").
+ *
+ * DELIBERATELY EXCLUDED (second-pass review, point 9 — the multi-machine standby
+ * escalation gap the converged spec did not cover):
+ *  - Authority/CAS skips `terminateSession` returns BEFORE the keep-guard runs —
+ *    `not-lease-holder` (a STANDBY machine returns this every tick for every idle
+ *    session — escalating it as "vetoed from cleanup" is false), `in-flight`,
+ *    `not-found`, `already-completed`/`already-killed`/`already-*`. These are not
+ *    keep-reasons at all.
+ *  - Intentional / transient keep-reasons that are NOT a stuck anomaly:
+ *    `protected` (operator-configured permanent keep), `spawn-grace` (startup),
+ *    `recovery-in-flight` (a bounded recovery window), `guard-error` (a transient
+ *    inspect failure that resolves itself).
+ *
+ * A skip reason OUTSIDE this set still COOLS DOWN (recordVeto → the flood-stop
+ * benefit applies universally, incl. the standby `not-lease-holder` flood) — it
+ * simply never raises the "stuck session" attention item.
+ */
+export const IDLE_ZOMBIE_ESCALATION_REASONS = new Set([
+    'open-commitment',
+    'recent-user-message',
+    'active-subagent',
+    'structural-long-work',
+    'active-process',
+    'main-process-active',
+    'process-uninspectable',
+    'pending-injection',
+    'relay-lease',
+]);
+export class VetoedKillBackoff {
+    backoffMs;
+    maxTracked;
+    /** sessionId -> ledger entry (insertion-ordered for oldest-eviction). */
+    entries = new Map();
+    constructor(opts = {}) {
+        const d = DEFAULT_VETOED_KILL_BACKOFF;
+        // backoffMs may be 0 (no cooldown window) — only a negative/NaN falls back.
+        this.backoffMs = coerceNonNegInt(opts.backoffMs, d.backoffMs);
+        this.maxTracked = Math.max(1, coerceNonNegInt(opts.maxTracked, d.maxTracked));
+    }
+    /**
+     * Whether the kill branch may request a kill for this session right now.
+     *
+     * - backoffMs === 0 → always true (no cooldown gate).
+     * - no entry → true (never vetoed / already cleared).
+     * - STALE-REPRIEVE (R3-2): a stored key AND a supplied key that DIFFER means the
+     *   protection changed → invalidate the entry and allow one fresh evaluation now.
+     * - else → true once `nowMs >= entry.until`.
+     *
+     * Back-compat: `reasonKey` omitted (age-gate 2-arg callsites) ⇒ treated as null
+     * ⇒ no stale-reprieve, today's behavior.
+     */
+    shouldRequest(sessionId, nowMs, reasonKey) {
+        if (this.backoffMs === 0)
+            return true;
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return true;
+        if (entry.reasonKey != null && reasonKey != null && reasonKey !== entry.reasonKey) {
+            // Protection changed — re-check now rather than waiting out the window.
+            this.entries.delete(sessionId);
+            return true;
+        }
+        return nowMs >= entry.until;
+    }
+    /**
+     * Record that the guard KEPT this session (kill vetoed) — back off re-requests.
+     * Returns `firstOfEpisode`: true exactly once per (session, reasonKey) episode so
+     * the caller logs the WARN once, not every tick.
+     *
+     * With backoffMs === 0 (no cooldown) the entry is STILL recorded — episode
+     * counting, the once-per-episode log gate, and the P19 breaker all still work
+     * (R4-5: cooldownMs:0 is enabled-but-no-cooldown, NOT a disable).
+     */
+    recordVeto(sessionId, nowMs, reasonKey) {
+        const key = reasonKey ?? null;
+        const existing = this.entries.get(sessionId);
+        let firstOfEpisode;
+        if (!existing || existing.reasonKey !== key) {
+            // New episode (no entry, or the reason changed) — fresh entry, log once.
+            this.entries.set(sessionId, {
+                until: nowMs + this.backoffMs,
+                reasonKey: key,
+                logged: true,
+                episodeCount: 1,
+            });
+            firstOfEpisode = true;
+        }
+        else {
+            // Same reason, existing episode — extend the window + count the episode.
+            existing.until = nowMs + this.backoffMs;
+            existing.episodeCount++;
+            if (existing.logged) {
+                firstOfEpisode = false;
+            }
+            else {
+                existing.logged = true;
+                firstOfEpisode = true;
+            }
+        }
+        this.evictIfNeeded();
+        return firstOfEpisode;
+    }
+    /** Consecutive veto episodes recorded for this session (0 if none). */
+    episodeCount(sessionId) {
+        return this.entries.get(sessionId)?.episodeCount ?? 0;
+    }
+    /** The session was actually killed — drop its state (episode ends). */
+    recordKilled(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    /** Session is gone (cleanup on removal). */
+    clear(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    /** A session's state changed materially (e.g. it resumed work) — drop the
+     *  back-off so it is re-evaluated at the next tick rather than staying suppressed. */
+    reset(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    /** Test/inspection seam — ms remaining in the back-off window (0 if not
+     *  suppressed). Reads `.until`, never the whole object (L1). */
+    remainingMs(sessionId, nowMs) {
+        const entry = this.entries.get(sessionId);
+        return entry != null && entry.until > nowMs ? entry.until - nowMs : 0;
+    }
+    /** Test/inspection seam. */
+    get trackedCount() {
+        return this.entries.size;
+    }
+    /** Drop the oldest entry while over the cap (insertion-ordered Map). */
+    evictIfNeeded() {
+        while (this.entries.size > this.maxTracked) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+}
+//# sourceMappingURL=VetoedKillBackoff.js.map

package/dist/core/VetoedKillBackoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VetoedKillBackoff.js","sourceRoot":"","sources":["../../src/core/VetoedKillBackoff.ts"],"names":[],"mappings":"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"}

package/dist/core/types.d.ts

@@ -4509,6 +4509,24 @@ export interface MonitoringConfig {
     idleThrottleSettleGate?: {
         enabled?: boolean;
     };
+    /**
+     * Session-respawn-thrash Fix A (docs/specs/session-respawn-thrash-elimination.md):
+     * the veto-backoff ledger for the SessionManager bound-idle zombie killer. When a
+     * session is idle-at-prompt past its bound-idle threshold but the ReapGuard
+     * permanently vetoes the kill (open-commitment / recent-user-message), the killer
+     * used to re-fire terminateSession every 5s forever (the 132MB reap-log hot-spin).
+     * This ledger backs off re-attempts to one per `cooldownMs`, logs once per veto
+     * episode, and raises ONE attention item after `escalateAfterEpisodes` (P19
+     * breaker). `enabled` resolves via the developmentAgent dark-feature gate
+     * (live-on-dev, dark-fleet); `cooldownMs: 0` is enabled-but-no-cooldown (NOT a
+     * disable — the disable path is `enabled: false`, which never constructs the
+     * ledger). Machine-local by design (never replicated).
+     */
+    idleKillVetoBackoff?: {
+        enabled?: boolean;
+        cooldownMs?: number;
+        escalateAfterEpisodes?: number;
+    };
     /**
      * honest-session-state-surfaces Finding (b): lift the Tier-3 honest
      * stuck-state classification into PresenceProxy Tier 1 / Tier 2 standby —