instar 1.3.672 → 1.3.674

package/dist/core/inboundLossRouting.d.ts

@@ -0,0 +1,30 @@
+/**
+ * F3 (Inbound Delivery Is Sacred) — pure routing plan for inbound-queue loss
+ * notices. A lost inbound user message must reach the user who sent it (each
+ * loss item's `sessionKey` IS the topic id they messaged from) OR, if it has no
+ * resolvable destination, be surfaced LOUDLY — never silently expired. This pure
+ * function decides the routing; server.ts does the actual notify()/loud-surface.
+ * Constitution: "The User Experience Is the Product" → sub-standard #3 Inbound
+ * Delivery Is Sacred. Spec: docs/specs/inbound-delivery-sacred.md.
+ */
+export interface InboundLossRoutePlan {
+    /** Per-ORIGINATING-topic notice — each affected topic + how many of its
+     *  messages were lost (delivered IN that topic, the proven path). */
+    perTopic: Array<{
+        topicId: number;
+        count: number;
+    }>;
+    /** Count of lost items whose sessionKey is not a resolvable numeric topic.
+     *  These fall back to the attention topic; if that is unset too, they MUST be
+     *  surfaced loudly (the one seam where a loss could otherwise go silent). */
+    unresolved: number;
+}
+/**
+ * Group inbound loss items by their originating topic. Pure: same input → same
+ * output. A sessionKey that is a positive finite number is a topic id; anything
+ * else (empty, non-numeric, legacy single-file key) is counted as `unresolved`.
+ */
+export declare function planInboundLossNotices(items: ReadonlyArray<{
+    sessionKey: string;
+}>): InboundLossRoutePlan;
+//# sourceMappingURL=inboundLossRouting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inboundLossRouting.d.ts","sourceRoot":"","sources":["../../src/core/inboundLossRouting.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,oBAAoB;IACnC;yEACqE;IACrE,QAAQ,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD;;iFAE6E;IAC7E,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAC3C,oBAAoB,CAkBtB"}

package/dist/core/inboundLossRouting.js

@@ -0,0 +1,35 @@
+/**
+ * F3 (Inbound Delivery Is Sacred) — pure routing plan for inbound-queue loss
+ * notices. A lost inbound user message must reach the user who sent it (each
+ * loss item's `sessionKey` IS the topic id they messaged from) OR, if it has no
+ * resolvable destination, be surfaced LOUDLY — never silently expired. This pure
+ * function decides the routing; server.ts does the actual notify()/loud-surface.
+ * Constitution: "The User Experience Is the Product" → sub-standard #3 Inbound
+ * Delivery Is Sacred. Spec: docs/specs/inbound-delivery-sacred.md.
+ */
+/**
+ * Group inbound loss items by their originating topic. Pure: same input → same
+ * output. A sessionKey that is a positive finite number is a topic id; anything
+ * else (empty, non-numeric, legacy single-file key) is counted as `unresolved`.
+ */
+export function planInboundLossNotices(items) {
+    const byTopic = new Map();
+    let unresolved = 0;
+    for (const it of items) {
+        const tid = Number(it.sessionKey);
+        if (Number.isFinite(tid) && tid > 0) {
+            byTopic.set(tid, (byTopic.get(tid) ?? 0) + 1);
+        }
+        else {
+            unresolved++;
+        }
+    }
+    return {
+        // Deterministic order (ascending topic id) for stable notices + tests.
+        perTopic: [...byTopic.entries()]
+            .sort((a, b) => a[0] - b[0])
+            .map(([topicId, count]) => ({ topicId, count })),
+        unresolved,
+    };
+}
+//# sourceMappingURL=inboundLossRouting.js.map

package/dist/core/inboundLossRouting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inboundLossRouting.js","sourceRoot":"","sources":["../../src/core/inboundLossRouting.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAA4C;IAE5C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,KAAK,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;QAClC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;YACpC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,UAAU,EAAE,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO;QACL,uEAAuE;QACvE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;aAC7B,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3B,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;QAClD,UAAU;KACX,CAAC;AACJ,CAAC"}

package/dist/monitoring/EnforcedTerminationWatchdog.d.ts

@@ -0,0 +1,91 @@
+/**
+ * EnforcedTerminationWatchdog — the external hard-stop loop for autonomous runs
+ * that overrun their budget. Wires the pure decision core (computeOverrun +
+ * TerminationConfirmer) to injected, side-effecting dependencies so the loop is
+ * unit-testable with fakes and the real (session-killing) actuation lives behind
+ * one interface. Spec: docs/specs/enforced-termination-watchdog.md.
+ *
+ * Constitution: "The User Experience Is the Product" → sub-standard #2 Enforced
+ * Termination — "Structure beats Willpower" applied to the END of work. The
+ * counterweight to "An Autonomous Run Must Outlive Its Session": that keeps a run
+ * alive across vessel events; THIS keeps a run from outliving its budget.
+ *
+ * Dark/dryRun-first rollout (mirrors AutonomousLivenessReconciler): ships with
+ * `enabled` omitted from config defaults (resolves live only on a dev agent) and
+ * `dryRun` defaulting true (logs would-terminate, actuates nothing) until a
+ * deliberate flip. The actuation is deliberately NOT in this class — it is the
+ * injected `terminate` actuator, so this orchestration never imports a session
+ * killer and stays provable in isolation.
+ */
+import { type AutonomousRunSnapshot, type EnforcedTerminationConfig, type OverrunReason } from './enforcedTermination.js';
+export interface EnforcedTerminationDeps {
+    /** Returns the current durable snapshot of every autonomous run. */
+    listRuns: () => AutonomousRunSnapshot[];
+    /**
+     * Durably terminate a run so neither the liveness-reconciler nor the resume
+     * queue revives it (delete state file + record operator-stop + cancel resume +
+     * clear endedMidWork + killSession). Returns true on a clean actuation. Only
+     * ever called for a TWO-tick-confirmed overrun, and never in dryRun.
+     */
+    terminate: (topicId: string, reason: OverrunReason) => Promise<boolean>;
+    /** Append one audit row per transition. Must never throw into the loop. */
+    audit: (row: EnforcedTerminationAuditRow) => void;
+    /** Monotonic clock (injectable for tests). */
+    now?: () => number;
+}
+export interface EnforcedTerminationOptions extends Partial<EnforcedTerminationConfig> {
+    enabled: boolean;
+    dryRun?: boolean;
+    /** Consecutive overrun ticks required before a kill. Default 2. */
+    confirmThreshold?: number;
+    /** Per-window cap on actuations; a flapping detector gives up LOUDLY. Default 5. */
+    maxTerminationsPerWindow?: number;
+    tickIntervalSec?: number;
+}
+export interface EnforcedTerminationAuditRow {
+    ts: number;
+    topicId: string;
+    event: 'overrun-detected' | 'terminate-pending' | 'terminated' | 'would-terminate' | 'terminate-failed' | 'cap-exceeded';
+    reason?: OverrunReason;
+    dryRun: boolean;
+}
+export interface EnforcedTerminationGuardStatus {
+    enabled: boolean;
+    dryRun: boolean;
+    graceSeconds: number;
+    absoluteCeilingSeconds: number;
+    lastTickAt: number | null;
+    pending: string[];
+    terminatedCount: number;
+    wouldTerminateCount: number;
+    capExceededCount: number;
+}
+export declare class EnforcedTerminationWatchdog {
+    private readonly deps;
+    private readonly opts;
+    private readonly cfg;
+    private readonly confirmer;
+    private readonly now;
+    private timer;
+    private lastTickAt;
+    private terminatedCount;
+    private wouldTerminateCount;
+    private capExceededCount;
+    private readonly actuationTimes;
+    private readonly windowMs;
+    constructor(deps: EnforcedTerminationDeps, opts: EnforcedTerminationOptions);
+    /** Start the unref'd tick loop. No-op when disabled. */
+    start(): void;
+    stop(): void;
+    /**
+     * One reconcile pass. Pure-core decides overrun; the confirmer enforces the
+     * two-tick rule; only a CONFIRMED overrun actuates (and never in dryRun). Every
+     * predicate failure is swallowed toward NO actuation (fail-safe direction).
+     */
+    tick(): Promise<void>;
+    guardStatus(): EnforcedTerminationGuardStatus;
+    private get dryRun();
+    private withinCap;
+    private safeAudit;
+}
+//# sourceMappingURL=EnforcedTerminationWatchdog.d.ts.map

package/dist/monitoring/EnforcedTerminationWatchdog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnforcedTerminationWatchdog.d.ts","sourceRoot":"","sources":["../../src/monitoring/EnforcedTerminationWatchdog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAIL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,aAAa,EACnB,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,uBAAuB;IACtC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,qBAAqB,EAAE,CAAC;IACxC;;;;;OAKG;IACH,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,2EAA2E;IAC3E,KAAK,EAAE,CAAC,GAAG,EAAE,2BAA2B,KAAK,IAAI,CAAC;IAClD,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,0BAA2B,SAAQ,OAAO,CAAC,yBAAyB,CAAC;IACpF,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EACD,kBAAkB,GAClB,mBAAmB,GACnB,YAAY,GACZ,iBAAiB,GACjB,kBAAkB,GAClB,cAAc,CAAC;IACnB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,2BAA2B;IAepC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAfvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,KAAK,CAA+C;IAE5D,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,gBAAgB,CAAK;IAE7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAC/C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAGf,IAAI,EAAE,uBAAuB,EAC7B,IAAI,EAAE,0BAA0B;IAanD,wDAAwD;IACxD,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,IAAI;IAOZ;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoE3B,WAAW,IAAI,8BAA8B;IAc7C,OAAO,KAAK,MAAM,GAEjB;IAED,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,SAAS;CAOlB"}

package/dist/monitoring/EnforcedTerminationWatchdog.js

@@ -0,0 +1,172 @@
+/**
+ * EnforcedTerminationWatchdog — the external hard-stop loop for autonomous runs
+ * that overrun their budget. Wires the pure decision core (computeOverrun +
+ * TerminationConfirmer) to injected, side-effecting dependencies so the loop is
+ * unit-testable with fakes and the real (session-killing) actuation lives behind
+ * one interface. Spec: docs/specs/enforced-termination-watchdog.md.
+ *
+ * Constitution: "The User Experience Is the Product" → sub-standard #2 Enforced
+ * Termination — "Structure beats Willpower" applied to the END of work. The
+ * counterweight to "An Autonomous Run Must Outlive Its Session": that keeps a run
+ * alive across vessel events; THIS keeps a run from outliving its budget.
+ *
+ * Dark/dryRun-first rollout (mirrors AutonomousLivenessReconciler): ships with
+ * `enabled` omitted from config defaults (resolves live only on a dev agent) and
+ * `dryRun` defaulting true (logs would-terminate, actuates nothing) until a
+ * deliberate flip. The actuation is deliberately NOT in this class — it is the
+ * injected `terminate` actuator, so this orchestration never imports a session
+ * killer and stays provable in isolation.
+ */
+import { computeOverrun, TerminationConfirmer, DEFAULT_ENFORCED_TERMINATION_CONFIG, } from './enforcedTermination.js';
+export class EnforcedTerminationWatchdog {
+    deps;
+    opts;
+    cfg;
+    confirmer;
+    now;
+    timer = null;
+    lastTickAt = null;
+    terminatedCount = 0;
+    wouldTerminateCount = 0;
+    capExceededCount = 0;
+    // Window of actuation timestamps for the per-window cap.
+    actuationTimes = [];
+    windowMs;
+    constructor(deps, opts) {
+        this.deps = deps;
+        this.opts = opts;
+        this.cfg = {
+            graceSeconds: opts.graceSeconds ?? DEFAULT_ENFORCED_TERMINATION_CONFIG.graceSeconds,
+            absoluteCeilingSeconds: opts.absoluteCeilingSeconds ?? DEFAULT_ENFORCED_TERMINATION_CONFIG.absoluteCeilingSeconds,
+            maxIterations: opts.maxIterations,
+        };
+        this.confirmer = new TerminationConfirmer(opts.confirmThreshold ?? 2);
+        this.now = deps.now ?? Date.now;
+        this.windowMs = (opts.tickIntervalSec ?? 60) * 1000 * 60; // ~60 ticks
+    }
+    /** Start the unref'd tick loop. No-op when disabled. */
+    start() {
+        if (!this.opts.enabled || this.timer)
+            return;
+        const intervalMs = (this.opts.tickIntervalSec ?? 60) * 1000;
+        this.timer = setInterval(() => void this.tick().catch(() => {
+            // @silent-fallback-ok: tick() handles its own errors and fails safe toward
+            // NO actuation; a thrown tick must not crash the unref'd timer loop.
+        }), intervalMs);
+        if (typeof this.timer.unref === 'function') {
+            this.timer.unref();
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * One reconcile pass. Pure-core decides overrun; the confirmer enforces the
+     * two-tick rule; only a CONFIRMED overrun actuates (and never in dryRun). Every
+     * predicate failure is swallowed toward NO actuation (fail-safe direction).
+     */
+    async tick() {
+        if (!this.opts.enabled)
+            return;
+        const t = this.now();
+        this.lastTickAt = t;
+        let runs;
+        try {
+            runs = this.deps.listRuns();
+        }
+        catch {
+            // @silent-fallback-ok: can't read state → do nothing. Fail-safe is the
+            // SAFE direction for a session-killer (never kill on uncertainty); a louder
+            // surface here would risk noise on a transient read while changing nothing.
+            return;
+        }
+        const overrun = new Map();
+        for (const r of runs) {
+            let reason = null;
+            try {
+                reason = computeOverrun(r, this.cfg, t);
+            }
+            catch {
+                // @silent-fallback-ok: a malformed snapshot is not an overrun → skip it
+                // (fail-safe: never classify-to-kill on a parse error).
+                reason = null;
+            }
+            if (reason) {
+                overrun.set(r.topicId, reason);
+                this.safeAudit({ ts: t, topicId: r.topicId, event: 'overrun-detected', reason, dryRun: this.dryRun });
+            }
+        }
+        const confirmed = this.confirmer.reconcile(overrun.keys());
+        // Topics overrun but not yet confirmed are terminate-pending.
+        for (const topic of this.confirmer.pendingTopics()) {
+            this.safeAudit({ ts: t, topicId: topic, event: 'terminate-pending', reason: overrun.get(topic), dryRun: this.dryRun });
+        }
+        for (const topic of confirmed) {
+            const reason = overrun.get(topic);
+            if (this.dryRun) {
+                this.wouldTerminateCount++;
+                this.safeAudit({ ts: t, topicId: topic, event: 'would-terminate', reason, dryRun: true });
+                this.confirmer.clear(topic);
+                continue;
+            }
+            if (!this.withinCap(t)) {
+                this.capExceededCount++;
+                this.safeAudit({ ts: t, topicId: topic, event: 'cap-exceeded', reason, dryRun: false });
+                continue; // give up LOUDLY (audited) rather than kill-loop; keep pending
+            }
+            let ok = false;
+            try {
+                ok = await this.deps.terminate(topic, reason);
+            }
+            catch {
+                ok = false;
+            }
+            if (ok) {
+                this.terminatedCount++;
+                this.actuationTimes.push(t);
+                this.confirmer.clear(topic);
+                this.safeAudit({ ts: t, topicId: topic, event: 'terminated', reason, dryRun: false });
+            }
+            else {
+                this.safeAudit({ ts: t, topicId: topic, event: 'terminate-failed', reason, dryRun: false });
+                // leave pending so a later tick retries (subject to the cap)
+            }
+        }
+    }
+    guardStatus() {
+        return {
+            enabled: this.opts.enabled,
+            dryRun: this.dryRun,
+            graceSeconds: this.cfg.graceSeconds,
+            absoluteCeilingSeconds: this.cfg.absoluteCeilingSeconds,
+            lastTickAt: this.lastTickAt,
+            pending: this.confirmer.pendingTopics(),
+            terminatedCount: this.terminatedCount,
+            wouldTerminateCount: this.wouldTerminateCount,
+            capExceededCount: this.capExceededCount,
+        };
+    }
+    get dryRun() {
+        return this.opts.dryRun ?? true;
+    }
+    withinCap(now) {
+        const cap = this.opts.maxTerminationsPerWindow ?? 5;
+        // prune old actuations outside the window
+        while (this.actuationTimes.length && now - this.actuationTimes[0] > this.windowMs) {
+            this.actuationTimes.shift();
+        }
+        return this.actuationTimes.length < cap;
+    }
+    safeAudit(row) {
+        try {
+            this.deps.audit(row);
+        }
+        catch {
+            /* the audit sink must never endanger the loop */
+        }
+    }
+}
+//# sourceMappingURL=EnforcedTerminationWatchdog.js.map

package/dist/monitoring/EnforcedTerminationWatchdog.js.map

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

package/dist/monitoring/enforcedTermination.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Enforced Termination — the PURE decision core for the external hard-stop on
+ * autonomous runs. Spec: docs/specs/enforced-termination-watchdog.md.
+ * Constitution: "The User Experience Is the Product" → sub-standard #2 Enforced
+ * Termination; an instance of "Structure beats Willpower" applied to the END of
+ * work. Earned from 2026-06-25 (topic 27515 ran ~46h on a 24h budget).
+ *
+ * This module is intentionally dependency-free (no sessions, no fs, no clock of
+ * its own) so the overrun predicate and the two-phase confirm are unit-tested
+ * deterministically. The watchdog that actuates a kill (delete state file +
+ * record operator-stop + cancel resume + clear endedMidWork + killSession) wires
+ * THIS core to real deps — the safety-critical actuation is deliberately kept
+ * out of the pure logic so the decision boundary is provable in isolation.
+ */
+/** A durable snapshot of one autonomous run, parsed from its state frontmatter. */
+export interface AutonomousRunSnapshot {
+    /** Telegram topic id (string key of the run). */
+    topicId: string;
+    /** Parsed `started_at` epoch ms, or null when absent/unparseable. */
+    startedAtMs: number | null;
+    /**
+     * Fallback clock for the absolute ceiling ONLY — the run state file's mtime
+     * (ms). Used when `startedAtMs` is null so an unparseable timestamp still has
+     * a bounded ceiling (fail TOWARD termination, never toward run-forever).
+     */
+    fileMtimeMs: number;
+    /** `duration_seconds` budget. null or 0 ⇒ UNBOUNDED (no time budget). */
+    durationSeconds: number | null;
+    /** Current iteration count (for the optional iteration ceiling). */
+    iteration: number;
+    /** Whether the run is marked active. */
+    active: boolean;
+    /** Whether the run is paused (operator pause / move). Paused ⇒ never terminated. */
+    paused: boolean;
+    /**
+     * True when the run is mid cross-machine move (`move_suspended_at`/`moved_to`
+     * present). The destination re-evaluates; this watchdog must NOT kill it.
+     */
+    moveSuspended: boolean;
+}
+export interface EnforcedTerminationConfig {
+    /**
+     * Grace past the time budget before the watchdog fires, letting the
+     * cooperative in-hook duration check win the normal case. Default 120s.
+     */
+    graceSeconds: number;
+    /**
+     * Absolute hard ceiling from the run's start. Fires even for an UNBOUNDED run
+     * or an unparseable `started_at` (via file mtime). Default 26h.
+     */
+    absoluteCeilingSeconds: number;
+    /** Optional iteration ceiling. Unset ⇒ no iteration-based termination. */
+    maxIterations?: number;
+}
+export declare const DEFAULT_ENFORCED_TERMINATION_CONFIG: EnforcedTerminationConfig;
+export type OverrunReason = {
+    kind: 'time-budget';
+    elapsedSeconds: number;
+    budgetSeconds: number;
+} | {
+    kind: 'absolute-ceiling';
+    elapsedSeconds: number;
+    ceilingSeconds: number;
+    clock: 'started_at' | 'file-mtime';
+} | {
+    kind: 'iteration-ceiling';
+    iteration: number;
+    max: number;
+};
+/**
+ * Decide whether a run has PROVABLY overrun its budget. Pure: same inputs →
+ * same output. Returns the first matching reason, or null when the run is
+ * within budget / not eligible.
+ *
+ * Eligibility gates (return null): not active, paused, or mid-move. A run that
+ * is not eligible is NEVER terminated by this watchdog — the reaper handles
+ * idle/pressure; this fires ONLY on a genuine budget overrun.
+ */
+export declare function computeOverrun(run: AutonomousRunSnapshot, cfg: EnforcedTerminationConfig, nowMs: number): OverrunReason | null;
+/**
+ * Two-phase confirm — a topic is only terminated after it is observed overrun
+ * on TWO consecutive reconcile() ticks. This absorbs a clock blip, an in-flight
+ * cooperative stop landing between ticks, and a run that just completed. Mirrors
+ * SessionReaper's mark-pending / re-confirm pattern.
+ *
+ * Stateful but pure of side effects: it only tracks per-topic consecutive
+ * overrun counts. A topic that drops out of the overrun set is forgotten (its
+ * pending count resets), so a transient overrun never accumulates toward a kill.
+ */
+export declare class TerminationConfirmer {
+    private readonly pending;
+    private readonly threshold;
+    constructor(confirmThreshold?: number);
+    /**
+     * Feed the set of currently-overrun topic ids; returns the topics CONFIRMED
+     * for termination this tick (overrun for `threshold` consecutive ticks).
+     * Topics no longer overrun are cleared.
+     */
+    reconcile(overrunTopicIds: Iterable<string>): string[];
+    /** Drop a topic's pending state once it has been actuated (or cancelled). */
+    clear(topicId: string): void;
+    /** Topics currently marked terminate-pending (overrun but not yet confirmed). */
+    pendingTopics(): string[];
+}
+//# sourceMappingURL=enforcedTermination.d.ts.map

package/dist/monitoring/enforcedTermination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforcedTermination.d.ts","sourceRoot":"","sources":["../../src/monitoring/enforcedTermination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,MAAM,EAAE,OAAO,CAAC;IAChB,oFAAoF;IACpF,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,mCAAmC,EAAE,yBAGjD,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACtE;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,YAAY,GAAG,YAAY,CAAC;CACpC,GACD;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,qBAAqB,EAC1B,GAAG,EAAE,yBAAyB,EAC9B,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,IAAI,CAiCtB;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,gBAAgB,SAAI;IAIhC;;;;OAIG;IACH,SAAS,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE;IAetD,6EAA6E;IAC7E,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5B,iFAAiF;IACjF,aAAa,IAAI,MAAM,EAAE;CAG1B"}

package/dist/monitoring/enforcedTermination.js

@@ -0,0 +1,105 @@
+/**
+ * Enforced Termination — the PURE decision core for the external hard-stop on
+ * autonomous runs. Spec: docs/specs/enforced-termination-watchdog.md.
+ * Constitution: "The User Experience Is the Product" → sub-standard #2 Enforced
+ * Termination; an instance of "Structure beats Willpower" applied to the END of
+ * work. Earned from 2026-06-25 (topic 27515 ran ~46h on a 24h budget).
+ *
+ * This module is intentionally dependency-free (no sessions, no fs, no clock of
+ * its own) so the overrun predicate and the two-phase confirm are unit-tested
+ * deterministically. The watchdog that actuates a kill (delete state file +
+ * record operator-stop + cancel resume + clear endedMidWork + killSession) wires
+ * THIS core to real deps — the safety-critical actuation is deliberately kept
+ * out of the pure logic so the decision boundary is provable in isolation.
+ */
+export const DEFAULT_ENFORCED_TERMINATION_CONFIG = {
+    graceSeconds: 120,
+    absoluteCeilingSeconds: 26 * 60 * 60, // 26h
+};
+/**
+ * Decide whether a run has PROVABLY overrun its budget. Pure: same inputs →
+ * same output. Returns the first matching reason, or null when the run is
+ * within budget / not eligible.
+ *
+ * Eligibility gates (return null): not active, paused, or mid-move. A run that
+ * is not eligible is NEVER terminated by this watchdog — the reaper handles
+ * idle/pressure; this fires ONLY on a genuine budget overrun.
+ */
+export function computeOverrun(run, cfg, nowMs) {
+    if (!run.active || run.paused || run.moveSuspended)
+        return null;
+    // Iteration ceiling (optional, explicit opt-in).
+    if (cfg.maxIterations != null && cfg.maxIterations > 0 && run.iteration >= cfg.maxIterations) {
+        return { kind: 'iteration-ceiling', iteration: run.iteration, max: cfg.maxIterations };
+    }
+    // Time budget — only for a BOUNDED run with a parseable start. The grace
+    // window gives the cooperative in-hook check first right of termination.
+    if (run.startedAtMs != null && run.durationSeconds != null && run.durationSeconds > 0) {
+        const elapsed = (nowMs - run.startedAtMs) / 1000;
+        if (elapsed >= run.durationSeconds + cfg.graceSeconds) {
+            return { kind: 'time-budget', elapsedSeconds: elapsed, budgetSeconds: run.durationSeconds };
+        }
+    }
+    // Absolute ceiling — the backstop that covers the holes the in-hook check
+    // can't: an UNBOUNDED run (no duration), and an UNPARSEABLE started_at (uses
+    // file mtime). Fail TOWARD a bounded stop, never toward run-forever.
+    const clockMs = run.startedAtMs ?? run.fileMtimeMs;
+    const clock = run.startedAtMs != null ? 'started_at' : 'file-mtime';
+    const elapsedAbs = (nowMs - clockMs) / 1000;
+    if (elapsedAbs >= cfg.absoluteCeilingSeconds) {
+        return {
+            kind: 'absolute-ceiling',
+            elapsedSeconds: elapsedAbs,
+            ceilingSeconds: cfg.absoluteCeilingSeconds,
+            clock,
+        };
+    }
+    return null;
+}
+/**
+ * Two-phase confirm — a topic is only terminated after it is observed overrun
+ * on TWO consecutive reconcile() ticks. This absorbs a clock blip, an in-flight
+ * cooperative stop landing between ticks, and a run that just completed. Mirrors
+ * SessionReaper's mark-pending / re-confirm pattern.
+ *
+ * Stateful but pure of side effects: it only tracks per-topic consecutive
+ * overrun counts. A topic that drops out of the overrun set is forgotten (its
+ * pending count resets), so a transient overrun never accumulates toward a kill.
+ */
+export class TerminationConfirmer {
+    pending = new Map();
+    threshold;
+    constructor(confirmThreshold = 2) {
+        this.threshold = Math.max(1, confirmThreshold);
+    }
+    /**
+     * Feed the set of currently-overrun topic ids; returns the topics CONFIRMED
+     * for termination this tick (overrun for `threshold` consecutive ticks).
+     * Topics no longer overrun are cleared.
+     */
+    reconcile(overrunTopicIds) {
+        const overrun = new Set(overrunTopicIds);
+        const confirmed = [];
+        for (const topic of overrun) {
+            const next = (this.pending.get(topic) ?? 0) + 1;
+            this.pending.set(topic, next);
+            if (next >= this.threshold)
+                confirmed.push(topic);
+        }
+        // Forget topics that are no longer overrun (reset their streak).
+        for (const topic of [...this.pending.keys()]) {
+            if (!overrun.has(topic))
+                this.pending.delete(topic);
+        }
+        return confirmed;
+    }
+    /** Drop a topic's pending state once it has been actuated (or cancelled). */
+    clear(topicId) {
+        this.pending.delete(topicId);
+    }
+    /** Topics currently marked terminate-pending (overrun but not yet confirmed). */
+    pendingTopics() {
+        return [...this.pending.entries()].filter(([, n]) => n < this.threshold).map(([t]) => t);
+    }
+}
+//# sourceMappingURL=enforcedTermination.js.map

package/dist/monitoring/enforcedTermination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforcedTermination.js","sourceRoot":"","sources":["../../src/monitoring/enforcedTermination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA4CH,MAAM,CAAC,MAAM,mCAAmC,GAA8B;IAC5E,YAAY,EAAE,GAAG;IACjB,sBAAsB,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM;CAC7C,CAAC;AAYF;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,GAA0B,EAC1B,GAA8B,EAC9B,KAAa;IAEb,IAAI,CAAC,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,aAAa;QAAE,OAAO,IAAI,CAAC;IAEhE,iDAAiD;IACjD,IAAI,GAAG,CAAC,aAAa,IAAI,IAAI,IAAI,GAAG,CAAC,aAAa,GAAG,CAAC,IAAI,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,aAAa,EAAE,CAAC;QAC7F,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC;IACzF,CAAC;IAED,yEAAyE;IACzE,yEAAyE;IACzE,IAAI,GAAG,CAAC,WAAW,IAAI,IAAI,IAAI,GAAG,CAAC,eAAe,IAAI,IAAI,IAAI,GAAG,CAAC,eAAe,GAAG,CAAC,EAAE,CAAC;QACtF,MAAM,OAAO,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;QACjD,IAAI,OAAO,IAAI,GAAG,CAAC,eAAe,GAAG,GAAG,CAAC,YAAY,EAAE,CAAC;YACtD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,CAAC,eAAe,EAAE,CAAC;QAC9F,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,6EAA6E;IAC7E,qEAAqE;IACrE,MAAM,OAAO,GAAG,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,WAAW,CAAC;IACnD,MAAM,KAAK,GAAgC,GAAG,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC;IACjG,MAAM,UAAU,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,IAAI,UAAU,IAAI,GAAG,CAAC,sBAAsB,EAAE,CAAC;QAC7C,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,cAAc,EAAE,UAAU;YAC1B,cAAc,EAAE,GAAG,CAAC,sBAAsB;YAC1C,KAAK;SACN,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAoB;IACd,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IACpC,SAAS,CAAS;IAEnC,YAAY,gBAAgB,GAAG,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,eAAiC;QACzC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,CAAC;QACzC,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YAChD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAC9B,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS;gBAAE,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpD,CAAC;QACD,iEAAiE;QACjE,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,6EAA6E;IAC7E,KAAK,CAAC,OAAe;QACnB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED,iFAAiF;IACjF,aAAa;QACX,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC;CACF"}

package/dist/monitoring/enforcedTerminationWiring.d.ts

@@ -0,0 +1,18 @@
+import type { AutonomousRunSnapshot } from './enforcedTermination.js';
+import type { EnforcedTerminationAuditRow } from './EnforcedTerminationWatchdog.js';
+/**
+ * Build the `listRuns` provider: read every per-topic autonomous run file and
+ * project it into the pure-core snapshot. Legacy single-file jobs (topic === null)
+ * are skipped — the watchdog only governs per-topic runs (the only ones with a
+ * resolvable session to terminate). Each snapshot is durable-state only (file
+ * frontmatter + mtime), so the overrun decision survives a server restart.
+ */
+export declare function buildEnforcedTerminationListRuns(stateDir: string): () => AutonomousRunSnapshot[];
+/**
+ * Build the audit sink: append one JSON line per transition to
+ * `logs/enforced-termination.jsonl`. Bounded rotation at ~5MB so the audit can
+ * never grow unbounded. Wrapped by the watchdog's safeAudit so a write error
+ * never reaches the loop, but we also swallow here for defense in depth.
+ */
+export declare function buildEnforcedTerminationAudit(logsDir: string): (row: EnforcedTerminationAuditRow) => void;
+//# sourceMappingURL=enforcedTerminationWiring.d.ts.map

package/dist/monitoring/enforcedTerminationWiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforcedTerminationWiring.d.ts","sourceRoot":"","sources":["../../src/monitoring/enforcedTerminationWiring.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAEpF;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,qBAAqB,EAAE,CA8BhG;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,2BAA2B,KAAK,IAAI,CAiBzG"}