open-multi-agent-kit 0.80.7 → 0.80.8

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

@@ -1,185 +0,0 @@
-/**
- * Pure scheduler state module for the durable DAG orchestrator.
- *
- * This module is intentionally free of I/O: it owns the node state machine,
- * the read/write conflict model, the dispatchability predicate, and the
- * deterministic dispatch selection. Persistence (SQLite WAL), leases, and
- * dependency readiness live in sibling modules; this is the single source of
- * truth for the *rules* those modules enforce.
- *
- * Erasable TypeScript only (no enum/namespace/parameter properties). All time
- * values are epoch milliseconds so tests can use deterministic fake clocks.
- */
-/**
- * Legal direct transitions, derived from foundation.md section 2.2.
- *
- * Terminal statuses (completed, failed, blocked, cancelled, rolled_back,
- * in_doubt) map to the empty set: once terminal, a node never moves again.
- * block/cancel are legal from every non-terminal status ("any -> block",
- * "any except terminal -> cancel"). running -> running encodes the heartbeat
- * self-update.
- */
-const ALLOWED_TRANSITIONS = {
-    queued: new Set(["leased", "blocked", "cancelled"]),
-    leased: new Set(["queued", "running", "blocked", "cancelled"]),
-    running: new Set([
-        "running",
-        "verifying",
-        "retry_wait",
-        "failed",
-        "compensating",
-        "blocked",
-        "cancelled",
-    ]),
-    verifying: new Set([
-        "completed",
-        "retry_wait",
-        "failed",
-        "compensating",
-        "blocked",
-        "cancelled",
-    ]),
-    completed: new Set(),
-    retry_wait: new Set(["queued", "blocked", "cancelled"]),
-    compensating: new Set(["rolled_back", "in_doubt", "blocked", "cancelled"]),
-    rolled_back: new Set(),
-    in_doubt: new Set(),
-    blocked: new Set(),
-    cancelled: new Set(),
-    failed: new Set(),
-};
-/** True iff moving a node from `from` to `to` is a legal direct transition. */
-export function canTransitionNodeStatus(from, to) {
-    return ALLOWED_TRANSITIONS[from].has(to);
-}
-/** True iff the entry narrows on at least one symbol (empty list counts as no narrowing). */
-function declaresSymbols(entry) {
-    return Array.isArray(entry.symbols) && entry.symbols.length > 0;
-}
-/** True iff two non-empty symbol lists share at least one symbol. */
-function sharesSymbol(a, b) {
-    const seen = new Set(a);
-    for (const symbol of b) {
-        if (seen.has(symbol)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Two access entries conflict iff they reference the same path. When BOTH
- * entries declare (non-empty) symbols, the conflict narrows to a shared symbol;
- * otherwise the conflict is path-level (conservative).
- */
-export function accessEntriesConflict(a, b) {
-    if (a.path !== b.path) {
-        return false;
-    }
-    if (declaresSymbols(a) && declaresSymbols(b)) {
-        return sharesSymbol(a.symbols, b.symbols);
-    }
-    return true;
-}
-/** True iff any entry in `left` conflicts with any entry in `right`. */
-function setsOverlap(left, right) {
-    for (const l of left) {
-        for (const r of right) {
-            if (accessEntriesConflict(l, r)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * A candidate node conflicts with an in-flight node on write/write,
- * write/read, or read/write overlap. read/read never conflicts.
- */
-export function nodesConflict(candidate, inFlight) {
-    // write/write
-    if (setsOverlap(candidate.writeSet, inFlight.writeSet)) {
-        return true;
-    }
-    // write/read: candidate writes what in-flight reads
-    if (setsOverlap(candidate.writeSet, inFlight.readSet)) {
-        return true;
-    }
-    // read/write: candidate reads what in-flight writes
-    if (setsOverlap(candidate.readSet, inFlight.writeSet)) {
-        return true;
-    }
-    return false;
-}
-/**
- * A node is dispatchable iff it is `queued`, or `retry_wait` whose backoff
- * deadline has elapsed (retryWaitUntil <= now). Dependencies and leases are
- * checked elsewhere; this predicate only answers the time/status question.
- */
-export function isNodeDispatchable(node, now) {
-    if (node.status === "queued") {
-        return true;
-    }
-    if (node.status === "retry_wait") {
-        return node.retryWaitUntil !== undefined && node.retryWaitUntil <= now;
-    }
-    return false;
-}
-/** Deterministic ordering: priority ascending, then nodeId ascending. */
-function compareDispatchOrder(a, b) {
-    if (a.priority !== b.priority) {
-        return a.priority - b.priority;
-    }
-    if (a.nodeId < b.nodeId) {
-        return -1;
-    }
-    if (a.nodeId > b.nodeId) {
-        return 1;
-    }
-    return 0;
-}
-/**
- * Select dispatchable nodes for a single tick, deterministically.
- *
- * Ordering: priority ascending, then nodeId ascending. A candidate is excluded
- * if it conflicts (write/write, write/read, read/write) with any in-flight node
- * or any node already selected this tick. `parallelizable: false` nodes may be
- * selected only when nothing is selected and nothing is in-flight, and once one
- * is selected the tick stops (serialized lane). Selection stops once
- * in-flight + selected reaches `maxLeases`, or `maxParallel` is hit.
- */
-export function selectDispatchableNodes(nodes, options) {
-    const inFlight = options.inFlight ?? [];
-    const maxParallel = options.maxParallel ?? Number.POSITIVE_INFINITY;
-    // Remaining lease headroom after accounting for in-flight occupancy.
-    const remaining = Math.max(0, options.maxLeases - inFlight.length);
-    if (remaining === 0) {
-        return [];
-    }
-    const candidates = nodes.filter((node) => isNodeDispatchable(node, options.now));
-    const ordered = [...candidates].sort(compareDispatchOrder);
-    const selected = [];
-    for (const candidate of ordered) {
-        if (selected.length >= remaining || selected.length >= maxParallel) {
-            break;
-        }
-        // Serialized lane: a non-parallelizable node needs the lane to itself.
-        if (!candidate.parallelizable) {
-            if (selected.length > 0 || inFlight.length > 0) {
-                continue;
-            }
-        }
-        // Exclude candidates that conflict with anything already in flight or chosen.
-        const conflictsWithBusy = inFlight.some((busy) => nodesConflict(candidate, busy)) ||
-            selected.some((chosen) => nodesConflict(candidate, chosen));
-        if (conflictsWithBusy) {
-            continue;
-        }
-        selected.push(candidate);
-        // A non-parallelizable node claims the whole lane for this tick.
-        if (!candidate.parallelizable) {
-            break;
-        }
-    }
-    return selected;
-}
-//# sourceMappingURL=scheduler-state.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler-state.js","sourceRoot":"","sources":["../../../src/core/orchestration/scheduler-state.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure scheduler state module for the durable DAG orchestrator.\n *\n * This module is intentionally free of I/O: it owns the node state machine,\n * the read/write conflict model, the dispatchability predicate, and the\n * deterministic dispatch selection. Persistence (SQLite WAL), leases, and\n * dependency readiness live in sibling modules; this is the single source of\n * truth for the *rules* those modules enforce.\n *\n * Erasable TypeScript only (no enum/namespace/parameter properties). All time\n * values are epoch milliseconds so tests can use deterministic fake clocks.\n */\n\n/** Lifecycle status of a DAG node (see foundation.md section 2.1). */\nexport type SchedulerNodeStatus =\n\t| \"queued\"\n\t| \"leased\"\n\t| \"running\"\n\t| \"verifying\"\n\t| \"completed\"\n\t| \"retry_wait\"\n\t| \"compensating\"\n\t| \"rolled_back\"\n\t| \"in_doubt\"\n\t| \"blocked\"\n\t| \"cancelled\"\n\t| \"failed\";\n\n/** A single resource touched by a node's read_set or write_set. */\nexport interface AccessSetEntry {\n\t/** Filesystem path. Equality is exact string match (no prefix containment here). */\n\tpath: string;\n\t/** Optional symbol list for symbol-level conflict narrowing. */\n\tsymbols?: readonly string[];\n}\n\n/** A DAG node, narrowed to the fields the pure scheduler rules consume. */\nexport interface SchedulerNode {\n\tnodeId: string;\n\tstatus: SchedulerNodeStatus;\n\t/** Lower number dispatches sooner. */\n\tpriority: number;\n\t/** false => must run alone (no siblings selected or in-flight alongside it). */\n\tparallelizable: boolean;\n\treadSet: readonly AccessSetEntry[];\n\twriteSet: readonly AccessSetEntry[];\n\t/** Epoch ms backoff deadline; consulted only when status === \"retry_wait\". */\n\tretryWaitUntil?: number;\n\t/** Upstream node ids. Not consulted by these pure functions (dependency readiness is external). */\n\tdependsOn?: readonly string[];\n}\n\n/** Options driving a single dispatch selection pass. */\nexport interface DispatchSelectionOptions {\n\t/** Epoch ms \"now\"; used for retry_wait backoff comparison. */\n\tnow: number;\n\t/** Total in-flight lease ceiling. Selection stops once in-flight + selected reaches this. */\n\tmaxLeases: number;\n\t/** Optional per-tick cap on how many nodes may be selected. */\n\tmaxParallel?: number;\n\t/** Nodes already leased/running/verifying, counted toward maxLeases and conflict checks. */\n\tinFlight?: readonly SchedulerNode[];\n}\n\n/**\n * Legal direct transitions, derived from foundation.md section 2.2.\n *\n * Terminal statuses (completed, failed, blocked, cancelled, rolled_back,\n * in_doubt) map to the empty set: once terminal, a node never moves again.\n * block/cancel are legal from every non-terminal status (\"any -> block\",\n * \"any except terminal -> cancel\"). running -> running encodes the heartbeat\n * self-update.\n */\nconst ALLOWED_TRANSITIONS: Readonly<Record<SchedulerNodeStatus, ReadonlySet<SchedulerNodeStatus>>> = {\n\tqueued: new Set<SchedulerNodeStatus>([\"leased\", \"blocked\", \"cancelled\"]),\n\tleased: new Set<SchedulerNodeStatus>([\"queued\", \"running\", \"blocked\", \"cancelled\"]),\n\trunning: new Set<SchedulerNodeStatus>([\n\t\t\"running\",\n\t\t\"verifying\",\n\t\t\"retry_wait\",\n\t\t\"failed\",\n\t\t\"compensating\",\n\t\t\"blocked\",\n\t\t\"cancelled\",\n\t]),\n\tverifying: new Set<SchedulerNodeStatus>([\n\t\t\"completed\",\n\t\t\"retry_wait\",\n\t\t\"failed\",\n\t\t\"compensating\",\n\t\t\"blocked\",\n\t\t\"cancelled\",\n\t]),\n\tcompleted: new Set<SchedulerNodeStatus>(),\n\tretry_wait: new Set<SchedulerNodeStatus>([\"queued\", \"blocked\", \"cancelled\"]),\n\tcompensating: new Set<SchedulerNodeStatus>([\"rolled_back\", \"in_doubt\", \"blocked\", \"cancelled\"]),\n\trolled_back: new Set<SchedulerNodeStatus>(),\n\tin_doubt: new Set<SchedulerNodeStatus>(),\n\tblocked: new Set<SchedulerNodeStatus>(),\n\tcancelled: new Set<SchedulerNodeStatus>(),\n\tfailed: new Set<SchedulerNodeStatus>(),\n};\n\n/** True iff moving a node from `from` to `to` is a legal direct transition. */\nexport function canTransitionNodeStatus(from: SchedulerNodeStatus, to: SchedulerNodeStatus): boolean {\n\treturn ALLOWED_TRANSITIONS[from].has(to);\n}\n\n/** True iff the entry narrows on at least one symbol (empty list counts as no narrowing). */\nfunction declaresSymbols(entry: AccessSetEntry): boolean {\n\treturn Array.isArray(entry.symbols) && entry.symbols.length > 0;\n}\n\n/** True iff two non-empty symbol lists share at least one symbol. */\nfunction sharesSymbol(a: readonly string[], b: readonly string[]): boolean {\n\tconst seen = new Set(a);\n\tfor (const symbol of b) {\n\t\tif (seen.has(symbol)) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n/**\n * Two access entries conflict iff they reference the same path. When BOTH\n * entries declare (non-empty) symbols, the conflict narrows to a shared symbol;\n * otherwise the conflict is path-level (conservative).\n */\nexport function accessEntriesConflict(a: AccessSetEntry, b: AccessSetEntry): boolean {\n\tif (a.path !== b.path) {\n\t\treturn false;\n\t}\n\tif (declaresSymbols(a) && declaresSymbols(b)) {\n\t\treturn sharesSymbol(a.symbols as readonly string[], b.symbols as readonly string[]);\n\t}\n\treturn true;\n}\n\n/** True iff any entry in `left` conflicts with any entry in `right`. */\nfunction setsOverlap(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\n/**\n * A candidate node conflicts with an in-flight node on write/write,\n * write/read, or read/write overlap. read/read never conflicts.\n */\nexport function nodesConflict(candidate: SchedulerNode, inFlight: SchedulerNode): boolean {\n\t// write/write\n\tif (setsOverlap(candidate.writeSet, inFlight.writeSet)) {\n\t\treturn true;\n\t}\n\t// write/read: candidate writes what in-flight reads\n\tif (setsOverlap(candidate.writeSet, inFlight.readSet)) {\n\t\treturn true;\n\t}\n\t// read/write: candidate reads what in-flight writes\n\tif (setsOverlap(candidate.readSet, inFlight.writeSet)) {\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/**\n * A node is dispatchable iff it is `queued`, or `retry_wait` whose backoff\n * deadline has elapsed (retryWaitUntil <= now). Dependencies and leases are\n * checked elsewhere; this predicate only answers the time/status question.\n */\nexport function isNodeDispatchable(node: SchedulerNode, now: number): boolean {\n\tif (node.status === \"queued\") {\n\t\treturn true;\n\t}\n\tif (node.status === \"retry_wait\") {\n\t\treturn node.retryWaitUntil !== undefined && node.retryWaitUntil <= now;\n\t}\n\treturn false;\n}\n\n/** Deterministic ordering: priority ascending, then nodeId ascending. */\nfunction compareDispatchOrder(a: SchedulerNode, b: SchedulerNode): number {\n\tif (a.priority !== b.priority) {\n\t\treturn a.priority - b.priority;\n\t}\n\tif (a.nodeId < b.nodeId) {\n\t\treturn -1;\n\t}\n\tif (a.nodeId > b.nodeId) {\n\t\treturn 1;\n\t}\n\treturn 0;\n}\n\n/**\n * Select dispatchable nodes for a single tick, deterministically.\n *\n * Ordering: priority ascending, then nodeId ascending. A candidate is excluded\n * if it conflicts (write/write, write/read, read/write) with any in-flight node\n * or any node already selected this tick. `parallelizable: false` nodes may be\n * selected only when nothing is selected and nothing is in-flight, and once one\n * is selected the tick stops (serialized lane). Selection stops once\n * in-flight + selected reaches `maxLeases`, or `maxParallel` is hit.\n */\nexport function selectDispatchableNodes(\n\tnodes: readonly SchedulerNode[],\n\toptions: DispatchSelectionOptions,\n): SchedulerNode[] {\n\tconst inFlight = options.inFlight ?? [];\n\tconst maxParallel = options.maxParallel ?? Number.POSITIVE_INFINITY;\n\n\t// Remaining lease headroom after accounting for in-flight occupancy.\n\tconst remaining = Math.max(0, options.maxLeases - inFlight.length);\n\tif (remaining === 0) {\n\t\treturn [];\n\t}\n\n\tconst candidates = nodes.filter((node) => isNodeDispatchable(node, options.now));\n\tconst ordered = [...candidates].sort(compareDispatchOrder);\n\n\tconst selected: SchedulerNode[] = [];\n\tfor (const candidate of ordered) {\n\t\tif (selected.length >= remaining || selected.length >= maxParallel) {\n\t\t\tbreak;\n\t\t}\n\t\t// Serialized lane: a non-parallelizable node needs the lane to itself.\n\t\tif (!candidate.parallelizable) {\n\t\t\tif (selected.length > 0 || inFlight.length > 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\t// Exclude candidates that conflict with anything already in flight or chosen.\n\t\tconst conflictsWithBusy =\n\t\t\tinFlight.some((busy) => nodesConflict(candidate, busy)) ||\n\t\t\tselected.some((chosen) => nodesConflict(candidate, chosen));\n\t\tif (conflictsWithBusy) {\n\t\t\tcontinue;\n\t\t}\n\t\tselected.push(candidate);\n\t\t// A non-parallelizable node claims the whole lane for this tick.\n\t\tif (!candidate.parallelizable) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn selected;\n}\n"]}

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

@@ -1,309 +0,0 @@
-/**
- * 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 { type JsonValue } from "./replay-ledger.ts";
-import { type AccessSetEntry, type SchedulerNode, type SchedulerNodeStatus } from "./scheduler-state.ts";
-export type RunStatus = "running" | "paused" | "completed" | "failed" | "cancelled";
-export type NodeStatus = SchedulerNodeStatus;
-export type EdgeType = "strong" | "weak";
-export type AccessKind = "read" | "write";
-export type ConflictReason = "write-write" | "write-read" | "read-write";
-export type NodeRole = "planner" | "explorer" | "coder" | "tester" | "reviewer" | "security" | "memory" | "synthesizer";
-/** Retry envelope persisted as JSON on the node row. */
-export interface RetryPolicy {
-    maxAttempts: number;
-    baseMs: number;
-    maxMs: number;
-    multiplier: number;
-}
-export interface RunInput {
-    runId: string;
-    goal: string;
-    topology: string;
-    dagHash?: string;
-    rootNodeId?: string;
-}
-export interface RunRow {
-    runId: string;
-    goal: string;
-    topology: string;
-    status: RunStatus;
-    createdAt: string;
-    updatedAt: string;
-    completedAt: string | null;
-    dagHash: string | null;
-    rootNodeId: string | null;
-}
-/** A node as submitted by the root coordinator (caller owns `nodeId`). */
-export interface NodeInput {
-    nodeId: string;
-    role: NodeRole;
-    task: string;
-    readSet?: readonly AccessSetEntry[];
-    writeSet?: readonly AccessSetEntry[];
-    priority?: number;
-    parallelizable?: boolean;
-    retryPolicy?: RetryPolicy;
-    verificationContract?: string;
-    costBudget?: number;
-}
-/** A persisted node row, rehydrated from SQLite. */
-export interface NodeRow {
-    nodeId: string;
-    runId: string;
-    role: NodeRole;
-    task: string;
-    status: NodeStatus;
-    idempotencyKey: string;
-    readSet: AccessSetEntry[];
-    writeSet: AccessSetEntry[];
-    leaseId: string | null;
-    leaseExpiresAt: string | null;
-    heartbeatAt: string | null;
-    attemptCount: number;
-    requeueCount: number;
-    retryWaitUntil: string | null;
-    priority: number;
-    parallelizable: boolean;
-    createdAt: string;
-    startedAt: string | null;
-    finishedAt: string | null;
-}
-export interface EdgeInput {
-    fromNodeId: string;
-    toNodeId: string;
-    edgeType?: EdgeType;
-}
-export interface EdgeRow {
-    runId: string;
-    fromNodeId: string;
-    toNodeId: string;
-    edgeType: EdgeType;
-}
-/** A whole DAG submission: run header + nodes + edges. */
-export interface DagSubmission {
-    run: RunInput;
-    nodes: readonly NodeInput[];
-    edges?: readonly EdgeInput[];
-}
-/** Outcome of an idempotent DAG ingestion. */
-export interface DagIngestionResult {
-    runId: string;
-    dagHash: string;
-    /** All node ids present after ingestion, in submission order. */
-    nodeIds: string[];
-    /** Node ids freshly inserted by this call. */
-    insertedNodeIds: string[];
-    /** Node ids that already existed (idempotency hit). */
-    reusedNodeIds: string[];
-}
-export interface LeaseInput {
-    leaseId: string;
-    ownerToken: string;
-    /** ISO-8601 absolute expiry deadline. */
-    expiresAt: string;
-    /** ISO-8601 issue time; defaults to now() in the implementation. */
-    now?: string;
-}
-export interface LeaseRow {
-    leaseId: string;
-    runId: string;
-    nodeId: string;
-    attemptId: string | null;
-    issuedAt: string;
-    expiresAt: string;
-    heartbeatAt: string | null;
-    ownerToken: string;
-    released: boolean;
-}
-/** One undirected edge of the conflict graph (always stored nodeA < nodeB). */
-export interface ConflictEdge {
-    runId: string;
-    nodeA: string;
-    nodeB: string;
-    reason: ConflictReason;
-}
-export interface AttemptInput {
-    attemptId: string;
-    runId: string;
-    nodeId: string;
-    leaseId: string;
-    status: "running" | "completed" | "failed" | "rolled_back" | "in_doubt";
-    startedAt?: string;
-    finishedAt?: string;
-    exitCode?: number;
-    errorSummary?: JsonValue;
-    workerPid?: number;
-}
-export interface WorktreeInput {
-    worktreeId: string;
-    runId: string;
-    nodeId: string;
-    path: string;
-    branchName: string;
-    status?: "active" | "merged" | "reclaimed" | "orphaned";
-    createdAt?: string;
-}
-export interface ArtifactInput {
-    artifactId: string;
-    runId: string;
-    nodeId: string;
-    attemptId?: string;
-    path: string;
-    kind: "evidence" | "patch" | "result" | "checkpoint" | "contract";
-    sha256?: string;
-    sizeBytes?: number;
-    createdAt?: string;
-}
-/** A durable compensator row (mirrors recovery.ts CompensatorStep + run/node). */
-export interface CompensatorInput {
-    compensatorId: string;
-    runId: string;
-    nodeId: string;
-    kind: string;
-    sequence: number;
-    idempotent: boolean;
-    applied: boolean;
-    preparedStateHash?: string | null;
-    createdAt?: string;
-}
-export interface SchedulerEventInput {
-    eventId: string;
-    runId: string;
-    operationId: string;
-    sequence: number;
-    timestamp: string;
-    kind: string;
-    status: string;
-    causationId?: string | null;
-    nodeId?: string | null;
-    data?: JsonValue;
-}
-export interface SchedulerEventRow {
-    eventId: string;
-    runId: string;
-    operationId: string;
-    causationId: string | null;
-    sequence: number;
-    timestamp: string;
-    kind: string;
-    status: string;
-    nodeId: string | null;
-    data: JsonValue;
-}
-/**
- * The durable scheduler persistence contract. Mutating methods that race a
- * status guard return `boolean` (true iff the row was actually changed) so
- * callers get guard-based CAS semantics. All methods are synchronous because
- * both `node:sqlite` and `better-sqlite3` are synchronous.
- */
-export interface SchedulerStore {
-    open(path: string): void;
-    close(): void;
-    createSchema(): void;
-    exec(sql: string): void;
-    /** Read a single PRAGMA scalar (first column of the first row). */
-    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;
-    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[];
-}
-/**
- * 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 declare const SCHEDULER_STORE_PRAGMAS: readonly string[];
-/** Tables the schema must create, in dependency-safe creation order. */
-export declare const SCHEDULER_STORE_TABLES: readonly string[];
-/**
- * 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 declare 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";
-/**
- * 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 declare class NodeRedefinitionError extends Error {
-    readonly runId: string;
-    readonly nodeId: string;
-    constructor(runId: string, nodeId: string);
-}
-/** Default retry policy applied when a node omits one. */
-export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
-/**
- * Canonicalize one access entry: drop undefined symbols, sort symbols, so the
- * stable key never depends on declaration order.
- */
-export declare function canonicalizeAccessEntry(entry: AccessSetEntry): {
-    path: string;
-    symbols: string[];
-};
-/** Canonicalize an access set: canonicalize each entry, then sort entries. */
-export declare function canonicalizeAccessSet(entries: readonly AccessSetEntry[] | undefined): {
-    path: string;
-    symbols: string[];
-}[];
-/**
- * Deterministic node descriptor used for idempotency. Excludes runtime state
- * (status, leases, counters) so identical logical work always hashes the same.
- */
-export declare function canonicalNodeDescriptor(node: NodeInput): JsonValue;
-/**
- * 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 declare function computeIdempotencyKey(runId: string, node: NodeInput): string;
-/** Stable hash over the whole DAG (nodes + edges), order-independent. */
-export declare function computeDagHash(submission: DagSubmission): string;
-/**
- * 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 declare function classifyConflict(nodeA: SchedulerNode, nodeB: SchedulerNode): ConflictReason | undefined;
-//# sourceMappingURL=scheduler-store.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler-store.d.ts","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"]}