open-multi-agent-kit 0.80.6 → 0.80.7

package/dist/core/orchestration/scheduler-store.js

@@ -0,0 +1,368 @@
+/**
+ * Driver-agnostic SchedulerStore contract for the durable DAG orchestrator.
+ *
+ * This module owns the persistence *contract* and the deterministic, pure
+ * helpers that any concrete store implementation must honor:
+ *   - the canonical SQLite WAL DDL (one source of truth for the schema),
+ *   - the connection pragmas,
+ *   - stable idempotency / DAG hashing (so DAG ingestion is replay-safe),
+ *   - access-set canonicalization (so stable keys are order-independent).
+ *
+ * It performs NO I/O itself. The concrete `node:sqlite` implementation lives in
+ * `sqlite-scheduler-store.ts`. Keeping the contract and pure helpers here lets a
+ * second driver (e.g. better-sqlite3) be added later without touching scheduler
+ * logic, and lets tests assert determinism without a database.
+ *
+ * Schema reference: `.omk/runs/omk-orchestration-upgrade-plan/foundation.md` §3.
+ * Conflict policy is reused from `scheduler-state.ts`; hashing primitives from
+ * `replay-ledger.ts`. Erasable TypeScript only (no enum/namespace/param props).
+ */
+import { sha256Hex, stableStringify } from "./replay-ledger.js";
+import { accessEntriesConflict, nodesConflict, } from "./scheduler-state.js";
+/**
+ * Canonical connection pragmas. WAL is a no-op for `:memory:` databases (SQLite
+ * keeps an in-memory journal there) but is applied verbatim for file stores.
+ */
+export const SCHEDULER_STORE_PRAGMAS = [
+    "PRAGMA journal_mode = WAL",
+    "PRAGMA synchronous = NORMAL",
+    "PRAGMA busy_timeout = 5000",
+    "PRAGMA foreign_keys = ON",
+    "PRAGMA temp_store = MEMORY",
+];
+/** Tables the schema must create, in dependency-safe creation order. */
+export const SCHEDULER_STORE_TABLES = [
+    "runs",
+    "nodes",
+    "edges",
+    "access",
+    "conflicts",
+    "attempts",
+    "leases",
+    "artifacts",
+    "worktrees",
+    "merge_queue",
+    "compensators",
+    "events",
+];
+/**
+ * Canonical SQLite WAL DDL. Parent tables precede children so FK declarations
+ * resolve cleanly. This is the single source of truth for the durable schema.
+ */
+export const SCHEDULER_STORE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS runs (
+  run_id        TEXT PRIMARY KEY,
+  goal          TEXT NOT NULL,
+  topology      TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'running'
+    CHECK (status IN ('running','paused','completed','failed','cancelled')),
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL,
+  completed_at  TEXT,
+  dag_hash      TEXT,
+  root_node_id  TEXT
+);
+
+CREATE TABLE IF NOT EXISTS nodes (
+  node_id           TEXT NOT NULL,
+  run_id            TEXT NOT NULL,
+  role              TEXT NOT NULL
+    CHECK (role IN ('planner','explorer','coder','tester','reviewer','security','memory','synthesizer')),
+  task              TEXT NOT NULL,
+  status            TEXT NOT NULL DEFAULT 'queued'
+    CHECK (status IN ('queued','leased','running','verifying','completed','retry_wait',
+                      'compensating','rolled_back','in_doubt','blocked','cancelled','failed')),
+  idempotency_key   TEXT NOT NULL,
+  read_set          TEXT NOT NULL DEFAULT '[]',
+  write_set         TEXT NOT NULL DEFAULT '[]',
+  lease_id          TEXT,
+  lease_expires_at  TEXT,
+  heartbeat_at      TEXT,
+  retry_policy      TEXT NOT NULL DEFAULT '{}',
+  verification_contract TEXT,
+  cost_budget       REAL,
+  attempt_count     INTEGER NOT NULL DEFAULT 0,
+  requeue_count     INTEGER NOT NULL DEFAULT 0,
+  retry_wait_until  TEXT,
+  created_at        TEXT NOT NULL,
+  started_at        TEXT,
+  finished_at       TEXT,
+  priority          INTEGER NOT NULL DEFAULT 0,
+  parallelizable    INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (run_id, node_id),
+  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,
+  UNIQUE (run_id, idempotency_key)
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  run_id        TEXT NOT NULL,
+  from_node_id  TEXT NOT NULL,
+  to_node_id    TEXT NOT NULL,
+  edge_type     TEXT NOT NULL DEFAULT 'strong'
+    CHECK (edge_type IN ('strong','weak')),
+  PRIMARY KEY (run_id, from_node_id, to_node_id),
+  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,
+  FOREIGN KEY (run_id, from_node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  FOREIGN KEY (run_id, to_node_id)   REFERENCES nodes(run_id, node_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS access (
+  access_id     TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  node_id       TEXT NOT NULL,
+  kind          TEXT NOT NULL CHECK (kind IN ('read','write')),
+  path          TEXT NOT NULL,
+  symbols       TEXT NOT NULL DEFAULT '[]',
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  UNIQUE (run_id, node_id, kind, path, symbols)
+);
+
+CREATE TABLE IF NOT EXISTS conflicts (
+  run_id        TEXT NOT NULL,
+  node_a        TEXT NOT NULL,
+  node_b        TEXT NOT NULL,
+  reason        TEXT NOT NULL CHECK (reason IN ('write-write','write-read','read-write')),
+  PRIMARY KEY (run_id, node_a, node_b),
+  FOREIGN KEY (run_id, node_a) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  FOREIGN KEY (run_id, node_b) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  CHECK (node_a < node_b)
+);
+
+CREATE TABLE IF NOT EXISTS attempts (
+  attempt_id    TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  node_id       TEXT NOT NULL,
+  lease_id      TEXT NOT NULL,
+  started_at    TEXT NOT NULL,
+  finished_at   TEXT,
+  status        TEXT NOT NULL
+    CHECK (status IN ('running','completed','failed','rolled_back','in_doubt')),
+  exit_code     INTEGER,
+  error_summary TEXT,
+  worker_pid    INTEGER,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS leases (
+  lease_id      TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  node_id       TEXT NOT NULL,
+  attempt_id    TEXT,
+  issued_at     TEXT NOT NULL,
+  expires_at    TEXT NOT NULL,
+  heartbeat_at  TEXT,
+  owner_token   TEXT NOT NULL,
+  released      INTEGER NOT NULL DEFAULT 0,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  FOREIGN KEY (attempt_id) REFERENCES attempts(attempt_id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS artifacts (
+  artifact_id   TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  node_id       TEXT NOT NULL,
+  attempt_id    TEXT,
+  path          TEXT NOT NULL,
+  kind          TEXT NOT NULL
+    CHECK (kind IN ('evidence','patch','result','checkpoint','contract')),
+  sha256        TEXT,
+  size_bytes    INTEGER,
+  created_at    TEXT NOT NULL,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  FOREIGN KEY (attempt_id) REFERENCES attempts(attempt_id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS worktrees (
+  worktree_id   TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  node_id       TEXT NOT NULL,
+  path          TEXT NOT NULL,
+  branch_name   TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'active'
+    CHECK (status IN ('active','merged','reclaimed','orphaned')),
+  created_at    TEXT NOT NULL,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS merge_queue (
+  queue_id          TEXT PRIMARY KEY,
+  run_id            TEXT NOT NULL,
+  node_id           TEXT NOT NULL,
+  branch_name       TEXT NOT NULL,
+  target_branch     TEXT NOT NULL DEFAULT 'main',
+  status            TEXT NOT NULL DEFAULT 'pending'
+    CHECK (status IN ('pending','merging','merged','conflict','blocked')),
+  priority          INTEGER NOT NULL DEFAULT 0,
+  dag_depth         INTEGER NOT NULL DEFAULT 0,
+  lease_finished_at TEXT,
+  created_at        TEXT NOT NULL,
+  merged_at         TEXT,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS compensators (
+  compensator_id      TEXT PRIMARY KEY,
+  run_id              TEXT NOT NULL,
+  node_id             TEXT NOT NULL,
+  kind                TEXT NOT NULL,
+  sequence            INTEGER NOT NULL,
+  idempotent          INTEGER NOT NULL DEFAULT 1,
+  applied             INTEGER NOT NULL DEFAULT 0,
+  prepared_state_hash TEXT,
+  created_at          TEXT NOT NULL,
+  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,
+  UNIQUE (run_id, node_id, sequence)
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  event_id      TEXT PRIMARY KEY,
+  run_id        TEXT NOT NULL,
+  operation_id  TEXT NOT NULL,
+  causation_id  TEXT,
+  sequence      INTEGER NOT NULL,
+  timestamp     TEXT NOT NULL,
+  kind          TEXT NOT NULL,
+  status        TEXT NOT NULL,
+  node_id       TEXT,
+  data          TEXT NOT NULL,
+  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_dispatch
+  ON nodes(run_id, status, retry_wait_until, priority, attempt_count)
+  WHERE status IN ('queued','retry_wait');
+CREATE INDEX IF NOT EXISTS idx_nodes_lease ON nodes(run_id, lease_id);
+CREATE INDEX IF NOT EXISTS idx_nodes_expired
+  ON nodes(lease_expires_at)
+  WHERE status = 'leased' OR status = 'running' OR status = 'verifying';
+CREATE INDEX IF NOT EXISTS idx_edges_to   ON edges(run_id, to_node_id);
+CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(run_id, from_node_id);
+CREATE INDEX IF NOT EXISTS idx_access_node ON access(run_id, node_id);
+CREATE INDEX IF NOT EXISTS idx_conflicts_run ON conflicts(run_id, node_a, node_b);
+CREATE INDEX IF NOT EXISTS idx_artifacts_path ON artifacts(run_id, path);
+CREATE INDEX IF NOT EXISTS idx_events_run_seq ON events(run_id, sequence);
+CREATE INDEX IF NOT EXISTS idx_events_node    ON events(run_id, node_id, sequence);
+`;
+/**
+ * Thrown when a DAG re-submission reuses an existing `node_id` within a run but
+ * supplies a different canonical descriptor. DAGs are immutable within a run:
+ * identical re-submissions are idempotent replays, but a changed definition for
+ * an existing node id is a divergence the store surfaces fail-closed instead of
+ * silently keeping the old or overwriting with the new.
+ */
+export class NodeRedefinitionError extends Error {
+    runId;
+    nodeId;
+    constructor(runId, nodeId) {
+        super(`node "${nodeId}" in run "${runId}" was redefined with a different descriptor; DAGs are immutable within a run`);
+        this.name = "NodeRedefinitionError";
+        this.runId = runId;
+        this.nodeId = nodeId;
+    }
+}
+/** Default retry policy applied when a node omits one. */
+export const DEFAULT_RETRY_POLICY = {
+    maxAttempts: 3,
+    baseMs: 1000,
+    maxMs: 30000,
+    multiplier: 2,
+};
+/**
+ * Canonicalize one access entry: drop undefined symbols, sort symbols, so the
+ * stable key never depends on declaration order.
+ */
+export function canonicalizeAccessEntry(entry) {
+    const symbols = entry.symbols === undefined ? [] : [...entry.symbols].sort(compareString);
+    return { path: entry.path, symbols };
+}
+/** Canonicalize an access set: canonicalize each entry, then sort entries. */
+export function canonicalizeAccessSet(entries) {
+    const canonical = (entries ?? []).map(canonicalizeAccessEntry);
+    canonical.sort((a, b) => {
+        const byPath = compareString(a.path, b.path);
+        if (byPath !== 0) {
+            return byPath;
+        }
+        return compareString(stableStringify(a.symbols), stableStringify(b.symbols));
+    });
+    return canonical;
+}
+/**
+ * Deterministic node descriptor used for idempotency. Excludes runtime state
+ * (status, leases, counters) so identical logical work always hashes the same.
+ */
+export function canonicalNodeDescriptor(node) {
+    return {
+        nodeId: node.nodeId,
+        role: node.role,
+        task: node.task,
+        priority: node.priority ?? 0,
+        parallelizable: node.parallelizable ?? true,
+        readSet: canonicalizeAccessSet(node.readSet),
+        writeSet: canonicalizeAccessSet(node.writeSet),
+    };
+}
+/**
+ * Stable idempotency key: `sha256(stableStringify({runId, descriptor}))`.
+ * Two submissions of identical logical work produce the same key, so DAG
+ * ingestion can deduplicate across root-coordinator retries (foundation §6.5).
+ */
+export function computeIdempotencyKey(runId, node) {
+    return sha256Hex(stableStringify({ runId, descriptor: canonicalNodeDescriptor(node) }));
+}
+/** Stable hash over the whole DAG (nodes + edges), order-independent. */
+export function computeDagHash(submission) {
+    const nodes = submission.nodes.map(canonicalNodeDescriptor);
+    nodes.sort((a, b) => compareString(stableStringify(a), stableStringify(b)));
+    const edges = (submission.edges ?? []).map((edge) => ({
+        fromNodeId: edge.fromNodeId,
+        toNodeId: edge.toNodeId,
+        edgeType: edge.edgeType ?? "strong",
+    }));
+    edges.sort((a, b) => compareString(stableStringify(a), stableStringify(b)));
+    return sha256Hex(stableStringify({ runId: submission.run.runId, nodes, edges }));
+}
+/**
+ * Classify the conflict between two nodes in canonical (nodeA < nodeB) order.
+ *
+ * Existence is decided by the shared pure policy `nodesConflict`; the label is
+ * derived from the same atomic `accessEntriesConflict` predicate. Precedence is
+ * deterministic: write/write, then write/read, then read/write. Returns
+ * undefined when the nodes do not conflict.
+ */
+export function classifyConflict(nodeA, nodeB) {
+    if (!nodesConflict(nodeA, nodeB)) {
+        return undefined;
+    }
+    if (setsConflict(nodeA.writeSet, nodeB.writeSet)) {
+        return "write-write";
+    }
+    if (setsConflict(nodeA.writeSet, nodeB.readSet)) {
+        return "write-read";
+    }
+    if (setsConflict(nodeA.readSet, nodeB.writeSet)) {
+        return "read-write";
+    }
+    // nodesConflict was true, so one of the above must hold; fall back defensively.
+    return "write-write";
+}
+function setsConflict(left, right) {
+    for (const l of left) {
+        for (const r of right) {
+            if (accessEntriesConflict(l, r)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function compareString(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+//# sourceMappingURL=scheduler-store.js.map

package/dist/core/orchestration/scheduler-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler-store.js","sourceRoot":"","sources":["../../../src/core/orchestration/scheduler-store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Driver-agnostic SchedulerStore contract for the durable DAG orchestrator.\n *\n * This module owns the persistence *contract* and the deterministic, pure\n * helpers that any concrete store implementation must honor:\n *   - the canonical SQLite WAL DDL (one source of truth for the schema),\n *   - the connection pragmas,\n *   - stable idempotency / DAG hashing (so DAG ingestion is replay-safe),\n *   - access-set canonicalization (so stable keys are order-independent).\n *\n * It performs NO I/O itself. The concrete `node:sqlite` implementation lives in\n * `sqlite-scheduler-store.ts`. Keeping the contract and pure helpers here lets a\n * second driver (e.g. better-sqlite3) be added later without touching scheduler\n * logic, and lets tests assert determinism without a database.\n *\n * Schema reference: `.omk/runs/omk-orchestration-upgrade-plan/foundation.md` §3.\n * Conflict policy is reused from `scheduler-state.ts`; hashing primitives from\n * `replay-ledger.ts`. Erasable TypeScript only (no enum/namespace/param props).\n */\n\nimport { type JsonValue, sha256Hex, stableStringify } from \"./replay-ledger.ts\";\nimport {\n\ttype AccessSetEntry,\n\taccessEntriesConflict,\n\tnodesConflict,\n\ttype SchedulerNode,\n\ttype SchedulerNodeStatus,\n} from \"./scheduler-state.ts\";\n\nexport type RunStatus = \"running\" | \"paused\" | \"completed\" | \"failed\" | \"cancelled\";\nexport type NodeStatus = SchedulerNodeStatus;\nexport type EdgeType = \"strong\" | \"weak\";\nexport type AccessKind = \"read\" | \"write\";\nexport type ConflictReason = \"write-write\" | \"write-read\" | \"read-write\";\nexport type NodeRole = \"planner\" | \"explorer\" | \"coder\" | \"tester\" | \"reviewer\" | \"security\" | \"memory\" | \"synthesizer\";\n\n/** Retry envelope persisted as JSON on the node row. */\nexport interface RetryPolicy {\n\tmaxAttempts: number;\n\tbaseMs: number;\n\tmaxMs: number;\n\tmultiplier: number;\n}\n\nexport interface RunInput {\n\trunId: string;\n\tgoal: string;\n\ttopology: string;\n\tdagHash?: string;\n\trootNodeId?: string;\n}\n\nexport interface RunRow {\n\trunId: string;\n\tgoal: string;\n\ttopology: string;\n\tstatus: RunStatus;\n\tcreatedAt: string;\n\tupdatedAt: string;\n\tcompletedAt: string | null;\n\tdagHash: string | null;\n\trootNodeId: string | null;\n}\n\n/** A node as submitted by the root coordinator (caller owns `nodeId`). */\nexport interface NodeInput {\n\tnodeId: string;\n\trole: NodeRole;\n\ttask: string;\n\treadSet?: readonly AccessSetEntry[];\n\twriteSet?: readonly AccessSetEntry[];\n\tpriority?: number;\n\tparallelizable?: boolean;\n\tretryPolicy?: RetryPolicy;\n\tverificationContract?: string;\n\tcostBudget?: number;\n}\n\n/** A persisted node row, rehydrated from SQLite. */\nexport interface NodeRow {\n\tnodeId: string;\n\trunId: string;\n\trole: NodeRole;\n\ttask: string;\n\tstatus: NodeStatus;\n\tidempotencyKey: string;\n\treadSet: AccessSetEntry[];\n\twriteSet: AccessSetEntry[];\n\tleaseId: string | null;\n\tleaseExpiresAt: string | null;\n\theartbeatAt: string | null;\n\tattemptCount: number;\n\trequeueCount: number;\n\tretryWaitUntil: string | null;\n\tpriority: number;\n\tparallelizable: boolean;\n\tcreatedAt: string;\n\tstartedAt: string | null;\n\tfinishedAt: string | null;\n}\n\nexport interface EdgeInput {\n\tfromNodeId: string;\n\ttoNodeId: string;\n\tedgeType?: EdgeType;\n}\n\nexport interface EdgeRow {\n\trunId: string;\n\tfromNodeId: string;\n\ttoNodeId: string;\n\tedgeType: EdgeType;\n}\n\n/** A whole DAG submission: run header + nodes + edges. */\nexport interface DagSubmission {\n\trun: RunInput;\n\tnodes: readonly NodeInput[];\n\tedges?: readonly EdgeInput[];\n}\n\n/** Outcome of an idempotent DAG ingestion. */\nexport interface DagIngestionResult {\n\trunId: string;\n\tdagHash: string;\n\t/** All node ids present after ingestion, in submission order. */\n\tnodeIds: string[];\n\t/** Node ids freshly inserted by this call. */\n\tinsertedNodeIds: string[];\n\t/** Node ids that already existed (idempotency hit). */\n\treusedNodeIds: string[];\n}\n\nexport interface LeaseInput {\n\tleaseId: string;\n\townerToken: string;\n\t/** ISO-8601 absolute expiry deadline. */\n\texpiresAt: string;\n\t/** ISO-8601 issue time; defaults to now() in the implementation. */\n\tnow?: string;\n}\n\nexport interface LeaseRow {\n\tleaseId: string;\n\trunId: string;\n\tnodeId: string;\n\tattemptId: string | null;\n\tissuedAt: string;\n\texpiresAt: string;\n\theartbeatAt: string | null;\n\townerToken: string;\n\treleased: boolean;\n}\n\n/** One undirected edge of the conflict graph (always stored nodeA < nodeB). */\nexport interface ConflictEdge {\n\trunId: string;\n\tnodeA: string;\n\tnodeB: string;\n\treason: ConflictReason;\n}\n\nexport interface AttemptInput {\n\tattemptId: string;\n\trunId: string;\n\tnodeId: string;\n\tleaseId: string;\n\tstatus: \"running\" | \"completed\" | \"failed\" | \"rolled_back\" | \"in_doubt\";\n\tstartedAt?: string;\n\tfinishedAt?: string;\n\texitCode?: number;\n\terrorSummary?: JsonValue;\n\tworkerPid?: number;\n}\n\nexport interface WorktreeInput {\n\tworktreeId: string;\n\trunId: string;\n\tnodeId: string;\n\tpath: string;\n\tbranchName: string;\n\tstatus?: \"active\" | \"merged\" | \"reclaimed\" | \"orphaned\";\n\tcreatedAt?: string;\n}\n\nexport interface ArtifactInput {\n\tartifactId: string;\n\trunId: string;\n\tnodeId: string;\n\tattemptId?: string;\n\tpath: string;\n\tkind: \"evidence\" | \"patch\" | \"result\" | \"checkpoint\" | \"contract\";\n\tsha256?: string;\n\tsizeBytes?: number;\n\tcreatedAt?: string;\n}\n\n/** A durable compensator row (mirrors recovery.ts CompensatorStep + run/node). */\nexport interface CompensatorInput {\n\tcompensatorId: string;\n\trunId: string;\n\tnodeId: string;\n\tkind: string;\n\tsequence: number;\n\tidempotent: boolean;\n\tapplied: boolean;\n\tpreparedStateHash?: string | null;\n\tcreatedAt?: string;\n}\n\nexport interface SchedulerEventInput {\n\teventId: string;\n\trunId: string;\n\toperationId: string;\n\tsequence: number;\n\ttimestamp: string;\n\tkind: string;\n\tstatus: string;\n\tcausationId?: string | null;\n\tnodeId?: string | null;\n\tdata?: JsonValue;\n}\n\nexport interface SchedulerEventRow {\n\teventId: string;\n\trunId: string;\n\toperationId: string;\n\tcausationId: string | null;\n\tsequence: number;\n\ttimestamp: string;\n\tkind: string;\n\tstatus: string;\n\tnodeId: string | null;\n\tdata: JsonValue;\n}\n\n/**\n * The durable scheduler persistence contract. Mutating methods that race a\n * status guard return `boolean` (true iff the row was actually changed) so\n * callers get guard-based CAS semantics. All methods are synchronous because\n * both `node:sqlite` and `better-sqlite3` are synchronous.\n */\nexport interface SchedulerStore {\n\t// connection / schema\n\topen(path: string): void;\n\tclose(): void;\n\tcreateSchema(): void;\n\texec(sql: string): void;\n\t/** Read a single PRAGMA scalar (first column of the first row). */\n\tpragma(name: string): JsonValue;\n\n\t// run lifecycle\n\tcreateRun(run: RunInput): void;\n\tgetRun(runId: string): RunRow | undefined;\n\tupdateRunStatus(runId: string, status: RunStatus, now?: string): boolean;\n\n\t// DAG ingestion (idempotent)\n\tingestDag(submission: DagSubmission): DagIngestionResult;\n\tgetNode(runId: string, nodeId: string): NodeRow | undefined;\n\tgetNodesByRun(runId: string): NodeRow[];\n\tgetEdgesByRun(runId: string): EdgeRow[];\n\n\t// conflict graph\n\tbuildConflictGraph(runId: string): ConflictEdge[];\n\tgetConflicts(runId: string): ConflictEdge[];\n\n\t// lease lifecycle (owner-token fenced)\n\tacquireLease(runId: string, nodeId: string, lease: LeaseInput): boolean;\n\theartbeat(runId: string, nodeId: string, ownerToken: string, now: string, expiresAt: string): boolean;\n\tstartNode(runId: string, nodeId: string, ownerToken: string, now: string): boolean;\n\treclaimExpiredLeases(runId: string, now: string): string[];\n\tgetLease(leaseId: string): LeaseRow | undefined;\n\n\t// scaffolded sibling-lane tables (schema-complete, minimal writers)\n\trecordAttempt(attempt: AttemptInput): void;\n\tgetAttemptsByRun(runId: string): AttemptInput[];\n\tregisterWorktree(worktree: WorktreeInput): void;\n\tgetWorktreesByRun(runId: string): WorktreeInput[];\n\tregisterCompensator(compensator: CompensatorInput): void;\n\tgetCompensatorsByNode(runId: string, nodeId: string): CompensatorInput[];\n\trecordArtifact(artifact: ArtifactInput): void;\n\tgetArtifactsByRun(runId: string): ArtifactInput[];\n\n\t// ledger mirror\n\tappendEvent(event: SchedulerEventInput): void;\n\tgetEvents(runId: string): SchedulerEventRow[];\n}\n\n/**\n * Canonical connection pragmas. WAL is a no-op for `:memory:` databases (SQLite\n * keeps an in-memory journal there) but is applied verbatim for file stores.\n */\nexport const SCHEDULER_STORE_PRAGMAS: readonly string[] = [\n\t\"PRAGMA journal_mode = WAL\",\n\t\"PRAGMA synchronous = NORMAL\",\n\t\"PRAGMA busy_timeout = 5000\",\n\t\"PRAGMA foreign_keys = ON\",\n\t\"PRAGMA temp_store = MEMORY\",\n];\n\n/** Tables the schema must create, in dependency-safe creation order. */\nexport const SCHEDULER_STORE_TABLES: readonly string[] = [\n\t\"runs\",\n\t\"nodes\",\n\t\"edges\",\n\t\"access\",\n\t\"conflicts\",\n\t\"attempts\",\n\t\"leases\",\n\t\"artifacts\",\n\t\"worktrees\",\n\t\"merge_queue\",\n\t\"compensators\",\n\t\"events\",\n];\n\n/**\n * Canonical SQLite WAL DDL. Parent tables precede children so FK declarations\n * resolve cleanly. This is the single source of truth for the durable schema.\n */\nexport const SCHEDULER_STORE_SCHEMA = `\nCREATE TABLE IF NOT EXISTS runs (\n  run_id        TEXT PRIMARY KEY,\n  goal          TEXT NOT NULL,\n  topology      TEXT NOT NULL,\n  status        TEXT NOT NULL DEFAULT 'running'\n    CHECK (status IN ('running','paused','completed','failed','cancelled')),\n  created_at    TEXT NOT NULL,\n  updated_at    TEXT NOT NULL,\n  completed_at  TEXT,\n  dag_hash      TEXT,\n  root_node_id  TEXT\n);\n\nCREATE TABLE IF NOT EXISTS nodes (\n  node_id           TEXT NOT NULL,\n  run_id            TEXT NOT NULL,\n  role              TEXT NOT NULL\n    CHECK (role IN ('planner','explorer','coder','tester','reviewer','security','memory','synthesizer')),\n  task              TEXT NOT NULL,\n  status            TEXT NOT NULL DEFAULT 'queued'\n    CHECK (status IN ('queued','leased','running','verifying','completed','retry_wait',\n                      'compensating','rolled_back','in_doubt','blocked','cancelled','failed')),\n  idempotency_key   TEXT NOT NULL,\n  read_set          TEXT NOT NULL DEFAULT '[]',\n  write_set         TEXT NOT NULL DEFAULT '[]',\n  lease_id          TEXT,\n  lease_expires_at  TEXT,\n  heartbeat_at      TEXT,\n  retry_policy      TEXT NOT NULL DEFAULT '{}',\n  verification_contract TEXT,\n  cost_budget       REAL,\n  attempt_count     INTEGER NOT NULL DEFAULT 0,\n  requeue_count     INTEGER NOT NULL DEFAULT 0,\n  retry_wait_until  TEXT,\n  created_at        TEXT NOT NULL,\n  started_at        TEXT,\n  finished_at       TEXT,\n  priority          INTEGER NOT NULL DEFAULT 0,\n  parallelizable    INTEGER NOT NULL DEFAULT 1,\n  PRIMARY KEY (run_id, node_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,\n  UNIQUE (run_id, idempotency_key)\n);\n\nCREATE TABLE IF NOT EXISTS edges (\n  run_id        TEXT NOT NULL,\n  from_node_id  TEXT NOT NULL,\n  to_node_id    TEXT NOT NULL,\n  edge_type     TEXT NOT NULL DEFAULT 'strong'\n    CHECK (edge_type IN ('strong','weak')),\n  PRIMARY KEY (run_id, from_node_id, to_node_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE,\n  FOREIGN KEY (run_id, from_node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  FOREIGN KEY (run_id, to_node_id)   REFERENCES nodes(run_id, node_id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS access (\n  access_id     TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  node_id       TEXT NOT NULL,\n  kind          TEXT NOT NULL CHECK (kind IN ('read','write')),\n  path          TEXT NOT NULL,\n  symbols       TEXT NOT NULL DEFAULT '[]',\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  UNIQUE (run_id, node_id, kind, path, symbols)\n);\n\nCREATE TABLE IF NOT EXISTS conflicts (\n  run_id        TEXT NOT NULL,\n  node_a        TEXT NOT NULL,\n  node_b        TEXT NOT NULL,\n  reason        TEXT NOT NULL CHECK (reason IN ('write-write','write-read','read-write')),\n  PRIMARY KEY (run_id, node_a, node_b),\n  FOREIGN KEY (run_id, node_a) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  FOREIGN KEY (run_id, node_b) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  CHECK (node_a < node_b)\n);\n\nCREATE TABLE IF NOT EXISTS attempts (\n  attempt_id    TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  node_id       TEXT NOT NULL,\n  lease_id      TEXT NOT NULL,\n  started_at    TEXT NOT NULL,\n  finished_at   TEXT,\n  status        TEXT NOT NULL\n    CHECK (status IN ('running','completed','failed','rolled_back','in_doubt')),\n  exit_code     INTEGER,\n  error_summary TEXT,\n  worker_pid    INTEGER,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS leases (\n  lease_id      TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  node_id       TEXT NOT NULL,\n  attempt_id    TEXT,\n  issued_at     TEXT NOT NULL,\n  expires_at    TEXT NOT NULL,\n  heartbeat_at  TEXT,\n  owner_token   TEXT NOT NULL,\n  released      INTEGER NOT NULL DEFAULT 0,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  FOREIGN KEY (attempt_id) REFERENCES attempts(attempt_id) ON DELETE SET NULL\n);\n\nCREATE TABLE IF NOT EXISTS artifacts (\n  artifact_id   TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  node_id       TEXT NOT NULL,\n  attempt_id    TEXT,\n  path          TEXT NOT NULL,\n  kind          TEXT NOT NULL\n    CHECK (kind IN ('evidence','patch','result','checkpoint','contract')),\n  sha256        TEXT,\n  size_bytes    INTEGER,\n  created_at    TEXT NOT NULL,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  FOREIGN KEY (attempt_id) REFERENCES attempts(attempt_id) ON DELETE SET NULL\n);\n\nCREATE TABLE IF NOT EXISTS worktrees (\n  worktree_id   TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  node_id       TEXT NOT NULL,\n  path          TEXT NOT NULL,\n  branch_name   TEXT NOT NULL,\n  status        TEXT NOT NULL DEFAULT 'active'\n    CHECK (status IN ('active','merged','reclaimed','orphaned')),\n  created_at    TEXT NOT NULL,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS merge_queue (\n  queue_id          TEXT PRIMARY KEY,\n  run_id            TEXT NOT NULL,\n  node_id           TEXT NOT NULL,\n  branch_name       TEXT NOT NULL,\n  target_branch     TEXT NOT NULL DEFAULT 'main',\n  status            TEXT NOT NULL DEFAULT 'pending'\n    CHECK (status IN ('pending','merging','merged','conflict','blocked')),\n  priority          INTEGER NOT NULL DEFAULT 0,\n  dag_depth         INTEGER NOT NULL DEFAULT 0,\n  lease_finished_at TEXT,\n  created_at        TEXT NOT NULL,\n  merged_at         TEXT,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE\n);\n\nCREATE TABLE IF NOT EXISTS compensators (\n  compensator_id      TEXT PRIMARY KEY,\n  run_id              TEXT NOT NULL,\n  node_id             TEXT NOT NULL,\n  kind                TEXT NOT NULL,\n  sequence            INTEGER NOT NULL,\n  idempotent          INTEGER NOT NULL DEFAULT 1,\n  applied             INTEGER NOT NULL DEFAULT 0,\n  prepared_state_hash TEXT,\n  created_at          TEXT NOT NULL,\n  FOREIGN KEY (run_id, node_id) REFERENCES nodes(run_id, node_id) ON DELETE CASCADE,\n  UNIQUE (run_id, node_id, sequence)\n);\n\nCREATE TABLE IF NOT EXISTS events (\n  event_id      TEXT PRIMARY KEY,\n  run_id        TEXT NOT NULL,\n  operation_id  TEXT NOT NULL,\n  causation_id  TEXT,\n  sequence      INTEGER NOT NULL,\n  timestamp     TEXT NOT NULL,\n  kind          TEXT NOT NULL,\n  status        TEXT NOT NULL,\n  node_id       TEXT,\n  data          TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id) ON DELETE CASCADE\n);\n\nCREATE INDEX IF NOT EXISTS idx_nodes_dispatch\n  ON nodes(run_id, status, retry_wait_until, priority, attempt_count)\n  WHERE status IN ('queued','retry_wait');\nCREATE INDEX IF NOT EXISTS idx_nodes_lease ON nodes(run_id, lease_id);\nCREATE INDEX IF NOT EXISTS idx_nodes_expired\n  ON nodes(lease_expires_at)\n  WHERE status = 'leased' OR status = 'running' OR status = 'verifying';\nCREATE INDEX IF NOT EXISTS idx_edges_to   ON edges(run_id, to_node_id);\nCREATE INDEX IF NOT EXISTS idx_edges_from ON edges(run_id, from_node_id);\nCREATE INDEX IF NOT EXISTS idx_access_node ON access(run_id, node_id);\nCREATE INDEX IF NOT EXISTS idx_conflicts_run ON conflicts(run_id, node_a, node_b);\nCREATE INDEX IF NOT EXISTS idx_artifacts_path ON artifacts(run_id, path);\nCREATE INDEX IF NOT EXISTS idx_events_run_seq ON events(run_id, sequence);\nCREATE INDEX IF NOT EXISTS idx_events_node    ON events(run_id, node_id, sequence);\n`;\n\n/**\n * Thrown when a DAG re-submission reuses an existing `node_id` within a run but\n * supplies a different canonical descriptor. DAGs are immutable within a run:\n * identical re-submissions are idempotent replays, but a changed definition for\n * an existing node id is a divergence the store surfaces fail-closed instead of\n * silently keeping the old or overwriting with the new.\n */\nexport class NodeRedefinitionError extends Error {\n\treadonly runId: string;\n\treadonly nodeId: string;\n\tconstructor(runId: string, nodeId: string) {\n\t\tsuper(\n\t\t\t`node \"${nodeId}\" in run \"${runId}\" was redefined with a different descriptor; DAGs are immutable within a run`,\n\t\t);\n\t\tthis.name = \"NodeRedefinitionError\";\n\t\tthis.runId = runId;\n\t\tthis.nodeId = nodeId;\n\t}\n}\n\n/** Default retry policy applied when a node omits one. */\nexport const DEFAULT_RETRY_POLICY: RetryPolicy = {\n\tmaxAttempts: 3,\n\tbaseMs: 1000,\n\tmaxMs: 30000,\n\tmultiplier: 2,\n};\n\n/**\n * Canonicalize one access entry: drop undefined symbols, sort symbols, so the\n * stable key never depends on declaration order.\n */\nexport function canonicalizeAccessEntry(entry: AccessSetEntry): { path: string; symbols: string[] } {\n\tconst symbols = entry.symbols === undefined ? [] : [...entry.symbols].sort(compareString);\n\treturn { path: entry.path, symbols };\n}\n\n/** Canonicalize an access set: canonicalize each entry, then sort entries. */\nexport function canonicalizeAccessSet(\n\tentries: readonly AccessSetEntry[] | undefined,\n): { path: string; symbols: string[] }[] {\n\tconst canonical = (entries ?? []).map(canonicalizeAccessEntry);\n\tcanonical.sort((a, b) => {\n\t\tconst byPath = compareString(a.path, b.path);\n\t\tif (byPath !== 0) {\n\t\t\treturn byPath;\n\t\t}\n\t\treturn compareString(stableStringify(a.symbols), stableStringify(b.symbols));\n\t});\n\treturn canonical;\n}\n\n/**\n * Deterministic node descriptor used for idempotency. Excludes runtime state\n * (status, leases, counters) so identical logical work always hashes the same.\n */\nexport function canonicalNodeDescriptor(node: NodeInput): JsonValue {\n\treturn {\n\t\tnodeId: node.nodeId,\n\t\trole: node.role,\n\t\ttask: node.task,\n\t\tpriority: node.priority ?? 0,\n\t\tparallelizable: node.parallelizable ?? true,\n\t\treadSet: canonicalizeAccessSet(node.readSet),\n\t\twriteSet: canonicalizeAccessSet(node.writeSet),\n\t};\n}\n\n/**\n * Stable idempotency key: `sha256(stableStringify({runId, descriptor}))`.\n * Two submissions of identical logical work produce the same key, so DAG\n * ingestion can deduplicate across root-coordinator retries (foundation §6.5).\n */\nexport function computeIdempotencyKey(runId: string, node: NodeInput): string {\n\treturn sha256Hex(stableStringify({ runId, descriptor: canonicalNodeDescriptor(node) }));\n}\n\n/** Stable hash over the whole DAG (nodes + edges), order-independent. */\nexport function computeDagHash(submission: DagSubmission): string {\n\tconst nodes = submission.nodes.map(canonicalNodeDescriptor);\n\tnodes.sort((a, b) => compareString(stableStringify(a), stableStringify(b)));\n\tconst edges = (submission.edges ?? []).map((edge) => ({\n\t\tfromNodeId: edge.fromNodeId,\n\t\ttoNodeId: edge.toNodeId,\n\t\tedgeType: edge.edgeType ?? \"strong\",\n\t}));\n\tedges.sort((a, b) => compareString(stableStringify(a), stableStringify(b)));\n\treturn sha256Hex(stableStringify({ runId: submission.run.runId, nodes, edges }));\n}\n\n/**\n * Classify the conflict between two nodes in canonical (nodeA < nodeB) order.\n *\n * Existence is decided by the shared pure policy `nodesConflict`; the label is\n * derived from the same atomic `accessEntriesConflict` predicate. Precedence is\n * deterministic: write/write, then write/read, then read/write. Returns\n * undefined when the nodes do not conflict.\n */\nexport function classifyConflict(nodeA: SchedulerNode, nodeB: SchedulerNode): ConflictReason | undefined {\n\tif (!nodesConflict(nodeA, nodeB)) {\n\t\treturn undefined;\n\t}\n\tif (setsConflict(nodeA.writeSet, nodeB.writeSet)) {\n\t\treturn \"write-write\";\n\t}\n\tif (setsConflict(nodeA.writeSet, nodeB.readSet)) {\n\t\treturn \"write-read\";\n\t}\n\tif (setsConflict(nodeA.readSet, nodeB.writeSet)) {\n\t\treturn \"read-write\";\n\t}\n\t// nodesConflict was true, so one of the above must hold; fall back defensively.\n\treturn \"write-write\";\n}\n\nfunction setsConflict(left: readonly AccessSetEntry[], right: readonly AccessSetEntry[]): boolean {\n\tfor (const l of left) {\n\t\tfor (const r of right) {\n\t\t\tif (accessEntriesConflict(l, r)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t}\n\treturn false;\n}\n\nfunction compareString(a: string, b: string): number {\n\tif (a < b) {\n\t\treturn -1;\n\t}\n\tif (a > b) {\n\t\treturn 1;\n\t}\n\treturn 0;\n}\n"]}

package/dist/core/orchestration/sqlite-scheduler-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `node:sqlite` (DatabaseSync) implementation of {@link SchedulerStore}.
+ *
+ * This is the default durable driver for the DAG scheduler. It owns ONLY
+ * persistence: schema creation, WAL pragmas, idempotent DAG ingestion, conflict
+ * graph materialization (reusing the pure conflict policy), and owner-token
+ * fenced lease lifecycle. It performs NO scheduling decisions and NO runtime
+ * wiring — the dispatch engine consumes this store through the interface.
+ *
+ * Determinism: every method takes explicit ISO-8601 timestamps where time
+ * matters, so tests drive it with fixed clocks. Guard-based CAS is implemented
+ * with `UPDATE ... WHERE <guard>` and the `changes` count returned by the
+ * driver. Erasable TypeScript only (no enum/namespace/parameter properties).
+ *
+ * Schema source of truth: `scheduler-store.ts`. Conflict policy: `scheduler-state.ts`.
+ */
+import { type JsonValue } from "./replay-ledger.ts";
+import { type ArtifactInput, type AttemptInput, type CompensatorInput, type ConflictEdge, type DagIngestionResult, type DagSubmission, type EdgeRow, type LeaseInput, type LeaseRow, type NodeRow, type RunInput, type RunRow, type RunStatus, type SchedulerEventInput, type SchedulerEventRow, type SchedulerStore, type WorktreeInput } from "./scheduler-store.ts";
+export declare class SqliteSchedulerStore implements SchedulerStore {
+    private db;
+    /** Construct a store; optionally open a database immediately. */
+    constructor(path?: string);
+    open(path: string): void;
+    close(): void;
+    createSchema(): void;
+    exec(sql: string): void;
+    pragma(name: string): JsonValue;
+    createRun(run: RunInput): void;
+    getRun(runId: string): RunRow | undefined;
+    updateRunStatus(runId: string, status: RunStatus, now?: string): boolean;
+    ingestDag(submission: DagSubmission): DagIngestionResult;
+    private insertNode;
+    getNode(runId: string, nodeId: string): NodeRow | undefined;
+    getNodesByRun(runId: string): NodeRow[];
+    getEdgesByRun(runId: string): EdgeRow[];
+    buildConflictGraph(runId: string): ConflictEdge[];
+    getConflicts(runId: string): ConflictEdge[];
+    acquireLease(runId: string, nodeId: string, lease: LeaseInput): boolean;
+    heartbeat(runId: string, nodeId: string, ownerToken: string, now: string, expiresAt: string): boolean;
+    startNode(runId: string, nodeId: string, ownerToken: string, now: string): boolean;
+    reclaimExpiredLeases(runId: string, now: string): string[];
+    getLease(leaseId: string): LeaseRow | undefined;
+    recordAttempt(attempt: AttemptInput): void;
+    getAttemptsByRun(runId: string): AttemptInput[];
+    registerWorktree(worktree: WorktreeInput): void;
+    getWorktreesByRun(runId: string): WorktreeInput[];
+    registerCompensator(compensator: CompensatorInput): void;
+    getCompensatorsByNode(runId: string, nodeId: string): CompensatorInput[];
+    recordArtifact(artifact: ArtifactInput): void;
+    getArtifactsByRun(runId: string): ArtifactInput[];
+    appendEvent(event: SchedulerEventInput): void;
+    getEvents(runId: string): SchedulerEventRow[];
+    private connection;
+    /** Run `fn` inside a single transaction; rollback on throw. */
+    private transaction;
+}
+//# sourceMappingURL=sqlite-scheduler-store.d.ts.map

package/dist/core/orchestration/sqlite-scheduler-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-scheduler-store.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/sqlite-scheduler-store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `node:sqlite` (DatabaseSync) implementation of {@link SchedulerStore}.\n *\n * This is the default durable driver for the DAG scheduler. It owns ONLY\n * persistence: schema creation, WAL pragmas, idempotent DAG ingestion, conflict\n * graph materialization (reusing the pure conflict policy), and owner-token\n * fenced lease lifecycle. It performs NO scheduling decisions and NO runtime\n * wiring — the dispatch engine consumes this store through the interface.\n *\n * Determinism: every method takes explicit ISO-8601 timestamps where time\n * matters, so tests drive it with fixed clocks. Guard-based CAS is implemented\n * with `UPDATE ... WHERE <guard>` and the `changes` count returned by the\n * driver. Erasable TypeScript only (no enum/namespace/parameter properties).\n *\n * Schema source of truth: `scheduler-store.ts`. Conflict policy: `scheduler-state.ts`.\n */\n\nimport { DatabaseSync } from \"node:sqlite\";\nimport { type JsonValue, stableStringify } from \"./replay-ledger.ts\";\nimport type { AccessSetEntry, SchedulerNode } from \"./scheduler-state.ts\";\nimport {\n\ttype ArtifactInput,\n\ttype AttemptInput,\n\ttype CompensatorInput,\n\ttype ConflictEdge,\n\tclassifyConflict,\n\tcomputeDagHash,\n\tcomputeIdempotencyKey,\n\ttype DagIngestionResult,\n\ttype DagSubmission,\n\tDEFAULT_RETRY_POLICY,\n\ttype EdgeRow,\n\ttype LeaseInput,\n\ttype LeaseRow,\n\ttype NodeInput,\n\tNodeRedefinitionError,\n\ttype NodeRow,\n\ttype RunInput,\n\ttype RunRow,\n\ttype RunStatus,\n\tSCHEDULER_STORE_PRAGMAS,\n\tSCHEDULER_STORE_SCHEMA,\n\ttype SchedulerEventInput,\n\ttype SchedulerEventRow,\n\ttype SchedulerStore,\n\ttype WorktreeInput,\n} from \"./scheduler-store.ts\";\n\n/** A single row returned by the driver: column name -> scalar value. */\ntype SqliteRow = Record<string, string | number | bigint | null | Uint8Array>;\n\nexport class SqliteSchedulerStore implements SchedulerStore {\n\tprivate db: DatabaseSync | null = null;\n\n\t/** Construct a store; optionally open a database immediately. */\n\tconstructor(path?: string) {\n\t\tif (path !== undefined) {\n\t\t\tthis.open(path);\n\t\t}\n\t}\n\n\topen(path: string): void {\n\t\tif (this.db !== null) {\n\t\t\tthrow new Error(\"SqliteSchedulerStore is already open\");\n\t\t}\n\t\tthis.db = new DatabaseSync(path);\n\t\tfor (const pragma of SCHEDULER_STORE_PRAGMAS) {\n\t\t\tthis.db.exec(pragma);\n\t\t}\n\t}\n\n\tclose(): void {\n\t\tif (this.db !== null) {\n\t\t\tthis.db.close();\n\t\t\tthis.db = null;\n\t\t}\n\t}\n\n\tcreateSchema(): void {\n\t\tthis.connection().exec(SCHEDULER_STORE_SCHEMA);\n\t}\n\n\texec(sql: string): void {\n\t\tthis.connection().exec(sql);\n\t}\n\n\tpragma(name: string): JsonValue {\n\t\tconst row = this.connection().prepare(`PRAGMA ${name}`).get() as SqliteRow | undefined;\n\t\tif (row === undefined) {\n\t\t\treturn null;\n\t\t}\n\t\tconst keys = Object.keys(row);\n\t\tif (keys.length === 0) {\n\t\t\treturn null;\n\t\t}\n\t\treturn scalar(row[keys[0]]);\n\t}\n\n\t// --- run lifecycle ---------------------------------------------------------\n\n\tcreateRun(run: RunInput): void {\n\t\tconst now = nowIso();\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO runs (run_id, goal, topology, status, created_at, updated_at, dag_hash, root_node_id)\n\t\t\t\t VALUES (?, ?, ?, 'running', ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(run.runId, run.goal, run.topology, now, now, run.dagHash ?? null, run.rootNodeId ?? null);\n\t}\n\n\tgetRun(runId: string): RunRow | undefined {\n\t\tconst row = this.connection().prepare(`SELECT * FROM runs WHERE run_id = ?`).get(runId) as SqliteRow | undefined;\n\t\treturn row === undefined ? undefined : mapRunRow(row);\n\t}\n\n\tupdateRunStatus(runId: string, status: RunStatus, now?: string): boolean {\n\t\tconst ts = now ?? nowIso();\n\t\tconst completedAt = status === \"completed\" || status === \"failed\" || status === \"cancelled\" ? ts : null;\n\t\tconst result = this.connection()\n\t\t\t.prepare(\n\t\t\t\t`UPDATE runs\n\t\t\t\t SET status = ?, updated_at = ?, completed_at = COALESCE(?, completed_at)\n\t\t\t\t WHERE run_id = ?`,\n\t\t\t)\n\t\t\t.run(status, ts, completedAt, runId);\n\t\treturn changed(result);\n\t}\n\n\t// --- DAG ingestion (idempotent) -------------------------------------------\n\n\tingestDag(submission: DagSubmission): DagIngestionResult {\n\t\tconst db = this.connection();\n\t\tconst dagHash = computeDagHash(submission);\n\t\tconst nodeIds: string[] = [];\n\t\tconst insertedNodeIds: string[] = [];\n\t\tconst reusedNodeIds: string[] = [];\n\n\t\tthis.transaction(() => {\n\t\t\tconst now = nowIso();\n\t\t\t// Run header: insert once; never overwrite on replay.\n\t\t\tdb.prepare(\n\t\t\t\t`INSERT OR IGNORE INTO runs (run_id, goal, topology, status, created_at, updated_at, dag_hash, root_node_id)\n\t\t\t\t VALUES (?, ?, ?, 'running', ?, ?, ?, ?)`,\n\t\t\t).run(\n\t\t\t\tsubmission.run.runId,\n\t\t\t\tsubmission.run.goal,\n\t\t\t\tsubmission.run.topology,\n\t\t\t\tnow,\n\t\t\t\tnow,\n\t\t\t\tdagHash,\n\t\t\t\tsubmission.run.rootNodeId ?? null,\n\t\t\t);\n\n\t\t\tfor (const node of submission.nodes) {\n\t\t\t\tconst key = computeIdempotencyKey(submission.run.runId, node);\n\t\t\t\t// Identity is (run_id, node_id). The idempotency key (which itself\n\t\t\t\t// includes node_id) distinguishes a true replay from a redefinition.\n\t\t\t\tconst existing = db\n\t\t\t\t\t.prepare(`SELECT idempotency_key FROM nodes WHERE run_id = ? AND node_id = ?`)\n\t\t\t\t\t.get(submission.run.runId, node.nodeId) as SqliteRow | undefined;\n\t\t\t\tif (existing !== undefined) {\n\t\t\t\t\tif (asString(existing.idempotency_key) !== key) {\n\t\t\t\t\t\tthrow new NodeRedefinitionError(submission.run.runId, node.nodeId);\n\t\t\t\t\t}\n\t\t\t\t\tnodeIds.push(node.nodeId);\n\t\t\t\t\treusedNodeIds.push(node.nodeId);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tthis.insertNode(submission.run.runId, node, key, now);\n\t\t\t\tnodeIds.push(node.nodeId);\n\t\t\t\tinsertedNodeIds.push(node.nodeId);\n\t\t\t}\n\n\t\t\tfor (const edge of submission.edges ?? []) {\n\t\t\t\tdb.prepare(\n\t\t\t\t\t`INSERT OR IGNORE INTO edges (run_id, from_node_id, to_node_id, edge_type)\n\t\t\t\t\t VALUES (?, ?, ?, ?)`,\n\t\t\t\t).run(submission.run.runId, edge.fromNodeId, edge.toNodeId, edge.edgeType ?? \"strong\");\n\t\t\t}\n\t\t});\n\n\t\treturn { runId: submission.run.runId, dagHash, nodeIds, insertedNodeIds, reusedNodeIds };\n\t}\n\n\tprivate insertNode(runId: string, node: NodeInput, idempotencyKey: string, now: string): void {\n\t\tconst db = this.connection();\n\t\tconst readSet = (node.readSet ?? []).map(normalizeAccessEntry);\n\t\tconst writeSet = (node.writeSet ?? []).map(normalizeAccessEntry);\n\t\tdb.prepare(\n\t\t\t`INSERT INTO nodes (\n\t\t\t\tnode_id, run_id, role, task, status, idempotency_key,\n\t\t\t\tread_set, write_set, retry_policy, verification_contract, cost_budget,\n\t\t\t\tcreated_at, priority, parallelizable\n\t\t\t ) VALUES (?, ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n\t\t).run(\n\t\t\tnode.nodeId,\n\t\t\trunId,\n\t\t\tnode.role,\n\t\t\tnode.task,\n\t\t\tidempotencyKey,\n\t\t\tJSON.stringify(readSet),\n\t\t\tJSON.stringify(writeSet),\n\t\t\tJSON.stringify(node.retryPolicy ?? DEFAULT_RETRY_POLICY),\n\t\t\tnode.verificationContract ?? null,\n\t\t\tnode.costBudget ?? null,\n\t\t\tnow,\n\t\t\tnode.priority ?? 0,\n\t\t\tnode.parallelizable === false ? 0 : 1,\n\t\t);\n\n\t\tconst insertAccess = db.prepare(\n\t\t\t`INSERT OR IGNORE INTO access (access_id, run_id, node_id, kind, path, symbols)\n\t\t\t VALUES (?, ?, ?, ?, ?, ?)`,\n\t\t);\n\t\tfor (const entry of readSet) {\n\t\t\tinsertAccess.run(\n\t\t\t\taccessId(runId, node.nodeId, \"read\", entry),\n\t\t\t\trunId,\n\t\t\t\tnode.nodeId,\n\t\t\t\t\"read\",\n\t\t\t\tentry.path,\n\t\t\t\tJSON.stringify(entry.symbols),\n\t\t\t);\n\t\t}\n\t\tfor (const entry of writeSet) {\n\t\t\tinsertAccess.run(\n\t\t\t\taccessId(runId, node.nodeId, \"write\", entry),\n\t\t\t\trunId,\n\t\t\t\tnode.nodeId,\n\t\t\t\t\"write\",\n\t\t\t\tentry.path,\n\t\t\t\tJSON.stringify(entry.symbols),\n\t\t\t);\n\t\t}\n\t}\n\n\tgetNode(runId: string, nodeId: string): NodeRow | undefined {\n\t\tconst row = this.connection()\n\t\t\t.prepare(`SELECT * FROM nodes WHERE run_id = ? AND node_id = ?`)\n\t\t\t.get(runId, nodeId) as SqliteRow | undefined;\n\t\treturn row === undefined ? undefined : mapNodeRow(row);\n\t}\n\n\tgetNodesByRun(runId: string): NodeRow[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM nodes WHERE run_id = ? ORDER BY node_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map(mapNodeRow);\n\t}\n\n\tgetEdgesByRun(runId: string): EdgeRow[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM edges WHERE run_id = ? ORDER BY from_node_id ASC, to_node_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\trunId: asString(row.run_id),\n\t\t\tfromNodeId: asString(row.from_node_id),\n\t\t\ttoNodeId: asString(row.to_node_id),\n\t\t\tedgeType: asString(row.edge_type) === \"weak\" ? \"weak\" : \"strong\",\n\t\t}));\n\t}\n\n\t// --- conflict graph --------------------------------------------------------\n\n\tbuildConflictGraph(runId: string): ConflictEdge[] {\n\t\tconst nodes = this.getNodesByRun(runId);\n\t\tconst schedulerNodes = nodes.map(toSchedulerNode);\n\t\tconst edges: ConflictEdge[] = [];\n\n\t\tthis.transaction(() => {\n\t\t\tconst db = this.connection();\n\t\t\tdb.prepare(`DELETE FROM conflicts WHERE run_id = ?`).run(runId);\n\t\t\tconst insert = db.prepare(\n\t\t\t\t`INSERT OR IGNORE INTO conflicts (run_id, node_a, node_b, reason) VALUES (?, ?, ?, ?)`,\n\t\t\t);\n\t\t\tfor (let i = 0; i < schedulerNodes.length; i += 1) {\n\t\t\t\tfor (let j = i + 1; j < schedulerNodes.length; j += 1) {\n\t\t\t\t\t// Canonical order: nodeA < nodeB (getNodesByRun already sorts by node_id).\n\t\t\t\t\tconst a = schedulerNodes[i];\n\t\t\t\t\tconst b = schedulerNodes[j];\n\t\t\t\t\tconst reason = classifyConflict(a, b);\n\t\t\t\t\tif (reason === undefined) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tinsert.run(runId, a.nodeId, b.nodeId, reason);\n\t\t\t\t\tedges.push({ runId, nodeA: a.nodeId, nodeB: b.nodeId, reason });\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\treturn edges;\n\t}\n\n\tgetConflicts(runId: string): ConflictEdge[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM conflicts WHERE run_id = ? ORDER BY node_a ASC, node_b ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeA: asString(row.node_a),\n\t\t\tnodeB: asString(row.node_b),\n\t\t\treason: asString(row.reason) as ConflictEdge[\"reason\"],\n\t\t}));\n\t}\n\n\t// --- lease lifecycle (owner-token fenced) ----------------------------------\n\n\tacquireLease(runId: string, nodeId: string, lease: LeaseInput): boolean {\n\t\tconst db = this.connection();\n\t\tlet acquired = false;\n\t\tthis.transaction(() => {\n\t\t\tconst result = db\n\t\t\t\t.prepare(\n\t\t\t\t\t`UPDATE nodes\n\t\t\t\t\t SET status = 'leased', lease_id = ?, lease_expires_at = ?, heartbeat_at = NULL,\n\t\t\t\t\t\t attempt_count = attempt_count + 1\n\t\t\t\t\t WHERE run_id = ? AND node_id = ? AND status = 'queued'`,\n\t\t\t\t)\n\t\t\t\t.run(lease.leaseId, lease.expiresAt, runId, nodeId);\n\t\t\tif (!changed(result)) {\n\t\t\t\t// Guard lost (already leased / not queued): leave the transaction a no-op.\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tdb.prepare(\n\t\t\t\t`INSERT INTO leases (lease_id, run_id, node_id, issued_at, expires_at, heartbeat_at, owner_token, released)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, NULL, ?, 0)`,\n\t\t\t).run(lease.leaseId, runId, nodeId, lease.now ?? nowIso(), lease.expiresAt, lease.ownerToken);\n\t\t\tacquired = true;\n\t\t});\n\t\treturn acquired;\n\t}\n\n\theartbeat(runId: string, nodeId: string, ownerToken: string, now: string, expiresAt: string): boolean {\n\t\tconst db = this.connection();\n\t\tlet ok = false;\n\t\tthis.transaction(() => {\n\t\t\tconst result = db\n\t\t\t\t.prepare(\n\t\t\t\t\t`UPDATE leases\n\t\t\t\t\t SET heartbeat_at = ?, expires_at = ?\n\t\t\t\t\t WHERE run_id = ? AND node_id = ? AND owner_token = ? AND released = 0`,\n\t\t\t\t)\n\t\t\t\t.run(now, expiresAt, runId, nodeId, ownerToken);\n\t\t\tif (!changed(result)) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// Mirror the extension onto the scheduler's node view (reclaim reads nodes).\n\t\t\tdb.prepare(\n\t\t\t\t`UPDATE nodes\n\t\t\t\t SET heartbeat_at = ?, lease_expires_at = ?\n\t\t\t\t WHERE run_id = ? AND node_id = ?\n\t\t\t\t   AND lease_id IN (SELECT lease_id FROM leases\n\t\t\t\t\t\t\t\t\tWHERE run_id = ? AND node_id = ? AND owner_token = ? AND released = 0)`,\n\t\t\t).run(now, expiresAt, runId, nodeId, runId, nodeId, ownerToken);\n\t\t\tok = true;\n\t\t});\n\t\treturn ok;\n\t}\n\n\tstartNode(runId: string, nodeId: string, ownerToken: string, now: string): boolean {\n\t\tconst result = this.connection()\n\t\t\t.prepare(\n\t\t\t\t`UPDATE nodes\n\t\t\t\t SET status = 'running', started_at = ?, heartbeat_at = ?\n\t\t\t\t WHERE run_id = ? AND node_id = ? AND status = 'leased'\n\t\t\t\t   AND lease_id IN (SELECT lease_id FROM leases\n\t\t\t\t\t\t\t\t\tWHERE run_id = ? AND node_id = ? AND owner_token = ? AND released = 0)`,\n\t\t\t)\n\t\t\t.run(now, now, runId, nodeId, runId, nodeId, ownerToken);\n\t\treturn changed(result);\n\t}\n\n\treclaimExpiredLeases(runId: string, now: string): string[] {\n\t\tconst db = this.connection();\n\t\tconst reclaimed: string[] = [];\n\t\tthis.transaction(() => {\n\t\t\tconst rows = db\n\t\t\t\t.prepare(\n\t\t\t\t\t`SELECT node_id, lease_id FROM nodes\n\t\t\t\t\t WHERE run_id = ?\n\t\t\t\t\t   AND status IN ('leased','running','verifying')\n\t\t\t\t\t   AND lease_expires_at IS NOT NULL\n\t\t\t\t\t   AND lease_expires_at < ?`,\n\t\t\t\t)\n\t\t\t\t.all(runId, now) as SqliteRow[];\n\t\t\tfor (const row of rows) {\n\t\t\t\tconst nodeId = asString(row.node_id);\n\t\t\t\tconst leaseId = row.lease_id === null ? null : asString(row.lease_id);\n\t\t\t\tif (leaseId !== null) {\n\t\t\t\t\tdb.prepare(`UPDATE leases SET released = 1 WHERE lease_id = ?`).run(leaseId);\n\t\t\t\t}\n\t\t\t\tdb.prepare(\n\t\t\t\t\t`UPDATE nodes\n\t\t\t\t\t SET status = 'queued', lease_id = NULL, lease_expires_at = NULL, heartbeat_at = NULL,\n\t\t\t\t\t\t requeue_count = requeue_count + 1\n\t\t\t\t\t WHERE run_id = ? AND node_id = ?`,\n\t\t\t\t).run(runId, nodeId);\n\t\t\t\treclaimed.push(nodeId);\n\t\t\t}\n\t\t});\n\t\treturn reclaimed;\n\t}\n\n\tgetLease(leaseId: string): LeaseRow | undefined {\n\t\tconst row = this.connection().prepare(`SELECT * FROM leases WHERE lease_id = ?`).get(leaseId) as\n\t\t\t| SqliteRow\n\t\t\t| undefined;\n\t\tif (row === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn {\n\t\t\tleaseId: asString(row.lease_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeId: asString(row.node_id),\n\t\t\tattemptId: row.attempt_id === null ? null : asString(row.attempt_id),\n\t\t\tissuedAt: asString(row.issued_at),\n\t\t\texpiresAt: asString(row.expires_at),\n\t\t\theartbeatAt: row.heartbeat_at === null ? null : asString(row.heartbeat_at),\n\t\t\townerToken: asString(row.owner_token),\n\t\t\treleased: asNumber(row.released) !== 0,\n\t\t};\n\t}\n\n\t// --- scaffolded sibling-lane tables ---------------------------------------\n\n\trecordAttempt(attempt: AttemptInput): void {\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO attempts (attempt_id, run_id, node_id, lease_id, started_at, finished_at, status,\n\t\t\t\t\t\t\t\t\t   exit_code, error_summary, worker_pid)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(\n\t\t\t\tattempt.attemptId,\n\t\t\t\tattempt.runId,\n\t\t\t\tattempt.nodeId,\n\t\t\t\tattempt.leaseId,\n\t\t\t\tattempt.startedAt ?? nowIso(),\n\t\t\t\tattempt.finishedAt ?? null,\n\t\t\t\tattempt.status,\n\t\t\t\tattempt.exitCode ?? null,\n\t\t\t\tattempt.errorSummary === undefined ? null : stableStringify(attempt.errorSummary),\n\t\t\t\tattempt.workerPid ?? null,\n\t\t\t);\n\t}\n\n\tgetAttemptsByRun(runId: string): AttemptInput[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM attempts WHERE run_id = ? ORDER BY started_at ASC, attempt_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\tattemptId: asString(row.attempt_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeId: asString(row.node_id),\n\t\t\tleaseId: asString(row.lease_id),\n\t\t\tstatus: asString(row.status) as AttemptInput[\"status\"],\n\t\t\tstartedAt: asString(row.started_at),\n\t\t\tfinishedAt: row.finished_at === null ? undefined : asString(row.finished_at),\n\t\t\texitCode: row.exit_code === null ? undefined : asNumber(row.exit_code),\n\t\t\terrorSummary: row.error_summary === null ? undefined : (JSON.parse(asString(row.error_summary)) as JsonValue),\n\t\t\tworkerPid: row.worker_pid === null ? undefined : asNumber(row.worker_pid),\n\t\t}));\n\t}\n\n\tregisterWorktree(worktree: WorktreeInput): void {\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO worktrees (worktree_id, run_id, node_id, path, branch_name, status, created_at)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(\n\t\t\t\tworktree.worktreeId,\n\t\t\t\tworktree.runId,\n\t\t\t\tworktree.nodeId,\n\t\t\t\tworktree.path,\n\t\t\t\tworktree.branchName,\n\t\t\t\tworktree.status ?? \"active\",\n\t\t\t\tworktree.createdAt ?? nowIso(),\n\t\t\t);\n\t}\n\n\tgetWorktreesByRun(runId: string): WorktreeInput[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM worktrees WHERE run_id = ? ORDER BY worktree_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\tworktreeId: asString(row.worktree_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeId: asString(row.node_id),\n\t\t\tpath: asString(row.path),\n\t\t\tbranchName: asString(row.branch_name),\n\t\t\tstatus: asString(row.status) as WorktreeInput[\"status\"],\n\t\t\tcreatedAt: asString(row.created_at),\n\t\t}));\n\t}\n\n\tregisterCompensator(compensator: CompensatorInput): void {\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO compensators (compensator_id, run_id, node_id, kind, sequence, idempotent, applied,\n\t\t\t\t\t\t\t\t\t\t  prepared_state_hash, created_at)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(\n\t\t\t\tcompensator.compensatorId,\n\t\t\t\tcompensator.runId,\n\t\t\t\tcompensator.nodeId,\n\t\t\t\tcompensator.kind,\n\t\t\t\tcompensator.sequence,\n\t\t\t\tcompensator.idempotent ? 1 : 0,\n\t\t\t\tcompensator.applied ? 1 : 0,\n\t\t\t\tcompensator.preparedStateHash ?? null,\n\t\t\t\tcompensator.createdAt ?? nowIso(),\n\t\t\t);\n\t}\n\n\tgetCompensatorsByNode(runId: string, nodeId: string): CompensatorInput[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM compensators WHERE run_id = ? AND node_id = ? ORDER BY sequence ASC`)\n\t\t\t.all(runId, nodeId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\tcompensatorId: asString(row.compensator_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeId: asString(row.node_id),\n\t\t\tkind: asString(row.kind),\n\t\t\tsequence: asNumber(row.sequence),\n\t\t\tidempotent: asNumber(row.idempotent) !== 0,\n\t\t\tapplied: asNumber(row.applied) !== 0,\n\t\t\tpreparedStateHash: row.prepared_state_hash === null ? null : asString(row.prepared_state_hash),\n\t\t\tcreatedAt: asString(row.created_at),\n\t\t}));\n\t}\n\n\trecordArtifact(artifact: ArtifactInput): void {\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO artifacts (artifact_id, run_id, node_id, attempt_id, path, kind, sha256, size_bytes, created_at)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(\n\t\t\t\tartifact.artifactId,\n\t\t\t\tartifact.runId,\n\t\t\t\tartifact.nodeId,\n\t\t\t\tartifact.attemptId ?? null,\n\t\t\t\tartifact.path,\n\t\t\t\tartifact.kind,\n\t\t\t\tartifact.sha256 ?? null,\n\t\t\t\tartifact.sizeBytes ?? null,\n\t\t\t\tartifact.createdAt ?? nowIso(),\n\t\t\t);\n\t}\n\n\tgetArtifactsByRun(runId: string): ArtifactInput[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM artifacts WHERE run_id = ? ORDER BY path ASC, artifact_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\tartifactId: asString(row.artifact_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\tnodeId: asString(row.node_id),\n\t\t\tattemptId: row.attempt_id === null ? undefined : asString(row.attempt_id),\n\t\t\tpath: asString(row.path),\n\t\t\tkind: asString(row.kind) as ArtifactInput[\"kind\"],\n\t\t\tsha256: row.sha256 === null ? undefined : asString(row.sha256),\n\t\t\tsizeBytes: row.size_bytes === null ? undefined : asNumber(row.size_bytes),\n\t\t\tcreatedAt: asString(row.created_at),\n\t\t}));\n\t}\n\n\t// --- ledger mirror ---------------------------------------------------------\n\n\tappendEvent(event: SchedulerEventInput): void {\n\t\tthis.connection()\n\t\t\t.prepare(\n\t\t\t\t`INSERT INTO events (event_id, run_id, operation_id, causation_id, sequence, timestamp, kind, status, node_id, data)\n\t\t\t\t VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n\t\t\t)\n\t\t\t.run(\n\t\t\t\tevent.eventId,\n\t\t\t\tevent.runId,\n\t\t\t\tevent.operationId,\n\t\t\t\tevent.causationId ?? null,\n\t\t\t\tevent.sequence,\n\t\t\t\tevent.timestamp,\n\t\t\t\tevent.kind,\n\t\t\t\tevent.status,\n\t\t\t\tevent.nodeId ?? null,\n\t\t\t\tstableStringify(event.data ?? null),\n\t\t\t);\n\t}\n\n\tgetEvents(runId: string): SchedulerEventRow[] {\n\t\tconst rows = this.connection()\n\t\t\t.prepare(`SELECT * FROM events WHERE run_id = ? ORDER BY sequence ASC, event_id ASC`)\n\t\t\t.all(runId) as SqliteRow[];\n\t\treturn rows.map((row) => ({\n\t\t\teventId: asString(row.event_id),\n\t\t\trunId: asString(row.run_id),\n\t\t\toperationId: asString(row.operation_id),\n\t\t\tcausationId: row.causation_id === null ? null : asString(row.causation_id),\n\t\t\tsequence: asNumber(row.sequence),\n\t\t\ttimestamp: asString(row.timestamp),\n\t\t\tkind: asString(row.kind),\n\t\t\tstatus: asString(row.status),\n\t\t\tnodeId: row.node_id === null ? null : asString(row.node_id),\n\t\t\tdata: JSON.parse(asString(row.data)) as JsonValue,\n\t\t}));\n\t}\n\n\t// --- internals -------------------------------------------------------------\n\n\tprivate connection(): DatabaseSync {\n\t\tif (this.db === null) {\n\t\t\tthrow new Error(\"SqliteSchedulerStore is not open\");\n\t\t}\n\t\treturn this.db;\n\t}\n\n\t/** Run `fn` inside a single transaction; rollback on throw. */\n\tprivate transaction(fn: () => void): void {\n\t\tconst db = this.connection();\n\t\tdb.exec(\"BEGIN\");\n\t\ttry {\n\t\t\tfn();\n\t\t\tdb.exec(\"COMMIT\");\n\t\t} catch (error) {\n\t\t\tdb.exec(\"ROLLBACK\");\n\t\t\tthrow error;\n\t\t}\n\t}\n}\n\nfunction normalizeAccessEntry(entry: AccessSetEntry): { path: string; symbols: string[] } {\n\treturn { path: entry.path, symbols: entry.symbols === undefined ? [] : [...entry.symbols] };\n}\n\nfunction accessId(runId: string, nodeId: string, kind: string, entry: { path: string; symbols: string[] }): string {\n\treturn `${runId}\\u0000${nodeId}\\u0000${kind}\\u0000${entry.path}\\u0000${stableStringify([...entry.symbols].sort())}`;\n}\n\nfunction toSchedulerNode(row: NodeRow): SchedulerNode {\n\treturn {\n\t\tnodeId: row.nodeId,\n\t\tstatus: row.status,\n\t\tpriority: row.priority,\n\t\tparallelizable: row.parallelizable,\n\t\treadSet: row.readSet,\n\t\twriteSet: row.writeSet,\n\t};\n}\n\nfunction mapRunRow(row: SqliteRow): RunRow {\n\treturn {\n\t\trunId: asString(row.run_id),\n\t\tgoal: asString(row.goal),\n\t\ttopology: asString(row.topology),\n\t\tstatus: asString(row.status) as RunStatus,\n\t\tcreatedAt: asString(row.created_at),\n\t\tupdatedAt: asString(row.updated_at),\n\t\tcompletedAt: row.completed_at === null ? null : asString(row.completed_at),\n\t\tdagHash: row.dag_hash === null ? null : asString(row.dag_hash),\n\t\trootNodeId: row.root_node_id === null ? null : asString(row.root_node_id),\n\t};\n}\n\nfunction mapNodeRow(row: SqliteRow): NodeRow {\n\treturn {\n\t\tnodeId: asString(row.node_id),\n\t\trunId: asString(row.run_id),\n\t\trole: asString(row.role) as NodeRow[\"role\"],\n\t\ttask: asString(row.task),\n\t\tstatus: asString(row.status) as NodeRow[\"status\"],\n\t\tidempotencyKey: asString(row.idempotency_key),\n\t\treadSet: parseAccessSet(asString(row.read_set)),\n\t\twriteSet: parseAccessSet(asString(row.write_set)),\n\t\tleaseId: row.lease_id === null ? null : asString(row.lease_id),\n\t\tleaseExpiresAt: row.lease_expires_at === null ? null : asString(row.lease_expires_at),\n\t\theartbeatAt: row.heartbeat_at === null ? null : asString(row.heartbeat_at),\n\t\tattemptCount: asNumber(row.attempt_count),\n\t\trequeueCount: asNumber(row.requeue_count),\n\t\tretryWaitUntil: row.retry_wait_until === null ? null : asString(row.retry_wait_until),\n\t\tpriority: asNumber(row.priority),\n\t\tparallelizable: asNumber(row.parallelizable) !== 0,\n\t\tcreatedAt: asString(row.created_at),\n\t\tstartedAt: row.started_at === null ? null : asString(row.started_at),\n\t\tfinishedAt: row.finished_at === null ? null : asString(row.finished_at),\n\t};\n}\n\nfunction parseAccessSet(json: string): AccessSetEntry[] {\n\tconst parsed = JSON.parse(json) as Array<{ path: string; symbols?: string[] }>;\n\treturn parsed.map((entry) =>\n\t\tentry.symbols !== undefined && entry.symbols.length > 0\n\t\t\t? { path: entry.path, symbols: entry.symbols }\n\t\t\t: { path: entry.path },\n\t);\n}\n\nfunction changed(result: { changes: number | bigint }): boolean {\n\treturn Number(result.changes) > 0;\n}\n\nfunction scalar(value: string | number | bigint | null | Uint8Array): JsonValue {\n\tif (value === null) {\n\t\treturn null;\n\t}\n\tif (typeof value === \"bigint\") {\n\t\treturn Number(value);\n\t}\n\tif (value instanceof Uint8Array) {\n\t\treturn Buffer.from(value).toString(\"base64\");\n\t}\n\treturn value;\n}\n\nfunction asString(value: string | number | bigint | null | Uint8Array): string {\n\tif (typeof value === \"string\") {\n\t\treturn value;\n\t}\n\tif (value === null) {\n\t\tthrow new Error(\"expected string column, got null\");\n\t}\n\tif (typeof value === \"bigint\" || typeof value === \"number\") {\n\t\treturn String(value);\n\t}\n\tthrow new Error(\"expected string column, got blob\");\n}\n\nfunction asNumber(value: string | number | bigint | null | Uint8Array): number {\n\tif (typeof value === \"number\") {\n\t\treturn value;\n\t}\n\tif (typeof value === \"bigint\") {\n\t\treturn Number(value);\n\t}\n\tif (typeof value === \"string\") {\n\t\treturn Number(value);\n\t}\n\tthrow new Error(\"expected numeric column\");\n}\n\nfunction nowIso(): string {\n\treturn new Date().toISOString();\n}\n"]}