opensquid 0.5.395

package/dist/runtime/drift_catalog.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Roll-up drift catalogs across pack layers (Task 5.4).
+ *
+ * Per `docs/opensquid-real-design.md` §"Phases 2–7 summary" Phase 5: every
+ * pack writes its own `drift-catalog.jsonl` under
+ * `~/.opensquid/packs/<id>/state/`, and the session writes a session-level
+ * `drift-catalog.jsonl` under `~/.opensquid/sessions/<id>/state/`. The
+ * runtime exposes the AGGREGATED view; pack-level catalogs are the
+ * source-of-truth on disk, never mutated by the reader.
+ *
+ * `readAllDriftCatalogs` is the read-side companion. It walks every
+ * supplied pack id + the session catalog, parses JSONL line-by-line,
+ * decorates each event with its `pack` provenance, and chronologically
+ * sorts the merged list by `timestamp`. Missing files are silently OK
+ * (ENOENT swallowed): not every pack has emitted a drift event, and a
+ * brand-new session has no session catalog yet.
+ *
+ * Provenance: the `pack` field in the returned `DriftEvent` always reflects
+ * the FILE the event was read from (the pack id passed to `readAllDriftCatalogs`,
+ * or `<session>` for the session-level catalog). Any `pack` field present
+ * in the raw JSONL is OVERWRITTEN — the on-disk catalog can lie about its
+ * pack origin, but the aggregator pins provenance to the actual file
+ * location it found. This matters for audit + supports the MCP tool that
+ * surfaces the aggregated view to humans.
+ *
+ * JSONL parsing: `.filter(Boolean)` discards the empty string after a
+ * trailing newline (standard JSONL convention) and any blank line. A
+ * malformed line throws synchronously inside the `for` loop; the caller
+ * wraps the call so the MCP tool surface can degrade gracefully. Future
+ * hardening could try/catch per line and surface counts of parse failures.
+ *
+ * Imports from: node:fs/promises, runtime/paths.ts.
+ * Imported by: src/mcp/tools/list-drift-events.ts.
+ */
+export interface DriftEvent {
+    /** ISO-8601 timestamp; sort key. */
+    timestamp: string;
+    /** Pack id that produced this event, or `<session>` for the session catalog. */
+    pack: string;
+    /** Rule id that produced the event. */
+    ruleId: string;
+    /** Verdict level — `block` / `warn` / `surface`. Loose-typed at the aggregator. */
+    level: string;
+    /** Human-readable verdict message. */
+    message: string;
+}
+export interface DriftEventWithProvenance extends DriftEvent {
+    subagentId?: string;
+    professionPack?: string;
+}
+export interface SubagentSdkDrift {
+    timestamp?: string;
+    pack?: string;
+    ruleId?: string;
+    level?: string;
+    message?: string;
+}
+export declare function readAllDriftCatalogs(packIds: string[], sessionId: string): Promise<DriftEvent[]>;
+/**
+ * Append a single drift event to a session's drift catalog
+ * (`sessions/<sessionId>/state/drift-catalog.jsonl`). Used by the
+ * compression orchestrator (CMP.4) to surface a recall-replay-gate
+ * failure / engine error so the user sees "Mc kept alongside its
+ * predecessors; nothing deleted" via `list_drift_events`. Best-effort:
+ * the caller owns whether a write failure should propagate.
+ */
+export declare function appendSessionDriftEvent(sessionId: string, event: DriftEvent): Promise<void>;
+export declare function recordSubagentDrifts(parentSessionId: string, subagentId: string, professionPack: string, drifts: SubagentSdkDrift[]): Promise<void>;
+//# sourceMappingURL=drift_catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drift_catalog.d.ts","sourceRoot":"","sources":["../../src/runtime/drift_catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAQH,MAAM,WAAW,UAAU;IACzB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAoBD,MAAM,WAAW,wBAAyB,SAAQ,UAAU;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAWD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA0BD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,UAAU,EAAE,CAAC,CAkBvB;AA4CD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjG;AAED,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,gBAAgB,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/runtime/drift_catalog.js

@@ -0,0 +1,152 @@
+/**
+ * Roll-up drift catalogs across pack layers (Task 5.4).
+ *
+ * Per `docs/opensquid-real-design.md` §"Phases 2–7 summary" Phase 5: every
+ * pack writes its own `drift-catalog.jsonl` under
+ * `~/.opensquid/packs/<id>/state/`, and the session writes a session-level
+ * `drift-catalog.jsonl` under `~/.opensquid/sessions/<id>/state/`. The
+ * runtime exposes the AGGREGATED view; pack-level catalogs are the
+ * source-of-truth on disk, never mutated by the reader.
+ *
+ * `readAllDriftCatalogs` is the read-side companion. It walks every
+ * supplied pack id + the session catalog, parses JSONL line-by-line,
+ * decorates each event with its `pack` provenance, and chronologically
+ * sorts the merged list by `timestamp`. Missing files are silently OK
+ * (ENOENT swallowed): not every pack has emitted a drift event, and a
+ * brand-new session has no session catalog yet.
+ *
+ * Provenance: the `pack` field in the returned `DriftEvent` always reflects
+ * the FILE the event was read from (the pack id passed to `readAllDriftCatalogs`,
+ * or `<session>` for the session-level catalog). Any `pack` field present
+ * in the raw JSONL is OVERWRITTEN — the on-disk catalog can lie about its
+ * pack origin, but the aggregator pins provenance to the actual file
+ * location it found. This matters for audit + supports the MCP tool that
+ * surfaces the aggregated view to humans.
+ *
+ * JSONL parsing: `.filter(Boolean)` discards the empty string after a
+ * trailing newline (standard JSONL convention) and any blank line. A
+ * malformed line throws synchronously inside the `for` loop; the caller
+ * wraps the call so the MCP tool surface can degrade gracefully. Future
+ * hardening could try/catch per line and surface counts of parse failures.
+ *
+ * Imports from: node:fs/promises, runtime/paths.ts.
+ * Imported by: src/mcp/tools/list-drift-events.ts.
+ */
+import { appendFile, mkdir } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { packLogFile, sessionLogFile } from './paths.js';
+async function readJsonl(path, packTag) {
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+    const out = [];
+    for (const line of raw.split('\n').filter(Boolean)) {
+        const parsed = JSON.parse(line);
+        // Provenance OVERWRITE: trust the file location, not the file content,
+        // for `pack`. See file-level comment.
+        out.push({
+            timestamp: String(parsed.timestamp ?? ''),
+            ruleId: String(parsed.ruleId ?? ''),
+            level: String(parsed.level ?? ''),
+            message: String(parsed.message ?? ''),
+            pack: packTag,
+        });
+    }
+    return out;
+}
+export async function readAllDriftCatalogs(packIds, sessionId) {
+    const all = [];
+    // Per-pack catalogs first. Order at this stage doesn't matter; the final
+    // sort happens once below.
+    for (const pid of packIds) {
+        const events = await readJsonl(packLogFile(pid, 'drift-catalog'), pid);
+        all.push(...events);
+    }
+    // Session-level catalog. Marked with the sentinel pack tag `<session>`
+    // so consumers can render it differently in the aggregated view.
+    const sessionEvents = await readJsonl(sessionLogFile(sessionId, 'drift-catalog'), '<session>');
+    all.push(...sessionEvents);
+    // Chronological sort. `localeCompare` on ISO-8601 strings is safe because
+    // the format is monotonic alphabetically.
+    return all.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+// ---------------------------------------------------------------------------
+// recordSubagentDrifts — Task 6.4 roll-up write path.
+//
+// Append each subagent-surfaced drift event to the PARENT's session-level
+// drift catalog (`sessions/<parentSessionId>/state/drift-catalog.jsonl`)
+// enriched with the subagent's id + profession pack as provenance fields.
+//
+// The append target is the same JSONL file the session-level reader picks
+// up (sentinel pack tag `<session>` in `readAllDriftCatalogs`). The
+// aggregator returns these enriched events as plain `DriftEvent` because
+// structural subtyping treats the extra `subagentId` / `professionPack`
+// fields as ignored — a richer reader (e.g. the MCP tool surface that
+// renders "Drift from subagent X under profession Y") parses the JSONL
+// directly with the `DriftEventWithProvenance` type.
+//
+// Per Task 6.4 risk callout — "independent catalog write decision": the
+// subagent ALSO persists its own pack-level catalog during its run (the
+// SDK-side evaluator writes to `packs/<subagent-pack>/state/drift-catalog.jsonl`
+// via the normal evaluator path). This function intentionally does NOT
+// double-write to the subagent's pack catalog from the parent process —
+// the subagent's evaluator owns that write, and the parent's role is
+// roll-up to the SESSION-level view. Two catalog writes (subagent's pack
+// catalog + parent's session catalog) is the documented dual-write per
+// design doc §"Team modes" Mode A — "audit-trail at both layers".
+//
+// Field normalization: SDK drifts may have any subset of fields populated.
+// We coerce every field via `String(... ?? '')` so the JSONL line is
+// always well-formed even if the SDK omitted some fields. `timestamp` is
+// the sort key in the aggregator, so a missing timestamp drops the event
+// to the bottom of any chronological sort — that's a degraded-but-safe
+// behavior, never a crash.
+//
+// Directory creation: `mkdir(..., { recursive: true })` is idempotent and
+// matches the pattern used by `src/functions/state.ts`. We do it inside
+// the loop to keep the function self-contained — the directory only needs
+// to exist before the first append, but the cost of an extra mkdir per
+// drift is negligible (the per-loop cost is `appendFile`, not `mkdir`).
+//
+// Empty drifts array: no-op (no file created). Matches the contract that
+// a successful subagent with zero drifts produces zero catalog writes.
+// ---------------------------------------------------------------------------
+/**
+ * Append a single drift event to a session's drift catalog
+ * (`sessions/<sessionId>/state/drift-catalog.jsonl`). Used by the
+ * compression orchestrator (CMP.4) to surface a recall-replay-gate
+ * failure / engine error so the user sees "Mc kept alongside its
+ * predecessors; nothing deleted" via `list_drift_events`. Best-effort:
+ * the caller owns whether a write failure should propagate.
+ */
+export async function appendSessionDriftEvent(sessionId, event) {
+    const path = sessionLogFile(sessionId, 'drift-catalog');
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, `${JSON.stringify(event)}\n`, 'utf8');
+}
+export async function recordSubagentDrifts(parentSessionId, subagentId, professionPack, drifts) {
+    if (drifts.length === 0)
+        return;
+    const path = sessionLogFile(parentSessionId, 'drift-catalog');
+    await mkdir(dirname(path), { recursive: true });
+    for (const d of drifts) {
+        const enriched = {
+            timestamp: String(d.timestamp ?? ''),
+            pack: String(d.pack ?? professionPack),
+            ruleId: String(d.ruleId ?? ''),
+            level: String(d.level ?? ''),
+            message: String(d.message ?? ''),
+            subagentId,
+            professionPack,
+        };
+        await appendFile(path, `${JSON.stringify(enriched)}\n`, 'utf8');
+    }
+}
+//# sourceMappingURL=drift_catalog.js.map

package/dist/runtime/drift_catalog.js.map

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

package/dist/runtime/drift_response.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Drift response dispatcher: maps (Verdict, DriftPolicy) → RuntimeAction.
+ *
+ * Sits between the rule evaluator (which produces `Verdict`s) and the hook
+ * layer (which executes `RuntimeAction`s). A rule decides what happened;
+ * the pack-declared `drift_response` policy decides what to do about it.
+ * All six `DriftPolicy` variants are wired here (AUTO.4 finished the two
+ * previously-deferred policies — `auto_correct` and `escalate`).
+ *
+ * Dispatch shape is intentionally a `Record<DriftPolicy, ...>` lookup table,
+ * NOT an if/else (or switch) cascade — constraint from the design doc
+ * §"Drift response policies" + Task 1.6 acceptance criteria. The lookup
+ * lets a future Phase widen the policy set by appending one map entry,
+ * with TS's exhaustiveness check on `DriftPolicy` guaranteeing every variant
+ * has a handler (the `Record<DriftPolicy, ...>` type errors on omission).
+ *
+ * `auto_correct` semantics (AUTO.4): produces an action descriptor
+ * `{kind: 'auto_correct', correctiveSkill, verdict}`. The dispatcher
+ * resolves the corrective skill from the pack's
+ * `drift_response.corrective_skills[ruleId]` map. If no corrective skill is
+ * declared for the rule, the dispatcher degrades to `notify_pause` with
+ * severity 'critical' and a reason naming the missing entry — no silent
+ * fail-open (constraint C10). The runtime layer (`runtime/auto_correct.ts`)
+ * picks up the descriptor, runs the capability gate, invokes the corrective
+ * skill via the evaluator, and re-evaluates the original rule.
+ *
+ * `escalate` semantics (AUTO.4): produces an action descriptor
+ * `{kind: 'escalate', reroutedSeverity: 'critical', verdict}`. The runtime
+ * layer (`runtime/escalate.ts`) does the side-effects — applies the
+ * RateLimiter (paging-fatigue prevention) then multicasts via
+ * NotificationRouter using the critical-tier channel list.
+ *
+ * Unknown-policy fail-safe (constraint C10 — no silent fail-open): if the
+ * caller hands us a policy string that isn't in `DISPATCH` (e.g. a typo in
+ * pack YAML that slipped past schema validation, or a future variant the
+ * dispatcher doesn't recognize), we degrade to `notify_pause` with severity
+ * `'critical'` rather than silently picking a "safe default" policy. The
+ * cast at the call site (`policy as DriftPolicy`) is the only path that
+ * reaches this branch; the TS layer above prevents legitimate callers from
+ * hitting it.
+ *
+ * Imports from: ./types.js.
+ * Imported by: src/runtime/index.ts (re-export), runtime/hooks/ (Task 1.7),
+ * runtime/auto_correct.ts + runtime/escalate.ts (action-descriptor consumers).
+ */
+import type { DriftPolicy, MessageVerdict, RuntimeAction, VerdictLevel } from './types.js';
+/**
+ * Fallback drift-response policy when a pack ships no `drift_response.yaml`
+ * (no per-rule entry, no pack default). DERIVES the policy from the verdict
+ * level so a rule's authored `level:` is honored without a separate policy
+ * file:
+ *
+ *   block                              → block_tool   (hard block; exit 2)
+ *   warn | surface | pass | directive  → warn         (non-blocking notice; exit 0)
+ *
+ * This replaces the historical blanket `block_tool` default, which silently
+ * hard-blocked every warn/surface-level rule in any pack lacking the file —
+ * discarding the level the author wrote. `drift_response.yaml` remains an
+ * OVERRIDE (per_rule / default) layered on top of this; precedence is
+ * unchanged (the dispatcher consults the file first, this fallback last).
+ *
+ * Total over the closed `VerdictLevel` enum by construction (single branch).
+ */
+export declare function defaultPolicyForLevel(level: VerdictLevel): DriftPolicy;
+/**
+ * T-ASC ASC.3: drift_response only processes message-bearing verdicts.
+ * Directive-level verdicts flow through a separate dispatcher path
+ * (DispatchResult.directives aggregation, surfaced via UserPromptSubmit
+ * envelope) and never reach applyDriftResponse.
+ */
+type Verdict = MessageVerdict;
+/**
+ * Per-call dispatch context. Only `auto_correct` needs the corrective-skill
+ * map; the other handlers ignore it. Field is optional so callers that only
+ * use the 4 stable policies don't have to construct an empty record.
+ */
+export interface DriftDispatchCtx {
+    correctiveSkills?: Record<string, string>;
+}
+export declare function applyDriftResponse(verdict: Verdict, policy: DriftPolicy, ctx?: DriftDispatchCtx): RuntimeAction;
+export {};
+//# sourceMappingURL=drift_response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drift_response.d.ts","sourceRoot":"","sources":["../../src/runtime/drift_response.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE3F;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,CAEtE;AAED;;;;;GAKG;AACH,KAAK,OAAO,GAAG,cAAc,CAAC;AAkB9B;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAgCD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,GAAG,GAAE,gBAAqB,GACzB,aAAa,CAaf"}

package/dist/runtime/drift_response.js

@@ -0,0 +1,108 @@
+/**
+ * Drift response dispatcher: maps (Verdict, DriftPolicy) → RuntimeAction.
+ *
+ * Sits between the rule evaluator (which produces `Verdict`s) and the hook
+ * layer (which executes `RuntimeAction`s). A rule decides what happened;
+ * the pack-declared `drift_response` policy decides what to do about it.
+ * All six `DriftPolicy` variants are wired here (AUTO.4 finished the two
+ * previously-deferred policies — `auto_correct` and `escalate`).
+ *
+ * Dispatch shape is intentionally a `Record<DriftPolicy, ...>` lookup table,
+ * NOT an if/else (or switch) cascade — constraint from the design doc
+ * §"Drift response policies" + Task 1.6 acceptance criteria. The lookup
+ * lets a future Phase widen the policy set by appending one map entry,
+ * with TS's exhaustiveness check on `DriftPolicy` guaranteeing every variant
+ * has a handler (the `Record<DriftPolicy, ...>` type errors on omission).
+ *
+ * `auto_correct` semantics (AUTO.4): produces an action descriptor
+ * `{kind: 'auto_correct', correctiveSkill, verdict}`. The dispatcher
+ * resolves the corrective skill from the pack's
+ * `drift_response.corrective_skills[ruleId]` map. If no corrective skill is
+ * declared for the rule, the dispatcher degrades to `notify_pause` with
+ * severity 'critical' and a reason naming the missing entry — no silent
+ * fail-open (constraint C10). The runtime layer (`runtime/auto_correct.ts`)
+ * picks up the descriptor, runs the capability gate, invokes the corrective
+ * skill via the evaluator, and re-evaluates the original rule.
+ *
+ * `escalate` semantics (AUTO.4): produces an action descriptor
+ * `{kind: 'escalate', reroutedSeverity: 'critical', verdict}`. The runtime
+ * layer (`runtime/escalate.ts`) does the side-effects — applies the
+ * RateLimiter (paging-fatigue prevention) then multicasts via
+ * NotificationRouter using the critical-tier channel list.
+ *
+ * Unknown-policy fail-safe (constraint C10 — no silent fail-open): if the
+ * caller hands us a policy string that isn't in `DISPATCH` (e.g. a typo in
+ * pack YAML that slipped past schema validation, or a future variant the
+ * dispatcher doesn't recognize), we degrade to `notify_pause` with severity
+ * `'critical'` rather than silently picking a "safe default" policy. The
+ * cast at the call site (`policy as DriftPolicy`) is the only path that
+ * reaches this branch; the TS layer above prevents legitimate callers from
+ * hitting it.
+ *
+ * Imports from: ./types.js.
+ * Imported by: src/runtime/index.ts (re-export), runtime/hooks/ (Task 1.7),
+ * runtime/auto_correct.ts + runtime/escalate.ts (action-descriptor consumers).
+ */
+/**
+ * Fallback drift-response policy when a pack ships no `drift_response.yaml`
+ * (no per-rule entry, no pack default). DERIVES the policy from the verdict
+ * level so a rule's authored `level:` is honored without a separate policy
+ * file:
+ *
+ *   block                              → block_tool   (hard block; exit 2)
+ *   warn | surface | pass | directive  → warn         (non-blocking notice; exit 0)
+ *
+ * This replaces the historical blanket `block_tool` default, which silently
+ * hard-blocked every warn/surface-level rule in any pack lacking the file —
+ * discarding the level the author wrote. `drift_response.yaml` remains an
+ * OVERRIDE (per_rule / default) layered on top of this; precedence is
+ * unchanged (the dispatcher consults the file first, this fallback last).
+ *
+ * Total over the closed `VerdictLevel` enum by construction (single branch).
+ */
+export function defaultPolicyForLevel(level) {
+    return level === 'block' ? 'block_tool' : 'warn';
+}
+const DISPATCH = {
+    block_tool: (v) => ({ kind: 'block_tool', message: v.message }),
+    warn: (v) => ({ kind: 'warn', message: v.message }),
+    full_stop_and_redo: (v) => ({ kind: 'halt', reason: v.message }),
+    notify_and_pause: (v) => ({
+        kind: 'notify_pause',
+        reason: v.message,
+        severity: 'error',
+    }),
+    auto_correct: (v, ctx) => {
+        // C10: corrective skill MUST be declared for the rule, else fail-loud.
+        // We need a ruleId to resolve from `corrective_skills`; without one the
+        // map is unusable and we degrade rather than guessing.
+        const ruleId = v.ruleId;
+        const correctiveSkill = ruleId !== undefined ? ctx.correctiveSkills?.[ruleId] : undefined;
+        if (correctiveSkill === undefined || correctiveSkill === '') {
+            return {
+                kind: 'notify_pause',
+                reason: ruleId === undefined
+                    ? 'auto_correct policy requires a verdict with `ruleId`; none provided'
+                    : `auto_correct policy for rule "${ruleId}" missing entry in corrective_skills`,
+                severity: 'critical',
+            };
+        }
+        return { kind: 'auto_correct', correctiveSkill, verdict: v };
+    },
+    escalate: (v) => ({ kind: 'escalate', reroutedSeverity: 'critical', verdict: v }),
+};
+export function applyDriftResponse(verdict, policy, ctx = {}) {
+    const fn = DISPATCH[policy];
+    if (!fn) {
+        // C10 fail-safe: unknown policy ⇒ notify_pause + 'critical'.
+        // The unknown string is interpolated raw so audit trails capture
+        // exactly what came in (helps debug the pack-author typo case).
+        return {
+            kind: 'notify_pause',
+            reason: `Unknown policy "${String(policy)}"`,
+            severity: 'critical',
+        };
+    }
+    return fn(verdict, ctx);
+}
+//# sourceMappingURL=drift_response.js.map

package/dist/runtime/drift_response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drift_response.js","sourceRoot":"","sources":["../../src/runtime/drift_response.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAmB;IACvD,OAAO,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC;AACnD,CAAC;AAmCD,MAAM,QAAQ,GAA8E;IAC1F,UAAU,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAC/D,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IACnD,kBAAkB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAChE,gBAAgB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACxB,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,CAAC,CAAC,OAAO;QACjB,QAAQ,EAAE,OAAO;KAClB,CAAC;IACF,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE;QACvB,uEAAuE;QACvE,wEAAwE;QACxE,uDAAuD;QACvD,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACxB,MAAM,eAAe,GAAG,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1F,IAAI,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,EAAE,EAAE,CAAC;YAC5D,OAAO;gBACL,IAAI,EAAE,cAAc;gBACpB,MAAM,EACJ,MAAM,KAAK,SAAS;oBAClB,CAAC,CAAC,qEAAqE;oBACvE,CAAC,CAAC,iCAAiC,MAAM,sCAAsC;gBACnF,QAAQ,EAAE,UAAU;aACrB,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC/D,CAAC;IACD,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;CAClF,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAChC,OAAgB,EAChB,MAAmB,EACnB,MAAwB,EAAE;IAE1B,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,6DAA6D;QAC7D,iEAAiE;QACjE,gEAAgE;QAChE,OAAO;YACL,IAAI,EAAE,cAAc;YACpB,MAAM,EAAE,mBAAmB,MAAM,CAAC,MAAM,CAAC,GAAG;YAC5C,QAAQ,EAAE,UAAU;SACrB,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAC1B,CAAC"}

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

@@ -0,0 +1,47 @@
+/**
+ * Canonical JSON serialization for durable execution (DURABLE.1).
+ *
+ * Two requirements drive this module:
+ *
+ *   1. `run_id` derivation must be byte-stable across processes — JSON key
+ *      order matters, so we sort keys recursively before stringifying.
+ *
+ *   2. Checkpoint outputs must round-trip through libsql `TEXT` storage and
+ *      back into evaluator bindings. JavaScript values that `JSON.stringify`
+ *      cannot losslessly handle (Date, Buffer / typed arrays) get tagged
+ *      envelopes here and unwrapped on parse:
+ *
+ *        Date           → string  (ISO 8601)
+ *        Buffer         → { __type: 'base64', data: '<base64>' }
+ *        Uint8Array     → { __type: 'base64', data: '<base64>' }
+ *
+ * Anything `JSON.stringify` would normally drop (functions, symbols,
+ * `undefined` values inside an object) is also dropped here, matching the
+ * stdlib's behavior. Inside arrays, `undefined` becomes `null` — also
+ * matching stdlib.
+ *
+ * Cycles raise a TypeError just like `JSON.stringify` would; primitive
+ * authors must not return cyclic outputs.
+ *
+ * Imports from: nothing (Node stdlib only).
+ * Imported by: ./run_id.ts, ./checkpoint_store.ts.
+ */
+/**
+ * Canonical JSON: sorted keys, dates/buffers tagged, deterministic byte
+ * output. Drop-in replacement for `JSON.stringify(x)` when stability is
+ * required.
+ */
+export declare function canonicalJsonStringify(value: unknown): string;
+/**
+ * Inverse of `canonicalJsonStringify` for the tagged-envelope shapes.
+ * Plain JSON shapes (string, number, boolean, null, object, array) pass
+ * through unchanged.
+ *
+ * Date envelopes intentionally do NOT exist — we collapsed `Date` to its
+ * ISO string on write because the consumer (binding lookup, downstream
+ * primitive) can re-parse with `new Date(str)` if needed. Forcing every
+ * string-looking ISO to a Date on the read side would mis-restore strings
+ * that just happen to look like dates.
+ */
+export declare function canonicalJsonParse(text: string): unknown;
+//# sourceMappingURL=canonical_json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canonical_json.d.ts","sourceRoot":"","sources":["../../../src/runtime/durable/canonical_json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAkEH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/runtime/durable/canonical_json.js

@@ -0,0 +1,127 @@
+/**
+ * Canonical JSON serialization for durable execution (DURABLE.1).
+ *
+ * Two requirements drive this module:
+ *
+ *   1. `run_id` derivation must be byte-stable across processes — JSON key
+ *      order matters, so we sort keys recursively before stringifying.
+ *
+ *   2. Checkpoint outputs must round-trip through libsql `TEXT` storage and
+ *      back into evaluator bindings. JavaScript values that `JSON.stringify`
+ *      cannot losslessly handle (Date, Buffer / typed arrays) get tagged
+ *      envelopes here and unwrapped on parse:
+ *
+ *        Date           → string  (ISO 8601)
+ *        Buffer         → { __type: 'base64', data: '<base64>' }
+ *        Uint8Array     → { __type: 'base64', data: '<base64>' }
+ *
+ * Anything `JSON.stringify` would normally drop (functions, symbols,
+ * `undefined` values inside an object) is also dropped here, matching the
+ * stdlib's behavior. Inside arrays, `undefined` becomes `null` — also
+ * matching stdlib.
+ *
+ * Cycles raise a TypeError just like `JSON.stringify` would; primitive
+ * authors must not return cyclic outputs.
+ *
+ * Imports from: nothing (Node stdlib only).
+ * Imported by: ./run_id.ts, ./checkpoint_store.ts.
+ */
+function isBase64Envelope(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const rec = v;
+    return rec.__type === 'base64' && typeof rec.data === 'string';
+}
+/**
+ * Convert a value into the canonical-JSON-friendly shape. Recurses through
+ * plain objects and arrays. Returns a value that's safe to feed to
+ * `JSON.stringify` with sorted keys.
+ *
+ * `seen` is a WeakSet used for cycle detection. We raise instead of
+ * silently breaking the cycle — durable checkpointing should fail loudly
+ * if a primitive author shipped a cyclic output.
+ */
+function canonicalize(value, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return value;
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    // Buffer (a Node Uint8Array subclass) and bare Uint8Array both serialize
+    // to the same base64 envelope. Other typed arrays (Float32Array etc.)
+    // would round-trip lossily so we deliberately do NOT special-case them;
+    // primitive authors who need raw bytes must hand us a Buffer.
+    if (value instanceof Uint8Array) {
+        return { __type: 'base64', data: Buffer.from(value).toString('base64') };
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value))
+            throw new TypeError('canonical-json: cyclic array');
+        seen.add(value);
+        const out = value.map((v) => (v === undefined ? null : canonicalize(v, seen)));
+        seen.delete(value);
+        return out;
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value))
+            throw new TypeError('canonical-json: cyclic object');
+        seen.add(value);
+        const src = value;
+        const out = {};
+        for (const key of Object.keys(src).sort()) {
+            const v = src[key];
+            if (v === undefined)
+                continue; // match JSON.stringify
+            out[key] = canonicalize(v, seen);
+        }
+        seen.delete(value);
+        return out;
+    }
+    // string | number | boolean | bigint | function | symbol — only the
+    // first three round-trip through JSON. bigint throws inside
+    // JSON.stringify; function and symbol silently drop. We let
+    // JSON.stringify enforce that contract to avoid duplicating its checks.
+    return value;
+}
+/**
+ * Canonical JSON: sorted keys, dates/buffers tagged, deterministic byte
+ * output. Drop-in replacement for `JSON.stringify(x)` when stability is
+ * required.
+ */
+export function canonicalJsonStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+/**
+ * Inverse of `canonicalJsonStringify` for the tagged-envelope shapes.
+ * Plain JSON shapes (string, number, boolean, null, object, array) pass
+ * through unchanged.
+ *
+ * Date envelopes intentionally do NOT exist — we collapsed `Date` to its
+ * ISO string on write because the consumer (binding lookup, downstream
+ * primitive) can re-parse with `new Date(str)` if needed. Forcing every
+ * string-looking ISO to a Date on the read side would mis-restore strings
+ * that just happen to look like dates.
+ */
+export function canonicalJsonParse(text) {
+    const raw = JSON.parse(text);
+    return revive(raw);
+}
+function revive(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(revive);
+    if (typeof value === 'object') {
+        if (isBase64Envelope(value)) {
+            return Buffer.from(value.data, 'base64');
+        }
+        const src = value;
+        const out = {};
+        for (const key of Object.keys(src)) {
+            out[key] = revive(src[key]);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=canonical_json.js.map

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

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