@autonome-research/thread-phase 3.0.0

package/dist/patterns/with-retry.js

@@ -0,0 +1,73 @@
+/**
+ * with-retry — higher-order phase wrapper for retrying flaky work.
+ *
+ * Wraps any `Phase` and retries it on failure. Failure means either:
+ *  - the inner phase throws an exception, OR
+ *  - the inner phase yields then sets `ctx.stop` (a clean failure signal)
+ *
+ * Both default to retryable. Override with `isFailure(ctx, error?)` if a
+ * specific `ctx.stop.reason` should *not* trigger a retry (e.g. user
+ * cancellation, terminal validation error).
+ *
+ * Retries are bounded by `maxAttempts` (default 3) and spaced with
+ * exponential backoff starting at `baseDelayMs` (default 1000).
+ *
+ * Idempotence is the caller's responsibility. The wrapper does NOT
+ * snapshot/restore ctx between attempts — a partially-applied mutation
+ * from a failed attempt is visible to the retry. Pass `resetState` if
+ * you need to undo partial work before each retry.
+ *
+ * Events emitted by the inner phase pass through unmodified. The wrapper
+ * additionally emits `data` events with key `${phase.name}.attempt`.
+ */
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function withRetry(phase, options = {}) {
+    const maxAttempts = options.maxAttempts ?? 3;
+    const baseDelay = options.baseDelayMs ?? 1000;
+    const isFailure = options.isFailure ?? ((ctx, error) => error !== undefined || ctx.stop !== undefined);
+    return {
+        name: phase.name,
+        async *run(ctx) {
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                yield {
+                    type: 'data',
+                    key: `${phase.name}.attempt`,
+                    value: { attempt, maxAttempts },
+                };
+                const stopBefore = ctx.stop;
+                let thrown = undefined;
+                try {
+                    // Clear ctx.stop so the inner phase has a clean slate; restore on
+                    // failure-and-retry so we don't leak the previous attempt's signal
+                    // to the predicate.
+                    ctx.stop = undefined;
+                    yield* phase.run(ctx);
+                }
+                catch (err) {
+                    thrown = err;
+                }
+                const failed = isFailure(ctx, thrown);
+                if (!failed) {
+                    // Success — but only if the inner phase didn't deliberately stop
+                    // (an isFailure override may treat ctx.stop as success for some
+                    // reasons; the caller knows best).
+                    return;
+                }
+                if (attempt === maxAttempts) {
+                    // Exhausted — propagate the failure mode the inner phase used.
+                    if (thrown !== undefined) {
+                        throw thrown;
+                    }
+                    // ctx.stop is already set by the inner phase; leave it.
+                    return;
+                }
+                options.onRetry?.(ctx, attempt, thrown);
+                ctx.stop = stopBefore; // restore upstream stop, if any
+                options.resetState?.(ctx);
+                const delay = baseDelay * 2 ** (attempt - 1);
+                await sleep(delay);
+            }
+        },
+    };
+}
+//# sourceMappingURL=with-retry.js.map

package/dist/patterns/with-retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-retry.js","sourceRoot":"","sources":["../../src/patterns/with-retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAiBH,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,IAAI,OAAO,CAAO,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAE1E,MAAM,UAAU,SAAS,CACvB,KAAkB,EAClB,UAAkC,EAAE;IAEpC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC;IAC7C,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC;IAC9C,MAAM,SAAS,GACb,OAAO,CAAC,SAAS,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAEvF,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG;YACZ,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;gBACxD,MAAM;oBACJ,IAAI,EAAE,MAAM;oBACZ,GAAG,EAAE,GAAG,KAAK,CAAC,IAAI,UAAU;oBAC5B,KAAK,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE;iBAChC,CAAC;gBAEF,MAAM,UAAU,GAAG,GAAG,CAAC,IAAI,CAAC;gBAC5B,IAAI,MAAM,GAAY,SAAS,CAAC;gBAEhC,IAAI,CAAC;oBACH,kEAAkE;oBAClE,mEAAmE;oBACnE,oBAAoB;oBACpB,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC;oBACrB,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACxB,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,GAAG,GAAG,CAAC;gBACf,CAAC;gBAED,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAEtC,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,iEAAiE;oBACjE,gEAAgE;oBAChE,mCAAmC;oBACnC,OAAO;gBACT,CAAC;gBAED,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC;oBAC5B,+DAA+D;oBAC/D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;wBACzB,MAAM,MAAM,CAAC;oBACf,CAAC;oBACD,wDAAwD;oBACxD,OAAO;gBACT,CAAC;gBAED,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;gBACxC,GAAG,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC,gCAAgC;gBACvD,OAAO,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;gBAE1B,MAAM,KAAK,GAAG,SAAS,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;gBAC7C,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/phase.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Phase framework — the core of thread-phase.
+ *
+ * A pipeline is an ordered list of phases. Each phase reads typed inputs from
+ * a shared `PipelineContext`, calls an agent (or pure code), writes typed
+ * outputs back to the context, and yields streamed events.
+ *
+ * Conventions:
+ * - Phases mutate `ctx` for results. Reads are advertised via `requireCtx` at
+ *   the top of each phase, which throws loudly if a prerequisite phase did
+ *   not run or did not populate the field.
+ * - A phase sets `ctx.stop = { reason }` to halt the rest of the pipeline.
+ * - Sub-flows call other phases directly: `yield* otherPhase.run(ctx)`. No
+ *   DAG framework.
+ *
+ * Downstream apps extend `BasePipelineContext` with their own typed fields
+ * and parameterize `Phase` on that context type.
+ *
+ * Custom event types: `Phase` has a second optional type parameter `TEvent`
+ * for downstream apps that want a discriminated union of their own events
+ * instead of the generic `{ type: 'data', key, value }` shape. Default is
+ * the framework's `PipelineEvent`. The orchestrator and JobRunner are
+ * parameterized accordingly.
+ */
+import type { PipelineCache } from './cache.js';
+export interface BasePipelineContext {
+    readonly cache: PipelineCache;
+    /** Set by any phase to halt the rest of the pipeline. */
+    stop?: {
+        reason: string;
+    };
+    /**
+     * Optional AbortSignal observable by phases for mid-phase cancellation.
+     * Populated by `runTrigger` per dispatch; `runPipeline` checks it
+     * between phases as well. Phases doing long async work should pass
+     * this into `runAgentWithTools({ signal })` or observe it directly.
+     */
+    signal?: AbortSignal;
+}
+export type PipelineEvent = {
+    type: 'phase';
+    phase: string;
+    detail?: string;
+    counts?: Record<string, number>;
+} | {
+    type: 'content';
+    content: string;
+} | {
+    type: 'agent_activity';
+    agent: string;
+    action: string;
+    detail?: string;
+} | {
+    type: 'tool_call';
+    toolName: string;
+    toolUseId: string;
+    args: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+} | {
+    type: 'data';
+    key: string;
+    value: unknown;
+} | {
+    type: 'done';
+    reason?: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export interface Phase<TCtx extends BasePipelineContext = BasePipelineContext, TEvent = PipelineEvent> {
+    readonly name: string;
+    run(ctx: TCtx): AsyncGenerator<TEvent, void>;
+}
+export declare function requireCtx<TCtx extends BasePipelineContext, K extends keyof TCtx>(ctx: TCtx, key: K, phaseName: string): NonNullable<TCtx[K]>;
+//# sourceMappingURL=phase.d.ts.map

package/dist/phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase.d.ts","sourceRoot":"","sources":["../src/phase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,yDAAyD;IACzD,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAWD,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAClF;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACzF;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAcvC,MAAM,WAAW,KAAK,CACpB,IAAI,SAAS,mBAAmB,GAAG,mBAAmB,EACtD,MAAM,GAAG,aAAa;IAEtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,GAAG,EAAE,IAAI,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;CAC9C;AAMD,wBAAgB,UAAU,CAAC,IAAI,SAAS,mBAAmB,EAAE,CAAC,SAAS,MAAM,IAAI,EAC/E,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,CAAC,EACN,SAAS,EAAE,MAAM,GAChB,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAStB"}

package/dist/phase.js

@@ -0,0 +1,36 @@
+/**
+ * Phase framework — the core of thread-phase.
+ *
+ * A pipeline is an ordered list of phases. Each phase reads typed inputs from
+ * a shared `PipelineContext`, calls an agent (or pure code), writes typed
+ * outputs back to the context, and yields streamed events.
+ *
+ * Conventions:
+ * - Phases mutate `ctx` for results. Reads are advertised via `requireCtx` at
+ *   the top of each phase, which throws loudly if a prerequisite phase did
+ *   not run or did not populate the field.
+ * - A phase sets `ctx.stop = { reason }` to halt the rest of the pipeline.
+ * - Sub-flows call other phases directly: `yield* otherPhase.run(ctx)`. No
+ *   DAG framework.
+ *
+ * Downstream apps extend `BasePipelineContext` with their own typed fields
+ * and parameterize `Phase` on that context type.
+ *
+ * Custom event types: `Phase` has a second optional type parameter `TEvent`
+ * for downstream apps that want a discriminated union of their own events
+ * instead of the generic `{ type: 'data', key, value }` shape. Default is
+ * the framework's `PipelineEvent`. The orchestrator and JobRunner are
+ * parameterized accordingly.
+ */
+// ---------------------------------------------------------------------------
+// Runtime precondition helper — fails loud on phase-reordering bugs.
+// ---------------------------------------------------------------------------
+export function requireCtx(ctx, key, phaseName) {
+    const value = ctx[key];
+    if (value === undefined || value === null) {
+        throw new Error(`[${phaseName}] precondition failed: ctx.${String(key)} is not set. ` +
+            `A prerequisite phase did not run or did not populate this field.`);
+    }
+    return value;
+}
+//# sourceMappingURL=phase.js.map

package/dist/phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase.js","sourceRoot":"","sources":["../src/phase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AA6DH,8EAA8E;AAC9E,qEAAqE;AACrE,8EAA8E;AAE9E,MAAM,UAAU,UAAU,CACxB,GAAS,EACT,GAAM,EACN,SAAiB;IAEjB,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CACb,IAAI,SAAS,8BAA8B,MAAM,CAAC,GAAG,CAAC,eAAe;YACnE,kEAAkE,CACrE,CAAC;IACJ,CAAC;IACD,OAAO,KAA6B,CAAC;AACvC,CAAC"}

package/dist/session/index.d.ts

@@ -0,0 +1,5 @@
+export { type JobStore, type JobRecord, type EventRecord, type JobStatus, type ListJobsOptions, } from './job-store.js';
+export { SqliteJobStore } from './sqlite-job-store.js';
+export { JobRunner, type LiveEvent, } from './job-runner.js';
+export { streamToSSE, type SSEResponse, type StreamToSSEOptions, } from './sse.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EACL,SAAS,EACT,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,WAAW,EACX,KAAK,WAAW,EAChB,KAAK,kBAAkB,GACxB,MAAM,UAAU,CAAC"}

package/dist/session/index.js

@@ -0,0 +1,4 @@
+export { SqliteJobStore } from './sqlite-job-store.js';
+export { JobRunner, } from './job-runner.js';
+export { streamToSSE, } from './sse.js';
+//# sourceMappingURL=index.js.map

package/dist/session/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EACL,SAAS,GAEV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,WAAW,GAGZ,MAAM,UAAU,CAAC"}

package/dist/session/job-runner.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Job runner — wraps a pipeline run with persistent event logging and live
+ * event emission.
+ *
+ * Three audiences for the same event stream:
+ *   - The store (for resumability via JobStore.getEvents).
+ *   - Live SSE-style listeners (subscribe via runner.on(`job:${id}`, ...)).
+ *   - The caller's own AsyncGenerator consumer if they want to drive directly.
+ *
+ * Pipeline execution is decoupled from client connection: a job runs to
+ * completion regardless of who's listening. Late-attaching consumers replay
+ * via JobStore.getEvents.
+ *
+ * Cancellation: each in-flight job tracks an AbortController. Call
+ * `runner.cancel(jobId, reason?)` to abort the in-flight pipeline. The
+ * controller's signal is exposed via `runner.signalFor(jobId)` so callers
+ * (typically phase code that calls runAgentWithTools) can plumb it into
+ * the inference layer. Without that plumbing, cancellation only halts
+ * BETWEEN phases.
+ */
+import { EventEmitter } from 'events';
+import type { BasePipelineContext, Phase, PipelineEvent } from '../phase.js';
+import { type PipelineSummary } from '../orchestrator.js';
+import type { JobStore } from './job-store.js';
+export interface LiveEvent {
+    id: number;
+    jobId: string;
+    eventType: string;
+    data: PipelineEvent;
+    createdAt: string;
+}
+export declare class JobRunner extends EventEmitter {
+    private readonly store;
+    private inflight;
+    constructor(store: JobStore);
+    /**
+     * Create a job row, return its id. Use `start()` to actually run it.
+     */
+    create(name: string, input: unknown): Promise<string>;
+    /**
+     * AbortSignal for a running job. Phase code should pass this through to
+     * `runAgentWithTools({ signal })` so cancellation reaches the inference
+     * call instead of just halting between phases.
+     *
+     * Returns `undefined` if the job isn't currently running on this runner.
+     */
+    signalFor(jobId: string): AbortSignal | undefined;
+    /**
+     * Request cancellation of an in-flight job. Aborts the controller (which
+     * propagates into any inference call wired to `signalFor(jobId)`) and
+     * lets the run-loop unwind. The job is marked FAILED with the given
+     * reason once unwinding completes. No-op if the job isn't running.
+     */
+    cancel(jobId: string, reason?: string): void;
+    /**
+     * Run a pipeline as job `jobId`. Persists every event, emits on `job:${id}`.
+     *
+     * Returns a `PipelineSummary` on success; rejects with the original error
+     * on phase failure (after the runner has marked the job FAILED, written a
+     * synthesized `error` event to the store, and emitted it to subscribers).
+     * Cancellation via `runner.cancel(jobId, reason)` rejects with an
+     * `AbortError`-shaped Error (`name === 'AbortError'`); the same FAILED
+     * persistence path runs first.
+     */
+    run<TCtx extends BasePipelineContext, TEvent extends PipelineEvent = PipelineEvent>(jobId: string, phases: ReadonlyArray<Phase<TCtx, TEvent>>, ctx: TCtx, finalResult?: () => unknown): Promise<PipelineSummary>;
+}
+//# sourceMappingURL=job-runner.d.ts.map

package/dist/session/job-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../src/session/job-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,SAAU,SAAQ,YAAY;IAG7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAsC;gBAEzB,KAAK,EAAE,QAAQ;IAK5C;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrD;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIjD;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,MAAoB,GAAG,IAAI;IASzD;;;;;;;;;OASG;IACG,GAAG,CAAC,IAAI,SAAS,mBAAmB,EAAE,MAAM,SAAS,aAAa,GAAG,aAAa,EACtF,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EAC1C,GAAG,EAAE,IAAI,EACT,WAAW,CAAC,EAAE,MAAM,OAAO,GAC1B,OAAO,CAAC,eAAe,CAAC;CA8D5B"}

package/dist/session/job-runner.js

@@ -0,0 +1,131 @@
+/**
+ * Job runner — wraps a pipeline run with persistent event logging and live
+ * event emission.
+ *
+ * Three audiences for the same event stream:
+ *   - The store (for resumability via JobStore.getEvents).
+ *   - Live SSE-style listeners (subscribe via runner.on(`job:${id}`, ...)).
+ *   - The caller's own AsyncGenerator consumer if they want to drive directly.
+ *
+ * Pipeline execution is decoupled from client connection: a job runs to
+ * completion regardless of who's listening. Late-attaching consumers replay
+ * via JobStore.getEvents.
+ *
+ * Cancellation: each in-flight job tracks an AbortController. Call
+ * `runner.cancel(jobId, reason?)` to abort the in-flight pipeline. The
+ * controller's signal is exposed via `runner.signalFor(jobId)` so callers
+ * (typically phase code that calls runAgentWithTools) can plumb it into
+ * the inference layer. Without that plumbing, cancellation only halts
+ * BETWEEN phases.
+ */
+import { EventEmitter } from 'events';
+import { runPipeline } from '../orchestrator.js';
+export class JobRunner extends EventEmitter {
+    store;
+    inflight = new Map();
+    constructor(store) {
+        super();
+        this.store = store;
+        this.setMaxListeners(100);
+    }
+    /**
+     * Create a job row, return its id. Use `start()` to actually run it.
+     */
+    create(name, input) {
+        return this.store.createJob(name, input);
+    }
+    /**
+     * AbortSignal for a running job. Phase code should pass this through to
+     * `runAgentWithTools({ signal })` so cancellation reaches the inference
+     * call instead of just halting between phases.
+     *
+     * Returns `undefined` if the job isn't currently running on this runner.
+     */
+    signalFor(jobId) {
+        return this.inflight.get(jobId)?.signal;
+    }
+    /**
+     * Request cancellation of an in-flight job. Aborts the controller (which
+     * propagates into any inference call wired to `signalFor(jobId)`) and
+     * lets the run-loop unwind. The job is marked FAILED with the given
+     * reason once unwinding completes. No-op if the job isn't running.
+     */
+    cancel(jobId, reason = 'cancelled') {
+        const controller = this.inflight.get(jobId);
+        if (!controller)
+            return;
+        if (!controller.signal.aborted) {
+            // Node's AbortController accepts an optional reason on abort().
+            controller.abort(reason);
+        }
+    }
+    /**
+     * Run a pipeline as job `jobId`. Persists every event, emits on `job:${id}`.
+     *
+     * Returns a `PipelineSummary` on success; rejects with the original error
+     * on phase failure (after the runner has marked the job FAILED, written a
+     * synthesized `error` event to the store, and emitted it to subscribers).
+     * Cancellation via `runner.cancel(jobId, reason)` rejects with an
+     * `AbortError`-shaped Error (`name === 'AbortError'`); the same FAILED
+     * persistence path runs first.
+     */
+    async run(jobId, phases, ctx, finalResult) {
+        const controller = new AbortController();
+        this.inflight.set(jobId, controller);
+        await this.store.setRunning(jobId);
+        let eventCount = 0;
+        let stopReason;
+        const persistError = async (message) => {
+            await this.store.setFailed(jobId, message);
+            const errEvent = { type: 'error', message };
+            const eventId = await this.store.appendEvent(jobId, errEvent);
+            this.emit(`job:${jobId}`, {
+                id: eventId,
+                jobId,
+                eventType: 'error',
+                data: errEvent,
+                createdAt: new Date().toISOString(),
+            });
+        };
+        try {
+            for await (const event of runPipeline(phases, ctx)) {
+                const eventId = await this.store.appendEvent(jobId, event);
+                this.emit(`job:${jobId}`, {
+                    id: eventId,
+                    jobId,
+                    eventType: event.type,
+                    data: event,
+                    createdAt: new Date().toISOString(),
+                });
+                eventCount++;
+                if (event.type === 'done') {
+                    stopReason = event.reason;
+                }
+                if (controller.signal.aborted) {
+                    const reason = controller.signal.reason ?? 'cancelled';
+                    await persistError(`cancelled: ${reason}`);
+                    const err = new Error(`cancelled: ${reason}`);
+                    err.name = 'AbortError';
+                    throw err;
+                }
+            }
+            await this.store.setCompleted(jobId, finalResult ? finalResult() : null);
+            return stopReason !== undefined
+                ? { status: 'stopped', reason: stopReason, eventCount }
+                : { status: 'completed', eventCount };
+        }
+        catch (err) {
+            // Re-throw cancellation rejections (already persisted above).
+            if (err instanceof Error && err.name === 'AbortError')
+                throw err;
+            // Phase exception: persist + rethrow.
+            const message = err instanceof Error ? err.message : String(err);
+            await persistError(message);
+            throw err;
+        }
+        finally {
+            this.inflight.delete(jobId);
+        }
+    }
+}
+//# sourceMappingURL=job-runner.js.map

package/dist/session/job-runner.js.map

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

package/dist/session/job-store.d.ts

@@ -0,0 +1,98 @@
+/**
+ * JobStore interface — the persistence boundary for thread-phase jobs and
+ * their event logs.
+ *
+ * SqliteJobStore is the bundled default (single-file, zero-config). Other
+ * backends (Postgres, Redis, custom file-based for embedded use) just
+ * need to implement this interface.
+ *
+ * # v3 interface: async by default
+ *
+ * Every method returns a Promise. This is the breaking change in v3.0.0:
+ * pre-v3 the interface was sync (sqlite hot path; fire-and-forget event
+ * writes) and that blocked any backend whose underlying I/O is async
+ * (Postgres, Redis, network-attached stores). Going async at the
+ * interface level unblocks those backends without forcing them to fake
+ * a sync boundary via in-process queues.
+ *
+ * Performance note for SqliteJobStore: better-sqlite3 stays sync
+ * internally; the bundled implementation just wraps its prepared-
+ * statement calls in `async` methods. The added cost is one microtask
+ * per call — sub-microsecond, swamped by the actual I/O on every other
+ * backend, and negligible on sqlite given the prior sub-millisecond
+ * write cost.
+ *
+ * Migration from v2: every `store.xxx(...)` call site needs `await`.
+ * `JobRunner` and `streamToSSE` handle this internally; user code that
+ * touched the store directly (custom dashboards, replay scripts) needs
+ * to add `await` and become `async` at the call site.
+ *
+ * `close()` is the one exception — it stays sync because closing isn't
+ * a perf-sensitive code path and several embedded backends (sqlite,
+ * in-memory) have no async work to do on close. Implementations whose
+ * close is genuinely async can still return a Promise; the type allows
+ * either (`void | Promise<void>` is the relaxation).
+ */
+import type { PipelineEvent } from '../phase.js';
+export type JobStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED';
+export interface JobRecord {
+    id: string;
+    name: string;
+    input: unknown;
+    status: JobStatus;
+    result: unknown | null;
+    error: string | null;
+    eventCount: number;
+    createdAt: Date;
+    startedAt: Date | null;
+    completedAt: Date | null;
+}
+export interface EventRecord {
+    id: number;
+    jobId: string;
+    eventType: string;
+    data: PipelineEvent;
+    createdAt: Date;
+}
+export interface ListJobsOptions {
+    /** Filter to a single pipeline name. */
+    name?: string;
+    /** Page size cap. Default: 50. */
+    limit?: number;
+}
+export interface JobStore {
+    /** Insert a PENDING job row, return its id. */
+    createJob(name: string, input: unknown): Promise<string>;
+    /**
+     * Atomically claim a single-runner slot for `name`. If no job with this
+     * name is currently RUNNING, insert a new job row directly in RUNNING
+     * state and return its id. Otherwise return null.
+     *
+     * Use this for cron-driven pipelines that should never overlap with
+     * themselves (e.g. a 10-minute timer where a run can occasionally take
+     * longer than the interval). Implementations must perform the
+     * existence check + insert in a single transaction.
+     *
+     * `JobRunner.run` will still call setRunning on the returned id; that's
+     * a no-op state transition and (with the COALESCE in setRunning) leaves
+     * the original startedAt intact.
+     */
+    acquireExclusive(name: string, input: unknown): Promise<string | null>;
+    setRunning(jobId: string): Promise<void>;
+    setCompleted(jobId: string, result: unknown): Promise<void>;
+    setFailed(jobId: string, error: string): Promise<void>;
+    getJob(jobId: string): Promise<JobRecord | null>;
+    listJobs(options?: ListJobsOptions): Promise<JobRecord[]>;
+    /** Append one event to the log; returns its monotonic id (resume cursor). */
+    appendEvent(jobId: string, event: PipelineEvent): Promise<number>;
+    /** Read events. `afterId` is the resume cursor — use 0 for "from the start". */
+    getEvents(jobId: string, afterId?: number): Promise<EventRecord[]>;
+    /**
+     * Release any underlying resources (connections, file handles). May be
+     * sync or async — implementations whose close has no async work
+     * (sqlite, in-memory) may return void; networked backends should return
+     * a Promise that resolves when the connection is fully torn down.
+     */
+    close(): void | Promise<void>;
+}
+//# sourceMappingURL=job-store.d.ts.map

package/dist/session/job-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-store.d.ts","sourceRoot":"","sources":["../../src/session/job-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,+CAA+C;IAC/C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACvE,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IACjD,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAE1D,6EAA6E;IAC7E,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAClE,gFAAgF;IAChF,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEnE;;;;;OAKG;IACH,KAAK,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B"}

package/dist/session/job-store.js

@@ -0,0 +1,37 @@
+/**
+ * JobStore interface — the persistence boundary for thread-phase jobs and
+ * their event logs.
+ *
+ * SqliteJobStore is the bundled default (single-file, zero-config). Other
+ * backends (Postgres, Redis, custom file-based for embedded use) just
+ * need to implement this interface.
+ *
+ * # v3 interface: async by default
+ *
+ * Every method returns a Promise. This is the breaking change in v3.0.0:
+ * pre-v3 the interface was sync (sqlite hot path; fire-and-forget event
+ * writes) and that blocked any backend whose underlying I/O is async
+ * (Postgres, Redis, network-attached stores). Going async at the
+ * interface level unblocks those backends without forcing them to fake
+ * a sync boundary via in-process queues.
+ *
+ * Performance note for SqliteJobStore: better-sqlite3 stays sync
+ * internally; the bundled implementation just wraps its prepared-
+ * statement calls in `async` methods. The added cost is one microtask
+ * per call — sub-microsecond, swamped by the actual I/O on every other
+ * backend, and negligible on sqlite given the prior sub-millisecond
+ * write cost.
+ *
+ * Migration from v2: every `store.xxx(...)` call site needs `await`.
+ * `JobRunner` and `streamToSSE` handle this internally; user code that
+ * touched the store directly (custom dashboards, replay scripts) needs
+ * to add `await` and become `async` at the call site.
+ *
+ * `close()` is the one exception — it stays sync because closing isn't
+ * a perf-sensitive code path and several embedded backends (sqlite,
+ * in-memory) have no async work to do on close. Implementations whose
+ * close is genuinely async can still return a Promise; the type allows
+ * either (`void | Promise<void>` is the relaxation).
+ */
+export {};
+//# sourceMappingURL=job-store.js.map

package/dist/session/job-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-store.js","sourceRoot":"","sources":["../../src/session/job-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG"}

package/dist/session/sqlite-job-store.d.ts

@@ -0,0 +1,40 @@
+/**
+ * sqlite-backed JobStore implementation — the bundled default.
+ *
+ * Two tables (job, event) on a single sqlite file. WAL journal for write
+ * concurrency, foreign keys enforced.
+ *
+ * The interface (`JobStore`) is async-by-default in v3.0.0; this
+ * implementation wraps its sync better-sqlite3 calls in `async` methods.
+ * better-sqlite3 stays sync internally — the only overhead is one
+ * microtask per call, which is negligible against sqlite's already
+ * sub-millisecond write cost. We pay this cost to keep one unified
+ * interface across all backends (Postgres, Redis, network stores)
+ * instead of two parallel sync + async hierarchies.
+ */
+import type { PipelineEvent } from '../phase.js';
+import type { EventRecord, JobRecord, JobStore, ListJobsOptions } from './job-store.js';
+export declare class SqliteJobStore implements JobStore {
+    private db;
+    constructor(dbPath?: string);
+    /**
+     * Apply any unapplied migrations. Reads `PRAGMA user_version`, applies
+     * each entry from `MIGRATIONS` whose version is greater, inside a
+     * transaction per step, then bumps user_version.
+     *
+     * Idempotent: running twice is a no-op once the schema is current.
+     */
+    private runMigrations;
+    createJob(name: string, input: unknown): Promise<string>;
+    acquireExclusive(name: string, input: unknown): Promise<string | null>;
+    setRunning(jobId: string): Promise<void>;
+    setCompleted(jobId: string, result: unknown): Promise<void>;
+    setFailed(jobId: string, error: string): Promise<void>;
+    getJob(jobId: string): Promise<JobRecord | null>;
+    listJobs(options?: ListJobsOptions): Promise<JobRecord[]>;
+    private toJobRecord;
+    appendEvent(jobId: string, event: PipelineEvent): Promise<number>;
+    getEvents(jobId: string, afterId?: number): Promise<EventRecord[]>;
+    close(): void;
+}
+//# sourceMappingURL=sqlite-job-store.d.ts.map

package/dist/session/sqlite-job-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-job-store.d.ts","sourceRoot":"","sources":["../../src/session/sqlite-job-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EAET,QAAQ,EACR,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAgFxB,qBAAa,cAAe,YAAW,QAAQ;IAC7C,OAAO,CAAC,EAAE,CAAK;gBAEH,MAAM,GAAE,MAAwB;IAO5C;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAiBf,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAQxD,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAwBtE,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYtD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAUhD,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAiBnE,OAAO,CAAC,WAAW;IAmBb,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAOjE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAgB3E,KAAK,IAAI,IAAI;CAGd"}