stageflow 0.19.0 → 0.25.0

package/dist/mcp/providerTools.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { inspectProviderReadiness, mapProviderAuthError, } from "../agent/providerInspect.js";
+import { textResult } from "./toolResults.js";
+export function registerProviderTools(server, deps) {
+    server.registerTool("list_providers", {
+        description: "List login-capable model providers with auth readiness and a Pi-home detect summary. Read-only; does not log in or return secrets.",
+        inputSchema: z.object({}),
+    }, async () => {
+        try {
+            return textResult(await inspectProviderReadiness(deps.cwd, deps.providerAuthContext));
+        }
+        catch (err) {
+            const mapped = mapProviderAuthError(err);
+            return textResult({ error: mapped.body.error, status: mapped.status }, true);
+        }
+    });
+}

package/dist/mcp/readArtifact.d.ts

@@ -1,4 +1,13 @@
 import type { RunStore } from "../runstore/port.js";
 export declare function artifactMediaType(relativePath: string): string | undefined;
+export type ClassifiedArtifactContent = {
+    kind: "image";
+    mimeType: string;
+} | {
+    kind: "utf8";
+} | {
+    kind: "binary";
+};
+export declare function classifyArtifactContent(relativePath: string, bytes: Buffer): ClassifiedArtifactContent;
 export declare function readRunArtifact(store: RunStore, runId: string, relativePath: string): Promise<string>;
 export declare function readRunArtifactBytes(store: RunStore, runId: string, relativePath: string): Promise<Buffer>;

package/dist/mcp/readArtifact.js

@@ -1,3 +1,4 @@
+import { isUtf8 } from "node:buffer";
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import { isInsideDir } from "../runstore/workspaceLayout.js";
@@ -28,6 +29,16 @@ export function artifactMediaType(relativePath) {
             return undefined;
     }
 }
+export function classifyArtifactContent(relativePath, bytes) {
+    const mimeType = artifactMediaType(relativePath);
+    if (mimeType !== undefined) {
+        return { kind: "image", mimeType };
+    }
+    if (isUtf8(bytes)) {
+        return { kind: "utf8" };
+    }
+    return { kind: "binary" };
+}
 async function resolveRunArtifactFile(store, runId, relativePath) {
     assertSafeRunId(runId);
     if (typeof relativePath !== "string" || relativePath.trim().length === 0) {

package/dist/mcp/server.js

@@ -34,7 +34,15 @@ function sessionIdFromRequest(req) {
     return undefined;
 }
 function toolDepsFrom(deps) {
-    return { manager: deps.manager, store: deps.store, cwd: deps.cwd };
+    return {
+        manager: deps.manager,
+        store: deps.store,
+        cwd: deps.cwd,
+        ...(deps.providerAuthContext !== undefined
+            ? { providerAuthContext: deps.providerAuthContext }
+            : {}),
+        ...(deps.projectRoot !== undefined ? { projectRoot: deps.projectRoot } : {}),
+    };
 }
 function attachBusNotifications(server, bus) {
     return bus.on((event) => {

package/dist/mcp/tailStreamLog.d.ts

@@ -0,0 +1,8 @@
+export type StreamLogTail = {
+    text: string;
+    nextOffset: number;
+    truncated?: boolean;
+    earliestOffset?: number;
+};
+/** Read new content from a stage's stream.log since a caller's last cursor. */
+export declare function readStreamLogTail(streamLogPath: string, sinceOffset: number | undefined): Promise<StreamLogTail>;

package/dist/mcp/tailStreamLog.js

@@ -0,0 +1,28 @@
+import { readFile } from "node:fs/promises";
+import { parseStreamLogHeader } from "../runtime/stageStreamLog.js";
+/** Read new content from a stage's stream.log since a caller's last cursor. */
+export async function readStreamLogTail(streamLogPath, sinceOffset) {
+    let raw;
+    try {
+        raw = await readFile(streamLogPath);
+    }
+    catch {
+        return { text: "", nextOffset: 0 };
+    }
+    const { base, headerLength } = parseStreamLogHeader(raw);
+    const contentBytes = raw.subarray(headerLength);
+    const eof = base + contentBytes.length;
+    if (sinceOffset === undefined || sinceOffset < base) {
+        const truncated = sinceOffset !== undefined && sinceOffset < base;
+        return {
+            text: contentBytes.toString("utf8"),
+            nextOffset: eof,
+            ...(truncated ? { truncated: true, earliestOffset: base } : {}),
+        };
+    }
+    if (sinceOffset >= eof) {
+        return { text: "", nextOffset: eof };
+    }
+    const slice = contentBytes.subarray(sinceOffset - base);
+    return { text: slice.toString("utf8"), nextOffset: eof };
+}

package/dist/mcp/toolResults.d.ts

@@ -5,3 +5,20 @@ export declare function textResult(data: unknown, isError?: boolean): {
     }[];
     isError?: boolean | undefined;
 };
+export declare function imageResult(mimeType: string, bytes: Buffer, identity: {
+    runId: string;
+    path: string;
+    mimeType: string;
+}): {
+    content: ({
+        type: "image";
+        mimeType: string;
+        data: string;
+        text?: undefined;
+    } | {
+        mimeType?: undefined;
+        data?: undefined;
+        type: "text";
+        text: string;
+    })[];
+};

package/dist/mcp/toolResults.js

@@ -4,3 +4,18 @@ export function textResult(data, isError = false) {
         ...(isError ? { isError: true } : {}),
     };
 }
+export function imageResult(mimeType, bytes, identity) {
+    return {
+        content: [
+            {
+                type: "image",
+                mimeType,
+                data: bytes.toString("base64"),
+            },
+            {
+                type: "text",
+                text: JSON.stringify(identity, null, 2),
+            },
+        ],
+    };
+}

package/dist/mcp/tools.js

@@ -1,12 +1,16 @@
 import { z } from "zod";
 import { registerCatalogTools } from "./catalogTools.js";
 import { registerControlTools } from "./controlTools.js";
+import { registerProjectMcpTools } from "./projectMcpTools.js";
+import { registerProviderTools } from "./providerTools.js";
 import { textResult } from "./toolResults.js";
 import { DEFAULT_TIMEOUT_MS, waitRun } from "./waitRun.js";
 export function registerMcpTools(server, deps) {
     const { store } = deps;
     registerCatalogTools(server, deps);
     registerControlTools(server, deps);
+    registerProviderTools(server, deps);
+    registerProjectMcpTools(server, deps);
     server.registerTool("wait_run", {
         description: "Long-poll until a run is waiting for HITL input and/or terminal (succeeded/failed), or until timeout_ms. Default until=any wakes on waiting OR terminal. Abort cancels only this wait (not the run). Optional notifications/progress when the client supplies _meta.progressToken. Compose: wait_run → answer_gate → wait_run.",
         inputSchema: z.object({

package/dist/mcp/waitRun.js

@@ -1,3 +1,4 @@
+import { mapStoreLookupError } from "../server/operatorResults.js";
 import { projectRunForMcp } from "./projectRun.js";
 export const DEFAULT_TIMEOUT_MS = 60_000;
 export const MAX_TIMEOUT_MS = 240_000;
@@ -90,12 +91,11 @@ export async function waitRun(opts) {
             detail = await opts.store.readRun(opts.runId);
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            const notFound = /not found|no such|unknown run/i.test(message);
+            const mapped = mapStoreLookupError(err, { policy: "run" });
             return {
                 ok: false,
-                error: message,
-                status: notFound ? 404 : 500,
+                error: mapped.error,
+                status: mapped.status,
             };
         }
         const run = projectRunForMcp(detail);

package/dist/mcp/waitingGates.d.ts

@@ -9,5 +9,6 @@ export declare function projectWaitingGate(opts: {
 }): Record<string, unknown>;
 export declare function projectWaitingGates(store: RunStore, opts?: {
     runId?: string;
+    projectRoot?: string;
 }): Promise<Array<Record<string, unknown>>>;
 export {};

package/dist/mcp/waitingGates.js

@@ -83,8 +83,9 @@ export async function projectWaitingGates(store, opts) {
         return projectGatesForRun(detail, detail);
     }
     const summaries = await store.listRuns();
-    const waiting = summaries.filter((r) => (r.waiting_stage_ids !== undefined && r.waiting_stage_ids.length > 0) ||
-        r.waiting_stage_id !== undefined);
+    const waiting = summaries.filter((r) => (opts?.projectRoot === undefined || r.project_root === opts.projectRoot) &&
+        ((r.waiting_stage_ids !== undefined && r.waiting_stage_ids.length > 0) ||
+            r.waiting_stage_id !== undefined));
     const perRun = await Promise.all(waiting.map(async (summary) => {
         let detail;
         try {

package/dist/package-meta.d.ts

@@ -1,2 +1,2 @@
 export declare const PACKAGE_NAME = "stageflow";
-export declare const PACKAGE_VERSION = "0.19.0";
+export declare const PACKAGE_VERSION = "0.25.0";

package/dist/package-meta.js

@@ -1,2 +1,2 @@
 export const PACKAGE_NAME = "stageflow";
-export const PACKAGE_VERSION = "0.19.0";
+export const PACKAGE_VERSION = "0.25.0";

package/dist/projection/projectRun.d.ts

@@ -16,6 +16,8 @@ export type StageProjection = {
     artifacts: string[];
     last_at?: string;
     pending_prompt?: AskOperatorPrompt;
+    definition_id?: string;
+    cost_usd?: number;
 };
 export type RunProjection = {
     run_id: string;
@@ -40,6 +42,7 @@ export type RunProjection = {
     failed_reason?: RunSummary["failed_reason"];
     active_feedback_loop?: FeedbackLoopRecord;
     feedback_loops: FeedbackLoopHistory[];
+    total_cost_usd?: number;
 };
 export declare function projectRun(detail: RunDetail): RunProjection;
 export { projectRun as projectRunForMcp };

package/dist/projection/projectRun.js

@@ -44,6 +44,9 @@ export function projectRun(detail) {
         ...(detail.active_feedback_loop !== undefined
             ? { active_feedback_loop: detail.active_feedback_loop }
             : {}),
+        ...(detail.total_cost_usd !== undefined
+            ? { total_cost_usd: detail.total_cost_usd }
+            : {}),
         feedback_loops: detail.feedback_loops ?? [],
         stages: detail.stages.map((stage) => ({
             stage_id: stage.stage_id,
@@ -69,6 +72,10 @@ export function projectRun(detail) {
             ...(stage.pending_prompt
                 ? { pending_prompt: stage.pending_prompt }
                 : {}),
+            ...(stage.definition_id !== undefined
+                ? { definition_id: stage.definition_id }
+                : {}),
+            ...(stage.cost_usd !== undefined ? { cost_usd: stage.cost_usd } : {}),
         })),
     };
 }

package/dist/runstore/createStore.d.ts

@@ -1,3 +1,4 @@
+import type Database from "better-sqlite3";
 import type { RunStore } from "./port.js";
 export type RunStoreKind = "sqlite";
 export type RunStoreConfig = {
@@ -7,6 +8,15 @@ export type RunStoreConfig = {
     kind?: RunStoreKind | "disk";
 };
 export declare const DISK_STORE_REJECTED = "SF_STORE=disk is no longer a live RunStore. SQLite is the only adapter. Disk-era .stageflow/runs trees import automatically when the SQLite store is empty.";
+/**
+ * Composition-root factory: hands back the concrete SQLite connection alongside the `RunStore`,
+ * for the one caller wiring a second, colocated store (A2A's tables) into the same `state.db`
+ * file. Ordinary call sites use `createRunStore` below and never see this.
+ */
+export declare function createRunStoreWithConnection(config: RunStoreConfig): {
+    store: RunStore;
+    connection: Database.Database;
+};
 /**
  * Factory at the application edge. Call sites should receive the returned `RunStore`
  * and must not branch on backend kind.

package/dist/runstore/createStore.js

@@ -11,13 +11,22 @@ function resolveKind(kind) {
     return "sqlite";
 }
 /**
- * Factory at the application edge. Call sites should receive the returned `RunStore`
- * and must not branch on backend kind.
+ * Composition-root factory: hands back the concrete SQLite connection alongside the `RunStore`,
+ * for the one caller wiring a second, colocated store (A2A's tables) into the same `state.db`
+ * file. Ordinary call sites use `createRunStore` below and never see this.
  */
-export function createRunStore(config) {
+export function createRunStoreWithConnection(config) {
     resolveKind(config.kind);
     migrateLegacyStoreRoot(config.rootDir);
     const storeRoot = storeRootFor(config.rootDir);
     mkdirSync(storeRoot, { recursive: true });
-    return new SqliteRunStore(storeRoot);
+    const store = new SqliteRunStore(storeRoot);
+    return { store, connection: store.connection };
+}
+/**
+ * Factory at the application edge. Call sites should receive the returned `RunStore`
+ * and must not branch on backend kind.
+ */
+export function createRunStore(config) {
+    return createRunStoreWithConnection(config).store;
 }

package/dist/runstore/port.d.ts

@@ -1,7 +1,8 @@
 import type { StageLogLine } from "../agent/activity.js";
+import type { RunSubmission, RunSubmissionRecord } from "./submission.js";
 import type { AskOperatorPrompt } from "../tools/askOperator.js";
 import type { StageEnvelope } from "../types/envelope.js";
-import type { FeedbackLoopConfig, ResolvedPipelineDag } from "../types/pipeline.js";
+import type { FeedbackLoopConfig, InlinePipelineDefinition, ResolvedPipelineDag } from "../types/pipeline.js";
 import type { CompletionCheck } from "../types/completion.js";
 import type { StageGateKind } from "../types/stage.js";
 import type { StageUsage } from "../types/usage.js";
@@ -51,6 +52,14 @@ export type RunMeta = {
     pipeline_path?: string;
     task_path?: string;
     project_root?: string;
+    /**
+     * The raw pipeline body for a run started from an inline pipeline
+     * (no pipeline_path). Lets a fresh stage-worker process — which has no
+     * memory of the original in-process call — reconstruct the pipeline
+     * without needing a catalog file, mirroring how task_yaml already lets
+     * task reconstruction work without a task_path.
+     */
+    inline_pipeline?: InlinePipelineDefinition;
 };
 export type CreatedRun = {
     runId: string;
@@ -275,6 +284,7 @@ export type FeedbackLoopHistory = {
     fork_generations: ForkGenerationRecord[];
 };
 export type CreateRunInput = {
+    submission?: RunSubmission;
     pipelineId: string;
     taskYaml: string;
     taskId?: string;
@@ -286,6 +296,8 @@ export type CreateRunInput = {
     pipelinePath?: string;
     taskPath?: string;
     projectRoot?: string;
+    /** Raw inline pipeline body, persisted only when pipelinePath is absent. */
+    inlinePipeline?: InlinePipelineDefinition;
 };
 export type ListRunsFilter = {
     status?: RunStatus;
@@ -301,6 +313,7 @@ export type ListRunsFilter = {
  * run id is all you have (catalog / rehydrate).
  */
 export interface RunStore {
+    getRunBySubmission(key: string): Promise<RunSubmissionRecord | null>;
     createRun(input: CreateRunInput): Promise<CreatedRun>;
     updateRunStatus(runId: string, status: RunStatus): Promise<void>;
     readRunMeta(runId: string): Promise<RunMeta>;
@@ -327,12 +340,14 @@ export interface RunStore {
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
-    readEnvelope(runId: string, stageId: string): Promise<StageEnvelope>;
+    readEnvelope(runId: string, stageId: string, attempt?: number): Promise<StageEnvelope>;
     appendStageEvent(runId: string, stageId: string, event: StageLogLine, options?: {
         attempt?: number;
     }): Promise<void>;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
+    /** Every distinct non-empty project_root recorded across all runs. */
+    listProjectRoots(): Promise<string[]>;
     readRun(runId: string): Promise<RunDetail>;
     updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.d.ts

@@ -1,6 +1,8 @@
+import Database from "better-sqlite3";
 import type { StageEnvelope } from "../../types/envelope.js";
 import type { StageLogLine } from "../../agent/activity.js";
 import { type CreateFeedbackLoopInput, type CreateFeedbackReplayInput, type CreateFeedbackReplayStagePassInput, type CreateForkGenerationInput, type CreateRunInput, type CreatedRun, type FeedbackLoopPatch, type FeedbackLoopRecord, type FeedbackLoopState, type FeedbackReplayPatch, type FeedbackReplayRecord, type FeedbackReplayStagePassPatch, type FeedbackReplayStagePassRecord, type ForkGenerationPatch, type ForkGenerationRecord, type ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent, type VerificationCheckResult, type VerificationCheckResultPatch } from "../port.js";
+import { type RunSubmissionRecord } from "../submission.js";
 export declare class SqliteRunStore implements RunStore {
     private readonly storeRoot;
     private readonly db;
@@ -8,8 +10,15 @@ export declare class SqliteRunStore implements RunStore {
     constructor(storeRoot: string);
     /** Await one-shot disk import before catalog reads (create paths also wait). */
     ready(): Promise<void>;
+    /**
+     * The connection this store owns, for the one caller allowed to share it: the composition root
+     * wiring the A2A tables into the same `state.db` file. Not part of the `RunStore` interface.
+     */
+    get connection(): Database.Database;
     getWorkspaceDir(runId: string): string;
     createRun(input: CreateRunInput): Promise<CreatedRun>;
+    private readSubmission;
+    getRunBySubmission(key: string): Promise<RunSubmissionRecord | null>;
     updateRunStatus(runId: string, status: RunStatus): Promise<void>;
     updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
     readRunMeta(runId: string): Promise<RunMeta>;
@@ -29,7 +38,7 @@ export declare class SqliteRunStore implements RunStore {
     writeEnvelope(runId: string, stageId: string, envelope: StageEnvelope, options?: {
         attempt?: number;
     }): Promise<void>;
-    readEnvelope(runId: string, stageId: string): Promise<StageEnvelope>;
+    readEnvelope(runId: string, stageId: string, attempt?: number): Promise<StageEnvelope>;
     private readEnvelopeFromDb;
     appendStageEvent(runId: string, stageId: string, event: StageLogLine, options?: {
         attempt?: number;
@@ -43,6 +52,7 @@ export declare class SqliteRunStore implements RunStore {
     private updateStageStatusDenorm;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
+    listProjectRoots(): Promise<string[]>;
     readRun(runId: string): Promise<RunDetail>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;
     getFeedbackLoop(runId: string, loopId: string): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -9,6 +9,7 @@ import { newRunId, runWorkspaceDir } from "../paths.js";
 import { attemptAgentDir, attemptArtifactsDir, stageDir, } from "../workspaceLayout.js";
 import { importDiskRunsIfEmpty } from "./migrateFromDisk.js";
 import { SCHEMA_SQL } from "./schema.js";
+import { RunSubmissionExistsError } from "../submission.js";
 const ensuredStageDirs = new Set();
 const DEFAULT_SQLITE_BUSY_TIMEOUT_MS = 5000;
 function readSqliteBusyTimeoutMs() {
@@ -52,6 +53,12 @@ function ensureRunLocatorColumns(db) {
         }
     }
 }
+function ensureInlinePipelineColumn(db) {
+    const cols = db.prepare(`PRAGMA table_info(runs)`).all();
+    if (!cols.some((c) => c.name === "inline_pipeline_json")) {
+        db.exec(`ALTER TABLE runs ADD COLUMN inline_pipeline_json TEXT`);
+    }
+}
 function ensureStageExecutionsTable(db) {
     db.exec(`
 CREATE TABLE IF NOT EXISTS stage_executions (
@@ -304,6 +311,7 @@ export class SqliteRunStore {
         ensureCiIdentityColumns(this.db);
         ensurePipelineDagColumn(this.db);
         ensureRunLocatorColumns(this.db);
+        ensureInlinePipelineColumn(this.db);
         ensureStageExecutionsTable(this.db);
         ensureStageExecutionVerificationOutcomeColumn(this.db);
         ensureStageExecutionCostColumns(this.db);
@@ -319,6 +327,13 @@ export class SqliteRunStore {
     async ready() {
         await this.migratePromise;
     }
+    /**
+     * The connection this store owns, for the one caller allowed to share it: the composition root
+     * wiring the A2A tables into the same `state.db` file. Not part of the `RunStore` interface.
+     */
+    get connection() {
+        return this.db;
+    }
     getWorkspaceDir(runId) {
         return runWorkspaceDir(this.storeRoot, runId);
     }
@@ -337,32 +352,55 @@ export class SqliteRunStore {
         const projectRoot = input.projectRoot
             ? normalizeCatalogPath(input.projectRoot)
             : null;
-        this.db
-            .prepare(`INSERT INTO runs
-          (run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root)
+        this.db.transaction(() => {
+            if (input.submission) {
+                const existing = this.readSubmission(input.submission.key);
+                if (existing)
+                    throw new RunSubmissionExistsError(existing);
+            }
+            this.db
+                .prepare(`INSERT INTO runs
+          (run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, inline_pipeline_json)
          VALUES
-          (@run_id, @pipeline_id, @task_id, @task_yaml, @status, @created_at, @updated_at, @checkout_root, @pipeline_dag_json, @git_sha, @ci_pr_url, @ci_job_url, @pipeline_path, @task_path, @project_root)`)
-            .run({
-            run_id: runId,
-            pipeline_id: input.pipelineId,
-            task_id: input.taskId ?? null,
-            task_yaml: input.taskYaml,
-            status: "running",
-            created_at: now,
-            updated_at: now,
-            checkout_root: input.checkoutRoot ?? null,
-            pipeline_dag_json: input.pipelineDag
-                ? JSON.stringify(input.pipelineDag)
-                : null,
-            git_sha: input.gitSha ?? null,
-            ci_pr_url: input.ciPrUrl ?? null,
-            ci_job_url: input.ciJobUrl ?? null,
-            pipeline_path: pipelinePath,
-            task_path: taskPath,
-            project_root: projectRoot,
-        });
+          (@run_id, @pipeline_id, @task_id, @task_yaml, @status, @created_at, @updated_at, @checkout_root, @pipeline_dag_json, @git_sha, @ci_pr_url, @ci_job_url, @pipeline_path, @task_path, @project_root, @inline_pipeline_json)`)
+                .run({
+                run_id: runId,
+                pipeline_id: input.pipelineId,
+                task_id: input.taskId ?? null,
+                task_yaml: input.taskYaml,
+                status: "running",
+                created_at: now,
+                updated_at: now,
+                checkout_root: input.checkoutRoot ?? null,
+                pipeline_dag_json: input.pipelineDag
+                    ? JSON.stringify(input.pipelineDag)
+                    : null,
+                git_sha: input.gitSha ?? null,
+                ci_pr_url: input.ciPrUrl ?? null,
+                ci_job_url: input.ciJobUrl ?? null,
+                pipeline_path: pipelinePath,
+                task_path: taskPath,
+                project_root: projectRoot,
+                inline_pipeline_json: input.inlinePipeline
+                    ? JSON.stringify(input.inlinePipeline)
+                    : null,
+            });
+            if (input.submission) {
+                this.db.prepare("INSERT INTO run_submissions (submission_key, request_hash, run_id) VALUES (?, ?, ?)")
+                    .run(input.submission.key, input.submission.requestHash, runId);
+            }
+        })();
         return { runId, workspaceDir };
     }
+    readSubmission(key) {
+        const row = this.db.prepare("SELECT submission_key AS key, request_hash AS requestHash, run_id AS runId FROM run_submissions WHERE submission_key = ?")
+            .get(key);
+        return row ?? null;
+    }
+    async getRunBySubmission(key) {
+        await this.ready();
+        return this.readSubmission(key);
+    }
     async updateRunStatus(runId, status) {
         await this.ready();
         const result = this.db
@@ -606,8 +644,15 @@ export class SqliteRunStore {
         });
         await this.updateStageExecution(runId, stageId, attempt, { envelope });
     }
-    async readEnvelope(runId, stageId) {
+    async readEnvelope(runId, stageId, attempt) {
         await this.ready();
+        if (attempt !== undefined) {
+            const execution = await this.getStageExecution(runId, stageId, attempt);
+            if (execution.envelope != null) {
+                return execution.envelope;
+            }
+            throw new Error(`Envelope not found: ${runId}/${stageId}`);
+        }
         const execution = await this.getLatestStageExecution(runId, stageId);
         if (execution?.envelope != null) {
             return execution.envelope;
@@ -703,7 +748,7 @@ export class SqliteRunStore {
         }
         const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
         const rows = this.db
-            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root
+            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, inline_pipeline_json
          FROM runs ${where} ORDER BY created_at DESC`)
             .all(...params);
         const summaries = [];
@@ -717,6 +762,13 @@ export class SqliteRunStore {
         }
         return summaries;
     }
+    async listProjectRoots() {
+        await this.ready();
+        const rows = this.db
+            .prepare(`SELECT DISTINCT project_root FROM runs WHERE project_root IS NOT NULL AND project_root != ''`)
+            .all();
+        return rows.map((row) => row.project_root);
+    }
     async readRun(runId) {
         await this.ready();
         const row = this.getRunRow(runId);
@@ -1125,11 +1177,14 @@ export class SqliteRunStore {
             ...(row.task_path != null ? { task_path: row.task_path } : {}),
             ...(row.project_root != null ? { project_root: row.project_root } : {}),
             ...(pipeline_dag ? { pipeline_dag } : {}),
+            ...(row.inline_pipeline_json != null
+                ? { inline_pipeline: JSON.parse(row.inline_pipeline_json) }
+                : {}),
         };
     }
     getRunRow(runId) {
         const row = this.db
-            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root
+            .prepare(`SELECT run_id, pipeline_id, task_id, task_yaml, status, created_at, updated_at, checkout_root, pipeline_dag_json, git_sha, ci_pr_url, ci_job_url, pipeline_path, task_path, project_root, inline_pipeline_json
          FROM runs WHERE run_id = ?`)
             .get(runId);
         if (!row)

package/dist/runstore/sqlite/schema.d.ts

@@ -1 +1 @@
-export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS runs (\n  run_id TEXT PRIMARY KEY,\n  pipeline_id TEXT NOT NULL,\n  task_id TEXT,\n  task_yaml TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  checkout_root TEXT,\n  pipeline_dag_json TEXT,\n  git_sha TEXT,\n  ci_pr_url TEXT,\n  ci_job_url TEXT,\n  pipeline_path TEXT,\n  task_path TEXT,\n  project_root TEXT\n);\n\nCREATE TABLE IF NOT EXISTS stages (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  status TEXT,\n  summary TEXT,\n  envelope_json TEXT,\n  started_at TEXT,\n  finished_at TEXT,\n  PRIMARY KEY (run_id, stage_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS stage_events (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  at TEXT NOT NULL,\n  event TEXT NOT NULL,\n  payload_json TEXT,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_runs_status_created\n  ON runs (status, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_runs_pipeline_created\n  ON runs (pipeline_id, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_at\n  ON stage_events (run_id, stage_id, at);\n\nCREATE TABLE IF NOT EXISTS stage_executions (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  verification_outcome TEXT NOT NULL DEFAULT 'not_run',\n  started_at TEXT,\n  finished_at TEXT,\n  envelope_json TEXT,\n  cost_usd REAL,\n  usage_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage\n  ON stage_executions (run_id, stage_id, attempt);\n\nCREATE TABLE IF NOT EXISTS verification_check_results (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  check_id TEXT NOT NULL,\n  check_type TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  evidence_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt, check_id),\n  FOREIGN KEY (run_id, stage_id, attempt)\n    REFERENCES stage_executions(run_id, stage_id, attempt)\n);\n\nCREATE INDEX IF NOT EXISTS idx_verification_check_results_execution\n  ON verification_check_results (run_id, stage_id, attempt, check_id);\n\nCREATE TABLE IF NOT EXISTS feedback_loops (\n  run_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  policy_json TEXT NOT NULL,\n  state TEXT NOT NULL,\n  current_replay_id TEXT,\n  current_replay_number INTEGER,\n  deferred_send_back_json TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, loop_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_loops_run_state\n  ON feedback_loops (run_id, state, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replays (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  target_stage_id TEXT NOT NULL,\n  replay_number INTEGER NOT NULL,\n  max_replays INTEGER NOT NULL,\n  replay_session TEXT NOT NULL,\n  route_stage_ids_json TEXT NOT NULL,\n  feedback_envelope_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, replay_id),\n  FOREIGN KEY (run_id, loop_id) REFERENCES feedback_loops(run_id, loop_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_feedback_replays_loop_number\n  ON feedback_replays (run_id, loop_id, replay_number);\nCREATE INDEX IF NOT EXISTS idx_feedback_replays_run_loop\n  ON feedback_replays (run_id, loop_id, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replay_stage_passes (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  stage_attempt INTEGER NOT NULL,\n  session_origin_attempt INTEGER,\n  session_mode TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  emitted_envelope_json TEXT,\n  PRIMARY KEY (run_id, replay_id, stage_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_replay_stage_passes_replay\n  ON feedback_replay_stage_passes (run_id, replay_id, stage_id);\n\nCREATE TABLE IF NOT EXISTS fork_generations (\n  run_id TEXT NOT NULL,\n  generation_id TEXT NOT NULL,\n  replay_id TEXT,\n  fork_parent_stage_id TEXT NOT NULL,\n  generation_number INTEGER NOT NULL,\n  clone_stage_ids_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, generation_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_fork_generations_parent_number\n  ON fork_generations (run_id, fork_parent_stage_id, generation_number);\nCREATE INDEX IF NOT EXISTS idx_fork_generations_run_replay\n  ON fork_generations (run_id, replay_id, created_at);\n";
+export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS runs (\n  run_id TEXT PRIMARY KEY,\n  pipeline_id TEXT NOT NULL,\n  task_id TEXT,\n  task_yaml TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  checkout_root TEXT,\n  pipeline_dag_json TEXT,\n  git_sha TEXT,\n  ci_pr_url TEXT,\n  ci_job_url TEXT,\n  pipeline_path TEXT,\n  task_path TEXT,\n  project_root TEXT\n);\n\nCREATE TABLE IF NOT EXISTS run_submissions (\n  submission_key TEXT PRIMARY KEY,\n  request_hash TEXT NOT NULL,\n  run_id TEXT NOT NULL UNIQUE REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS stages (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  status TEXT,\n  summary TEXT,\n  envelope_json TEXT,\n  started_at TEXT,\n  finished_at TEXT,\n  PRIMARY KEY (run_id, stage_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS stage_events (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  at TEXT NOT NULL,\n  event TEXT NOT NULL,\n  payload_json TEXT,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_runs_status_created\n  ON runs (status, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_runs_pipeline_created\n  ON runs (pipeline_id, created_at DESC);\n\nCREATE INDEX IF NOT EXISTS idx_stage_events_run_stage_at\n  ON stage_events (run_id, stage_id, at);\n\nCREATE TABLE IF NOT EXISTS stage_executions (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  verification_outcome TEXT NOT NULL DEFAULT 'not_run',\n  started_at TEXT,\n  finished_at TEXT,\n  envelope_json TEXT,\n  cost_usd REAL,\n  usage_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_stage_executions_run_stage\n  ON stage_executions (run_id, stage_id, attempt);\n\nCREATE TABLE IF NOT EXISTS verification_check_results (\n  run_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  attempt INTEGER NOT NULL,\n  check_id TEXT NOT NULL,\n  check_type TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  evidence_json TEXT,\n  PRIMARY KEY (run_id, stage_id, attempt, check_id),\n  FOREIGN KEY (run_id, stage_id, attempt)\n    REFERENCES stage_executions(run_id, stage_id, attempt)\n);\n\nCREATE INDEX IF NOT EXISTS idx_verification_check_results_execution\n  ON verification_check_results (run_id, stage_id, attempt, check_id);\n\nCREATE TABLE IF NOT EXISTS feedback_loops (\n  run_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  policy_json TEXT NOT NULL,\n  state TEXT NOT NULL,\n  current_replay_id TEXT,\n  current_replay_number INTEGER,\n  deferred_send_back_json TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, loop_id),\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_loops_run_state\n  ON feedback_loops (run_id, state, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replays (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  loop_id TEXT NOT NULL,\n  source_stage_id TEXT NOT NULL,\n  source_attempt INTEGER NOT NULL,\n  target_stage_id TEXT NOT NULL,\n  replay_number INTEGER NOT NULL,\n  max_replays INTEGER NOT NULL,\n  replay_session TEXT NOT NULL,\n  route_stage_ids_json TEXT NOT NULL,\n  feedback_envelope_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, replay_id),\n  FOREIGN KEY (run_id, loop_id) REFERENCES feedback_loops(run_id, loop_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_feedback_replays_loop_number\n  ON feedback_replays (run_id, loop_id, replay_number);\nCREATE INDEX IF NOT EXISTS idx_feedback_replays_run_loop\n  ON feedback_replays (run_id, loop_id, created_at);\n\nCREATE TABLE IF NOT EXISTS feedback_replay_stage_passes (\n  run_id TEXT NOT NULL,\n  replay_id TEXT NOT NULL,\n  stage_id TEXT NOT NULL,\n  stage_attempt INTEGER NOT NULL,\n  session_origin_attempt INTEGER,\n  session_mode TEXT NOT NULL,\n  status TEXT NOT NULL,\n  started_at TEXT,\n  finished_at TEXT,\n  emitted_envelope_json TEXT,\n  PRIMARY KEY (run_id, replay_id, stage_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_feedback_replay_stage_passes_replay\n  ON feedback_replay_stage_passes (run_id, replay_id, stage_id);\n\nCREATE TABLE IF NOT EXISTS fork_generations (\n  run_id TEXT NOT NULL,\n  generation_id TEXT NOT NULL,\n  replay_id TEXT,\n  fork_parent_stage_id TEXT NOT NULL,\n  generation_number INTEGER NOT NULL,\n  clone_stage_ids_json TEXT NOT NULL,\n  status TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  PRIMARY KEY (run_id, generation_id),\n  FOREIGN KEY (run_id, replay_id) REFERENCES feedback_replays(run_id, replay_id)\n);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_fork_generations_parent_number\n  ON fork_generations (run_id, fork_parent_stage_id, generation_number);\nCREATE INDEX IF NOT EXISTS idx_fork_generations_run_replay\n  ON fork_generations (run_id, replay_id, created_at);\n";

package/dist/runstore/sqlite/schema.js

@@ -17,6 +17,12 @@ CREATE TABLE IF NOT EXISTS runs (
   project_root TEXT
 );
 
+CREATE TABLE IF NOT EXISTS run_submissions (
+  submission_key TEXT PRIMARY KEY,
+  request_hash TEXT NOT NULL,
+  run_id TEXT NOT NULL UNIQUE REFERENCES runs(run_id)
+);
+
 CREATE TABLE IF NOT EXISTS stages (
   run_id TEXT NOT NULL,
   stage_id TEXT NOT NULL,

package/dist/runstore/submission.d.ts

@@ -0,0 +1,11 @@
+export type RunSubmission = {
+    key: string;
+    requestHash: string;
+};
+export type RunSubmissionRecord = RunSubmission & {
+    runId: string;
+};
+export declare class RunSubmissionExistsError extends Error {
+    readonly submission: RunSubmissionRecord;
+    constructor(submission: RunSubmissionRecord);
+}