@interf/compiler 0.7.3 → 0.9.1

package/dist/packages/local-service/runtime.js

@@ -0,0 +1,2841 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { CompileRunSchema, } from "../execution/lib/schema.js";
+import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
+import { compiledRuntimeRunHistoryPath, compiledRuntimeRoot, testRootForCompiled, } from "../compiler/compiled-paths.js";
+import { loadState, } from "../compiler/state.js";
+import { ReadinessStateSchema, RuntimeRunSchema, } from "../compiler/lib/schema.js";
+import { discoverSourceFiles, } from "../compiler/discovery.js";
+import { ensurePortableContextScaffold, readInterfConfig, } from "../project-model/interf.js";
+import { findSourceDatasetConfig, fingerprintReadinessChecks, listSourceDatasetConfigs, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourceDatasetPath, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../project-model/source-config.js";
+import { defaultDatasetNameForPath, listSourceFolderChoices, normalizeSourceDatasetPathForConfig, } from "../project-model/source-folders.js";
+import { datasetLatestTestStatePath, portableContextPath, } from "../project-model/project-paths.js";
+import { getCompiledWorkflow, listCompiledWorkflowChoices, } from "../workflow-package/workflow-definitions.js";
+import { resolveWorkflowPackageSourcePath, } from "../workflow-package/local-workflows.js";
+import { resolveAgent, detectAgents, supportsAutomatedRuns, } from "../agents/lib/detection.js";
+import { AGENTS, } from "../agents/lib/constants.js";
+import { loadUserConfig, saveUserConfig, } from "../agents/lib/user-config.js";
+import { TestRunComparisonSchema, } from "../testing/lib/schema.js";
+import { createCompiledTestTarget, } from "../testing/test-targets.js";
+import { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, DatasetSetupCreateRequestSchema, DatasetResourceSchema, MethodResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, PreparationReadinessStateSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, RunObservabilityResourceSchema, TestRunCreateRequestSchema, TestRunResourceSchema, WorkflowAuthoringCreateRequestSchema, WorkflowAuthoringResultSchema, WorkflowPackageResourceSchema, } from "./lib/schema.js";
+import { buildLocalServiceUrl, } from "./routes.js";
+import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, PreparationSetupActionValuesSchema, } from "./action-values.js";
+function createRunId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function createActionProposalId() {
+    return `action_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonFile(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function compileRunsRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "compile-runs");
+}
+function compileRunPath(compiledPath, runId) {
+    return join(compileRunsRoot(compiledPath), `${runId}.json`);
+}
+function testRunsRoot(compiledPath) {
+    return join(testRootForCompiled(compiledPath), "service-runs");
+}
+function testRunPath(compiledPath, runId) {
+    return join(testRunsRoot(compiledPath), `${runId}.json`);
+}
+function localJobsRoot(rootPath) {
+    return join(rootPath, "interf", ".service", "jobs");
+}
+function localJobPath(rootPath, runId) {
+    return join(localJobsRoot(rootPath), `${runId}.json`);
+}
+function actionProposalsRoot(rootPath) {
+    return join(rootPath, "interf", ".service", "action-proposals");
+}
+function actionProposalPath(rootPath, proposalId) {
+    return join(actionProposalsRoot(rootPath), `${proposalId}.json`);
+}
+function listJsonFiles(dirPath) {
+    if (!existsSync(dirPath))
+        return [];
+    try {
+        if (!statSync(dirPath).isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    return readdirSync(dirPath)
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => join(dirPath, entry));
+}
+function readCompileRunAt(filePath) {
+    const parsed = CompileRunSchema.safeParse(readJsonFile(filePath));
+    return parsed.success ? parsed.data : null;
+}
+function readRuntimeRunHistory(compiledPath) {
+    const historyPath = compiledRuntimeRunHistoryPath(compiledPath);
+    if (!existsSync(historyPath))
+        return [];
+    try {
+        return readFileSync(historyPath, "utf8")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            try {
+                return RuntimeRunSchema.safeParse(JSON.parse(line));
+            }
+            catch {
+                return { success: false };
+            }
+        })
+            .filter((parsed) => parsed.success)
+            .map((parsed) => parsed.data);
+    }
+    catch {
+        return [];
+    }
+}
+function readTestRunAt(filePath) {
+    const parsed = TestRunResourceSchema.safeParse(readJsonFile(filePath));
+    return parsed.success ? parsed.data : null;
+}
+function readLocalJobRunAt(filePath) {
+    const parsed = LocalJobRunResourceSchema.safeParse(readJsonFile(filePath));
+    return parsed.success ? parsed.data : null;
+}
+function readActionProposalAt(filePath) {
+    const parsed = ActionProposalResourceSchema.safeParse(readJsonFile(filePath));
+    return parsed.success ? parsed.data : null;
+}
+function newestFirst(items) {
+    return [...items].sort((left, right) => {
+        const leftTime = Date.parse(left.started_at ?? left.finished_at ?? "");
+        const rightTime = Date.parse(right.started_at ?? right.finished_at ?? "");
+        return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
+    });
+}
+function newestJobFirst(items) {
+    return [...items].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+}
+function newestActionProposalFirst(items) {
+    return [...items].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+}
+function newestCompileFirst(items) {
+    return [...items].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+}
+function configuredAgentName() {
+    const config = loadUserConfig();
+    if (!config)
+        return null;
+    const configured = AGENTS.find((agent) => agent.command === config.agentCommand) ??
+        AGENTS.find((agent) => agent.name === config.agent) ??
+        AGENTS.find((agent) => agent.displayName === config.agent);
+    return configured?.name ?? null;
+}
+function detectedExecutorOptions(currentAgentName) {
+    return detectAgents()
+        .filter(supportsAutomatedRuns)
+        .map((agent) => ({
+        name: agent.name,
+        display_name: agent.displayName,
+        command: agent.command,
+        current: agent.name === currentAgentName,
+    }));
+}
+function uniqueArtifacts(artifacts) {
+    const seen = new Set();
+    const result = [];
+    for (const artifact of artifacts) {
+        const key = `${artifact.role}:${artifact.stage_id ?? ""}:${artifact.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(artifact);
+    }
+    return result;
+}
+function observableRunStatus(status) {
+    if (status === "queued" || status === "pending")
+        return "queued";
+    if (status === "running")
+        return "running";
+    if (status === "failed")
+        return "failed";
+    if (status === "cancelled")
+        return "cancelled";
+    return "succeeded";
+}
+function workflowTraceRunStatus(status) {
+    if (status === "queued" || status === "pending")
+        return "pending";
+    if (status === "running")
+        return "running";
+    if (status === "failed")
+        return "failed";
+    if (status === "cancelled")
+        return "cancelled";
+    return "completed";
+}
+function safeWorkflowNamePart(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._/-]+/g, "-")
+        .replace(/\/+/g, "/")
+        .replace(/^-+|-+$/g, "")
+        || "run";
+}
+function workflowTraceName(runType, name) {
+    return `workflow//./interf/${runType}//${safeWorkflowNamePart(name)}`;
+}
+function workflowStepName(runType, label) {
+    return `step//./interf/${runType}//${safeWorkflowNamePart(label)}`;
+}
+function structuredWorkflowError(message) {
+    return {
+        message: message || "Run failed.",
+        code: "INTERF_RUN_ERROR",
+    };
+}
+function traceEvent(runId, eventType, createdAt, index, eventData, correlationId) {
+    return {
+        runId,
+        eventId: `${runId}:event:${index}`,
+        eventType,
+        specVersion: 1,
+        createdAt: createdAt ?? createRunEventTimestamp(),
+        ...(correlationId ? { correlationId } : {}),
+        ...(eventData === undefined ? {} : { eventData }),
+    };
+}
+function traceStreamChunk(runId, index, createdAt, text, data) {
+    return {
+        streamId: `${runId}:events`,
+        chunkId: `${runId}:events:${index}`,
+        index,
+        createdAt: createdAt ?? createRunEventTimestamp(),
+        text,
+        ...(data === undefined ? {} : { data }),
+    };
+}
+function buildTraceStreamChunks(runId, events) {
+    return events.map((event, index) => traceStreamChunk(runId, index, event.timestamp, JSON.stringify({
+        time: event.timestamp ?? null,
+        type: event.type,
+        scope: event.stage_id ?? event.step_id ?? event.type,
+        message: event.message ?? event.summary ?? event.error ?? event.type,
+    }), event));
+}
+function proofChecksForCompileRun(run) {
+    return run.stages.flatMap((stage) => (stage.latest_proof?.checks ?? []).map((check) => ({
+        ...check,
+        detail: check.detail ?? `${stage.stage_label ?? stage.stage_id} / ${stage.status}`,
+    })));
+}
+function agentLabelForJob(job) {
+    return job.agent?.display_name ?? job.agent?.name ?? null;
+}
+function jobTypeLabelForMetric(type) {
+    if (type === "readiness-check-draft")
+        return "Readiness-check draft";
+    if (type === "method-authoring")
+        return "Method draft";
+    if (type === "method-improvement")
+        return "Method improvement";
+    if (type === "compile")
+        return "Compile";
+    if (type === "test")
+        return "Readiness check";
+    return "Local job";
+}
+function stageArtifactRefs(stageId, artifacts) {
+    return (artifacts ?? []).map((path) => ({
+        path,
+        role: "output",
+        stage_id: stageId,
+        label: path,
+    }));
+}
+function proofForStage(options) {
+    return {
+        id: `${options.runId}-${options.stageId}-proof`,
+        run_id: options.runId,
+        stage_id: options.stageId,
+        generated_at: options.stageState.finished_at ?? new Date().toISOString(),
+        summary: options.summary ?? `${options.stageId} produced stage evidence.`,
+        files_processed: options.stageState.counts?.source_total,
+        artifacts: options.artifacts,
+        checks: [
+            {
+                id: `${options.stageId}-status`,
+                label: "stage completed",
+                ok: options.stageState.status === "succeeded",
+                ...(options.stageState.status === "succeeded"
+                    ? {}
+                    : { detail: options.stageState.summary ?? "Stage did not complete successfully." }),
+            },
+            {
+                id: `${options.stageId}-artifacts`,
+                label: "artifacts recorded",
+                ok: options.artifacts.length > 0,
+                ...(options.artifacts.length > 0
+                    ? {}
+                    : { detail: "No stage artifacts were recorded." }),
+            },
+        ],
+    };
+}
+function logsForStageRun(stageState) {
+    const runId = stageState?.run_id;
+    if (!runId)
+        return undefined;
+    return {
+        prompt_path: `.interf/runtime/logs/${runId}.prompt.txt`,
+        event_stream_path: `.interf/runtime/logs/${runId}.events.ndjson`,
+        status_path: `.interf/runtime/logs/${runId}.status.log`,
+        contract_path: `.interf/runtime/logs/${runId}.stage-contract.json`,
+    };
+}
+function logsForRuntimeRun(run) {
+    if (!run)
+        return undefined;
+    return {
+        ...(run.logs?.prompt_path ? { prompt_path: run.logs.prompt_path } : {}),
+        ...(run.logs?.event_stream_path ? { event_stream_path: run.logs.event_stream_path } : {}),
+        ...(run.logs?.status_path ? { status_path: run.logs.status_path } : {}),
+        contract_path: run.contract_path,
+    };
+}
+function stageTracePayload(stage) {
+    return {
+        status: stage.status,
+        ...(stage.summary ? { summary: stage.summary } : {}),
+        ...(stage.artifacts.length > 0 ? { artifacts: stage.artifacts } : {}),
+        ...(stage.logs ? { logs: stage.logs } : {}),
+        ...(stage.latest_proof ? { proof: stage.latest_proof } : {}),
+    };
+}
+function timestampKey(value) {
+    const parsed = Date.parse(value ?? "");
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function applyEventToCompileRun(run, event) {
+    const now = event.timestamp;
+    const stageFor = (stageId) => {
+        const existing = run.stages.find((stage) => stage.stage_id === stageId);
+        if (existing)
+            return existing;
+        const created = {
+            run_id: run.run_id,
+            stage_id: stageId,
+            status: "queued",
+            artifacts: [],
+        };
+        run.stages.push(created);
+        return created;
+    };
+    const updateStage = (stageId, patch) => {
+        const current = stageFor(stageId);
+        Object.assign(current, patch);
+    };
+    switch (event.type) {
+        case "run.started":
+            return {
+                ...run,
+                status: "running",
+                started_at: run.started_at ?? now,
+                events: [...run.events, event],
+            };
+        case "stage.started":
+            updateStage(event.stage_id, {
+                status: "running",
+                started_at: now,
+                stage_index: event.stage_index,
+                stage_total: event.stage_total,
+            });
+            break;
+        case "artifact.written": {
+            const stage = stageFor(event.stage_id);
+            updateStage(event.stage_id, {
+                artifacts: uniqueArtifacts([...(stage.artifacts ?? []), event.artifact]),
+            });
+            break;
+        }
+        case "proof.updated":
+            if (event.stage_id) {
+                updateStage(event.stage_id, {
+                    latest_proof: event.proof,
+                });
+            }
+            return {
+                ...run,
+                latest_proof: event.proof,
+                events: [...run.events, event],
+            };
+        case "log.appended":
+            break;
+        case "stage.passed":
+            updateStage(event.stage_id, {
+                status: "succeeded",
+                finished_at: now,
+                summary: event.summary ?? null,
+                failure: null,
+            });
+            break;
+        case "stage.failed":
+            updateStage(event.stage_id, {
+                status: "failed",
+                finished_at: now,
+                summary: event.error,
+                failure: event.error,
+            });
+            break;
+        case "run.completed":
+            return {
+                ...run,
+                status: "succeeded",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
+        case "run.failed":
+            return {
+                ...run,
+                status: "failed",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
+        default:
+            break;
+    }
+    return {
+        ...run,
+        events: [...run.events, event],
+    };
+}
+function applyEventToLocalJob(run, event) {
+    const stepFor = (stepId) => {
+        const existing = run.steps.find((step) => step.id === stepId);
+        if (existing)
+            return existing;
+        const created = {
+            id: stepId,
+            label: stepId,
+            status: "queued",
+        };
+        run.steps.push(created);
+        return created;
+    };
+    const updateStep = (stepId, patch) => {
+        if (!stepId)
+            return;
+        Object.assign(stepFor(stepId), patch);
+    };
+    switch (event.type) {
+        case "job.started":
+            return {
+                ...run,
+                status: "running",
+                started_at: run.started_at ?? event.timestamp,
+                events: [...run.events, event],
+            };
+        case "step.started":
+            updateStep(event.step_id, {
+                status: "running",
+                started_at: event.timestamp,
+                ...(event.input ? { input: event.input } : {}),
+            });
+            break;
+        case "step.completed":
+            updateStep(event.step_id, {
+                status: "succeeded",
+                finished_at: event.timestamp,
+                summary: event.message ?? null,
+                ...(event.output ? { output: event.output } : {}),
+            });
+            break;
+        case "step.failed":
+            updateStep(event.step_id, {
+                status: "failed",
+                finished_at: event.timestamp,
+                summary: event.message ?? null,
+                ...(event.output ? { output: event.output } : {}),
+            });
+            break;
+        case "job.completed":
+            return {
+                ...run,
+                status: "succeeded",
+                finished_at: run.finished_at ?? event.timestamp,
+                events: [...run.events, event],
+            };
+        case "job.failed":
+            return {
+                ...run,
+                status: "failed",
+                finished_at: run.finished_at ?? event.timestamp,
+                error: event.message ?? "Job failed.",
+                events: [...run.events, event],
+            };
+        case "artifact.written":
+        case "log.appended":
+            break;
+        default:
+            break;
+    }
+    return {
+        ...run,
+        events: [...run.events, event],
+    };
+}
+function compileRunToObservability(run) {
+    const artifacts = uniqueArtifacts(run.stages.flatMap((stage) => stage.artifacts));
+    const proof = proofChecksForCompileRun(run);
+    const executor = run.stages.find((stage) => stage.executor)?.executor ?? null;
+    const traceStatus = workflowTraceRunStatus(run.status);
+    const workflowName = workflowTraceName("compile", run.method);
+    const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? run.started_at ?? run.created_at
+        : undefined);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(run.run_id, "run_created", run.created_at, eventIndex++, {
+            deploymentId: "local-interf",
+            workflowName,
+            input: {
+                kind: "compile",
+                preparation: run.preparation,
+                method: run.method,
+                source_path: run.source_path,
+            },
+            executionContext: {
+                backend: run.backend,
+                executor,
+            },
+        }),
+    ];
+    if (run.started_at) {
+        events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
+            workflowName,
+            input: {
+                preparation: run.preparation,
+                method: run.method,
+            },
+            executionContext: {
+                backend: run.backend,
+                executor,
+            },
+        }));
+    }
+    for (const stage of run.stages) {
+        const stepName = workflowStepName("compile", stage.stage_label ?? stage.stage_id);
+        const stepCreatedAt = stage.started_at ?? run.started_at ?? run.created_at;
+        events.push(traceEvent(run.run_id, "step_created", stepCreatedAt, eventIndex++, {
+            stepName,
+            input: {
+                stage_id: stage.stage_id,
+                stage_label: stage.stage_label ?? null,
+                stage_index: stage.stage_index ?? null,
+                stage_total: stage.stage_total ?? null,
+                reads: stage.contract?.reads ?? [],
+                writes: stage.contract?.writes ?? [],
+                acceptance: stage.contract?.acceptance ?? null,
+                executor: stage.executor ?? null,
+            },
+        }, stage.stage_id));
+        if (stage.started_at || stage.status !== "queued") {
+            events.push(traceEvent(run.run_id, "step_started", stage.started_at ?? stepCreatedAt, eventIndex++, {
+                attempt: 1,
+            }, stage.stage_id));
+        }
+        if (stage.status === "failed") {
+            events.push(traceEvent(run.run_id, "step_failed", stage.finished_at ?? run.finished_at ?? stepCreatedAt, eventIndex++, {
+                error: structuredWorkflowError(stage.failure ?? stage.summary),
+                output: stageTracePayload(stage),
+            }, stage.stage_id));
+        }
+        else if (stage.status === "succeeded" || stage.status === "skipped") {
+            events.push(traceEvent(run.run_id, "step_completed", stage.finished_at ?? run.finished_at ?? stepCreatedAt, eventIndex++, {
+                result: stageTracePayload(stage),
+            }, stage.stage_id));
+        }
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
+            output: {
+                portable_context_path: run.portable_context_path,
+                artifacts,
+                proof,
+                latest_proof: run.latest_proof ?? null,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(run.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredWorkflowError(run.stages.find((stage) => stage.failure)?.failure ?? run.latest_proof?.summary),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(run.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: run.run_id,
+        run_type: "compile",
+        title: `Prepare ${run.preparation}`,
+        status: observableRunStatus(run.status),
+        preparation: run.preparation,
+        method: run.method,
+        source_path: run.source_path,
+        output_path: run.portable_context_path,
+        executor,
+        agent_label: executor?.display_name ?? run.backend,
+        created_at: run.created_at,
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        metrics: [
+            { label: "Preparation", value: run.preparation },
+            { label: "Method", value: run.method },
+            { label: "Executor", value: executor?.display_name ?? run.backend },
+            { label: "Stages", value: `${run.stages.filter((stage) => stage.status === "succeeded").length}/${run.stages.length}` },
+            { label: "Proof", value: `${proof.filter((check) => check.ok).length}/${proof.length}` },
+            { label: "Artifacts", value: String(artifacts.length) },
+        ],
+        artifacts,
+        proof,
+        trace: {
+            run: {
+                runId: run.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                workflowName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: "compile",
+                    preparation: run.preparation,
+                    method: run.method,
+                    backend: run.backend,
+                    executor,
+                },
+                input: {
+                    preparation: run.preparation,
+                    method: run.method,
+                    source_path: run.source_path,
+                },
+                ...(traceStatus === "completed"
+                    ? {
+                        output: {
+                            portable_context_path: run.portable_context_path,
+                            artifacts,
+                            proof,
+                        },
+                    }
+                    : {}),
+                ...(traceStatus === "failed" ? { error: structuredWorkflowError(run.stages.find((stage) => stage.failure)?.failure) } : {}),
+                ...(run.started_at ? { startedAt: run.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: run.created_at,
+                updatedAt: completedAt ?? run.started_at ?? run.created_at,
+            },
+            events,
+            streams: buildTraceStreamChunks(run.run_id, run.events),
+        },
+    });
+}
+function testRunToObservability(run) {
+    const traceStatus = workflowTraceRunStatus(run.status);
+    const title = `Check readiness ${run.preparation}`;
+    const workflowName = workflowTraceName("test", title);
+    const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? run.started_at ?? new Date().toISOString()
+        : undefined);
+    const raw = run.comparison?.raw ?? null;
+    const compiled = run.comparison?.compiled ?? null;
+    const proofCandidates = [
+        raw
+            ? {
+                id: `${run.run_id}-source-files`,
+                label: "source files baseline",
+                ok: raw.ok ?? raw.passed_cases === raw.total_cases,
+                detail: `${raw.passed_cases}/${raw.total_cases} checks`,
+            }
+            : null,
+        compiled
+            ? {
+                id: `${run.run_id}-portable-context`,
+                label: "portable context",
+                ok: compiled.ok ?? compiled.passed_cases === compiled.total_cases,
+                detail: `${compiled.passed_cases}/${compiled.total_cases} checks`,
+            }
+            : null,
+    ];
+    const proof = proofCandidates.filter((value) => value !== null);
+    const artifacts = uniqueArtifacts([
+        ...(raw?.run_path ? [{ path: raw.run_path, role: "test", label: "source files readiness run" }] : []),
+        ...(compiled?.run_path ? [{ path: compiled.run_path, role: "test", label: "portable context readiness run" }] : []),
+    ]);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(run.run_id, "run_created", run.started_at, eventIndex++, {
+            deploymentId: "local-interf",
+            workflowName,
+            input: {
+                kind: "test",
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+        }),
+    ];
+    if (run.started_at) {
+        events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
+            workflowName,
+            input: {
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+        }));
+    }
+    const targetStepCandidates = [
+        raw
+            ? {
+                id: "source-files-baseline",
+                label: "Source files baseline",
+                status: raw.ok ?? raw.passed_cases === raw.total_cases ? "succeeded" : "failed",
+                input: raw.target ?? { type: "source-files", path: run.source_path ?? null },
+                output: raw,
+            }
+            : null,
+        compiled
+            ? {
+                id: "portable-context-check",
+                label: "Portable context",
+                status: compiled.ok ?? compiled.passed_cases === compiled.total_cases ? "succeeded" : "failed",
+                input: compiled.target ?? { type: "portable-context", path: run.portable_context_path ?? null },
+                output: compiled,
+            }
+            : null,
+    ];
+    const targetSteps = targetStepCandidates.filter((value) => value !== null);
+    if (targetSteps.length === 0) {
+        targetSteps.push({
+            id: "check-readiness",
+            label: "Run readiness checks",
+            status: run.status === "failed" ? "failed" : "succeeded",
+            input: {
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+            output: run.comparison ?? null,
+        });
+    }
+    for (const step of targetSteps) {
+        const timestamp = run.started_at ?? run.finished_at ?? new Date().toISOString();
+        events.push(traceEvent(run.run_id, "step_created", timestamp, eventIndex++, {
+            stepName: workflowStepName("test", step.label),
+            input: step.input,
+        }, step.id));
+        events.push(traceEvent(run.run_id, "step_started", timestamp, eventIndex++, {
+            attempt: 1,
+        }, step.id));
+        events.push(traceEvent(run.run_id, step.status === "failed" ? "step_failed" : "step_completed", run.finished_at ?? timestamp, eventIndex++, step.status === "failed"
+            ? { error: structuredWorkflowError(run.error ?? `${step.label} did not pass.`), output: step.output }
+            : { result: step.output }, step.id));
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
+            output: {
+                comparison: run.comparison,
+                proof,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(run.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredWorkflowError(run.error),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(run.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: run.run_id,
+        run_type: "test",
+        title,
+        status: observableRunStatus(run.status),
+        preparation: run.preparation,
+        method: compiled?.target?.workflow ?? null,
+        source_path: run.source_path ?? null,
+        output_path: run.portable_context_path ?? null,
+        created_at: run.started_at ?? completedAt ?? new Date().toISOString(),
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        metrics: [
+            { label: "Preparation", value: run.preparation },
+            { label: "Mode", value: run.mode },
+            { label: "Readiness checks", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : raw ? `${raw.passed_cases}/${raw.total_cases}` : "0/0" },
+            { label: "Source files", value: raw ? `${raw.passed_cases}/${raw.total_cases}` : "-" },
+            { label: "Portable context", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : "-" },
+        ],
+        artifacts,
+        proof,
+        trace: {
+            run: {
+                runId: run.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                workflowName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: "test",
+                    preparation: run.preparation,
+                    mode: run.mode,
+                },
+                input: {
+                    preparation: run.preparation,
+                    mode: run.mode,
+                    source_path: run.source_path ?? null,
+                    portable_context_path: run.portable_context_path ?? null,
+                },
+                ...(traceStatus === "completed" ? { output: { comparison: run.comparison, proof } } : {}),
+                ...(traceStatus === "failed" ? { error: structuredWorkflowError(run.error) } : {}),
+                ...(run.started_at ? { startedAt: run.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: run.started_at ?? completedAt ?? new Date().toISOString(),
+                updatedAt: completedAt ?? run.started_at ?? new Date().toISOString(),
+            },
+            events,
+            streams: buildTraceStreamChunks(run.run_id, run.events ?? []),
+        },
+    });
+}
+function jobRunToObservability(job) {
+    const runType = (job.job_type === "preparation-setup" ||
+        job.job_type === "readiness-check-draft" ||
+        job.job_type === "method-authoring" ||
+        job.job_type === "method-improvement"
+        ? job.job_type
+        : "job");
+    const executor = job.agent
+        ? {
+            kind: "local-agent",
+            name: job.agent.name,
+            display_name: job.agent.display_name,
+            command: job.agent.command ?? null,
+        }
+        : null;
+    const traceStatus = workflowTraceRunStatus(job.status);
+    const workflowName = workflowTraceName(runType, job.title);
+    const completedAt = job.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? job.started_at ?? job.created_at
+        : undefined);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(job.run_id, "run_created", job.created_at, eventIndex++, {
+            deploymentId: "local-interf",
+            workflowName,
+            input: {
+                job_type: job.job_type,
+                preparation: job.preparation ?? null,
+                method: job.method ?? null,
+            },
+            executionContext: {
+                executor,
+            },
+        }),
+    ];
+    if (job.started_at) {
+        events.push(traceEvent(job.run_id, "run_started", job.started_at, eventIndex++, {
+            workflowName,
+            input: {
+                job_type: job.job_type,
+                preparation: job.preparation ?? null,
+            },
+            executionContext: {
+                executor,
+            },
+        }));
+    }
+    for (const step of job.steps) {
+        const timestamp = step.started_at ?? job.started_at ?? job.created_at;
+        events.push(traceEvent(job.run_id, "step_created", timestamp, eventIndex++, {
+            stepName: workflowStepName(runType, step.label),
+            input: step.input ?? {
+                step_id: step.id,
+                label: step.label,
+            },
+        }, step.id));
+        if (step.started_at || step.status !== "queued") {
+            events.push(traceEvent(job.run_id, "step_started", step.started_at ?? timestamp, eventIndex++, {
+                attempt: 1,
+            }, step.id));
+        }
+        if (step.status === "failed") {
+            events.push(traceEvent(job.run_id, "step_failed", step.finished_at ?? completedAt ?? timestamp, eventIndex++, {
+                error: structuredWorkflowError(step.summary ?? job.error),
+                output: step.output ?? null,
+            }, step.id));
+        }
+        else if (step.status === "succeeded") {
+            events.push(traceEvent(job.run_id, "step_completed", step.finished_at ?? completedAt ?? timestamp, eventIndex++, {
+                result: step.output ?? {
+                    summary: step.summary ?? null,
+                },
+            }, step.id));
+        }
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(job.run_id, "run_completed", completedAt, eventIndex++, {
+            output: job.result ?? {
+                output_path: job.output_path ?? null,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(job.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredWorkflowError(job.error),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(job.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    const outputPath = job.output_path ?? (typeof job.result?.path === "string" ? job.result.path : null);
+    const artifacts = uniqueArtifacts(outputPath ? [{ path: outputPath, role: "output" }] : []);
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: job.run_id,
+        run_type: runType,
+        title: job.title,
+        status: observableRunStatus(job.status),
+        preparation: job.preparation ?? null,
+        method: job.method ?? null,
+        source_path: job.source_path ?? null,
+        output_path: outputPath,
+        executor,
+        agent_label: agentLabelForJob(job),
+        created_at: job.created_at,
+        started_at: job.started_at ?? null,
+        finished_at: job.finished_at ?? null,
+        metrics: [
+            { label: "Kind", value: jobTypeLabelForMetric(job.job_type) },
+            { label: "Executor", value: agentLabelForJob(job) ?? "local executor" },
+            { label: "Phases", value: `${job.steps.filter((step) => step.status === "succeeded").length}/${job.steps.length}` },
+            { label: "Preparation", value: job.preparation ?? "-" },
+            { label: "Method", value: job.method ?? "-" },
+        ],
+        artifacts,
+        proof: [],
+        trace: {
+            run: {
+                runId: job.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                workflowName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: runType,
+                    job_type: job.job_type,
+                    preparation: job.preparation ?? null,
+                    method: job.method ?? null,
+                    executor,
+                },
+                input: {
+                    job_type: job.job_type,
+                    preparation: job.preparation ?? null,
+                    method: job.method ?? null,
+                    source_path: job.source_path ?? null,
+                },
+                ...(traceStatus === "completed" ? { output: job.result ?? { output_path: outputPath } } : {}),
+                ...(traceStatus === "failed" ? { error: structuredWorkflowError(job.error) } : {}),
+                ...(job.started_at ? { startedAt: job.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: job.created_at,
+                updatedAt: completedAt ?? job.started_at ?? job.created_at,
+            },
+            events,
+            streams: buildTraceStreamChunks(job.run_id, job.events),
+        },
+    });
+}
+function slugFromText(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 42)
+        .replace(/-+$/g, "");
+    return slug || "custom";
+}
+function stringValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function numberValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function testModeFromValues(values) {
+    const value = stringValue(values, "mode") ?? stringValue(values, "target");
+    return value === "raw" || value === "compiled" || value === "both" ? value : null;
+}
+function testModeValue(values, defaultMode = "both") {
+    return testModeFromValues(values) ?? defaultMode;
+}
+function workflowIdForProposal(message, values) {
+    const explicit = stringValue(values, "method_id") ??
+        stringValue(values, "method");
+    return explicit ?? `custom-${slugFromText(message)}`;
+}
+function actionValueMethodTaskPrompt(values) {
+    const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
+    return parsed.success ? methodAuthoringTaskPrompt(parsed.data) : null;
+}
+function datasetSetupPathValue(values) {
+    return stringValue(values, "path") ??
+        stringValue(values, "source_folder_path") ??
+        stringValue(values, "source_path") ??
+        stringValue(values, "source_folder") ??
+        stringValue(values, "folder");
+}
+function datasetSetupNameValue(values) {
+    const parsed = PreparationSetupActionValuesSchema.safeParse(values);
+    return parsed.success ? parsed.data.name : stringValue(values, "name") ??
+        stringValue(values, "preparation") ??
+        stringValue(values, "preparation_name");
+}
+function actionCommandPreview(actionType, datasetName, workflowId, values) {
+    if (actionType === "preparation-setup") {
+        const datasetPart = datasetName ? ` # Preparation: ${datasetName}` : "";
+        const pathPart = datasetSetupPathValue(values);
+        return pathPart ? `interf init # source: ${pathPart}${datasetPart}` : `interf init${datasetPart}`;
+    }
+    if (actionType === "compile") {
+        const workflowSuffix = workflowId ? ` # Method: ${workflowId}` : "";
+        return datasetName
+            ? `interf compile --preparation ${datasetName}${workflowSuffix}`
+            : `interf compile${workflowSuffix}`;
+    }
+    if (actionType === "test") {
+        const mode = testModeValue(values);
+        return datasetName
+            ? `interf test --preparation ${datasetName} --target ${mode}`
+            : `interf test --target ${mode}`;
+    }
+    if (actionType === "readiness-check-draft") {
+        return "interf # choose Auto-create readiness checks";
+    }
+    if (actionType === "method-authoring" || actionType === "method-improvement") {
+        return "interf create method";
+    }
+    return "Try: create a Preparation, prepare, check readiness, draft readiness checks, or draft a Method.";
+}
+function hasCompiledTestTarget(sourcePath, datasetConfig) {
+    const compiledPath = portableContextPath(sourcePath, datasetConfig.name);
+    if (!existsSync(compiledPath))
+        return false;
+    return createCompiledTestTarget(compiledPath, datasetConfig.name, methodIdForSourcePreparationConfig(datasetConfig) ?? "interf").eligible;
+}
+function actionAssistantMessage(actionType, datasetName, commandPreview) {
+    const datasetSuffix = datasetName ? ` for Preparation "${datasetName}"` : "";
+    if (actionType === "preparation-setup") {
+        return `Interf prepared a Preparation setup proposal${datasetSuffix}. Approve to save the source folder and create the portable-context scaffold. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "compile") {
+        return `Interf prepared a prepare-run proposal${datasetSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "test") {
+        return `Interf prepared a readiness-check proposal${datasetSuffix}. Approve to run the requested target against saved readiness checks. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "readiness-check-draft") {
+        return `Interf prepared a readiness-check draft proposal${datasetSuffix}. Approve to ask the configured local executor to draft checks as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "method-authoring" || actionType === "method-improvement") {
+        return `Interf prepared a Method draft proposal${datasetSuffix}. Approve to draft a reusable local Method as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    return "I could not map that to a safe Interf action. Ask for one action in plain English, such as create a Preparation, prepare the data, check readiness, draft readiness checks, or draft a Method.";
+}
+function passRate(passed, total) {
+    if (total <= 0)
+        return null;
+    return Math.round((passed / total) * 100);
+}
+function readinessTargetResult(summary, currentFingerprint, comparisonFingerprint) {
+    if (!summary)
+        return null;
+    const resultFingerprint = comparisonFingerprint ?? null;
+    return {
+        passed: summary.passed_cases,
+        total: summary.total_cases,
+        pass_rate: passRate(summary.passed_cases, summary.total_cases),
+        checks_fingerprint: resultFingerprint,
+        stale: Boolean(currentFingerprint && resultFingerprint && currentFingerprint !== resultFingerprint),
+        run_id: null,
+        run_path: summary.run_path,
+    };
+}
+function readinessSummaryForStatus(status) {
+    if (status === "ready")
+        return "Ready for agent work.";
+    if (status === "not-ready")
+        return "Readiness checks did not pass.";
+    if (status === "stale")
+        return "Readiness checks are stale for the current saved checks.";
+    if (status === "checking")
+        return "Readiness checks are running.";
+    if (status === "building")
+        return "Portable context is building.";
+    if (status === "built")
+        return "Portable context is built; readiness has not been proven yet.";
+    if (status === "not-built")
+        return "Portable context has not been built yet.";
+    if (status === "not-configured")
+        return "No readiness checks are configured.";
+    return "Latest preparation failed.";
+}
+function readinessStateToPreparationReadiness(readiness) {
+    return PreparationReadinessStateSchema.parse({
+        ...readiness,
+        checks: readiness.checks.map((check) => ({ ...check })),
+    });
+}
+function datasetResourceToPreparationResource(rootPath, resource) {
+    const latestCompileRunId = resource.latest_compile_run_id ?? null;
+    const latestTestRunId = resource.latest_test_run_id ?? null;
+    const methodId = methodIdForSourcePreparationConfig(resource.dataset);
+    return PreparationResourceSchema.parse({
+        id: resource.dataset.name,
+        name: resource.dataset.name,
+        preparation: resource.dataset,
+        source_path: resolveSourceDatasetPath(rootPath, resource.dataset),
+        method_id: methodId,
+        checks: resource.dataset.checks,
+        portable_context: {
+            preparation: resource.dataset.name,
+            path: resource.portable_context_path,
+            exists: resource.portable_context_path !== null,
+            method_id: methodId,
+            latest_compile_run_id: latestCompileRunId,
+            latest_test_run_id: latestTestRunId,
+        },
+        portable_context_path: resource.portable_context_path,
+        readiness: readinessStateToPreparationReadiness(resource.readiness),
+        runs: {
+            latest_compile_run_id: latestCompileRunId,
+            latest_test_run_id: latestTestRunId,
+        },
+        latest_compile_run_id: latestCompileRunId,
+        latest_test_run_id: latestTestRunId,
+    });
+}
+function workflowPackageResourceToMethodResource(resource) {
+    return MethodResourceSchema.parse({
+        id: resource.id,
+        method_id: resource.id,
+        path: resource.path,
+        ...(resource.label ? { label: resource.label } : {}),
+        ...(resource.hint ? { hint: resource.hint } : {}),
+        source_kind: resource.source_kind,
+        built_in: resource.built_in,
+        active_for_preparations: resource.active_for_datasets,
+        stages: resource.stages,
+    });
+}
+export class LocalServiceRuntime {
+    rootPath;
+    host;
+    port;
+    startedAt;
+    packageVersion;
+    handlers;
+    constructor(options) {
+        this.rootPath = resolve(options.rootPath);
+        this.host = options.host;
+        this.port = options.port;
+        this.startedAt = options.startedAt ?? new Date().toISOString();
+        this.packageVersion = options.packageVersion;
+        this.handlers = options.handlers ?? {};
+    }
+    health() {
+        const sourceFolderPath = resolveConfiguredSourceFolderPath(this.rootPath);
+        return LocalServiceHealthSchema.parse({
+            kind: "interf-local-service-health",
+            version: 1,
+            status: "ok",
+            host: this.host,
+            port: this.port,
+            service_url: buildLocalServiceUrl({ host: this.host, port: this.port }),
+            control_path: this.rootPath,
+            source_folder_path: sourceFolderPath,
+            started_at: this.startedAt,
+            ...(this.packageVersion ? { package_version: this.packageVersion } : {}),
+        });
+    }
+    listDatasets() {
+        const config = loadSourceFolderConfig(this.rootPath);
+        return listSourceDatasetConfigs(config).map((dataset) => {
+            const compileRuns = this.listCompileRunsForDataset(dataset.name);
+            const testRuns = this.listTestRunsForDataset(dataset.name);
+            const path = portableContextPath(this.rootPath, dataset.name);
+            const readiness = this.computeDatasetReadiness(dataset);
+            return DatasetResourceSchema.parse({
+                dataset,
+                portable_context_path: existsSync(path) ? path : null,
+                readiness,
+                latest_compile_run_id: compileRuns[0]?.run_id ?? null,
+                latest_test_run_id: testRuns[0]?.run_id ?? null,
+            });
+        });
+    }
+    getDataset(datasetName) {
+        return this.listDatasets().find((dataset) => dataset.dataset.name === datasetName) ?? null;
+    }
+    listPreparations() {
+        return this.listDatasets().map((resource) => datasetResourceToPreparationResource(this.rootPath, resource));
+    }
+    getPreparation(preparationName) {
+        const dataset = this.getDataset(preparationName);
+        return dataset ? datasetResourceToPreparationResource(this.rootPath, dataset) : null;
+    }
+    listPreparationReadiness() {
+        return this.listReadiness().map(readinessStateToPreparationReadiness);
+    }
+    getPreparationReadiness(preparationName) {
+        const readiness = this.getReadiness(preparationName);
+        return readiness ? readinessStateToPreparationReadiness(readiness) : null;
+    }
+    listReadiness() {
+        const config = loadSourceFolderConfig(this.rootPath);
+        return listSourceDatasetConfigs(config).map((dataset) => this.computeDatasetReadiness(dataset));
+    }
+    getReadiness(datasetName) {
+        const dataset = findSourceDatasetConfig(loadSourceFolderConfig(this.rootPath), datasetName);
+        return dataset ? this.computeDatasetReadiness(dataset) : null;
+    }
+    computeDatasetReadiness(dataset) {
+        const generatedAt = new Date().toISOString();
+        const compiledPath = portableContextPath(this.rootPath, dataset.name);
+        const contextExists = existsSync(compiledPath);
+        const compileRun = this.listCompileRunsForDataset(dataset.name)[0] ?? null;
+        const testRun = this.listTestRunsForDataset(dataset.name)[0] ?? null;
+        const comparison = testRun?.comparison ?? this.readLatestComparison(dataset.name);
+        const configuredChecks = dataset.checks.length;
+        const currentFingerprint = configuredChecks > 0 ? fingerprintReadinessChecks(dataset.checks) : null;
+        const comparisonFingerprint = comparison?.checks_fingerprint ?? null;
+        const sourceResult = readinessTargetResult(comparison?.raw, currentFingerprint, comparisonFingerprint);
+        const contextResult = readinessTargetResult(comparison?.compiled, currentFingerprint, comparisonFingerprint);
+        const checksStale = Boolean(currentFingerprint && comparisonFingerprint && currentFingerprint !== comparisonFingerprint);
+        const compileCheck = (() => {
+            if (!compileRun) {
+                return {
+                    gate: "compile-run",
+                    ok: false,
+                    status: "not-built",
+                    summary: "No compile run has built portable context yet.",
+                    artifact_path: contextExists ? compiledPath : null,
+                };
+            }
+            if (compileRun.status === "succeeded") {
+                return {
+                    gate: "compile-run",
+                    ok: contextExists,
+                    status: contextExists ? "built" : "failed",
+                    summary: contextExists
+                        ? "Latest compile run built portable context."
+                        : "Latest compile run finished, but portable context is missing.",
+                    run_id: compileRun.run_id,
+                    artifact_path: contextExists ? compiledPath : null,
+                };
+            }
+            if (compileRun.status === "queued" || compileRun.status === "running") {
+                return {
+                    gate: "compile-run",
+                    ok: false,
+                    status: "building",
+                    summary: "Latest compile run is still building portable context.",
+                    run_id: compileRun.run_id,
+                    artifact_path: contextExists ? compiledPath : null,
+                };
+            }
+            return {
+                gate: "compile-run",
+                ok: false,
+                status: "failed",
+                summary: compileRun.status === "cancelled"
+                    ? "Latest compile run was cancelled."
+                    : "Latest compile run failed.",
+                run_id: compileRun.run_id,
+                artifact_path: contextExists ? compiledPath : null,
+            };
+        })();
+        const checks = [
+            {
+                gate: "preparation-config",
+                ok: true,
+                summary: "Preparation is saved in this control plane folder.",
+            },
+            {
+                gate: "portable-context",
+                ok: contextExists,
+                status: contextExists ? "built" : "not-built",
+                summary: contextExists
+                    ? "Portable context folder exists."
+                    : "Portable context folder has not been created.",
+                artifact_path: contextExists ? compiledPath : null,
+            },
+            compileCheck,
+            {
+                gate: "readiness-checks",
+                ok: configuredChecks > 0,
+                status: configuredChecks > 0 ? "built" : "not-configured",
+                summary: configuredChecks > 0
+                    ? `${configuredChecks} readiness check${configuredChecks === 1 ? "" : "s"} configured.`
+                    : "No readiness checks are configured.",
+            },
+            {
+                gate: "checks-current",
+                ok: !checksStale,
+                status: checksStale ? "stale" : "built",
+                summary: checksStale
+                    ? "Latest readiness result is stale for the current saved checks."
+                    : "Latest readiness result matches the current saved checks.",
+            },
+        ];
+        const status = (() => {
+            if (compileRun?.status === "queued" || compileRun?.status === "running")
+                return "building";
+            if (testRun?.status === "queued" || testRun?.status === "running")
+                return "checking";
+            if (compileRun?.status === "failed" || compileRun?.status === "cancelled")
+                return "failed";
+            if (!compileRun || !contextExists)
+                return "not-built";
+            if (configuredChecks === 0)
+                return "not-configured";
+            if (checksStale)
+                return "stale";
+            if (!contextResult)
+                return "built";
+            return contextResult.total > 0 && contextResult.passed === contextResult.total ? "ready" : "not-ready";
+        })();
+        const ready = status === "ready";
+        return ReadinessStateSchema.parse({
+            kind: "interf-readiness-state",
+            version: 1,
+            generated_at: generatedAt,
+            preparation: dataset.name,
+            status,
+            ready,
+            summary: readinessSummaryForStatus(status),
+            portable_context_path: contextExists ? compiledPath : null,
+            latest_compile_run_id: compileRun?.run_id ?? null,
+            latest_test_run_id: testRun?.run_id ?? null,
+            compile: compileCheck,
+            check_results: {
+                configured: configuredChecks,
+                fingerprint: currentFingerprint,
+                source_files: sourceResult,
+                portable_context: contextResult,
+                delta: comparison?.summary.pass_rate_delta ?? null,
+            },
+            checks,
+        });
+    }
+    listSourceFiles(datasetName) {
+        const datasets = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath))
+            .filter((dataset) => !datasetName || dataset.name === datasetName);
+        return datasets.flatMap((dataset) => {
+            const sourceFolderPath = resolveSourceDatasetPath(this.rootPath, dataset);
+            const compiledPath = portableContextPath(this.rootPath, dataset.name);
+            return discoverSourceFiles(sourceFolderPath, compiledPath).sourceFiles.map((relativePath) => {
+                const absolutePath = join(sourceFolderPath, relativePath);
+                let sizeBytes = 0;
+                let modifiedAt = null;
+                try {
+                    const stat = statSync(absolutePath);
+                    sizeBytes = stat.size;
+                    modifiedAt = stat.mtime.toISOString();
+                }
+                catch {
+                    sizeBytes = 0;
+                    modifiedAt = null;
+                }
+                return SourceFileResourceSchema.parse({
+                    preparation: dataset.name,
+                    path: relativePath,
+                    absolute_path: absolutePath,
+                    size_bytes: sizeBytes,
+                    modified_at: modifiedAt,
+                    source_folder_path: sourceFolderPath,
+                });
+            });
+        });
+    }
+    listWorkspaceFiles() {
+        const sourceFolderPath = resolveConfiguredSourceFolderPath(this.rootPath) ?? this.rootPath;
+        return discoverSourceFiles(sourceFolderPath, join(this.rootPath, "interf")).sourceFiles.map((relativePath) => {
+            const absolutePath = join(sourceFolderPath, relativePath);
+            let sizeBytes = 0;
+            let modifiedAt = null;
+            try {
+                const stat = statSync(absolutePath);
+                sizeBytes = stat.size;
+                modifiedAt = stat.mtime.toISOString();
+            }
+            catch {
+                sizeBytes = 0;
+                modifiedAt = null;
+            }
+            return WorkspaceFileResourceSchema.parse({
+                path: relativePath,
+                absolute_path: absolutePath,
+                size_bytes: sizeBytes,
+                modified_at: modifiedAt,
+            });
+        });
+    }
+    listWorkflowPackages() {
+        const datasets = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath));
+        const choices = listCompiledWorkflowChoices(this.rootPath);
+        const hasLocalDefault = choices.some((workflow) => workflow.scope === "local" && workflow.id === "interf-default");
+        const implicitDefaultWorkflowId = hasLocalDefault ? "interf-default" : "interf";
+        return choices.filter((workflow) => !(hasLocalDefault && workflow.scope === "builtin" && workflow.id === "interf")).map((workflow) => {
+            const activeForDatasets = datasets
+                .filter((dataset) => (methodIdForSourcePreparationConfig(dataset) ?? implicitDefaultWorkflowId) === workflow.id)
+                .map((dataset) => dataset.name);
+            return WorkflowPackageResourceSchema.parse({
+                id: workflow.id,
+                path: resolveWorkflowPackageSourcePath(this.rootPath, workflow.id) ?? workflow.id,
+                label: workflow.label,
+                hint: workflow.hint,
+                source_kind: workflow.scope === "builtin" ? "builtin" : "local",
+                built_in: workflow.scope === "builtin",
+                active_for_datasets: activeForDatasets,
+                stages: workflow.stages.map((stage) => ({
+                    id: stage.id,
+                    label: stage.label,
+                    description: stage.description,
+                    contract_type: stage.contractType,
+                    skill_dir: stage.skillDir,
+                    reads: stage.reads,
+                    writes: stage.writes,
+                    ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
+                })),
+            });
+        });
+    }
+    getWorkflowPackage(workflowId) {
+        return this.listWorkflowPackages().find((workflow) => workflow.id === workflowId) ?? null;
+    }
+    listMethods() {
+        return this.listWorkflowPackages().map(workflowPackageResourceToMethodResource);
+    }
+    getMethod(methodId) {
+        const workflowPackage = this.getWorkflowPackage(methodId);
+        return workflowPackage ? workflowPackageResourceToMethodResource(workflowPackage) : null;
+    }
+    listJobs() {
+        return newestJobFirst(listJsonFiles(localJobsRoot(this.rootPath))
+            .map(readLocalJobRunAt)
+            .filter((run) => run !== null));
+    }
+    getJob(runId) {
+        return this.listJobs().find((run) => run.run_id === runId) ?? null;
+    }
+    getJobEvents(runId) {
+        return this.getJob(runId)?.events ?? null;
+    }
+    getExecutorStatus() {
+        const checkedAt = new Date().toISOString();
+        try {
+            const resolved = resolveAgent();
+            const currentName = resolved.agent?.name ?? configuredAgentName();
+            const availableExecutors = detectedExecutorOptions(currentName);
+            if (!resolved.agent) {
+                return LocalExecutorStatusSchema.parse({
+                    kind: "interf-local-executor-status",
+                    version: 1,
+                    status: "unavailable",
+                    checked_at: checkedAt,
+                    executor: null,
+                    available_executors: availableExecutors,
+                    message: resolved.error ?? "No supported local coding agent is configured.",
+                });
+            }
+            return LocalExecutorStatusSchema.parse({
+                kind: "interf-local-executor-status",
+                version: 1,
+                status: "connected",
+                checked_at: checkedAt,
+                executor: {
+                    name: resolved.agent.name,
+                    display_name: resolved.agent.displayName,
+                    command: resolved.agent.command,
+                },
+                available_executors: availableExecutors.length > 0
+                    ? availableExecutors
+                    : [{
+                            name: resolved.agent.name,
+                            display_name: resolved.agent.displayName,
+                            command: resolved.agent.command,
+                            current: true,
+                        }],
+                message: `${resolved.agent.displayName} is configured for local Interf actions.`,
+            });
+        }
+        catch (error) {
+            const currentName = configuredAgentName();
+            return LocalExecutorStatusSchema.parse({
+                kind: "interf-local-executor-status",
+                version: 1,
+                status: "unavailable",
+                checked_at: checkedAt,
+                executor: null,
+                available_executors: detectedExecutorOptions(currentName),
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    selectExecutor(requestValue) {
+        const request = LocalExecutorSelectRequestSchema.parse(requestValue);
+        const selected = detectAgents()
+            .filter(supportsAutomatedRuns)
+            .find((agent) => agent.name === request.agent);
+        if (!selected) {
+            throw new Error(`Local agent "${request.agent}" is not detected or cannot run Interf runs.`);
+        }
+        const current = loadUserConfig();
+        saveUserConfig({
+            agent: selected.name,
+            agentCommand: selected.command,
+            skillsInstalled: current?.skillsInstalled ?? false,
+            initialized: current?.initialized ?? new Date().toISOString(),
+        });
+        return this.getExecutorStatus();
+    }
+    listActionProposals() {
+        return newestActionProposalFirst(listJsonFiles(actionProposalsRoot(this.rootPath))
+            .map(readActionProposalAt)
+            .filter((proposal) => proposal !== null));
+    }
+    getActionProposal(proposalId) {
+        return this.listActionProposals().find((proposal) => proposal.proposal_id === proposalId) ?? null;
+    }
+    async createActionProposal(requestValue) {
+        const request = ActionProposalCreateRequestSchema.parse(requestValue);
+        const proposal = await this.buildActionProposal(request);
+        this.writeActionProposal(proposal);
+        return proposal;
+    }
+    async decideActionProposal(proposalId, requestValue) {
+        const decision = ActionProposalApprovalRequestSchema.parse(requestValue);
+        const current = this.getActionProposal(proposalId);
+        if (!current)
+            return null;
+        if (current.status !== "awaiting_approval") {
+            throw new Error(`Action proposal "${proposalId}" is already ${current.status}.`);
+        }
+        const now = new Date().toISOString();
+        const decided = ActionProposalResourceSchema.parse({
+            ...current,
+            status: decision.approved ? "approved" : "denied",
+            updated_at: now,
+            approval: {
+                approved: decision.approved,
+                decided_at: now,
+                ...(decision.note ? { note: decision.note } : {}),
+            },
+        });
+        this.writeActionProposal(decided);
+        if (!decision.approved)
+            return decided;
+        try {
+            const submission = await this.submitActionProposal(decided);
+            const submitted = ActionProposalResourceSchema.parse({
+                ...decided,
+                status: "submitted",
+                updated_at: new Date().toISOString(),
+                submitted_run_id: submission.runId,
+                submitted_run_type: submission.runType,
+            });
+            this.writeActionProposal(submitted);
+            return submitted;
+        }
+        catch (error) {
+            const failed = ActionProposalResourceSchema.parse({
+                ...decided,
+                status: "failed",
+                updated_at: new Date().toISOString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.writeActionProposal(failed);
+            return failed;
+        }
+    }
+    listRunObservability() {
+        return [
+            ...this.listCompileRuns().map((resource) => compileRunToObservability(resource.run)),
+            ...this.listTestRuns().map(testRunToObservability),
+            ...this.listJobs().map(jobRunToObservability),
+        ].sort((left, right) => {
+            const leftTime = timestampKey(left.started_at ?? left.created_at ?? left.finished_at);
+            const rightTime = timestampKey(right.started_at ?? right.created_at ?? right.finished_at);
+            return rightTime - leftTime;
+        });
+    }
+    getRunObservability(runId) {
+        return this.listRunObservability().find((run) => run.run_id === runId) ?? null;
+    }
+    createJobRun(requestValue) {
+        const request = LocalJobRunCreateRequestSchema.parse(requestValue);
+        const runId = createRunId("job");
+        const now = new Date().toISOString();
+        const run = LocalJobRunResourceSchema.parse({
+            kind: "interf-local-job-run",
+            version: 1,
+            run_id: runId,
+            job_type: request.job_type,
+            status: "running",
+            title: request.title,
+            ...(request.preparation !== undefined ? { preparation: request.preparation } : {}),
+            ...(request.method !== undefined ? { method: request.method } : {}),
+            ...(request.source_path !== undefined ? { source_path: request.source_path } : {}),
+            ...(request.output_path !== undefined ? { output_path: request.output_path } : {}),
+            ...(request.agent !== undefined ? { agent: request.agent } : {}),
+            created_at: now,
+            started_at: now,
+            steps: request.steps.map((step) => ({
+                ...step,
+                status: "queued",
+            })),
+            events: [
+                {
+                    type: "job.started",
+                    event_id: createRunEventId("event"),
+                    run_id: runId,
+                    timestamp: now,
+                    message: request.title,
+                },
+            ],
+        });
+        this.writeJobRun(run);
+        return run;
+    }
+    appendJobRunEvent(runId, requestValue) {
+        const request = LocalJobEventAppendRequestSchema.parse(requestValue);
+        const current = this.getJob(runId);
+        if (!current)
+            return null;
+        const event = {
+            type: request.type,
+            event_id: createRunEventId("event"),
+            run_id: runId,
+            timestamp: new Date().toISOString(),
+            ...(request.step_id ? { step_id: request.step_id } : {}),
+            ...(request.message ? { message: request.message } : {}),
+            ...(request.artifact ? { artifact: request.artifact } : {}),
+            ...(request.input ? { input: request.input } : {}),
+            ...(request.output ? { output: request.output } : {}),
+        };
+        const next = LocalJobRunResourceSchema.parse(applyEventToLocalJob(current, event));
+        this.writeJobRun(next);
+        return next;
+    }
+    async createReadinessCheckDraftRun(requestValue) {
+        const request = ReadinessCheckDraftCreateRequestSchema.parse(requestValue);
+        const job = this.createJobRun({
+            job_type: "readiness-check-draft",
+            title: `Draft readiness checks for ${request.preparation}`,
+            preparation: request.preparation,
+            source_path: request.source_folder_path,
+            steps: [
+                {
+                    id: "read-source",
+                    label: "Read source files",
+                    input: {
+                        preparation: request.preparation,
+                        source_folder_path: request.source_folder_path,
+                    },
+                },
+                {
+                    id: "agent-draft",
+                    label: "Draft readiness checks",
+                    input: {
+                        about: request.about ?? null,
+                        target_count: request.target_count,
+                    },
+                },
+                {
+                    id: "normalize-checks",
+                    label: "Normalize saved readiness checks",
+                },
+            ],
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.started",
+            step_id: "read-source",
+            message: "Reading source files for readiness-check evidence.",
+            input: {
+                preparation: request.preparation,
+                source_folder_path: request.source_folder_path,
+            },
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.completed",
+            step_id: "read-source",
+            message: "Source folder is ready for readiness-check drafting.",
+            output: {
+                preparation: request.preparation,
+                source_folder_path: request.source_folder_path,
+            },
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.started",
+            step_id: "agent-draft",
+            message: "Drafting saved readiness checks from the source files.",
+            input: {
+                about: request.about ?? null,
+                target_count: request.target_count,
+            },
+        });
+        void this.runReadinessCheckDraftInBackground(request, job.run_id);
+        return this.getJob(job.run_id) ?? job;
+    }
+    async createDatasetSetupRun(requestValue) {
+        const request = DatasetSetupCreateRequestSchema.parse(requestValue);
+        const datasetConfig = request.preparation;
+        const methodId = methodIdForSourcePreparationConfig(datasetConfig) ?? "interf-default";
+        const sourceFolderPath = resolveSourceDatasetPath(this.rootPath, datasetConfig);
+        const outputPath = portableContextPath(this.rootPath, datasetConfig.name);
+        const job = this.createJobRun({
+            job_type: "preparation-setup",
+            title: `Create Preparation ${datasetConfig.name}`,
+            preparation: datasetConfig.name,
+            method: methodId,
+            source_path: sourceFolderPath,
+            output_path: outputPath,
+            agent: this.getExecutorStatus().executor,
+            steps: [
+                {
+                    id: "validate-source",
+                    label: "Validate source folder",
+                    input: {
+                        preparation: datasetConfig.name,
+                        path: datasetConfig.path,
+                    },
+                },
+                {
+                    id: "write-config",
+                    label: "Save Preparation config",
+                    input: {
+                        config_path: join(this.rootPath, "interf", "interf.json"),
+                    },
+                },
+                {
+                    id: "prepare-scaffold",
+                    label: "Prepare portable context",
+                    input: {
+                        output_path: outputPath,
+                        method: methodId,
+                    },
+                },
+            ],
+        });
+        let activeStep = "validate-source";
+        try {
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.started",
+                step_id: "validate-source",
+                message: "Validating source folder.",
+                input: {
+                    path: datasetConfig.path,
+                    source_folder_path: sourceFolderPath,
+                },
+            });
+            if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
+                throw new Error(`Source folder "${datasetConfig.path}" is not available.`);
+            }
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.completed",
+                step_id: "validate-source",
+                message: "Source folder is available.",
+                output: {
+                    source_folder_path: sourceFolderPath,
+                },
+            });
+            activeStep = "write-config";
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.started",
+                step_id: "write-config",
+                message: "Saving Preparation in the control plane config.",
+                input: {
+                    preparation: datasetConfig.name,
+                    path: datasetConfig.path,
+                },
+            });
+            upsertSourceDatasetConfig(this.rootPath, datasetConfig);
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.completed",
+                step_id: "write-config",
+                message: "Preparation config saved.",
+                output: {
+                    config_path: join(this.rootPath, "interf", "interf.json"),
+                    preparation: datasetConfig.name,
+                },
+            });
+            activeStep = "prepare-scaffold";
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.started",
+                step_id: "prepare-scaffold",
+                message: "Preparing portable-context scaffold.",
+                input: {
+                    output_path: outputPath,
+                    method: methodId,
+                },
+            });
+            const compiledPath = ensurePortableContextScaffold(this.rootPath, datasetConfig.name, methodId);
+            syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig);
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.completed",
+                step_id: "prepare-scaffold",
+                message: "Portable-context scaffold is ready.",
+                output: {
+                    portable_context_path: compiledPath,
+                },
+            });
+            this.setJobRunResult(job.run_id, {
+                preparation: datasetConfig,
+                source_folder_path: sourceFolderPath,
+                portable_context_path: compiledPath,
+            });
+            this.appendJobRunEvent(job.run_id, {
+                type: "job.completed",
+                message: `Preparation ${datasetConfig.name} is ready for Interf runs.`,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendJobRunEvent(job.run_id, {
+                type: "step.failed",
+                step_id: activeStep,
+                message,
+                output: {
+                    error: message,
+                },
+            });
+            this.appendJobRunEvent(job.run_id, {
+                type: "job.failed",
+                message,
+            });
+        }
+        return this.getJob(job.run_id) ?? job;
+    }
+    async createWorkflowAuthoringRun(requestValue) {
+        const request = WorkflowAuthoringCreateRequestSchema.parse(requestValue);
+        const job = this.createJobRun({
+            job_type: "method-authoring",
+            title: `Draft Method ${request.method_id}`,
+            preparation: request.preparation ?? null,
+            method: request.method_id,
+            source_path: request.source_folder_path,
+            output_path: join(this.rootPath, "interf", "methods", request.method_id),
+            steps: [
+                {
+                    id: "inspect-source",
+                    label: "Inspect source files",
+                    input: {
+                        preparation: request.preparation ?? null,
+                        source_folder_path: request.source_folder_path,
+                        checks: request.checks.length,
+                    },
+                },
+                {
+                    id: "draft-package",
+                    label: "Draft Method package",
+                    input: {
+                        method_id: request.method_id,
+                        label: request.label,
+                        task_prompt: request.task_prompt,
+                    },
+                },
+                {
+                    id: "validate-package",
+                    label: "Validate Method package",
+                    input: {
+                        method_id: request.method_id,
+                    },
+                },
+            ],
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.started",
+            step_id: "inspect-source",
+            message: "Inspecting source files for Method drafting.",
+            input: {
+                preparation: request.preparation ?? null,
+                source_folder_path: request.source_folder_path,
+                checks: request.checks.length,
+            },
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.completed",
+            step_id: "inspect-source",
+            message: "Source context is ready.",
+            output: {
+                source_folder_path: request.source_folder_path,
+                checks: request.checks.length,
+            },
+        });
+        this.appendJobRunEvent(job.run_id, {
+            type: "step.started",
+            step_id: "draft-package",
+            message: "Drafting Method package.",
+            input: {
+                method_id: request.method_id,
+                label: request.label,
+                task_prompt: request.task_prompt,
+            },
+        });
+        void this.runWorkflowAuthoringInBackground(request, job.run_id);
+        return this.getJob(job.run_id) ?? job;
+    }
+    listPortableContexts() {
+        return this.listDatasets().map((dataset) => this.getPortableContext(dataset.dataset.name))
+            .filter((context) => context !== null);
+    }
+    getPortableContext(datasetName) {
+        const dataset = findSourceDatasetConfig(loadSourceFolderConfig(this.rootPath), datasetName);
+        if (!dataset)
+            return null;
+        const path = portableContextPath(this.rootPath, dataset.name);
+        const config = readInterfConfig(path);
+        const compileRuns = this.listCompileRunsForDataset(dataset.name);
+        const testRuns = this.listTestRunsForDataset(dataset.name);
+        const readiness = this.computeDatasetReadiness(dataset);
+        const method = config?.method ?? config?.workflow ?? methodIdForSourcePreparationConfig(dataset);
+        return PortableContextResourceSchema.parse({
+            preparation: dataset.name,
+            path,
+            exists: existsSync(path),
+            readiness,
+            method,
+            latest_compile_run_id: compileRuns[0]?.run_id ?? null,
+            latest_test_run_id: testRuns[0]?.run_id ?? null,
+            artifacts: uniqueArtifacts(compileRuns[0]?.stages.flatMap((stage) => stage.artifacts) ?? []),
+        });
+    }
+    listCompileRuns() {
+        return newestCompileFirst(this.listDatasets().flatMap((dataset) => this.listCompileRunsForDataset(dataset.dataset.name))).map((run) => CompileRunResourceSchema.parse({ run }));
+    }
+    listCompileRunsForDataset(datasetName) {
+        const compiledPath = portableContextPath(this.rootPath, datasetName);
+        return newestCompileFirst(listJsonFiles(compileRunsRoot(compiledPath))
+            .map(readCompileRunAt)
+            .filter((run) => run !== null));
+    }
+    getCompileRun(runId) {
+        for (const resource of this.listCompileRuns()) {
+            if (resource.run.run_id === runId)
+                return resource;
+        }
+        return null;
+    }
+    getCompileRunEvents(runId) {
+        return this.getCompileRun(runId)?.run.events ?? null;
+    }
+    getCompileRunProof(runId) {
+        const run = this.getCompileRun(runId)?.run;
+        if (!run)
+            return null;
+        return run.stages
+            .map((stage) => stage.latest_proof ?? null)
+            .filter((proof) => proof !== null);
+    }
+    getCompileRunArtifacts(runId) {
+        const run = this.getCompileRun(runId)?.run;
+        if (!run)
+            return null;
+        return uniqueArtifacts(run.stages.flatMap((stage) => stage.artifacts));
+    }
+    async createCompileRun(requestValue) {
+        const request = CompileRunCreateRequestSchema.parse(requestValue);
+        const datasetConfig = this.resolveDatasetConfig(request.preparation, {
+            method: request.method,
+            max_attempts: request.max_attempts,
+            max_loops: request.max_loops,
+        });
+        const compiledPath = this.ensureCompiledForRun(datasetConfig);
+        const runId = createRunId("compile");
+        const now = new Date().toISOString();
+        const workflow = getCompiledWorkflow(methodIdForSourcePreparationConfig(datasetConfig) ?? "interf", {
+            sourcePath: this.rootPath,
+        });
+        const stageTotal = workflow.stages.length;
+        const run = CompileRunSchema.parse({
+            kind: "interf-compile-run",
+            version: 1,
+            run_id: runId,
+            status: "running",
+            preparation: datasetConfig.name,
+            method: workflow.id,
+            backend: "native",
+            source_path: resolveSourceDatasetPath(this.rootPath, datasetConfig),
+            portable_context_path: compiledPath,
+            created_at: now,
+            started_at: now,
+            stages: workflow.stages.map((stage, index) => ({
+                run_id: runId,
+                stage_id: stage.id,
+                stage_label: stage.label,
+                stage_index: index,
+                stage_total: stageTotal,
+                status: "queued",
+                contract: {
+                    stage_label: stage.label,
+                    stage_index: index,
+                    stage_total: stageTotal,
+                    reads: stage.reads,
+                    writes: stage.writes,
+                    ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
+                },
+                artifacts: [],
+            })),
+            events: [],
+        });
+        this.writeCompileRun(compiledPath, run);
+        await this.recordCompileRunEvent(compiledPath, runId, {
+            type: "run.started",
+            event_id: createRunEventId("event"),
+            run_id: runId,
+            timestamp: now,
+            preparation: datasetConfig.name,
+            method: workflow.id,
+            portable_context_path: compiledPath,
+            backend: "native",
+        });
+        const sink = {
+            emit: (event) => this.recordCompileRunEvent(compiledPath, runId, event),
+        };
+        void this.runCompileInBackground(request, {
+            runId,
+            sourcePath: this.rootPath,
+            compiledPath,
+            datasetConfig,
+            events: sink,
+        });
+        const saved = this.readCompileRun(compiledPath, runId) ?? run;
+        return CompileRunResourceSchema.parse({ run: saved });
+    }
+    listTestRuns() {
+        return newestFirst(this.listDatasets().flatMap((dataset) => this.listTestRunsForDataset(dataset.dataset.name)));
+    }
+    listTestRunsForDataset(datasetName) {
+        const compiledPath = portableContextPath(this.rootPath, datasetName);
+        return newestFirst(listJsonFiles(testRunsRoot(compiledPath))
+            .map(readTestRunAt)
+            .filter((run) => run !== null));
+    }
+    getTestRun(runId) {
+        return this.listTestRuns().find((run) => run.run_id === runId) ?? null;
+    }
+    async createTestRun(requestValue) {
+        const request = TestRunCreateRequestSchema.parse(requestValue);
+        const datasetConfig = this.resolveDatasetConfig(request.preparation);
+        const compiledPath = portableContextPath(this.rootPath, datasetConfig.name);
+        const compiledTarget = createCompiledTestTarget(compiledPath, datasetConfig.name, methodIdForSourcePreparationConfig(datasetConfig) ?? "interf");
+        const runId = createRunId("test");
+        const now = new Date().toISOString();
+        const initial = TestRunResourceSchema.parse({
+            run_id: runId,
+            status: "running",
+            preparation: datasetConfig.name,
+            mode: request.mode,
+            source_path: this.rootPath,
+            portable_context_path: compiledTarget.eligible ? compiledPath : null,
+            started_at: now,
+            comparison: null,
+            events: [],
+        });
+        this.writeTestRun(compiledPath, initial);
+        void this.runTestInBackground(request, {
+            runId,
+            sourcePath: this.rootPath,
+            compiledPath,
+            datasetConfig,
+        }, initial);
+        return initial;
+    }
+    async runCompileInBackground(request, context) {
+        try {
+            if (!this.handlers.createCompileRun) {
+                throw new Error("No compile-run handler is configured for this local service.");
+            }
+            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createCompileRun(request, context));
+            this.refreshCompileRunFromRuntime(context.compiledPath, context.runId);
+            await this.emitRuntimeDerivedEvents(context.compiledPath, context.runId);
+            if (!result.ok) {
+                await this.recordCompileRunEvent(context.compiledPath, context.runId, {
+                    type: "run.failed",
+                    event_id: createRunEventId("event"),
+                    run_id: context.runId,
+                    timestamp: createRunEventTimestamp(),
+                    error: result.error ?? "Compile run failed.",
+                });
+            }
+            else {
+                await this.recordCompileRunEvent(context.compiledPath, context.runId, {
+                    type: "run.completed",
+                    event_id: createRunEventId("event"),
+                    run_id: context.runId,
+                    timestamp: createRunEventTimestamp(),
+                    summary: "Portable context ready.",
+                });
+            }
+        }
+        catch (error) {
+            await this.recordCompileRunEvent(context.compiledPath, context.runId, {
+                type: "run.failed",
+                event_id: createRunEventId("event"),
+                run_id: context.runId,
+                timestamp: createRunEventTimestamp(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async runTestInBackground(request, context, initial) {
+        try {
+            if (!this.handlers.createTestRun) {
+                throw new Error("No test-run handler is configured for this local service.");
+            }
+            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createTestRun(request, context));
+            const comparison = this.readLatestComparison(context.datasetConfig.name);
+            const resultEvent = comparison
+                ? this.checksEvaluatedEvent(context.runId, comparison)
+                : null;
+            const nextWithoutReadiness = TestRunResourceSchema.parse({
+                ...initial,
+                status: result.ok ? "succeeded" : "failed",
+                finished_at: new Date().toISOString(),
+                comparison,
+                events: resultEvent ? [resultEvent] : [],
+                ...(!result.ok ? { error: result.error ?? "Readiness check failed." } : {}),
+            });
+            this.writeTestRun(context.compiledPath, nextWithoutReadiness);
+            const readiness = this.computeDatasetReadiness(context.datasetConfig);
+            const next = TestRunResourceSchema.parse({
+                ...nextWithoutReadiness,
+                readiness,
+                events: [
+                    ...nextWithoutReadiness.events,
+                    this.readinessUpdatedEvent(context.runId, context.datasetConfig.name, readiness),
+                ],
+            });
+            this.writeTestRun(context.compiledPath, next);
+        }
+        catch (error) {
+            const failedWithoutReadiness = TestRunResourceSchema.parse({
+                ...initial,
+                status: "failed",
+                finished_at: new Date().toISOString(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.writeTestRun(context.compiledPath, failedWithoutReadiness);
+            const readiness = this.computeDatasetReadiness(context.datasetConfig);
+            const next = TestRunResourceSchema.parse({
+                ...failedWithoutReadiness,
+                readiness,
+                events: [this.readinessUpdatedEvent(context.runId, context.datasetConfig.name, readiness)],
+            });
+            this.writeTestRun(context.compiledPath, next);
+        }
+    }
+    async runReadinessCheckDraftInBackground(request, runId) {
+        try {
+            if (!this.handlers.createReadinessCheckDraft) {
+                throw new Error("No readiness-check-draft handler is configured for this local service.");
+            }
+            const result = ReadinessCheckDraftResultSchema.parse(await this.handlers.createReadinessCheckDraft(request, this.jobRunContext(runId)));
+            this.appendJobRunEvent(runId, {
+                type: "step.completed",
+                step_id: "agent-draft",
+                message: `Drafted ${result.checks.length} readiness checks.`,
+                output: {
+                    checks: result.checks,
+                },
+            });
+            this.appendJobRunEvent(runId, {
+                type: "step.started",
+                step_id: "normalize-checks",
+                message: "Normalizing readiness-check draft into saved check records.",
+                input: {
+                    checks: result.checks.length,
+                },
+            });
+            this.appendJobRunEvent(runId, {
+                type: "step.completed",
+                step_id: "normalize-checks",
+                message: `${result.checks.length} readiness checks ready for review.`,
+                output: {
+                    checks: result.checks.length,
+                },
+            });
+            this.setJobRunResult(runId, result);
+            this.appendJobRunEvent(runId, {
+                type: "job.completed",
+                message: `Drafted ${result.checks.length} readiness checks.`,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendJobRunEvent(runId, {
+                type: "step.failed",
+                step_id: "agent-draft",
+                message,
+                output: {
+                    error: message,
+                },
+            });
+            this.appendJobRunEvent(runId, {
+                type: "job.failed",
+                message,
+            });
+        }
+    }
+    async runWorkflowAuthoringInBackground(request, runId) {
+        try {
+            if (!this.handlers.createWorkflowAuthoringRun) {
+                throw new Error("No Method-authoring handler is configured for this local service.");
+            }
+            const result = WorkflowAuthoringResultSchema.parse(await this.handlers.createWorkflowAuthoringRun(request, this.jobRunContext(runId)));
+            this.setJobRunResult(runId, result);
+            this.appendJobRunEvent(runId, {
+                type: result.status === "executor-failed" ? "step.failed" : "step.completed",
+                step_id: "draft-package",
+                message: result.summary,
+                output: {
+                    status: result.status,
+                    changed: result.changed,
+                    method_path: result.method_path,
+                    shell_path: result.shell_path,
+                },
+            });
+            this.appendJobRunEvent(runId, {
+                type: "step.started",
+                step_id: "validate-package",
+                message: "Validating Method package structure and stage contract.",
+                input: {
+                    method_path: result.method_path,
+                },
+            });
+            if (result.status === "updated" || result.status === "no-change") {
+                this.appendJobRunEvent(runId, {
+                    type: "step.completed",
+                    step_id: "validate-package",
+                    message: result.summary,
+                    output: {
+                        status: result.status,
+                        validation: result.validation ?? null,
+                    },
+                });
+                this.appendJobRunEvent(runId, {
+                    type: "job.completed",
+                    message: result.summary,
+                });
+            }
+            else {
+                this.appendJobRunEvent(runId, {
+                    type: "step.failed",
+                    step_id: "validate-package",
+                    message: result.summary,
+                    output: {
+                        status: result.status,
+                        validation: result.validation ?? null,
+                    },
+                });
+                this.appendJobRunEvent(runId, {
+                    type: "job.failed",
+                    message: result.summary,
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.appendJobRunEvent(runId, {
+                type: "step.failed",
+                step_id: "draft-package",
+                message,
+                output: {
+                    error: message,
+                },
+            });
+            this.appendJobRunEvent(runId, {
+                type: "job.failed",
+                message,
+            });
+        }
+    }
+    jobRunContext(runId) {
+        return {
+            runId,
+            sourcePath: this.rootPath,
+            emit: (event) => {
+                this.appendJobRunEvent(runId, event);
+            },
+        };
+    }
+    defaultDatasetName() {
+        const dataset = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath))[0];
+        if (!dataset) {
+            throw new Error("No Preparation is saved in this control plane folder.");
+        }
+        return dataset.name;
+    }
+    async planActionProposal(request) {
+        if (!this.handlers.planActionProposal) {
+            return ActionProposalPlanSchema.parse({
+                action_type: "clarification",
+                ...(request.preparation ? { preparation: request.preparation } : {}),
+                assistant_message: "No local action planner is configured for this Interf Workspace.",
+            });
+        }
+        const datasets = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath));
+        let rawPlan;
+        try {
+            rawPlan = await this.handlers.planActionProposal(request, {
+                sourcePath: this.rootPath,
+                datasets,
+                preparationHealth: datasets.map((dataset) => {
+                    const readinessChecks = dataset.checks?.length ?? 0;
+                    const portableContextReady = hasCompiledTestTarget(this.rootPath, dataset);
+                    return {
+                        name: dataset.name,
+                        readiness_checks: readinessChecks,
+                        portable_context_ready: portableContextReady,
+                        can_check_readiness: readinessChecks > 0 && portableContextReady,
+                        recommended_next_actions: portableContextReady
+                            ? readinessChecks > 0
+                                ? ["check readiness", "improve", "prepare again"]
+                                : ["draft readiness checks", "prepare again"]
+                            : ["prepare"],
+                    };
+                }),
+                sourceFolders: listSourceFolderChoices(this.rootPath),
+                recentProposals: this.listActionProposals().slice(0, 5),
+            });
+        }
+        catch {
+            return ActionProposalPlanSchema.parse({
+                action_type: "clarification",
+                ...(request.preparation ? { preparation: request.preparation } : {}),
+                assistant_message: ACTION_PLANNER_CLARIFICATION_MESSAGE,
+            });
+        }
+        const parsed = ActionProposalPlanSchema.safeParse(rawPlan);
+        if (parsed.success)
+            return parsed.data;
+        return ActionProposalPlanSchema.parse({
+            action_type: "clarification",
+            ...(request.preparation ? { preparation: request.preparation } : {}),
+            assistant_message: ACTION_PLANNER_CLARIFICATION_MESSAGE,
+        });
+    }
+    buildDatasetSetupRequest(request, plan, values) {
+        const sourceFolderChoices = listSourceFolderChoices(this.rootPath);
+        const selectedPath = datasetSetupPathValue(values) ??
+            (sourceFolderChoices.length === 1 ? sourceFolderChoices[0].value : null);
+        if (!selectedPath) {
+            return {
+                error: "Tell Interf which source folder to use for the Preparation.",
+            };
+        }
+        let normalizedPath;
+        try {
+            normalizedPath = normalizeSourceDatasetPathForConfig(this.rootPath, selectedPath);
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        const explicitName = datasetSetupNameValue(values) ?? plan.preparation ?? request.preparation;
+        const datasetName = explicitName
+            ? slugFromText(explicitName)
+            : defaultDatasetNameForPath(normalizedPath);
+        const requestWorkflowId = stringValue(request.values, "method") ?? stringValue(request.values, "workflow");
+        const valueWorkflowId = stringValue(values, "method") ?? stringValue(values, "workflow");
+        const workflowId = requestWorkflowId ?? plan.method ?? valueWorkflowId ?? "interf-default";
+        try {
+            return {
+                datasetName,
+                workflowId,
+                request: DatasetSetupCreateRequestSchema.parse({
+                    preparation: {
+                        name: datasetName,
+                        path: normalizedPath,
+                        about: stringValue(values, "about") ?? stringValue(values, "task_prompt") ?? request.message,
+                        method: workflowId,
+                        checks: [],
+                    },
+                }),
+            };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async buildActionProposal(request) {
+        const plan = await this.planActionProposal(request);
+        const actionType = plan.action_type;
+        const now = new Date().toISOString();
+        if (actionType === "clarification") {
+            return ActionProposalResourceSchema.parse({
+                kind: "interf-action-proposal",
+                version: 1,
+                proposal_id: createActionProposalId(),
+                status: "needs_clarification",
+                action_type: actionType,
+                title: plan.title ?? "Clarify Interf action",
+                summary: plan.summary ?? "No local run was proposed because the request did not resolve to a confirmed Interf action.",
+                assistant_message: plan.assistant_message ?? ACTION_PLANNER_CLARIFICATION_MESSAGE,
+                ...(plan.command_preview ? { command_preview: plan.command_preview } : {}),
+                message: request.message,
+                preparation: plan.preparation ?? request.preparation ?? null,
+                method: plan.method ?? null,
+                request: {
+                    message: request.message,
+                    ...(plan.values ? { values: plan.values } : {}),
+                },
+                created_at: now,
+                updated_at: now,
+                proposed_by_executor: this.getExecutorStatus().executor,
+                approval: null,
+                submitted_run_id: null,
+                submitted_run_type: null,
+                error: null,
+            });
+        }
+        const proposalValues = {
+            ...(plan.values ?? {}),
+            ...(request.values ?? {}),
+        };
+        if (actionType === "preparation-setup") {
+            const setup = this.buildDatasetSetupRequest(request, plan, proposalValues);
+            if ("error" in setup) {
+                return ActionProposalResourceSchema.parse({
+                    kind: "interf-action-proposal",
+                    version: 1,
+                    proposal_id: createActionProposalId(),
+                    status: "needs_clarification",
+                    action_type: "clarification",
+                    title: "Clarify Preparation setup",
+                    summary: "Interf needs a source folder before it can save a Preparation.",
+                    assistant_message: setup.error,
+                    message: request.message,
+                    preparation: plan.preparation ?? request.preparation ?? null,
+                    method: plan.method ?? null,
+                    request: {
+                        message: request.message,
+                        ...(proposalValues ? { values: proposalValues } : {}),
+                    },
+                    created_at: now,
+                    updated_at: now,
+                    proposed_by_executor: this.getExecutorStatus().executor,
+                    approval: null,
+                    submitted_run_id: null,
+                    submitted_run_type: null,
+                    error: null,
+                });
+            }
+            const commandPreview = plan.command_preview ??
+                actionCommandPreview(actionType, setup.datasetName, setup.workflowId, {
+                    ...proposalValues,
+                    path: setup.request.preparation.path,
+                });
+            return ActionProposalResourceSchema.parse({
+                kind: "interf-action-proposal",
+                version: 1,
+                proposal_id: createActionProposalId(),
+                status: "awaiting_approval",
+                action_type: actionType,
+                title: plan.title ?? `Create Preparation ${setup.datasetName}`,
+                summary: plan.summary ?? "Save this source folder as an Interf Preparation.",
+                assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, setup.datasetName, commandPreview),
+                command_preview: commandPreview,
+                message: request.message,
+                preparation: setup.datasetName,
+                method: setup.workflowId,
+                request: setup.request,
+                created_at: now,
+                updated_at: now,
+                proposed_by_executor: this.getExecutorStatus().executor,
+                approval: null,
+                submitted_run_id: null,
+                submitted_run_type: null,
+                error: null,
+            });
+        }
+        const datasetConfig = this.resolveDatasetConfig(plan.preparation ?? request.preparation ?? this.defaultDatasetName());
+        const datasetPath = resolveSourceDatasetPath(this.rootPath, datasetConfig);
+        const requestedWorkflowId = stringValue(request.values, "method_id") ??
+            stringValue(request.values, "method") ??
+            stringValue(request.values, "workflow");
+        const plannedWorkflowId = plan.method ??
+            stringValue(plan.values, "method_id") ??
+            stringValue(plan.values, "method") ??
+            stringValue(plan.values, "workflow");
+        const workflowId = actionType === "method-authoring"
+            ? requestedWorkflowId ?? plannedWorkflowId ?? workflowIdForProposal(request.message, proposalValues)
+            : requestedWorkflowId ?? plannedWorkflowId ?? methodIdForSourcePreparationConfig(datasetConfig);
+        const clarifyResolvedAction = (options) => ActionProposalResourceSchema.parse({
+            kind: "interf-action-proposal",
+            version: 1,
+            proposal_id: createActionProposalId(),
+            status: "needs_clarification",
+            action_type: "clarification",
+            title: options.title,
+            summary: options.summary,
+            assistant_message: options.assistantMessage,
+            message: request.message,
+            preparation: datasetConfig.name,
+            method: workflowId ?? null,
+            request: {
+                message: request.message,
+                ...(proposalValues ? { values: proposalValues } : {}),
+            },
+            created_at: now,
+            updated_at: now,
+            proposed_by_executor: this.getExecutorStatus().executor,
+            approval: null,
+            submitted_run_id: null,
+            submitted_run_type: null,
+            error: null,
+        });
+        if (actionType === "test") {
+            const requestedMode = testModeFromValues(proposalValues);
+            const hasReadinessChecks = (datasetConfig.checks ?? []).length > 0;
+            const portableContextReady = hasCompiledTestTarget(this.rootPath, datasetConfig);
+            if (!hasReadinessChecks) {
+                return clarifyResolvedAction({
+                    title: `Add readiness checks for ${datasetConfig.name}`,
+                    summary: "Readiness cannot be checked until this Preparation has saved checks.",
+                    assistantMessage: `Preparation "${datasetConfig.name}" does not have saved readiness checks yet. Ask me to draft readiness checks after the Source Folder is prepared, or add readiness guidance first.`,
+                });
+            }
+            if (!portableContextReady && requestedMode !== "raw") {
+                return clarifyResolvedAction({
+                    title: `Prepare ${datasetConfig.name} first`,
+                    summary: "Readiness checks need portable context unless you explicitly ask for a source-files-only baseline.",
+                    assistantMessage: `Preparation "${datasetConfig.name}" has no prepared portable context yet. Prepare it first; after that Interf can check readiness. If you specifically want a source-files-only baseline, ask for source files only.`,
+                });
+            }
+        }
+        const actionRequest = (() => {
+            if (actionType === "compile") {
+                return {
+                    preparation: datasetConfig.name,
+                    ...(workflowId ? { method: workflowId } : {}),
+                };
+            }
+            if (actionType === "test") {
+                const defaultMode = hasCompiledTestTarget(this.rootPath, datasetConfig) ? "both" : "raw";
+                return {
+                    preparation: datasetConfig.name,
+                    mode: testModeValue(proposalValues, defaultMode),
+                };
+            }
+            if (actionType === "readiness-check-draft") {
+                return {
+                    preparation: datasetConfig.name,
+                    source_folder_path: datasetPath,
+                    about: stringValue(proposalValues, "about") ?? datasetConfig.about ?? request.message,
+                    target_count: Math.max(1, Math.min(8, Math.round(numberValue(proposalValues, "target_count") ?? 4))),
+                };
+            }
+            return {
+                preparation: datasetConfig.name,
+                source_folder_path: datasetPath,
+                method_id: workflowId,
+                label: stringValue(proposalValues, "label") ?? `Custom ${datasetConfig.name}`,
+                hint: stringValue(proposalValues, "hint") ?? request.message,
+                task_prompt: actionValueMethodTaskPrompt(proposalValues) ?? stringValue(proposalValues, "task_prompt") ?? request.message,
+                checks: datasetConfig.checks ?? [],
+            };
+        })();
+        const title = (() => {
+            if (plan.title)
+                return plan.title;
+            if (actionType === "compile")
+                return `Prepare ${datasetConfig.name}`;
+            if (actionType === "test")
+                return `Check readiness for ${datasetConfig.name}`;
+            if (actionType === "readiness-check-draft")
+                return `Draft readiness checks for ${datasetConfig.name}`;
+            return `Draft Method ${workflowId}`;
+        })();
+        const summary = (() => {
+            if (plan.summary)
+                return plan.summary;
+            if (actionType === "compile")
+                return "Build portable context agents can use.";
+            if (actionType === "test")
+                return "Run readiness checks against source files and portable context.";
+            if (actionType === "readiness-check-draft")
+                return "Ask the configured local executor to draft saved readiness checks.";
+            return "Ask the configured local executor to create a reusable local Method.";
+        })();
+        const previewValues = actionType === "test"
+            ? { mode: actionRequest.mode }
+            : proposalValues;
+        const commandPreview = plan.command_preview ?? actionCommandPreview(actionType, datasetConfig.name, workflowId, previewValues);
+        return ActionProposalResourceSchema.parse({
+            kind: "interf-action-proposal",
+            version: 1,
+            proposal_id: createActionProposalId(),
+            status: "awaiting_approval",
+            action_type: actionType,
+            title,
+            summary,
+            assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, datasetConfig.name, commandPreview),
+            command_preview: commandPreview,
+            message: request.message,
+            preparation: datasetConfig.name,
+            method: workflowId,
+            request: actionRequest,
+            created_at: now,
+            updated_at: now,
+            proposed_by_executor: this.getExecutorStatus().executor,
+            approval: null,
+            submitted_run_id: null,
+            submitted_run_type: null,
+            error: null,
+        });
+    }
+    async submitActionProposal(proposal) {
+        if (proposal.action_type === "clarification") {
+            throw new Error("Clarification proposals cannot be submitted.");
+        }
+        if (proposal.action_type === "compile") {
+            const resource = await this.createCompileRun(proposal.request);
+            return {
+                runId: resource.run.run_id,
+                runType: "compile-run",
+            };
+        }
+        if (proposal.action_type === "test") {
+            const resource = await this.createTestRun(proposal.request);
+            return {
+                runId: resource.run_id,
+                runType: "test-run",
+            };
+        }
+        if (proposal.action_type === "preparation-setup") {
+            const job = await this.createDatasetSetupRun(proposal.request);
+            return {
+                runId: job.run_id,
+                runType: "job-run",
+            };
+        }
+        if (proposal.action_type === "readiness-check-draft") {
+            const job = await this.createReadinessCheckDraftRun(proposal.request);
+            return {
+                runId: job.run_id,
+                runType: "job-run",
+            };
+        }
+        const job = await this.createWorkflowAuthoringRun(proposal.request);
+        return {
+            runId: job.run_id,
+            runType: "job-run",
+        };
+    }
+    resolveDatasetConfig(datasetName, overrides = {}) {
+        const dataset = findSourceDatasetConfig(loadSourceFolderConfig(this.rootPath), datasetName);
+        if (!dataset) {
+            throw new Error(`Preparation "${datasetName}" is not saved in this control plane folder.`);
+        }
+        const method = overrides.method ?? overrides.workflow ?? methodIdForSourcePreparationConfig(dataset) ?? undefined;
+        return {
+            ...dataset,
+            ...(method ? { method } : {}),
+            ...(typeof overrides.max_attempts === "number" ? { max_attempts: overrides.max_attempts } : {}),
+            ...(typeof overrides.max_loops === "number" ? { max_loops: overrides.max_loops } : {}),
+        };
+    }
+    ensureCompiledForRun(datasetConfig) {
+        const workflowId = methodIdForSourcePreparationConfig(datasetConfig) ?? "interf";
+        const compiledPath = ensurePortableContextScaffold(this.rootPath, datasetConfig.name, workflowId);
+        syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig);
+        return compiledPath;
+    }
+    readCompileRun(compiledPath, runId) {
+        return readCompileRunAt(compileRunPath(compiledPath, runId));
+    }
+    writeCompileRun(compiledPath, run) {
+        mkdirSync(compileRunsRoot(compiledPath), { recursive: true });
+        writeJsonFile(compileRunPath(compiledPath, run.run_id), CompileRunSchema.parse(run));
+    }
+    writeJobRun(run) {
+        mkdirSync(localJobsRoot(this.rootPath), { recursive: true });
+        writeJsonFile(localJobPath(this.rootPath, run.run_id), LocalJobRunResourceSchema.parse(run));
+    }
+    writeActionProposal(proposal) {
+        mkdirSync(actionProposalsRoot(this.rootPath), { recursive: true });
+        writeJsonFile(actionProposalPath(this.rootPath, proposal.proposal_id), ActionProposalResourceSchema.parse(proposal));
+    }
+    setJobRunResult(runId, result) {
+        const current = this.getJob(runId);
+        if (!current)
+            return;
+        const normalizedResult = result && typeof result === "object" && !Array.isArray(result)
+            ? result
+            : { value: result };
+        this.writeJobRun(LocalJobRunResourceSchema.parse({
+            ...current,
+            result: normalizedResult,
+        }));
+    }
+    async recordCompileRunEvent(compiledPath, runId, event) {
+        const current = this.readCompileRun(compiledPath, runId);
+        if (!current)
+            return;
+        this.writeCompileRun(compiledPath, applyEventToCompileRun(current, event));
+        if (event.type === "stage.passed" || event.type === "stage.failed") {
+            this.refreshCompileRunFromRuntime(compiledPath, runId);
+        }
+    }
+    refreshCompileRunFromRuntime(compiledPath, runId) {
+        const current = this.readCompileRun(compiledPath, runId);
+        if (!current)
+            return;
+        const state = loadState(compiledPath);
+        if (!state?.stages)
+            return;
+        const historyByStage = new Map();
+        for (const run of readRuntimeRunHistory(compiledPath)) {
+            if (run.target_name !== current.preparation)
+                continue;
+            const existing = historyByStage.get(run.stage);
+            if (!existing || timestampKey(run.updated_at) >= timestampKey(existing.updated_at)) {
+                historyByStage.set(run.stage, run);
+            }
+        }
+        const next = {
+            ...current,
+            stages: current.stages.map((stage) => {
+                const stageState = state.stages?.[stage.stage_id];
+                if (!stageState)
+                    return stage;
+                const runtimeRun = historyByStage.get(stage.stage_id);
+                const artifacts = uniqueArtifacts([
+                    ...(stage.artifacts ?? []),
+                    ...stageArtifactRefs(stage.stage_id, stageState.artifacts),
+                ]);
+                const proof = stage.latest_proof ?? proofForStage({
+                    runId,
+                    stageId: stage.stage_id,
+                    summary: stageState.summary,
+                    stageState,
+                    artifacts,
+                });
+                return {
+                    ...stage,
+                    started_at: stage.started_at ?? stageState.started_at,
+                    finished_at: stage.finished_at ?? stageState.finished_at,
+                    summary: stage.summary ?? stageState.summary ?? null,
+                    executor: stage.executor ?? runtimeRun?.executor ?? null,
+                    artifacts,
+                    logs: stage.logs ?? logsForRuntimeRun(runtimeRun) ?? logsForStageRun(stageState),
+                    latest_proof: proof,
+                };
+            }),
+        };
+        next.latest_proof = [...next.stages].reverse().find((stage) => Boolean(stage.latest_proof))?.latest_proof ?? next.latest_proof;
+        this.writeCompileRun(compiledPath, next);
+    }
+    async emitRuntimeDerivedEvents(compiledPath, runId) {
+        const state = loadState(compiledPath);
+        const run = this.readCompileRun(compiledPath, runId);
+        if (!state?.stages || !run)
+            return;
+        for (const stage of run.stages) {
+            const stageState = state.stages[stage.stage_id];
+            if (!stageState)
+                continue;
+            const artifacts = stageArtifactRefs(stage.stage_id, stageState.artifacts);
+            for (const artifact of artifacts) {
+                await this.recordCompileRunEvent(compiledPath, runId, {
+                    type: "artifact.written",
+                    event_id: createRunEventId("event"),
+                    run_id: runId,
+                    timestamp: stageState.finished_at ?? createRunEventTimestamp(),
+                    stage_id: stage.stage_id,
+                    artifact,
+                });
+            }
+            await this.recordCompileRunEvent(compiledPath, runId, {
+                type: "proof.updated",
+                event_id: createRunEventId("event"),
+                run_id: runId,
+                timestamp: stageState.finished_at ?? createRunEventTimestamp(),
+                stage_id: stage.stage_id,
+                proof: proofForStage({
+                    runId,
+                    stageId: stage.stage_id,
+                    summary: stageState.summary,
+                    stageState,
+                    artifacts,
+                }),
+            });
+        }
+    }
+    readLatestComparison(datasetName) {
+        const latestPath = datasetLatestTestStatePath(this.rootPath, datasetName);
+        if (!existsSync(latestPath))
+            return null;
+        const parsed = TestRunComparisonSchema.safeParse(readJsonFile(latestPath));
+        return parsed.success ? parsed.data : null;
+    }
+    checksEvaluatedEvent(runId, comparison) {
+        const target = comparison.compiled ?? comparison.raw;
+        return {
+            type: "checks.evaluated",
+            event_id: createRunEventId("event"),
+            run_id: runId,
+            timestamp: createRunEventTimestamp(),
+            passed: target?.passed_cases ?? 0,
+            total: target?.total_cases ?? 0,
+            test_run_id: runId,
+        };
+    }
+    readinessUpdatedEvent(runId, preparation, readiness) {
+        return {
+            type: "readiness.updated",
+            event_id: createRunEventId("event"),
+            run_id: runId,
+            timestamp: createRunEventTimestamp(),
+            preparation,
+            readiness,
+        };
+    }
+    writeTestRun(compiledPath, run) {
+        mkdirSync(testRunsRoot(compiledPath), { recursive: true });
+        writeJsonFile(testRunPath(compiledPath, run.run_id), TestRunResourceSchema.parse(run));
+    }
+}
+export function createLocalServiceRuntime(options) {
+    return new LocalServiceRuntime(options);
+}