opensquid 0.5.395

package/dist/runtime/durable/resumer.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Restart-safe resume of interrupted runs (DURABLE.4).
+ *
+ * Daemon boot fires `resumeOnStartup()` AFTER lock acquire + BEFORE cron
+ * registration. Scans the checkpoint store for runs that have a
+ * manifest, no terminal marker, and a last-completed step within the
+ * resume window. For each, resolves the rule's current `ProcessStep[]`
+ * (via caller-supplied `RuleResolver`), hydrates `as:` bindings, and
+ * re-invokes the caller-supplied `RunEvaluator` from the next step.
+ *
+ * Locks (DURABLE.4 §learn / §risk):
+ *   - Window default 60s; `OPENSQUID_RESUME_WINDOW_MS` env override.
+ *     Explicit `opensquid checkpoints resume <run_id>` bypasses window.
+ *   - Pack-version mismatch → skip + audit `pack_version_mismatch`.
+ *     No silent migration (rules may have changed shape).
+ *   - Audit posture: ONE summary entry per startup call; per-run
+ *     entries only for resumed + reason-worthy skips. Stale-window
+ *     runs are filtered at SQL level, never enumerated.
+ *   - Concurrent-execution race avoided by daemon's proper-lockfile
+ *     singleton (SCHED.1); Resumer holds no lock of its own.
+ *
+ * Terminal-marker choice: Option 2 (explicit `terminal_markers` table)
+ * — cheaper than reloading every pack at scan time to compute
+ * `lastCompletedStep === totalSteps - 1`.
+ *
+ * Imports from: ./checkpoint_store.js, ../types.js.
+ * Imported by: OpenSquidDaemon (DURABLE.4 wire), checkpoints CLI.
+ */
+import type { CheckpointStore, RunManifest } from './checkpoint_store.js';
+import type { ProcessStep } from '../types.js';
+/** 60s — long enough for fast restart, short enough to avoid ghost revives. */
+export declare const DEFAULT_RESUME_WINDOW_MS = 60000;
+/** Resolver: manifest → current `ProcessStep[]` + live `packVersion`, or `null`
+ *  when the pack/skill/rule no longer exists. Drives `pack_missing` skip. */
+export interface ResolvedRule {
+    process: ProcessStep[];
+    packVersion: string;
+}
+export type RuleResolver = (manifest: RunManifest) => Promise<ResolvedRule | null>;
+/** Caller-supplied evaluator entry. Resumer never imports `evaluateProcess`
+ *  directly — keeps the module dependency-light and stubbable in tests. */
+export interface RunEvaluatorInput {
+    manifest: RunManifest;
+    bindings: Record<string, unknown>;
+    entryStepIdx: number;
+}
+export type RunEvaluator = (input: RunEvaluatorInput) => Promise<void>;
+/** Joined view of an interrupted run — manifest + checkpoint cursor. */
+export interface InterruptedRun {
+    runId: string;
+    lastCompletedStep: number;
+    lastCompletedAtMs: number;
+    packId: string;
+    packVersion: string;
+    skill: string;
+    ruleId: string;
+    eventKind: string;
+    eventPayload: unknown;
+}
+/** Audit entry shapes. `resume_summary` fires once per startup;
+ *  `resume_run` / `resume_skipped` ride along per run. */
+export type SkipReason = 'manifest_missing' | 'pack_missing' | 'rule_missing' | 'pack_version_mismatch' | 'evaluator_error';
+export type AuditEntry = {
+    event: 'resume_summary';
+    scanned: number;
+    resumed: number;
+    skippedOther: number;
+} | {
+    event: 'resume_run';
+    runId: string;
+    packId: string;
+    fromStepIdx: number;
+} | {
+    event: 'resume_skipped';
+    runId: string;
+    reason: SkipReason;
+    detail?: string;
+};
+export type AuditSink = (entry: AuditEntry) => void;
+export interface ResumeOpts {
+    store: CheckpointStore;
+    evaluator: RunEvaluator;
+    resolver: RuleResolver;
+    /** Audit sink; default no-op. */
+    auditLog?: AuditSink;
+    /** Override the default resume window. `Number.POSITIVE_INFINITY` disables. */
+    resumeWindowMs?: number;
+    /** Injected clock for tests; defaults to `Date.now`. */
+    nowMs?: () => number;
+}
+export interface ResumeResult {
+    resumed: boolean;
+    reason?: SkipReason;
+}
+export interface ResumeStartupResult {
+    resumed: number;
+    skipped: number;
+}
+export declare class Resumer {
+    private readonly store;
+    private readonly evaluator;
+    private readonly resolver;
+    /** Primary sink supplied at construction. Patch C adds `additionalSinks`
+     *  via `attachAuditSink` so the daemon can fan-out resumer events into
+     *  its unified `AuditLog` without rebuilding the Resumer. */
+    private readonly auditLog;
+    private readonly additionalSinks;
+    private readonly resumeWindowMs;
+    private readonly nowMs;
+    constructor(opts: ResumeOpts);
+    /** Patch C — daemon-side wiring hook. Attaches an additional audit sink
+     *  that fires AFTER the primary sink for every emitted entry. Multiple
+     *  attaches accumulate; no detach (daemon lifetime owns the Resumer).
+     *  Errors thrown from attached sinks are swallowed so a downstream
+     *  AuditLog hiccup never blocks the primary audit path. */
+    attachAuditSink(sink: AuditSink): void;
+    /** Internal — fan-out wrapper used by every audit emit site. */
+    private emit;
+    /** Discover interrupted runs in the configured resume window. */
+    scanInterrupted(): Promise<InterruptedRun[]>;
+    /** Resume one interrupted run. Returns `{ resumed: false, reason }` on
+     *  any skip (pack uninstalled, version diverged, evaluator threw). */
+    resume(run: InterruptedRun): Promise<ResumeResult>;
+    /** Daemon-startup entrypoint: scan + resume all. Invoked AFTER lock
+     *  acquire + BEFORE cron registration so resumes finish before fresh
+     *  fires can race. One summary audit entry; per-run only for resumed +
+     *  reason-worthy skips. */
+    resumeOnStartup(): Promise<ResumeStartupResult>;
+    private joinManifests;
+}
+//# sourceMappingURL=resumer.d.ts.map

package/dist/runtime/durable/resumer.d.ts.map

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

package/dist/runtime/durable/resumer.js

@@ -0,0 +1,190 @@
+/**
+ * Restart-safe resume of interrupted runs (DURABLE.4).
+ *
+ * Daemon boot fires `resumeOnStartup()` AFTER lock acquire + BEFORE cron
+ * registration. Scans the checkpoint store for runs that have a
+ * manifest, no terminal marker, and a last-completed step within the
+ * resume window. For each, resolves the rule's current `ProcessStep[]`
+ * (via caller-supplied `RuleResolver`), hydrates `as:` bindings, and
+ * re-invokes the caller-supplied `RunEvaluator` from the next step.
+ *
+ * Locks (DURABLE.4 §learn / §risk):
+ *   - Window default 60s; `OPENSQUID_RESUME_WINDOW_MS` env override.
+ *     Explicit `opensquid checkpoints resume <run_id>` bypasses window.
+ *   - Pack-version mismatch → skip + audit `pack_version_mismatch`.
+ *     No silent migration (rules may have changed shape).
+ *   - Audit posture: ONE summary entry per startup call; per-run
+ *     entries only for resumed + reason-worthy skips. Stale-window
+ *     runs are filtered at SQL level, never enumerated.
+ *   - Concurrent-execution race avoided by daemon's proper-lockfile
+ *     singleton (SCHED.1); Resumer holds no lock of its own.
+ *
+ * Terminal-marker choice: Option 2 (explicit `terminal_markers` table)
+ * — cheaper than reloading every pack at scan time to compute
+ * `lastCompletedStep === totalSteps - 1`.
+ *
+ * Imports from: ./checkpoint_store.js, ../types.js.
+ * Imported by: OpenSquidDaemon (DURABLE.4 wire), checkpoints CLI.
+ */
+/** 60s — long enough for fast restart, short enough to avoid ghost revives. */
+export const DEFAULT_RESUME_WINDOW_MS = 60_000;
+const noopAudit = () => {
+    /* default audit sink */
+};
+export class Resumer {
+    store;
+    evaluator;
+    resolver;
+    /** Primary sink supplied at construction. Patch C adds `additionalSinks`
+     *  via `attachAuditSink` so the daemon can fan-out resumer events into
+     *  its unified `AuditLog` without rebuilding the Resumer. */
+    auditLog;
+    additionalSinks = [];
+    resumeWindowMs;
+    nowMs;
+    constructor(opts) {
+        this.store = opts.store;
+        this.evaluator = opts.evaluator;
+        this.resolver = opts.resolver;
+        this.auditLog = opts.auditLog ?? noopAudit;
+        this.resumeWindowMs =
+            opts.resumeWindowMs ?? readResumeWindowFromEnv() ?? DEFAULT_RESUME_WINDOW_MS;
+        this.nowMs = opts.nowMs ?? Date.now;
+    }
+    /** Patch C — daemon-side wiring hook. Attaches an additional audit sink
+     *  that fires AFTER the primary sink for every emitted entry. Multiple
+     *  attaches accumulate; no detach (daemon lifetime owns the Resumer).
+     *  Errors thrown from attached sinks are swallowed so a downstream
+     *  AuditLog hiccup never blocks the primary audit path. */
+    attachAuditSink(sink) {
+        this.additionalSinks.push(sink);
+    }
+    /** Internal — fan-out wrapper used by every audit emit site. */
+    emit(entry) {
+        this.auditLog(entry);
+        for (const sink of this.additionalSinks) {
+            try {
+                sink(entry);
+            }
+            catch {
+                /* swallow — attached sinks (e.g. unified AuditLog) must not
+                   influence primary audit flow. C10 / patch B discipline. */
+            }
+        }
+    }
+    /** Discover interrupted runs in the configured resume window. */
+    async scanInterrupted() {
+        const summaries = await this.store.scanInterrupted(this.resumeWindowMs, this.nowMs());
+        return this.joinManifests(summaries);
+    }
+    /** Resume one interrupted run. Returns `{ resumed: false, reason }` on
+     *  any skip (pack uninstalled, version diverged, evaluator threw). */
+    async resume(run) {
+        // Build the manifest shape the resolver expects from the joined view.
+        const manifest = {
+            runId: run.runId,
+            packId: run.packId,
+            packVersion: run.packVersion,
+            skill: run.skill,
+            ruleId: run.ruleId,
+            eventKind: run.eventKind,
+            eventPayload: run.eventPayload,
+            startedAtMs: run.lastCompletedAtMs,
+        };
+        const resolved = await this.resolver(manifest);
+        if (resolved === null) {
+            // Resolver returns null when the pack / skill / rule can't be
+            // found. Default reason is `pack_missing` (most common cause);
+            // the resolver can surface richer detail via its own audit hook.
+            this.emit({ event: 'resume_skipped', runId: run.runId, reason: 'pack_missing' });
+            return { resumed: false, reason: 'pack_missing' };
+        }
+        if (resolved.packVersion !== run.packVersion) {
+            this.emit({
+                event: 'resume_skipped',
+                runId: run.runId,
+                reason: 'pack_version_mismatch',
+                detail: `was=${run.packVersion} now=${resolved.packVersion}`,
+            });
+            return { resumed: false, reason: 'pack_version_mismatch' };
+        }
+        const bindings = await this.store.loadBindings(run.runId);
+        const entryStepIdx = run.lastCompletedStep + 1;
+        try {
+            await this.evaluator({ manifest, bindings, entryStepIdx });
+        }
+        catch (err) {
+            this.emit({
+                event: 'resume_skipped',
+                runId: run.runId,
+                reason: 'evaluator_error',
+                detail: err instanceof Error ? err.message : String(err),
+            });
+            return { resumed: false, reason: 'evaluator_error' };
+        }
+        this.emit({
+            event: 'resume_run',
+            runId: run.runId,
+            packId: run.packId,
+            fromStepIdx: entryStepIdx,
+        });
+        return { resumed: true };
+    }
+    /** Daemon-startup entrypoint: scan + resume all. Invoked AFTER lock
+     *  acquire + BEFORE cron registration so resumes finish before fresh
+     *  fires can race. One summary audit entry; per-run only for resumed +
+     *  reason-worthy skips. */
+    async resumeOnStartup() {
+        const interrupted = await this.scanInterrupted();
+        let resumed = 0;
+        let skippedOther = 0;
+        for (const run of interrupted) {
+            const r = await this.resume(run);
+            if (r.resumed)
+                resumed += 1;
+            else
+                skippedOther += 1;
+        }
+        this.emit({
+            event: 'resume_summary',
+            scanned: interrupted.length,
+            resumed,
+            skippedOther,
+        });
+        return { resumed, skipped: skippedOther };
+    }
+    async joinManifests(summaries) {
+        const out = [];
+        for (const s of summaries) {
+            const m = await this.store.getRunManifest(s.runId);
+            if (!m) {
+                // Orphan checkpoint: rule dispatcher forgot `recordRunStart`.
+                // Programmer error, not a normal recovery path → always audit.
+                this.emit({ event: 'resume_skipped', runId: s.runId, reason: 'manifest_missing' });
+                continue;
+            }
+            out.push({
+                runId: m.runId,
+                lastCompletedStep: s.lastCompletedStep,
+                lastCompletedAtMs: s.lastCompletedAtMs,
+                packId: m.packId,
+                packVersion: m.packVersion,
+                skill: m.skill,
+                ruleId: m.ruleId,
+                eventKind: m.eventKind,
+                eventPayload: m.eventPayload,
+            });
+        }
+        return out;
+    }
+}
+function readResumeWindowFromEnv() {
+    const raw = process.env.OPENSQUID_RESUME_WINDOW_MS;
+    if (raw === undefined)
+        return undefined;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return n;
+}
+//# sourceMappingURL=resumer.js.map

package/dist/runtime/durable/resumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resumer.js","sourceRoot":"","sources":["../../../src/runtime/durable/resumer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,+EAA+E;AAC/E,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC;AAkD/C,MAAM,SAAS,GAAc,GAAG,EAAE;IAChC,wBAAwB;AAC1B,CAAC,CAAC;AAwBF,MAAM,OAAO,OAAO;IACD,KAAK,CAAkB;IACvB,SAAS,CAAe;IACxB,QAAQ,CAAe;IACxC;;iEAE6D;IAC5C,QAAQ,CAAY;IACpB,eAAe,GAAgB,EAAE,CAAC;IAClC,cAAc,CAAS;IACvB,KAAK,CAAe;IAErC,YAAY,IAAgB;QAC1B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,SAAS,CAAC;QAC3C,IAAI,CAAC,cAAc;YACjB,IAAI,CAAC,cAAc,IAAI,uBAAuB,EAAE,IAAI,wBAAwB,CAAC;QAC/E,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC;IACtC,CAAC;IAED;;;;+DAI2D;IAC3D,eAAe,CAAC,IAAe;QAC7B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,gEAAgE;IACxD,IAAI,CAAC,KAAiB;QAC5B,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,IAAI,CAAC,KAAK,CAAC,CAAC;YACd,CAAC;YAAC,MAAM,CAAC;gBACP;6EAC6D;YAC/D,CAAC;QACH,CAAC;IACH,CAAC;IAED,iEAAiE;IACjE,KAAK,CAAC,eAAe;QACnB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACtF,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;0EACsE;IACtE,KAAK,CAAC,MAAM,CAAC,GAAmB;QAC9B,sEAAsE;QACtE,MAAM,QAAQ,GAAgB;YAC5B,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,YAAY,EAAE,GAAG,CAAC,YAAY;YAC9B,WAAW,EAAE,GAAG,CAAC,iBAAiB;SACnC,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtB,8DAA8D;YAC9D,+DAA+D;YAC/D,iEAAiE;YACjE,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;YACjF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;QACpD,CAAC;QACD,IAAI,QAAQ,CAAC,WAAW,KAAK,GAAG,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,CAAC,IAAI,CAAC;gBACR,KAAK,EAAE,gBAAgB;gBACvB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,MAAM,EAAE,uBAAuB;gBAC/B,MAAM,EAAE,OAAO,GAAG,CAAC,WAAW,QAAQ,QAAQ,CAAC,WAAW,EAAE;aAC7D,CAAC,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC;QAC7D,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC1D,MAAM,YAAY,GAAG,GAAG,CAAC,iBAAiB,GAAG,CAAC,CAAC;QAC/C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;QAC7D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC;gBACR,KAAK,EAAE,gBAAgB;gBACvB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,MAAM,EAAE,iBAAiB;gBACzB,MAAM,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;aACzD,CAAC,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,CAAC,IAAI,CAAC;YACR,KAAK,EAAE,YAAY;YACnB,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,WAAW,EAAE,YAAY;SAC1B,CAAC,CAAC;QACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC3B,CAAC;IAED;;;+BAG2B;IAC3B,KAAK,CAAC,eAAe;QACnB,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QACjD,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjC,IAAI,CAAC,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAC,CAAC;;gBACvB,YAAY,IAAI,CAAC,CAAC;QACzB,CAAC;QACD,IAAI,CAAC,IAAI,CAAC;YACR,KAAK,EAAE,gBAAgB;YACvB,OAAO,EAAE,WAAW,CAAC,MAAM;YAC3B,OAAO;YACP,YAAY;SACb,CAAC,CAAC;QACH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;IAC5C,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,SAA+B;QACzD,MAAM,GAAG,GAAqB,EAAE,CAAC;QACjC,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;YAC1B,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YACnD,IAAI,CAAC,CAAC,EAAE,CAAC;gBACP,8DAA8D;gBAC9D,+DAA+D;gBAC/D,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;gBACnF,SAAS;YACX,CAAC;YACD,GAAG,CAAC,IAAI,CAAC;gBACP,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,iBAAiB,EAAE,CAAC,CAAC,iBAAiB;gBACtC,iBAAiB,EAAE,CAAC,CAAC,iBAAiB;gBACtC,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,KAAK,EAAE,CAAC,CAAC,KAAK;gBACd,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,SAAS,EAAE,CAAC,CAAC,SAAS;gBACtB,YAAY,EAAE,CAAC,CAAC,YAAY;aAC7B,CAAC,CAAC;QACL,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAED,SAAS,uBAAuB;IAC9B,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IACnD,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACxC,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IACnC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IACpD,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/runtime/durable/run_id.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Deterministic run_id derivation for durable execution (DURABLE.1).
+ *
+ * A `run_id` MUST be stable across daemon restarts so a crashed process can
+ * resume from the exact same checkpoint stream. Given the same
+ * `(pack, skill, ruleId, eventKind, eventPayload)`, `runIdFor` returns the
+ * same SHA-256 hex string — both inside one node process and across cold
+ * restarts.
+ *
+ * Stability requires canonical JSON. Object keys sort alphabetically, dates
+ * serialize as ISO 8601, Buffer/Uint8Array serialize as a tagged base64
+ * envelope, undefined properties drop (matching `JSON.stringify`). These
+ * rules ALSO govern `outputs_json` storage in the checkpoint store — see
+ * `canonical_json.ts`.
+ *
+ * Why hash the event payload instead of using it raw: events can carry
+ * large or sensitive blobs (webhook bodies, file contents, LLM prompts).
+ * Hashing keeps run_id short, opaque, and storage-friendly while still
+ * giving us the stability guarantee.
+ *
+ * Imports from: node:crypto, ./canonical_json.js.
+ * Imported by: src/runtime/durable/checkpoint_store.ts, future evaluator
+ * wrap in DURABLE.2.
+ */
+/**
+ * Inputs for `runIdFor`. All five fields participate in the hash; changing
+ * any of them yields a different `run_id`. The `eventPayload` is hashed
+ * (not embedded) — see module docstring.
+ */
+export interface RunIdInput {
+    pack: string;
+    skill: string;
+    ruleId: string;
+    eventKind: string;
+    eventPayload: unknown;
+}
+/**
+ * Deterministic SHA-256 over canonical JSON of the run identity. Returns
+ * 64-char lowercase hex.
+ *
+ * Audit guarantee: the function is pure. No `Date.now`, no `Math.random`,
+ * no env reads. Same input → same output across processes.
+ */
+export declare function runIdFor(input: RunIdInput): string;
+/**
+ * SHA-256 over a UTF-8 string → lowercase hex. Centralized so every
+ * hashing site in the durable module uses the same encoding.
+ */
+export declare function sha256Hex(s: string): string;
+//# sourceMappingURL=run_id.d.ts.map

package/dist/runtime/durable/run_id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_id.d.ts","sourceRoot":"","sources":["../../../src/runtime/durable/run_id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAUlD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3C"}

package/dist/runtime/durable/run_id.js

@@ -0,0 +1,52 @@
+/**
+ * Deterministic run_id derivation for durable execution (DURABLE.1).
+ *
+ * A `run_id` MUST be stable across daemon restarts so a crashed process can
+ * resume from the exact same checkpoint stream. Given the same
+ * `(pack, skill, ruleId, eventKind, eventPayload)`, `runIdFor` returns the
+ * same SHA-256 hex string — both inside one node process and across cold
+ * restarts.
+ *
+ * Stability requires canonical JSON. Object keys sort alphabetically, dates
+ * serialize as ISO 8601, Buffer/Uint8Array serialize as a tagged base64
+ * envelope, undefined properties drop (matching `JSON.stringify`). These
+ * rules ALSO govern `outputs_json` storage in the checkpoint store — see
+ * `canonical_json.ts`.
+ *
+ * Why hash the event payload instead of using it raw: events can carry
+ * large or sensitive blobs (webhook bodies, file contents, LLM prompts).
+ * Hashing keeps run_id short, opaque, and storage-friendly while still
+ * giving us the stability guarantee.
+ *
+ * Imports from: node:crypto, ./canonical_json.js.
+ * Imported by: src/runtime/durable/checkpoint_store.ts, future evaluator
+ * wrap in DURABLE.2.
+ */
+import { createHash } from 'node:crypto';
+import { canonicalJsonStringify } from './canonical_json.js';
+/**
+ * Deterministic SHA-256 over canonical JSON of the run identity. Returns
+ * 64-char lowercase hex.
+ *
+ * Audit guarantee: the function is pure. No `Date.now`, no `Math.random`,
+ * no env reads. Same input → same output across processes.
+ */
+export function runIdFor(input) {
+    const eventHash = sha256Hex(canonicalJsonStringify(input.eventPayload));
+    const identity = {
+        pack: input.pack,
+        skill: input.skill,
+        ruleId: input.ruleId,
+        eventKind: input.eventKind,
+        eventHash,
+    };
+    return sha256Hex(canonicalJsonStringify(identity));
+}
+/**
+ * SHA-256 over a UTF-8 string → lowercase hex. Centralized so every
+ * hashing site in the durable module uses the same encoding.
+ */
+export function sha256Hex(s) {
+    return createHash('sha256').update(s, 'utf8').digest('hex');
+}
+//# sourceMappingURL=run_id.js.map

package/dist/runtime/durable/run_id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_id.js","sourceRoot":"","sources":["../../../src/runtime/durable/run_id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAe7D;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAiB;IACxC,MAAM,SAAS,GAAG,SAAS,CAAC,sBAAsB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;IACxE,MAAM,QAAQ,GAAG;QACf,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,SAAS;KACV,CAAC;IACF,OAAO,SAAS,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC;AACrD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,CAAS;IACjC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC9D,CAAC"}

package/dist/runtime/escalate.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Escalate drift policy runtime (AUTO.4).
+ *
+ * Authoritative source: `docs/tasks/automation.md` AUTO.4.
+ *
+ * Semantics: when a verdict's drift response is `escalate`, the runtime
+ * bumps the severity tier to `'critical'` (regardless of the original
+ * verdict level) and routes the message via `NotificationRouter` using the
+ * critical-tier channel list. The point is paging — a verdict that the pack
+ * author judged "important enough to escalate" goes to the user's loudest
+ * channel, not the default chat surface.
+ *
+ * RATE-LIMIT integration (locked):
+ *
+ *   AUTO.2's `RateLimiter` MUST apply on the escalate path, gated under the
+ *   `inbound_channel` trigger kind (closest fit — outbound critical pages
+ *   are paging-fatigue events). Without rate-limiting, a misbehaving rule
+ *   that fires on every event would page the user 1000× per minute and
+ *   train them to ignore alerts. The limiter is optional in the function
+ *   signature so unit tests can omit it, but the production wiring path
+ *   ALWAYS supplies one. When the limiter denies, we degrade to
+ *   `notify_pause` (severity 'critical' preserved) and surface the
+ *   rate-limit reason in the audit log — the operator can see WHY a page
+ *   was suppressed.
+ *
+ * FAIL-LOUD on empty critical-tier channels:
+ *
+ *   If `NotificationRouter.resolve()` returns zero targets for the critical
+ *   tier (no critical-tier channel mapped, AND the chat-fallback adapter is
+ *   not registered), we DO NOT silently drop the page. Returns a
+ *   `notify_pause` fall-through descriptor with `severity: 'critical'` and
+ *   a reason that names the empty-channels condition; the audit sink picks
+ *   it up. This matches the spec risk callout + the AUTO.2 RateLimiter's
+ *   fail-closed posture.
+ *
+ * Engine-vocabulary: speaks in severity / channel / verdict / pack only.
+ *
+ * Imports from: ./types.js, ./rate_limit.js, ../channels/router.js, ../channels/types.js.
+ * Imported by: drift-response runtime wiring (hooks layer — after AUTO.4 ships).
+ */
+import type { NotificationRouter, MulticastResult } from '../channels/router.js';
+import type { RoutingConfig } from '../channels/types.js';
+import type { RateLimiter } from './rate_limit.js';
+import type { MessageVerdict as Verdict } from './types.js';
+/**
+ * Outcome of one escalate cycle. `escalated: true` ⇒ multicast attempted
+ * (the `MulticastResult` carries partial-success accounting from
+ * NotificationRouter — `sent` may be 0 if every adapter failed; that's NOT
+ * the same as no-channels). `escalated: false` ⇒ caller MUST route to
+ * `notify_pause` with severity 'critical' using `fallthrough.reason`.
+ */
+export interface EscalateResult {
+    escalated: boolean;
+    reroutedSeverity: 'critical';
+    multicast: MulticastResult | null;
+    fallthrough?: {
+        reason: string;
+        kind: 'no_critical_channels' | 'rate_limited' | 'rate_limit_error';
+    };
+}
+export interface EscalateDeps {
+    /** The verdict being escalated (any drift level — message preserved). */
+    verdict: Verdict;
+    /** Routing config from the user's notifications.yaml. */
+    routing: RoutingConfig;
+    /** NotificationRouter instance from the channel stack. */
+    notificationRouter: NotificationRouter;
+    /** Pack name — needed for rate-limit bucket keying. */
+    packId: string;
+    /** Optional project id for per-project channel overrides. */
+    project?: string | null;
+    /**
+     * Optional rate limiter. AUTO.2 wiring. When supplied, the limiter's
+     * `inbound_channel` bucket applies to outbound critical pages —
+     * paging-fatigue prevention per the spec risk callout.
+     */
+    rateLimiter?: RateLimiter;
+    /** Bucket key for the rate limiter; defaults to verdict.ruleId or 'default'. */
+    rateLimitKey?: string;
+}
+/**
+ * Bump severity to 'critical' and reroute via NotificationRouter.
+ *
+ * Pure-ish: no recursion, no auto-correct, no halt. The single async path
+ * is the optional rate-limit check + the router multicast. Caller awaits
+ * the returned promise and acts on `escalated` boolean.
+ */
+export declare function escalateSeverity(deps: EscalateDeps): Promise<EscalateResult>;
+//# sourceMappingURL=escalate.d.ts.map

package/dist/runtime/escalate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalate.d.ts","sourceRoot":"","sources":["../../src/runtime/escalate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAInD,OAAO,KAAK,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,sBAAsB,GAAG,cAAc,GAAG,kBAAkB,CAAC;KACpE,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,OAAO,EAAE,aAAa,CAAC;IACvB,0DAA0D;IAC1D,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CA6DlF"}

package/dist/runtime/escalate.js

@@ -0,0 +1,118 @@
+/**
+ * Escalate drift policy runtime (AUTO.4).
+ *
+ * Authoritative source: `docs/tasks/automation.md` AUTO.4.
+ *
+ * Semantics: when a verdict's drift response is `escalate`, the runtime
+ * bumps the severity tier to `'critical'` (regardless of the original
+ * verdict level) and routes the message via `NotificationRouter` using the
+ * critical-tier channel list. The point is paging — a verdict that the pack
+ * author judged "important enough to escalate" goes to the user's loudest
+ * channel, not the default chat surface.
+ *
+ * RATE-LIMIT integration (locked):
+ *
+ *   AUTO.2's `RateLimiter` MUST apply on the escalate path, gated under the
+ *   `inbound_channel` trigger kind (closest fit — outbound critical pages
+ *   are paging-fatigue events). Without rate-limiting, a misbehaving rule
+ *   that fires on every event would page the user 1000× per minute and
+ *   train them to ignore alerts. The limiter is optional in the function
+ *   signature so unit tests can omit it, but the production wiring path
+ *   ALWAYS supplies one. When the limiter denies, we degrade to
+ *   `notify_pause` (severity 'critical' preserved) and surface the
+ *   rate-limit reason in the audit log — the operator can see WHY a page
+ *   was suppressed.
+ *
+ * FAIL-LOUD on empty critical-tier channels:
+ *
+ *   If `NotificationRouter.resolve()` returns zero targets for the critical
+ *   tier (no critical-tier channel mapped, AND the chat-fallback adapter is
+ *   not registered), we DO NOT silently drop the page. Returns a
+ *   `notify_pause` fall-through descriptor with `severity: 'critical'` and
+ *   a reason that names the empty-channels condition; the audit sink picks
+ *   it up. This matches the spec risk callout + the AUTO.2 RateLimiter's
+ *   fail-closed posture.
+ *
+ * Engine-vocabulary: speaks in severity / channel / verdict / pack only.
+ *
+ * Imports from: ./types.js, ./rate_limit.js, ../channels/router.js, ../channels/types.js.
+ * Imported by: drift-response runtime wiring (hooks layer — after AUTO.4 ships).
+ */
+/**
+ * Bump severity to 'critical' and reroute via NotificationRouter.
+ *
+ * Pure-ish: no recursion, no auto-correct, no halt. The single async path
+ * is the optional rate-limit check + the router multicast. Caller awaits
+ * the returned promise and acts on `escalated` boolean.
+ */
+export async function escalateSeverity(deps) {
+    const { verdict, routing, notificationRouter, packId, project = null, rateLimiter } = deps;
+    const reroutedSeverity = 'critical';
+    // 1. Rate-limit check (AUTO.2 integration). Locked: `inbound_channel`
+    //    trigger kind is the closest fit for outbound critical paging.
+    if (rateLimiter !== undefined) {
+        const key = deps.rateLimitKey ?? verdict.ruleId ?? 'default';
+        let decision;
+        try {
+            decision = await rateLimiter.check(packId, 'inbound_channel', key);
+        }
+        catch (e) {
+            return {
+                escalated: false,
+                reroutedSeverity,
+                multicast: null,
+                fallthrough: {
+                    kind: 'rate_limit_error',
+                    reason: `escalate: rate limiter threw: ${String(e)}`,
+                },
+            };
+        }
+        if (!decision.allowed) {
+            return {
+                escalated: false,
+                reroutedSeverity,
+                multicast: null,
+                fallthrough: {
+                    kind: 'rate_limited',
+                    reason: `escalate: rate-limit suppressed page (${decision.reason ?? 'unknown'})${decision.retryAfterMs !== undefined ? `; retry in ${decision.retryAfterMs}ms` : ''}`,
+                },
+            };
+        }
+    }
+    // 2. Resolve targets BEFORE sending. If zero, fail-loud + fall through to
+    //    notify_pause (C10: no silent drops).
+    const targets = notificationRouter.resolve(reroutedSeverity, project, routing);
+    if (targets.length === 0) {
+        return {
+            escalated: false,
+            reroutedSeverity,
+            multicast: null,
+            fallthrough: {
+                kind: 'no_critical_channels',
+                reason: `escalate: no critical-tier channels configured (project=${project ?? '∅'}); page suppressed`,
+            },
+        };
+    }
+    // 3. Multicast. NotificationRouter swallows per-adapter throws and
+    //    reports partial success via `MulticastResult.errors`.
+    const message = {
+        text: formatEscalateMessage(verdict),
+        severity: reroutedSeverity,
+    };
+    const multicast = await notificationRouter.multicast(reroutedSeverity, project, message, routing);
+    return { escalated: true, reroutedSeverity, multicast };
+}
+// ---------------------------------------------------------------------------
+// Message formatting — minimal, deterministic, no consumer vocabulary.
+//
+// The rule id is included when present so on-call can pivot from the page
+// to the audit log quickly. The original verdict level is preserved in the
+// message text even though `reroutedSeverity` is always 'critical' — the
+// difference matters for triage ("warn-level escalated" vs "block-level
+// escalated").
+// ---------------------------------------------------------------------------
+function formatEscalateMessage(verdict) {
+    const prefix = verdict.ruleId !== undefined ? `[${verdict.ruleId}] ` : '';
+    return `${prefix}escalated (${verdict.level}): ${verdict.message}`;
+}
+//# sourceMappingURL=escalate.js.map