@hasna/workflows 0.1.0 → 0.1.2

package/hasna.contract.json

@@ -3,8 +3,8 @@
   "name": "workflows",
   "class": "service",
   "contractVersion": "v1",
-  "kitVersion": "0.14.0",
-  "description": "Scaffold of the universal graph workflow app: version/health/readiness on all four surfaces (CLI, MCP, serve, SDK). The graph language, three-table store, session WAL, claims/leases daemon, and lane adapters (claude, codex, cursor, grok) are roadmap slices not shipped in 0.1.0.",
+  "kitVersion": "0.14.1",
+  "description": "Universal graph workflow app: graph language (start/step/decision/while/end), three-table run store, session WAL, claims/leases daemon, four lane adapters (claude, codex, cursor, grok), and a full CLI on four surfaces (CLI, MCP, serve, SDK).",
   "bins": [
     "workflows",
     "workflows-mcp",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/workflows",
-  "version": "0.1.0",
-  "description": "Universal graph workflow app \u2014 scaffold with version/health/readiness on all four surfaces; graph language, store, session WAL, daemon, and lane adapters are roadmap",
+  "version": "0.1.2",
+  "description": "Universal graph workflow app — graph language (start/step/decision/while/end), three-table store, session WAL, daemon with claims/leases, four lane adapters (claude/codex/cursor/grok), and a full CLI on four surfaces",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./types/index.d.ts",
@@ -65,16 +65,18 @@
     "url": "https://github.com/hasna/apps/issues"
   },
   "engines": {
-    "bun": ">=1.0.0",
-    "node": ">=20.0.0"
+    "bun": ">=1.0.0"
   },
   "author": "Hasna",
   "license": "Apache-2.0",
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.234",
+    "@cursor/sdk": "^1.0.28",
+    "@openai/codex-sdk": "^0.147.0",
     "commander": "^13.1.0"
   },
   "devDependencies": {
-    "@hasna/contracts": "0.14.0",
+    "@hasna/contracts": "0.14.1",
     "@types/bun": "latest",
     "@types/pg": "^8.15.6",
     "pg": "^8.16.3",

package/types/agent-tools.d.ts

@@ -1,8 +1,3 @@
-/**
- * MCP tool registry for @hasna/workflows — the agent interface layer over
- * WorkflowsService. Slice 1 ships identity/health tools; the graph language,
- * store, and daemon slices add their tools here.
- */
 import type { WorkflowsService } from "./service.js";
 export interface McpTool {
     name: string;
@@ -10,6 +5,7 @@ export interface McpTool {
     inputSchema: {
         type: "object";
         properties: Record<string, unknown>;
+        required?: string[];
     };
 }
 export interface ToolCallResult {
@@ -20,4 +16,4 @@ export interface ToolCallResult {
     isError: boolean;
 }
 export declare function workflowsTools(_service: WorkflowsService): McpTool[];
-export declare function callWorkflowTool(service: WorkflowsService, name: string, _args: Record<string, unknown>): ToolCallResult;
+export declare function callWorkflowTool(service: WorkflowsService, name: string, args: Record<string, unknown>): Promise<ToolCallResult>;

package/types/daemon.d.ts

@@ -0,0 +1,119 @@
+import { type WorkflowGraph } from "./graph.js";
+import type { RunRow, WorkflowsStore } from "./store.js";
+import { SessionWAL } from "./wal.js";
+import { type LaneJob, type LaneResult } from "./lanes/types.js";
+export type { LaneJob, LaneKind, LaneResult } from "./lanes/types.js";
+export { LANE_KINDS } from "./lanes/types.js";
+export type LaneRunner = (job: LaneJob) => Promise<LaneResult>;
+export interface Lease {
+    runId: string;
+    worker: string;
+    expiresAtMs: number;
+    fencing: number;
+}
+export interface DaemonOptions {
+    worker?: string;
+    leaseTtlMs?: number;
+    maxAttempts?: number;
+    maxDispatchPerCycle?: number;
+    maxStepsPerCycle?: number;
+    time?: () => number;
+    laneRunner?: LaneRunner;
+    env?: Record<string, string>;
+    /** When set, reap() dispatches/advances ONLY this run (foreground
+     * single-run isolation). Live-verify observation 2026-08-25: the
+     * foreground driver reaped every pending/running run in the shared store —
+     * an orphaned run executed its step inside the foreground run's cycle and
+     * blocked it. */
+    isolatedRunId?: string;
+}
+export interface ReapReport {
+    expired: number;
+    interrupted: number;
+    requeued: number;
+    failed: number;
+    dispatched: number;
+    advanced: number;
+    completed: number;
+}
+export type StepOutcome = {
+    kind: "advanced";
+    nodeId: string;
+} | {
+    kind: "completed";
+} | {
+    kind: "failed";
+    error: string;
+} | {
+    kind: "noop";
+} | {
+    kind: "blocked";
+};
+/** Execute a shell command with a bounded timeout (the built-in step executor). */
+export declare function runCommand(job: LaneJob): LaneResult;
+export declare class WorkflowsDaemon {
+    private readonly store;
+    private readonly wal;
+    readonly worker: string;
+    private readonly leaseTtlMs;
+    private readonly maxAttempts;
+    private readonly maxDispatchPerCycle;
+    private readonly maxStepsPerCycle;
+    private readonly time;
+    private readonly laneRunner;
+    private readonly env;
+    private readonly leases;
+    private readonly fencingCounter;
+    private graphCache;
+    private isolatedRunId;
+    constructor(store: WorkflowsStore, wal: SessionWAL, options?: DaemonOptions);
+    /** Foreground single-run mode: reap() touches only this run from now on. */
+    isolateRun(runId: string): void;
+    /**
+     * Recover graph definitions from the WAL. A replacement daemon (crash
+     * recovery) must be able to advance runs whose graphs were registered by
+     * the previous instance — the in-memory cache alone made `runs resume` and
+     * torn-run repair dead paths across processes (measured live 2026-08-25:
+     * "graph ... not found in daemon graph cache"). The latest registration of
+     * a name wins.
+     */
+    private replayRegisteredGraphs;
+    liveLeases(): ReadonlyMap<string, Lease>;
+    /** Acquire (or refresh) the lease on a run. Returns null while another
+     * worker's lease is live. */
+    claim(runId: string): Lease | null;
+    /** Extend a lease. Only the fencing-holding worker may. */
+    heartbeat(runId: string, fencing: number): boolean;
+    /** Release a lease. Only the fencing-holding worker may. */
+    release(runId: string, fencing: number): boolean;
+    /** One bounded cycle: expire leases -> repair torn runs -> dispatch pending
+     * runs -> advance every claimed run one step. */
+    reap(): Promise<ReapReport>;
+    /** Validate + persist a new run. Returns the pending run row. */
+    startRun(graph: WorkflowGraph, context: unknown): RunRow;
+    /** Execute ONE step of the graph for a claimed run. */
+    advanceRun(runId: string): Promise<StepOutcome>;
+    private loadGraph;
+    /** The condition scope: user context + steps + loop counter (i). */
+    private conditionScope;
+    private persistContext;
+    private executeStep;
+    /** Advance past a finished step node. Inside a while body with no next,
+     * the iteration completes and the while node re-enters. */
+    private afterNode;
+    private executeWhile;
+    private recordStepResult;
+    private completeRun;
+    private failRun;
+}
+export interface RunToCompletionOptions {
+    laneRunner?: LaneRunner;
+    time?: () => number;
+    env?: Record<string, string>;
+    maxCycles?: number;
+    /** Pre-set the daemon's isolation; the foreground driver always isolates
+     * to its own run anyway (see isolateRun in runGraphToCompletion). */
+    isolatedRunId?: string;
+}
+/** Drive a run to a terminal state with bounded cycles. Returns the final row. */
+export declare function runGraphToCompletion(store: WorkflowsStore, wal: SessionWAL, graph: WorkflowGraph, context: unknown, options?: RunToCompletionOptions): Promise<RunRow>;

package/types/expr.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A tiny, bounded expression language for decision/while conditions.
+ *
+ * Grammar (recursive descent):
+ *   expr       := or
+ *   or         := and ("or" and)*
+ *   and        := not ("and" not)*
+ *   not        := "not" not | comparison
+ *   comparison := primary (("==" | "!=" | "<" | "<=" | ">" | ">=") primary)?
+ *   primary    := "(" expr ")" | literal | path
+ *   literal    := number | string | true | false
+ *   path       := identifier ("." identifier)*   — resolves against the run context
+ *
+ * Values: numbers, strings, booleans. Comparisons require the same type on
+ * both sides. A path that does not resolve evaluates to undefined, so the
+ * canonical while-loop guard `steps.check.ok != true` is TRUE before the
+ * body has run — a missing step is simply not ok. Ordering comparisons
+ * against an unknown path are an error; equality is defined.
+ */
+export declare class ExprSyntaxError extends Error {
+    constructor(message: string);
+}
+export declare class ExprEvalError extends Error {
+    constructor(message: string);
+}
+export type ExprValue = number | string | boolean;
+export interface Token {
+    kind: "number" | "string" | "ident" | "op" | "lparen" | "rparen";
+    value: string;
+}
+export declare function tokenize(input: string): Token[];
+export type AstNode = {
+    kind: "literal";
+    value: ExprValue;
+} | {
+    kind: "path";
+    segments: string[];
+} | {
+    kind: "comparison";
+    op: string;
+    left: AstNode;
+    right: AstNode;
+} | {
+    kind: "and";
+    left: AstNode;
+    right: AstNode;
+} | {
+    kind: "or";
+    left: AstNode;
+    right: AstNode;
+} | {
+    kind: "not";
+    operand: AstNode;
+};
+/** Parse and return the AST without evaluating (used by validate()). */
+export declare function parseExpr(input: string): AstNode;
+/** Evaluate a condition expression against a run context. */
+export declare function evaluateExpr(input: string, context: Record<string, unknown>): ExprValue;

package/types/graph.d.ts

@@ -0,0 +1,80 @@
+export declare const GRAPH_NODE_TYPES: readonly ["start", "step", "decision", "while", "end"];
+export type GraphNodeType = (typeof GRAPH_NODE_TYPES)[number];
+export declare const LANE_KINDS: readonly ["claude", "codex", "cursor", "grok"];
+export type LaneKind = (typeof LANE_KINDS)[number];
+export interface StartNode {
+    id: string;
+    type: "start";
+    next?: string;
+}
+export interface StepNode {
+    id: string;
+    type: "step";
+    /** Lane that executes the work. Default "claude". */
+    lane?: LaneKind;
+    /** Prompt handed to the lane agent. Required unless `command` is set. */
+    prompt?: string;
+    /** Shell command alternative to a lane prompt. */
+    command?: string;
+    next?: string;
+    /** Retries on lane failure. Default 0. */
+    maxRetries?: number;
+    /** Memoize the node output by input hash across runs. Default false. */
+    memo?: boolean;
+    /** Per-invocation timeout budget in ms. Default 120000. */
+    timeoutMs?: number;
+}
+export interface DecisionNode {
+    id: string;
+    type: "decision";
+    /** Boolean expression over the run context (see expr.ts). */
+    condition: string;
+    then?: string;
+    else?: string;
+}
+export interface WhileNode {
+    id: string;
+    type: "while";
+    /** Loop-while-true; `i` is the loop counter in the condition scope. */
+    condition: string;
+    /** Node ids executed per iteration; steps/decisions only in v1. */
+    body: string[];
+    /** REQUIRED finite loop bound (SOL finite-budget rule). */
+    maxIterations: number;
+    /** Exit edge taken once the condition fails or the bound is reached. */
+    next?: string;
+}
+export interface EndNode {
+    id: string;
+    type: "end";
+}
+export type GraphNode = StartNode | StepNode | DecisionNode | WhileNode | EndNode;
+export interface WorkflowGraph {
+    name: string;
+    version: string;
+    nodes: GraphNode[];
+}
+export interface GraphIssue {
+    /** Dotted path to the offending member, e.g. "nodes.build" or "nodes.w.body". */
+    path: string;
+    message: string;
+}
+export interface GraphValidation {
+    ok: boolean;
+    issues: GraphIssue[];
+}
+export declare function findNode(graph: WorkflowGraph, id: string): GraphNode | undefined;
+export interface Edge {
+    from: string;
+    to: string;
+}
+/** Every explicit edge in the graph (next/then/else). While-body edges are
+ * internal and validated separately; the while's repetition is expressed by
+ * its condition, not by an edge. */
+export declare function collectEdges(graph: WorkflowGraph): Edge[];
+/** Nodes reachable from the (unique) start node over explicit edges. */
+export declare function reachableNodes(graph: WorkflowGraph): string[];
+/** Explicit cycles via depth-first search with white/grey/black coloring. */
+export declare function findCycles(graph: WorkflowGraph): string[][];
+/** Validate a graph. Every rule has a named, checkable failure. */
+export declare function validateGraph(graph: WorkflowGraph): GraphValidation;

package/types/handlers.d.ts

@@ -1,7 +1,3 @@
-/**
- * HTTP request handler for workflows-serve. Interface layer over
- * WorkflowsService; all business logic lives in the service.
- */
 import type { WorkflowsService } from "./service.js";
 export declare function jsonResponse(body: unknown, status?: number): Response;
-export declare function createRequestHandler(service: WorkflowsService): (req: Request) => Response;
+export declare function createRequestHandler(service: WorkflowsService): (req: Request) => Response | Promise<Response>;

package/types/lanes/claude.d.ts

@@ -0,0 +1,16 @@
+/**
+ * claude lane adapter — @anthropic-ai/claude-agent-sdk.
+ *
+ * The SDK's `query({ prompt, options })` returns an async generator of
+ * SDKMessage; assistant text blocks are accumulated into the result output.
+ * When the SDK package is unavailable, the adapter falls back to the local
+ * `claude` CLI in print mode (`claude -p <prompt>`).
+ */
+import { type LaneAdapter } from "./types.js";
+export interface ClaudeAdapterDeps {
+    /** SDK loader — injectable for tests; defaults to the real package import. */
+    sdkLoader?: () => Promise<unknown>;
+    /** CLI fallback binary name. Default "claude". */
+    cliPath?: string;
+}
+export declare function createClaudeAdapter(deps?: ClaudeAdapterDeps): LaneAdapter;

package/types/lanes/codex.d.ts

@@ -0,0 +1,12 @@
+/**
+ * codex lane adapter — @openai/codex-sdk.
+ *
+ * `new Codex({ config, env })` -> `thread.run(prompt)` -> `Turn` whose
+ * `finalResponse` is the completed agent output. CLI fallback: `codex exec`.
+ */
+import { type LaneAdapter } from "./types.js";
+export interface CodexAdapterDeps {
+    sdkLoader?: () => Promise<unknown>;
+    cliPath?: string;
+}
+export declare function createCodexAdapter(deps?: CodexAdapterDeps): LaneAdapter;

package/types/lanes/cursor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * cursor lane adapter — @cursor/sdk, LOCAL mode (owner spec 2026-08-25).
+ *
+ * `new Cursor(...)` -> `Agent` -> `agent.send(prompt, options)` -> `Run`
+ * whose `.result` is the final text and `.status` one of
+ * finished | error | cancelled. CLI fallback: `cursor-agent`.
+ */
+import { type LaneAdapter } from "./types.js";
+export interface CursorAdapterDeps {
+    sdkLoader?: () => Promise<unknown>;
+    cliPath?: string;
+}
+export declare function createCursorAdapter(deps?: CursorAdapterDeps): LaneAdapter;

package/types/lanes/grok.d.ts

@@ -0,0 +1,16 @@
+/**
+ * grok lane adapter — xAI Grok SDK.
+ *
+ * MEASURED 2026-08-25: no xAI Grok SDK exists on the npm registry under any
+ * candidate name (@xai/grok-sdk, @xai/sdk, @grok-ai/sdk, xai-sdk all absent;
+ * the only "grok-sdk" row is a squatted 0.0.1-security package and is never
+ * used). The adapter therefore drives the local `grok` CLI when present and
+ * reports LANE_DEPENDENCY_MISSING (exit 127) naming the missing substrate
+ * otherwise — the honest degradation contract, so a workflow fails loudly
+ * instead of pretending a lane ran.
+ */
+import { type LaneAdapter } from "./types.js";
+export interface GrokAdapterDeps {
+    cliPath?: string;
+}
+export declare function createGrokAdapter(deps?: GrokAdapterDeps): LaneAdapter;

package/types/lanes/index.d.ts

@@ -0,0 +1,14 @@
+import { type LaneAdapter, type LaneJob, type LaneProbe, type LaneResult, type LaneKind } from "./types.js";
+export type { LaneAdapter, LaneJob, LaneProbe, LaneResult, LaneKind } from "./types.js";
+export { LANE_KINDS, LaneDependencyMissingError, LaneAdapterShapeError, binaryOnPath } from "./types.js";
+export { createClaudeAdapter } from "./claude.js";
+export { createCodexAdapter } from "./codex.js";
+export { createCursorAdapter } from "./cursor.js";
+export { createGrokAdapter } from "./grok.js";
+export declare function resolveLane(kind: LaneKind): LaneAdapter;
+/** Run one lane job through the registry (used by the daemon's default runner). */
+export declare function runLaneJob(job: LaneJob): Promise<LaneResult>;
+/** Re-run one lane's maturity check and report wired / not-ready-with-reason. */
+export declare function probeLane(kind: LaneKind): Promise<LaneProbe>;
+/** Probe all four lanes and return the wired-vs-not-ready registry shape. */
+export declare function laneInventory(): Promise<LaneProbe[]>;

package/types/lanes/types.d.ts

@@ -0,0 +1,64 @@
+export declare const LANE_KINDS: readonly ["claude", "codex", "cursor", "grok"];
+export type LaneKind = (typeof LANE_KINDS)[number];
+export interface LaneJob {
+    lane: LaneKind;
+    /** Prompt handed to the lane agent. */
+    prompt?: string;
+    /** Shell command alternative (handled by the daemon's built-in executor). */
+    command?: string;
+    cwd?: string;
+    /** Environment for the lane process — never credentials from the vault. */
+    env?: Record<string, string>;
+    /** Per-invocation budget in ms. Default 120000. */
+    timeoutMs?: number;
+    model?: string;
+}
+export interface LaneResult {
+    ok: boolean;
+    exitCode: number;
+    output: string;
+    durationMs: number;
+    error?: string;
+}
+/**
+ * A lane maturity probe: is the substrate actually wired on THIS machine
+ * right now, and if not, why. `wired` means a usable substrate exists —
+ * the SDK package importable or the CLI binary on PATH — NOT that a live
+ * authenticated call would succeed (that is the live-verify gate's job).
+ */
+export interface LaneProbe {
+    kind: LaneKind;
+    sdk: string;
+    wired: boolean;
+    /** How the lane would execute when wired (e.g. "sdk" or "cli"). */
+    via?: string;
+    /** Why the lane is not ready, when not wired. */
+    reason?: string;
+}
+export interface LaneAdapter {
+    kind: LaneKind;
+    run(job: LaneJob): Promise<LaneResult>;
+    /** Re-run the maturity check for this lane. */
+    probe(): Promise<LaneProbe>;
+}
+/** The substrate (SDK package or CLI binary) is not installed/available. */
+export declare class LaneDependencyMissingError extends Error {
+    constructor(message: string);
+}
+/** Raised when a lane SDK's shape differs from the documented contract. */
+export declare class LaneAdapterShapeError extends Error {
+    constructor(message: string);
+}
+export declare const DEFAULT_LANE_TIMEOUT_MS = 120000;
+/** Is a binary present on PATH (read-only existence check; never runs it)? */
+export declare function binaryOnPath(binary: string): boolean;
+/** Run a promise with a bounded wall-clock budget. */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, what: string): Promise<T>;
+/** Spawn a CLI binary with a bounded timeout; maps ENOENT to a missing-substrate error. */
+export declare function spawnCli(cmd: string[], opts: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    binaryName: string;
+    packageHint: string;
+}): LaneResult;

package/types/render.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Graph rendering (the `workflows graph <file>` command) — deterministic
+ * text, DOT, and JSON renderings of a workflow graph. Presentation only:
+ * all graph semantics live in graph.ts; this module never mutates.
+ */
+import { type WorkflowGraph } from "./graph.js";
+/** Deterministic text rendering: one line per node in graph order. */
+export declare function renderGraphText(graph: WorkflowGraph): string;
+/** Graphviz DOT rendering (explicit edges solid, while-body edges dashed). */
+export declare function renderGraphDot(graph: WorkflowGraph): string;
+/** Machine-readable rendering: node registry + explicit edges + while bodies. */
+export declare function renderGraphJson(graph: WorkflowGraph): Record<string, unknown>;

package/types/secrets.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The secrets write-gate (slice C).
+ *
+ * Before the daemon persists ANY node output, run result, or run context to
+ * the store or the session WAL, it calls assertNoSecrets. A payload carrying
+ * a credential-shaped value is refused with the offending path named and the
+ * value never rendered. The gate is deliberately conservative: a workflow
+ * that stores {"apiKey": "..."} is a workflow that will leak credentials
+ * downstream, so the gate blocks the write.
+ *
+ * NOTE on construction: the regex sources are built from joined fragments so
+ * this very file does not contain literal credential prefixes (the repo's CI
+ * secret scan would trip on them and the gate would block its own source).
+ */
+export declare class SecretsGateError extends Error {
+    constructor(message: string);
+}
+export interface SecretFinding {
+    /** Dotted JSON path to the offending value, e.g. "$.output" or "$.steps.build.result". */
+    path: string;
+    /** Detector name. */
+    detector: string;
+}
+/** Recursively walk a JSON value and collect credential-shaped findings. */
+export declare function scanForSecrets(value: unknown, path?: string): SecretFinding[];
+/** Refuse a write whose payload carries a credential shape. Throws
+ * SecretsGateError naming the paths and detectors, never the values. */
+export declare function assertNoSecrets(value: unknown, what: string): void;
+/** Deep-copy a payload replacing credential-shaped values with a marker. */
+export declare function redactDeep(value: unknown): unknown;

package/types/service.d.ts

@@ -1,3 +1,4 @@
+import type { WorkflowGraph } from "./graph.js";
 import type { HealthReport, ReadinessReport, WorkflowsConfig } from "./types.js";
 export declare function packageVersion(): string;
 /** Resolve the service configuration from env + explicit overrides. */
@@ -10,5 +11,22 @@ export declare class WorkflowsService {
     constructor(config?: Partial<WorkflowsConfig>);
     health(): HealthReport;
     ready(): ReadinessReport;
+    /**
+     * The authenticated trigger: run a graph to a terminal state (bounded
+     * cycles) and return its summary. The HTTP layer authenticates; this
+     * method holds the business logic. When an idempotency key is supplied and
+     * a run carrying it already exists, that run's summary is returned instead
+     * of starting a new one.
+     */
+    triggerRun(graph: WorkflowGraph, context?: unknown, opts?: {
+        maxCycles?: number;
+        idempotencyKey?: string;
+    }): Promise<{
+        runId: string;
+        status: string;
+        error: string | null;
+        result: unknown;
+        reused: boolean;
+    }>;
 }
 export declare function createWorkflowsService(config?: Partial<WorkflowsConfig>): WorkflowsService;

package/types/session.d.ts

@@ -0,0 +1,51 @@
+import { SessionWAL } from "./wal.js";
+import type { RunRow, WorkflowsStore } from "./store.js";
+export interface RepairResult {
+    /** runs found running with no live claim */
+    interrupted: number;
+    /** torn runs marked interrupted (restorable via resume or the daemon) */
+    requeued: number;
+    /** torn runs failed after exhausting attempts */
+    failed: number;
+}
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+export declare function repairTornRuns(store: WorkflowsStore, wal: SessionWAL, opts?: {
+    maxAttempts?: number;
+    now?: number;
+}): RepairResult;
+/** Stable hash of a JSON-serializable payload. */
+export declare function inputHash(payload: unknown): string;
+/** Memo key: graphName:nodeId:<inputHash>. */
+export declare function memoKey(graphName: string, nodeId: string, input: unknown): string;
+/** Look up a memo by input; a hit increments hitCount and returns the row. */
+export declare function tryMemoHit(store: WorkflowsStore, graphName: string, nodeId: string, input: unknown): import("./store.js").MemoRow | undefined;
+/** Persist a node output for future runs with the same input. */
+export declare function recordMemo(store: WorkflowsStore, graphName: string, nodeId: string, input: unknown, output: unknown): void;
+/** Requeue a cancelled run's in-flight nodes (used by cancel + resume). */
+export declare function resetRunNodes(store: WorkflowsStore, run: RunRow): void;
+export interface RestoreResult {
+    runId: string;
+    status: string;
+    /** running/pending node rows returned to pending so the run can continue. */
+    nodesRestored: number;
+    /** completed node rows whose persisted output the restore reuses (memoized). */
+    memoizedNodes: number;
+    attempts: number;
+}
+/**
+ * Top-level `resume` — restore an INTERRUPTED run from its durable cursor.
+ *
+ * Distinct from `runs resume` (which requeues cancelled/failed runs): an
+ * interrupted run is one whose worker died mid-flight; its durable context
+ * (__wf cursor + steps) and completed node outputs are already persisted, so
+ * restore reuses them (memoization) and only running/pending nodes return to
+ * pending. The daemon then continues from the last durable checkpoint.
+ */
+export declare function restoreInterruptedRun(store: WorkflowsStore, runId: string): RestoreResult;
+/**
+ * Idempotent run lookup: the run whose context carries the given idempotency
+ * key, if any. The three-table law forbids an extra column, so the key lives
+ * in the reserved __wf namespace of context_json; the scan is bounded by the
+ * store's own listRuns cap (1000 rows).
+ */
+export declare function findRunByIdempotencyKey(store: WorkflowsStore, key: string): RunRow | undefined;