@webpresso/agent-kit 0.21.0

package/dist/esm/cli/commands/bench/session-memory.js

@@ -0,0 +1,242 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const DEFAULT_VARIANTS = ['baseline', 'context-mode', 'v1', 'v2'];
+const DEFAULT_MODEL = 'claude-sonnet-4-5';
+function resolveRepoRoot(fromUrl) {
+    let current = dirname(fileURLToPath(fromUrl));
+    while (true) {
+        if (existsSync(resolve(current, 'package.json'))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            throw new Error(`Unable to resolve repo root from ${fromUrl}`);
+        }
+        current = parent;
+    }
+}
+const REPO_ROOT = resolveRepoRoot(import.meta.url);
+const DEFAULT_OUTPUT_ROOT = resolve(REPO_ROOT, 'scripts', 'bench', 'runs');
+export function getBenchSessionMemoryHelpText() {
+    return [
+        'Run the session-memory benchmark harness.',
+        '',
+        'Examples:',
+        '  wp bench session-memory --dry-run',
+        '  wp bench session-memory --scenario debug-long-session --variant baseline --trials 1',
+        '  wp bench session-memory --scenario all --all-variants',
+    ].join('\n');
+}
+export function getBenchSessionMemoryCommandHelpText() {
+    return [
+        'wp bench session-memory',
+        '',
+        'Run the session-memory benchmark harness.',
+        '',
+        'Options:',
+        '  --scenario <id>     Scenario id or "all" (default: all)',
+        '  --variant <id>      Single variant id to run',
+        '  --all-variants      Run baseline, context-mode, v1, and v2',
+        '  --dry-run           Validate manifest, scenarios, and env without API calls',
+        '  --trials <n>        Trials per cell',
+        '  --model <name>      Pricing model alias to use for cost math',
+        '  --output-root <path>  Override the bench output root directory',
+        '  -h, --help          Display this message',
+        '',
+        'Examples:',
+        '  wp bench session-memory --dry-run',
+        '  wp bench session-memory --scenario debug-long-session --variant baseline --trials 1',
+        '  wp bench session-memory --scenario all --all-variants',
+    ].join('\n');
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, inner]) => `${JSON.stringify(key)}:${stableStringify(inner)}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+export function createRunId(manifest) {
+    return createHash('sha256').update(stableStringify(manifest)).digest('hex').slice(0, 12);
+}
+function normalizeTrials(input) {
+    if (typeof input.trials === 'number' && Number.isFinite(input.trials) && input.trials > 0) {
+        return Math.floor(input.trials);
+    }
+    return input.allVariants ? 2 : 1;
+}
+function resolveVariants(input) {
+    if (input.allVariants) {
+        return [...DEFAULT_VARIANTS];
+    }
+    if (input.variant) {
+        if (!DEFAULT_VARIANTS.includes(input.variant)) {
+            throw new Error(`Unknown bench variant: ${input.variant}`);
+        }
+        return [input.variant];
+    }
+    return ['baseline'];
+}
+function resolveSelectedScenarios(allScenarios, input) {
+    const requested = input.scenario ?? 'all';
+    if (requested === 'all') {
+        return allScenarios;
+    }
+    const scenario = allScenarios.find((candidate) => candidate.scenario_id === requested);
+    if (!scenario) {
+        throw new Error(`Unknown bench scenario: ${requested}`);
+    }
+    return [scenario];
+}
+function scenarioPrompt(scenario) {
+    return scenario.prompt_turns
+        .filter((turn) => turn.role === 'user')
+        .sort((left, right) => left.turn_idx - right.turn_idx)
+        .map((turn) => turn.text)
+        .join('\n\n');
+}
+function pluginDirForVariant(cwd, variant, env) {
+    switch (variant) {
+        case 'baseline':
+            return env.BENCH_PLUGIN_BASELINE ?? cwd;
+        case 'context-mode':
+            return env.BENCH_PLUGIN_CONTEXT_MODE ?? cwd;
+        case 'v1':
+            return env.BENCH_PLUGIN_V1 ?? cwd;
+        case 'v2':
+            return env.BENCH_PLUGIN_V2 ?? cwd;
+    }
+}
+function apiKeyMapFromEnv(env) {
+    return {
+        ANTHROPIC_API_KEY_BASELINE: env.ANTHROPIC_API_KEY_BASELINE ?? env.ANTHROPIC_API_KEY,
+        ANTHROPIC_API_KEY_CONTEXT_MODE: env.ANTHROPIC_API_KEY_CONTEXT_MODE ?? env.ANTHROPIC_API_KEY,
+        ANTHROPIC_API_KEY_V1: env.ANTHROPIC_API_KEY_V1,
+        ANTHROPIC_API_KEY_V2: env.ANTHROPIC_API_KEY_V2,
+    };
+}
+async function loadRuntimeModules() {
+    const [manifestModule, scenarioModule, costModule, runnerModule, reportModule,] = await Promise.all([
+        import(pathToFileURL(resolve(REPO_ROOT, 'scripts', 'bench', 'lib', 'manifest.ts')).href),
+        import(pathToFileURL(resolve(REPO_ROOT, 'scripts', 'bench', 'scenarios', '_schema.ts')).href),
+        import(pathToFileURL(resolve(REPO_ROOT, 'scripts', 'bench', 'lib', 'cost-aggregator.ts')).href),
+        import(pathToFileURL(resolve(REPO_ROOT, 'scripts', 'bench', 'lib', 'variant-runner.ts')).href),
+        import(pathToFileURL(resolve(REPO_ROOT, 'scripts', 'bench', 'lib', 'report-writer.ts')).href),
+    ]);
+    return {
+        aggregateCosts: costModule.aggregateCosts,
+        captureManifest: manifestModule.captureManifest,
+        loadAllScenarios: scenarioModule.loadAllScenarios,
+        loadManifest: manifestModule.loadManifest,
+        loadPricing: costModule.loadPricing,
+        resolveWorkspaceConfig: manifestModule.resolveWorkspaceConfig,
+        resolveWorkspaceIdentitiesFromEnv: manifestModule.resolveWorkspaceIdentitiesFromEnv,
+        runCell: runnerModule.runCell,
+        validateKnownAnthropicWorkspaces: manifestModule.validateKnownAnthropicWorkspaces,
+        validateWorkspaceKeyPresence: manifestModule.validateWorkspaceKeyPresence,
+        verifyManifest: manifestModule.verifyManifest,
+        writeReport: reportModule.writeReport,
+    };
+}
+async function runWorkspacePreflight(runtime, workspaceConfig, env) {
+    runtime.validateWorkspaceKeyPresence(workspaceConfig, env);
+    if (workspaceConfig.mode !== 'isolated') {
+        return;
+    }
+    const identities = runtime.resolveWorkspaceIdentitiesFromEnv(env);
+    const adminKey = env.ANTHROPIC_ADMIN_KEY;
+    if (workspaceConfig.adminVerification === 'required-for-proof' &&
+        typeof adminKey === 'string' &&
+        adminKey.length > 0) {
+        await runtime.validateKnownAnthropicWorkspaces(identities, adminKey);
+    }
+}
+export async function runBenchSessionMemoryCommand(input, deps) {
+    const runtime = deps ?? (await loadRuntimeModules());
+    const cwd = input.cwd ?? process.cwd();
+    const env = input.env ?? process.env;
+    const pinned = runtime.loadManifest();
+    const captured = await runtime.captureManifest();
+    runtime.verifyManifest(captured, pinned);
+    const workspaceConfig = runtime.resolveWorkspaceConfig(env);
+    await runWorkspacePreflight(runtime, workspaceConfig, env);
+    const allScenarios = runtime.loadAllScenarios();
+    const scenarios = resolveSelectedScenarios(allScenarios, input);
+    const variants = resolveVariants(input);
+    const trials = normalizeTrials(input);
+    const runId = createRunId(pinned);
+    const outputRoot = input.outputRoot ?? DEFAULT_OUTPUT_ROOT;
+    if (input.dryRun) {
+        return {
+            exitCode: 0,
+            runId,
+            dryRun: true,
+            reportPath: null,
+            cellCount: scenarios.length * variants.length,
+        };
+    }
+    const pricing = runtime.loadPricing();
+    const model = input.model ?? pinned.model ?? DEFAULT_MODEL;
+    const apiKeys = apiKeyMapFromEnv(env);
+    const cells = [];
+    for (const scenario of scenarios) {
+        for (const variant of variants) {
+            const results = [];
+            for (let trial = 1; trial <= trials; trial += 1) {
+                results.push(await runtime.runCell({
+                    scenario: scenario.scenario_id,
+                    prompt: scenarioPrompt(scenario),
+                    variant,
+                    trial,
+                    pluginDir: pluginDirForVariant(cwd, variant, env),
+                    runId,
+                    cwd,
+                    outputRoot,
+                    apiKeys,
+                }));
+            }
+            const okResults = results.filter((result) => result.ok);
+            const failed = results.find((result) => !result.ok);
+            const costSummary = okResults.length > 0
+                ? runtime.aggregateCosts(okResults.map((result) => result.usage), pricing, model || DEFAULT_MODEL)
+                : { mean: 0, std: 0, n: 0, total: 0 };
+            const wallSec = okResults.length > 0
+                ? Number((okResults.reduce((sum, result) => sum + result.usage.duration_ms, 0) /
+                    okResults.length /
+                    1000).toFixed(6))
+                : 0;
+            cells.push({
+                scenario_id: scenario.scenario_id,
+                variant,
+                trials,
+                status: failed?.error ?? 'ok',
+                cost_usd: costSummary.total,
+                recall_at_5: 0,
+                wall_sec: wallSec,
+            });
+        }
+    }
+    const reportPath = resolve(outputRoot, runId, 'report.md');
+    runtime.writeReport({
+        run_id: runId,
+        model,
+        dry_run: false,
+        cache_disclaimer: workspaceConfig.cacheDisclaimer,
+        cells,
+    }, reportPath);
+    return {
+        exitCode: 0,
+        runId,
+        dryRun: false,
+        reportPath,
+        cellCount: cells.length,
+    };
+}
+//# sourceMappingURL=session-memory.js.map

package/dist/esm/cli/commands/blueprint/db-commands.d.ts

@@ -0,0 +1,60 @@
+import { execSync } from 'node:child_process';
+export interface DbBuildResult {
+    readonly durationMs: number;
+    readonly blueprintsCount: number;
+    readonly techDebtCount: number;
+    readonly dbPath: string;
+}
+export interface DbVerifyResult {
+    readonly ok: boolean;
+    readonly blueprintsCount: number;
+    readonly techDebtCount: number;
+    readonly staleEntries: readonly StaleEntry[];
+    readonly dbPath: string;
+}
+export interface StaleEntry {
+    readonly table: 'blueprints' | 'tech_debt_items';
+    readonly slug: string;
+    readonly filePath: string;
+}
+export interface DbQueryResult {
+    readonly rows: unknown[];
+    readonly capped: boolean;
+    readonly rowCount: number;
+    readonly templateId: string;
+}
+/**
+ * Always rebuilds the canonical blueprint projection DB from all markdown
+ * files. Never deletes the DB — always calls ingestAll on a fresh connection.
+ */
+export declare function dbBuild(projectRoot: string): Promise<DbBuildResult>;
+/**
+ * Checks that the canonical blueprint projection DB is consistent with the
+ * markdown files on disk by re-hashing each known file and comparing with the
+ * stored hash.
+ */
+export declare function dbVerify(projectRoot: string): Promise<DbVerifyResult>;
+/**
+ * Runs a pre-registered SQL template and returns its rows.
+ * Ensures the DB exists via coldStartIfNeeded before querying.
+ */
+export declare function dbQuery(projectRoot: string, templateId: string, params?: Record<string, unknown>): Promise<DbQueryResult>;
+export type ExecSyncFn = typeof execSync;
+/**
+ * Generates a minimal datasette metadata JSON and launches datasette to serve
+ * the canonical blueprint projection DB as an interactive web UI.
+ *
+ * Prints a clear error and exits 1 if datasette is not installed.
+ *
+ * The optional `_execSync` parameter is injectable for testing — callers
+ * should omit it in production.
+ */
+export declare function dbBrowse(projectRoot: string, _execSync?: ExecSyncFn): void;
+export declare function formatDbBuildResult(result: DbBuildResult): string;
+export declare function formatDbVerifyResult(result: DbVerifyResult): string;
+export declare function executeBlueprintDbSubcommand(verb: string | undefined, args: readonly string[], options: {
+    readonly params?: string;
+    readonly projectRoot?: string;
+    readonly json?: boolean;
+}, print: (value: object | string, asJson?: boolean) => void): Promise<void>;
+//# sourceMappingURL=db-commands.d.ts.map

package/dist/esm/cli/commands/blueprint/db-commands.js

@@ -0,0 +1,244 @@
+import { createHash } from 'node:crypto';
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { coldStartIfNeeded } from '#db/cold-start.js';
+import { openDb } from '#db/connection.js';
+import { ingestAll } from '#db/ingester.js';
+import { migrateLegacyAgentDb } from '#db/legacy-migration.js';
+import { resolveBlueprintProjectionDbPath, withProjectionDbWriteLock } from '#db/paths.js';
+import { runTemplate } from '#db/template-runner.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const METADATA_FILENAME = '.datasette-metadata.json';
+function agentDbPath(projectRoot) {
+    // Migrate any legacy DB (idempotent + memoized) before resolving canonical path.
+    migrateLegacyAgentDb(projectRoot);
+    return resolveBlueprintProjectionDbPath(projectRoot);
+}
+function agentMetadataPath(projectRoot) {
+    return path.join(path.dirname(agentDbPath(projectRoot)), METADATA_FILENAME);
+}
+// ---------------------------------------------------------------------------
+// build
+// ---------------------------------------------------------------------------
+/**
+ * Always rebuilds the canonical blueprint projection DB from all markdown
+ * files. Never deletes the DB — always calls ingestAll on a fresh connection.
+ */
+export async function dbBuild(projectRoot) {
+    const start = Date.now();
+    const dbPath = agentDbPath(projectRoot);
+    const agentDir = path.dirname(dbPath);
+    mkdirSync(agentDir, { recursive: true });
+    // F9/R7: write path goes through the worktree-scoped projection lock. Throws
+    // LockTimeoutError on contention — no silent "proceeds anyway" escape.
+    return withProjectionDbWriteLock(projectRoot, async () => {
+        const conn = openDb(dbPath);
+        let blueprintsCount = 0;
+        let techDebtCount = 0;
+        try {
+            const result = await ingestAll({ db: conn.db, cwd: projectRoot });
+            blueprintsCount = result.blueprintsIngested;
+            techDebtCount = result.techDebtIngested;
+        }
+        finally {
+            conn.close();
+        }
+        return {
+            durationMs: Date.now() - start,
+            blueprintsCount,
+            techDebtCount,
+            dbPath,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// verify
+// ---------------------------------------------------------------------------
+/**
+ * Checks that the canonical blueprint projection DB is consistent with the
+ * markdown files on disk by re-hashing each known file and comparing with the
+ * stored hash.
+ */
+export async function dbVerify(projectRoot) {
+    const dbPath = agentDbPath(projectRoot);
+    if (!existsSync(dbPath)) {
+        throw new Error(`DB not found at ${dbPath}. Run \`wp blueprint db build\` first.`);
+    }
+    const conn = openDb(dbPath);
+    const staleEntries = [];
+    try {
+        // --- blueprints ---
+        const blueprintRows = conn.db
+            .prepare('SELECT slug, file_path, content_hash FROM blueprints')
+            .all();
+        for (const row of blueprintRows) {
+            if (!existsSync(row.file_path)) {
+                staleEntries.push({ table: 'blueprints', slug: row.slug, filePath: row.file_path });
+                continue;
+            }
+            const currentHash = createHash('sha256')
+                .update(readFileSync(row.file_path, 'utf8'))
+                .digest('hex');
+            if (currentHash !== row.content_hash) {
+                staleEntries.push({ table: 'blueprints', slug: row.slug, filePath: row.file_path });
+            }
+        }
+        // --- tech_debt_items ---
+        const techDebtRows = conn.db
+            .prepare('SELECT slug, file_path, content_hash FROM tech_debt_items')
+            .all();
+        for (const row of techDebtRows) {
+            if (!existsSync(row.file_path)) {
+                staleEntries.push({ table: 'tech_debt_items', slug: row.slug, filePath: row.file_path });
+                continue;
+            }
+            const currentHash = createHash('sha256')
+                .update(readFileSync(row.file_path, 'utf8'))
+                .digest('hex');
+            if (currentHash !== row.content_hash) {
+                staleEntries.push({ table: 'tech_debt_items', slug: row.slug, filePath: row.file_path });
+            }
+        }
+        return {
+            ok: staleEntries.length === 0,
+            blueprintsCount: blueprintRows.length,
+            techDebtCount: techDebtRows.length,
+            staleEntries,
+            dbPath,
+        };
+    }
+    finally {
+        conn.close();
+    }
+}
+// ---------------------------------------------------------------------------
+// query
+// ---------------------------------------------------------------------------
+/**
+ * Runs a pre-registered SQL template and returns its rows.
+ * Ensures the DB exists via coldStartIfNeeded before querying.
+ */
+export async function dbQuery(projectRoot, templateId, params = {}) {
+    await coldStartIfNeeded(projectRoot);
+    const dbPath = agentDbPath(projectRoot);
+    const conn = openDb(dbPath);
+    try {
+        const result = runTemplate(conn.db, templateId, params);
+        return {
+            rows: result.rows,
+            capped: result.capped,
+            rowCount: result.rowCount,
+            templateId,
+        };
+    }
+    finally {
+        conn.close();
+    }
+}
+/**
+ * Generates a minimal datasette metadata JSON and launches datasette to serve
+ * the canonical blueprint projection DB as an interactive web UI.
+ *
+ * Prints a clear error and exits 1 if datasette is not installed.
+ *
+ * The optional `_execSync` parameter is injectable for testing — callers
+ * should omit it in production.
+ */
+export function dbBrowse(projectRoot, _execSync = execSync) {
+    const dbPath = agentDbPath(projectRoot);
+    const metadataPath = agentMetadataPath(projectRoot);
+    const agentDir = path.dirname(dbPath);
+    if (!existsSync(dbPath)) {
+        process.stderr.write(`DB not found at ${dbPath}.\nRun \`wp blueprint db build\` first.\n`);
+        process.exit(1);
+    }
+    // Check datasette availability
+    try {
+        _execSync('datasette --version', { stdio: 'pipe', timeout: 3_000 });
+    }
+    catch {
+        process.stderr.write('Datasette is not installed. Install it with:\n\n  pip install datasette\n\n');
+        process.exit(1);
+    }
+    // Write minimal datasette metadata
+    mkdirSync(agentDir, { recursive: true });
+    const metadata = {
+        title: 'Blueprints DB',
+        description: 'Blueprint and tech-debt structured store (webpresso)',
+        source: 'wp blueprint db build',
+    };
+    writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + '\n', 'utf8');
+    // Launch datasette (blocking — inherits stdio so the user sees the URL)
+    _execSync(`datasette serve "${dbPath}" --metadata "${metadataPath}"`, { stdio: 'inherit' });
+}
+// ---------------------------------------------------------------------------
+// Format helpers (used by router-dispatch)
+// ---------------------------------------------------------------------------
+export function formatDbBuildResult(result) {
+    return `Rebuilt in ${result.durationMs}ms (${result.blueprintsCount} blueprints, ${result.techDebtCount} tech-debt items)`;
+}
+export function formatDbVerifyResult(result) {
+    if (result.ok) {
+        return `OK (${result.blueprintsCount} blueprints, ${result.techDebtCount} tech-debt items)`;
+    }
+    const lines = [`Stale entries (${result.staleEntries.length}):`];
+    for (const entry of result.staleEntries) {
+        lines.push(`  [${entry.table}] ${entry.slug} — ${entry.filePath}`);
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Dispatch helper — handles the `db` subcommand group
+// ---------------------------------------------------------------------------
+export async function executeBlueprintDbSubcommand(verb, args, options, print) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    switch (verb) {
+        case 'build': {
+            const result = await dbBuild(projectRoot);
+            print(options.json ? result : formatDbBuildResult(result), options.json);
+            return;
+        }
+        case 'query': {
+            const templateId = args[0];
+            if (!templateId) {
+                throw new Error('Usage: wp blueprint db query <template-id> [--params \'{"key":value}\']');
+            }
+            let params = {};
+            if (options.params) {
+                try {
+                    const parsed = JSON.parse(options.params);
+                    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                        throw new Error('--params must be a JSON object');
+                    }
+                    params = parsed;
+                }
+                catch (err) {
+                    throw new Error(`Invalid --params JSON: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            const result = await dbQuery(projectRoot, templateId, params);
+            print(options.json ? result : JSON.stringify(result.rows, null, 2), options.json);
+            return;
+        }
+        case 'verify': {
+            const result = await dbVerify(projectRoot);
+            print(options.json ? result : formatDbVerifyResult(result), options.json);
+            if (!result.ok) {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        case 'browse': {
+            // dbBrowse calls process.exit(1) on error — never throws
+            dbBrowse(projectRoot);
+            return;
+        }
+        default: {
+            throw new Error(`Unknown blueprint db verb: ${verb ?? '(none)'}\n\nUse one of: build, query, verify, browse`);
+        }
+    }
+}
+//# sourceMappingURL=db-commands.js.map

package/dist/esm/cli/commands/blueprint/execution-io.d.ts

@@ -0,0 +1,80 @@
+/**
+ * execution-io.ts — thin I/O layer with injected writers/readers.
+ *
+ * All file system operations live here. The writer/reader parameters default
+ * to the real `node:fs/promises` implementations so callers don't need to
+ * inject anything for production use. Tests pass fakes.
+ *
+ * Tested by execution-io.test.ts.
+ */
+import type { BlueprintExecutionArtifacts, BlueprintExecutionBackend, BlueprintProgressBridgeState, RuntimeStateStatus } from '#index';
+import { type BlueprintExecutionCompletionEvidence } from './execution-state.js';
+export type FileReader = (p: string, enc: BufferEncoding) => Promise<string>;
+export type FileWriter = (p: string, content: string, enc: BufferEncoding) => Promise<void>;
+export type DirMaker = (p: string, options: {
+    recursive: boolean;
+}) => Promise<string | undefined>;
+export type FileRenamer = (from: string, to: string) => Promise<void>;
+export declare function persistBlueprintExecutionMetadata(blueprintPath: string, metadata: {
+    backend: BlueprintExecutionBackend;
+    executionId: string;
+    status: RuntimeStateStatus;
+    updatedAt: string;
+}, writer?: FileWriter, reader?: FileReader): Promise<void>;
+export declare function readBlueprintExecutionState(blueprintPath: string, reader?: FileReader): Promise<import("#index").BlueprintExecutionMetadata | null>;
+export declare function clearBlueprintExecutionState(blueprintPath: string, writer?: FileWriter, reader?: FileReader): Promise<void>;
+export declare function persistBlueprintExecutionArtifacts(blueprintPath: string, evidence: BlueprintExecutionCompletionEvidence, writer?: FileWriter, reader?: FileReader): Promise<void>;
+export declare function readBlueprintExecutionArtifactsState(blueprintPath: string, reader?: FileReader): Promise<BlueprintExecutionArtifacts | null>;
+export declare function persistBlueprintProgressBridgeState(projectRoot: string, bridge: BlueprintProgressBridgeState, runtimeStateRoot?: string, writer?: FileWriter, dirMaker?: DirMaker): Promise<string>;
+export declare function readBlueprintProgressBridgeState(projectRoot: string, backend: BlueprintExecutionBackend, executionId: string, runtimeStateRoot?: string, reader?: FileReader): Promise<BlueprintProgressBridgeState>;
+export declare function writeBlueprintRuntimeSnapshot(projectRoot: string, snapshot: {
+    backend: BlueprintExecutionBackend;
+    executionId: string;
+    status: RuntimeStateStatus;
+    taskId?: string;
+    updatedAt: string;
+}, runtimeStateRoot?: string, writer?: FileWriter, dirMaker?: DirMaker): Promise<string>;
+export declare function readBlueprintRuntimeSnapshot(projectRoot: string, executionId: string, runtimeStateRoot?: string, reader?: FileReader): Promise<{
+    backend: "omx-team" | "omx-pll-interactive" | "claude-subagent" | "codex-exec" | "local-worktree";
+    executionId: string;
+    status: "pending" | "running" | "blocked" | "completed" | "failed" | "stopped";
+    updatedAt: string;
+    evidence?: ({
+        command: string;
+        exit_code: number;
+        result: "pass" | "fail";
+        ts: string;
+        kind: "test";
+        agent?: string | undefined;
+    } | {
+        target_files: string[];
+        command: string;
+        exit_code: number;
+        result: "pass" | "fail";
+        ts: string;
+        kind: "integration";
+        agent?: string | undefined;
+    } | {
+        audit_kind: string;
+        passed: boolean;
+        result: "pass" | "fail";
+        ts: string;
+        kind: "audit";
+        command?: string | undefined;
+        exit_code?: number | undefined;
+        agent?: string | undefined;
+    } | {
+        actor: string;
+        description: string;
+        allow_manual: true;
+        log_excerpt: string;
+        result: "pass" | "fail";
+        ts: string;
+        kind: "manual";
+        agent?: string | undefined;
+    })[] | undefined;
+    taskId?: string | undefined;
+}>;
+export declare function moveBlueprintDirectory(currentDir: string, targetDir: string, targetPath: string, nextMarkdown: string, writer?: FileWriter, dirMaker?: DirMaker, renamer?: FileRenamer): Promise<void>;
+export type { BlueprintExecutionArtifacts };
+//# sourceMappingURL=execution-io.d.ts.map