@interf/compiler 0.9.1 → 0.9.4

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

@@ -4,22 +4,24 @@ 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 { RuntimeRunSchema, } from "../compiler/lib/schema.js";
+import { ReadinessStateSchema, } from "../contracts/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 { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project-model/source-config.js";
+import { defaultPreparationNameForPath, listSourceFolderChoices, normalizeSourcePreparationPathForConfig, } from "../project-model/source-folders.js";
+import { portableContextPath, } from "../project-model/project-paths.js";
+import { getCompiledMethod, listCompiledMethodChoices, } from "../method-package/method-definitions.js";
+import { resolveMethodPackageSourcePath, } from "../method-package/local-methods.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 { readSavedReadinessCheckRun, } from "../testing/readiness-check-run.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 { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, MethodResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, PreparationReadinessStateSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationResourceSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
 import { buildLocalServiceUrl, } from "./routes.js";
 import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, PreparationSetupActionValuesSchema, } from "./action-values.js";
+import { compileRunToObservability, jobRunToObservability, testRunToObservability, uniqueArtifacts, } from "./run-observability.js";
 function createRunId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -39,6 +41,22 @@ function writeJsonFile(filePath, value) {
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
+function sanitizeActionProposalPlan(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const plan = { ...value };
+    for (const key of ["preparation", "method", "title", "summary", "assistant_message", "command_preview"]) {
+        const current = plan[key];
+        if (current === null || current === undefined) {
+            delete plan[key];
+            continue;
+        }
+        if (typeof current === "string" && current.trim().length === 0) {
+            delete plan[key];
+        }
+    }
+    return plan;
+}
 function compileRunsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "compile-runs");
 }
@@ -152,110 +170,6 @@ function detectedExecutorOptions(currentAgentName) {
         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,
@@ -314,15 +228,6 @@ function logsForRuntimeRun(run) {
         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;
@@ -495,481 +400,6 @@ function applyEventToLocalJob(run, event) {
         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()
@@ -989,12 +419,23 @@ function numberValue(values, key) {
 }
 function testModeFromValues(values) {
     const value = stringValue(values, "mode") ?? stringValue(values, "target");
+    if (value === "source-files")
+        return "raw";
+    if (value === "portable-context")
+        return "compiled";
     return value === "raw" || value === "compiled" || value === "both" ? value : null;
 }
 function testModeValue(values, defaultMode = "both") {
     return testModeFromValues(values) ?? defaultMode;
 }
-function workflowIdForProposal(message, values) {
+function testModeCliTarget(mode) {
+    if (mode === "raw")
+        return "source-files";
+    if (mode === "compiled")
+        return "portable-context";
+    return "both";
+}
+function methodIdForProposal(message, values) {
     const explicit = stringValue(values, "method_id") ??
         stringValue(values, "method");
     return explicit ?? `custom-${slugFromText(message)}`;
@@ -1003,35 +444,53 @@ function actionValueMethodTaskPrompt(values) {
     const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
     return parsed.success ? methodAuthoringTaskPrompt(parsed.data) : null;
 }
-function datasetSetupPathValue(values) {
+function booleanValue(values, key) {
+    const value = values?.[key];
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "yes" || normalized === "1")
+            return true;
+        if (normalized === "false" || normalized === "no" || normalized === "0")
+            return false;
+    }
+    return null;
+}
+function preparationSetupPathValue(values) {
     return stringValue(values, "path") ??
         stringValue(values, "source_folder_path") ??
         stringValue(values, "source_path") ??
         stringValue(values, "source_folder") ??
         stringValue(values, "folder");
 }
-function datasetSetupNameValue(values) {
+function preparationSetupNameValue(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) {
+function actionCommandPreview(actionType, preparationName, methodId, values) {
     if (actionType === "preparation-setup") {
-        const datasetPart = datasetName ? ` # Preparation: ${datasetName}` : "";
-        const pathPart = datasetSetupPathValue(values);
-        return pathPart ? `interf init # source: ${pathPart}${datasetPart}` : `interf init${datasetPart}`;
+        const preparationPart = preparationName ? ` # Preparation: ${preparationName}` : "";
+        const pathPart = preparationSetupPathValue(values);
+        const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
+        const setupPreview = pathPart ? `interf init # source: ${pathPart}${preparationPart}` : `interf init${preparationPart}`;
+        if (booleanValue(values, "prepare_after_setup") && preparationName) {
+            return `${setupPreview}\ninterf compile --preparation ${preparationName}${methodSuffix}`;
+        }
+        return setupPreview;
     }
     if (actionType === "compile") {
-        const workflowSuffix = workflowId ? ` # Method: ${workflowId}` : "";
-        return datasetName
-            ? `interf compile --preparation ${datasetName}${workflowSuffix}`
-            : `interf compile${workflowSuffix}`;
+        const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
+        return preparationName
+            ? `interf compile --preparation ${preparationName}${methodSuffix}`
+            : `interf compile${methodSuffix}`;
     }
     if (actionType === "test") {
-        const mode = testModeValue(values);
-        return datasetName
-            ? `interf test --preparation ${datasetName} --target ${mode}`
+        const mode = testModeCliTarget(testModeValue(values));
+        return preparationName
+            ? `interf test --preparation ${preparationName} --target ${mode}`
             : `interf test --target ${mode}`;
     }
     if (actionType === "readiness-check-draft") {
@@ -1042,28 +501,31 @@ function actionCommandPreview(actionType, datasetName, workflowId, values) {
     }
     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);
+function hasCompiledTestTarget(sourcePath, preparationConfig) {
+    const compiledPath = portableContextPath(sourcePath, preparationConfig.name);
     if (!existsSync(compiledPath))
         return false;
-    return createCompiledTestTarget(compiledPath, datasetConfig.name, methodIdForSourcePreparationConfig(datasetConfig) ?? "interf").eligible;
+    return createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID).eligible;
 }
-function actionAssistantMessage(actionType, datasetName, commandPreview) {
-    const datasetSuffix = datasetName ? ` for Preparation "${datasetName}"` : "";
+function actionAssistantMessage(actionType, preparationName, commandPreview, options = {}) {
+    const preparationSuffix = preparationName ? ` for Preparation "${preparationName}"` : "";
     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 (options.prepareAfterSetup) {
+            return `Interf prepared a prepare proposal${preparationSuffix}. Approve to save the Preparation and run the selected Method against the Source Folder. CLI equivalent: ${commandPreview}`;
+        }
+        return `Interf prepared a Preparation setup proposal${preparationSuffix}. Approve to save the source folder as a Preparation. Preparing portable context is a separate compile run. 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}`;
+        return `Interf prepared a prepare-run proposal${preparationSuffix}. 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}`;
+        return `Interf prepared a readiness-check proposal${preparationSuffix}. 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}`;
+        return `Interf prepared a readiness-check draft proposal${preparationSuffix}. 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 `Interf prepared a Method draft proposal${preparationSuffix}. 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.";
 }
@@ -1111,27 +573,25 @@ function readinessStateToPreparationReadiness(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);
+function buildPreparationResource(rootPath, preparation, readiness, latestCompileRunId, latestTestRunId) {
+    const methodId = methodIdForSourcePreparationConfig(preparation);
     return PreparationResourceSchema.parse({
-        id: resource.dataset.name,
-        name: resource.dataset.name,
-        preparation: resource.dataset,
-        source_path: resolveSourceDatasetPath(rootPath, resource.dataset),
+        id: preparation.name,
+        name: preparation.name,
+        preparation,
+        source_path: resolveSourcePreparationPath(rootPath, preparation),
         method_id: methodId,
-        checks: resource.dataset.checks,
+        checks: preparation.checks,
         portable_context: {
-            preparation: resource.dataset.name,
-            path: resource.portable_context_path,
-            exists: resource.portable_context_path !== null,
+            preparation: preparation.name,
+            path: readiness.portable_context_path,
+            exists: readiness.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),
+        portable_context_path: readiness.portable_context_path,
+        readiness: readinessStateToPreparationReadiness(readiness),
         runs: {
             latest_compile_run_id: latestCompileRunId,
             latest_test_run_id: latestTestRunId,
@@ -1140,7 +600,7 @@ function datasetResourceToPreparationResource(rootPath, resource) {
         latest_test_run_id: latestTestRunId,
     });
 }
-function workflowPackageResourceToMethodResource(resource) {
+function buildMethodResource(resource) {
     return MethodResourceSchema.parse({
         id: resource.id,
         method_id: resource.id,
@@ -1149,7 +609,7 @@ function workflowPackageResourceToMethodResource(resource) {
         ...(resource.hint ? { hint: resource.hint } : {}),
         source_kind: resource.source_kind,
         built_in: resource.built_in,
-        active_for_preparations: resource.active_for_datasets,
+        active_for_preparations: resource.active_for_preparations,
         stages: resource.stages,
     });
 }
@@ -1183,31 +643,17 @@ export class LocalServiceRuntime {
             ...(this.packageVersion ? { package_version: this.packageVersion } : {}),
         });
     }
-    listDatasets() {
+    listPreparations() {
         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,
-            });
+        return listSourcePreparationConfigs(config).map((preparation) => {
+            const compileRuns = this.listCompileRunsForPreparation(preparation.name);
+            const testRuns = this.listTestRunsForPreparation(preparation.name);
+            const readiness = this.computePreparationReadiness(preparation);
+            return buildPreparationResource(this.rootPath, preparation, readiness, compileRuns[0]?.run_id ?? null, 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;
+        return this.listPreparations().find((preparation) => preparation.name === preparationName) ?? null;
     }
     listPreparationReadiness() {
         return this.listReadiness().map(readinessStateToPreparationReadiness);
@@ -1218,21 +664,23 @@ export class LocalServiceRuntime {
     }
     listReadiness() {
         const config = loadSourceFolderConfig(this.rootPath);
-        return listSourceDatasetConfigs(config).map((dataset) => this.computeDatasetReadiness(dataset));
+        return listSourcePreparationConfigs(config).map((preparation) => this.computePreparationReadiness(preparation));
     }
-    getReadiness(datasetName) {
-        const dataset = findSourceDatasetConfig(loadSourceFolderConfig(this.rootPath), datasetName);
-        return dataset ? this.computeDatasetReadiness(dataset) : null;
+    getReadiness(preparationName) {
+        const preparation = findSourcePreparationConfig(loadSourceFolderConfig(this.rootPath), preparationName);
+        return preparation ? this.computePreparationReadiness(preparation) : null;
     }
-    computeDatasetReadiness(dataset) {
+    computePreparationReadiness(preparation) {
         const generatedAt = new Date().toISOString();
-        const compiledPath = portableContextPath(this.rootPath, dataset.name);
+        const compiledPath = portableContextPath(this.rootPath, preparation.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 compiledTarget = createCompiledTestTarget(compiledPath, preparation.name, methodIdForSourcePreparationConfig(preparation) ?? DEFAULT_METHOD_ID);
+        const contextReady = compiledTarget.eligible;
+        const compileRun = this.listCompileRunsForPreparation(preparation.name)[0] ?? null;
+        const testRun = this.listTestRunsForPreparation(preparation.name)[0] ?? null;
+        const comparison = this.readLatestComparison(preparation.name);
+        const configuredChecks = preparation.checks.length;
+        const currentFingerprint = configuredChecks > 0 ? fingerprintReadinessChecks(preparation.checks) : null;
         const comparisonFingerprint = comparison?.checks_fingerprint ?? null;
         const sourceResult = readinessTargetResult(comparison?.raw, currentFingerprint, comparisonFingerprint);
         const contextResult = readinessTargetResult(comparison?.compiled, currentFingerprint, comparisonFingerprint);
@@ -1244,19 +692,19 @@ export class LocalServiceRuntime {
                     ok: false,
                     status: "not-built",
                     summary: "No compile run has built portable context yet.",
-                    artifact_path: contextExists ? compiledPath : null,
+                    artifact_path: contextReady ? compiledPath : null,
                 };
             }
             if (compileRun.status === "succeeded") {
                 return {
                     gate: "compile-run",
-                    ok: contextExists,
-                    status: contextExists ? "built" : "failed",
-                    summary: contextExists
+                    ok: contextReady,
+                    status: contextReady ? "built" : "failed",
+                    summary: contextReady
                         ? "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,
+                    artifact_path: contextReady ? compiledPath : null,
                 };
             }
             if (compileRun.status === "queued" || compileRun.status === "running") {
@@ -1277,7 +725,7 @@ export class LocalServiceRuntime {
                     ? "Latest compile run was cancelled."
                     : "Latest compile run failed.",
                 run_id: compileRun.run_id,
-                artifact_path: contextExists ? compiledPath : null,
+                artifact_path: contextReady ? compiledPath : null,
             };
         })();
         const checks = [
@@ -1288,12 +736,12 @@ export class LocalServiceRuntime {
             },
             {
                 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,
+                ok: contextReady,
+                status: contextReady ? "built" : "not-built",
+                summary: contextReady
+                    ? "Portable context is built."
+                    : "Portable context has not been built.",
+                artifact_path: contextReady ? compiledPath : null,
             },
             compileCheck,
             {
@@ -1320,7 +768,7 @@ export class LocalServiceRuntime {
                 return "checking";
             if (compileRun?.status === "failed" || compileRun?.status === "cancelled")
                 return "failed";
-            if (!compileRun || !contextExists)
+            if (!compileRun || !contextReady)
                 return "not-built";
             if (configuredChecks === 0)
                 return "not-configured";
@@ -1335,11 +783,11 @@ export class LocalServiceRuntime {
             kind: "interf-readiness-state",
             version: 1,
             generated_at: generatedAt,
-            preparation: dataset.name,
+            preparation: preparation.name,
             status,
             ready,
             summary: readinessSummaryForStatus(status),
-            portable_context_path: contextExists ? compiledPath : null,
+            portable_context_path: contextReady ? compiledPath : null,
             latest_compile_run_id: compileRun?.run_id ?? null,
             latest_test_run_id: testRun?.run_id ?? null,
             compile: compileCheck,
@@ -1353,12 +801,12 @@ export class LocalServiceRuntime {
             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);
+    listSourceFiles(preparationName) {
+        const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))
+            .filter((preparation) => !preparationName || preparation.name === preparationName);
+        return preparations.flatMap((preparation) => {
+            const sourceFolderPath = resolveSourcePreparationPath(this.rootPath, preparation);
+            const compiledPath = portableContextPath(this.rootPath, preparation.name);
             return discoverSourceFiles(sourceFolderPath, compiledPath).sourceFiles.map((relativePath) => {
                 const absolutePath = join(sourceFolderPath, relativePath);
                 let sizeBytes = 0;
@@ -1373,7 +821,7 @@ export class LocalServiceRuntime {
                     modifiedAt = null;
                 }
                 return SourceFileResourceSchema.parse({
-                    preparation: dataset.name,
+                    preparation: preparation.name,
                     path: relativePath,
                     absolute_path: absolutePath,
                     size_bytes: sizeBytes,
@@ -1406,24 +854,22 @@ export class LocalServiceRuntime {
             });
         });
     }
-    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) => ({
+    listMethods() {
+        const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath));
+        const choices = listCompiledMethodChoices(this.rootPath);
+        return choices.map((method) => {
+            const activeForPreparations = preparations
+                .filter((preparation) => (methodIdForSourcePreparationConfig(preparation) ?? DEFAULT_METHOD_ID) === method.id)
+                .map((preparation) => preparation.name);
+            return buildMethodResource({
+                id: method.id,
+                path: resolveMethodPackageSourcePath(this.rootPath, method.id) ?? method.id,
+                label: method.label,
+                hint: method.hint,
+                source_kind: method.scope === "builtin" ? "builtin" : "local",
+                built_in: method.scope === "builtin",
+                active_for_preparations: activeForPreparations,
+                stages: method.stages.map((stage) => ({
                     id: stage.id,
                     label: stage.label,
                     description: stage.description,
@@ -1436,15 +882,8 @@ export class LocalServiceRuntime {
             });
         });
     }
-    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;
+        return this.listMethods().find((method) => method.id === methodId) ?? null;
     }
     listJobs() {
         return newestJobFirst(listJsonFiles(localJobsRoot(this.rootPath))
@@ -1713,27 +1152,29 @@ export class LocalServiceRuntime {
         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);
+    async createPreparationSetupRun(requestValue) {
+        const request = PreparationSetupCreateRequestSchema.parse(requestValue);
+        const preparationConfig = request.preparation;
+        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? "interf-default";
+        const normalizedPreparationConfig = {
+            ...preparationConfig,
+            method: methodId,
+        };
+        const sourceFolderPath = resolveSourcePreparationPath(this.rootPath, preparationConfig);
         const job = this.createJobRun({
             job_type: "preparation-setup",
-            title: `Create Preparation ${datasetConfig.name}`,
-            preparation: datasetConfig.name,
+            title: `Create Preparation ${preparationConfig.name}`,
+            preparation: preparationConfig.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,
+                        preparation: preparationConfig.name,
+                        path: preparationConfig.path,
                     },
                 },
                 {
@@ -1743,14 +1184,6 @@ export class LocalServiceRuntime {
                         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";
@@ -1760,12 +1193,12 @@ export class LocalServiceRuntime {
                 step_id: "validate-source",
                 message: "Validating source folder.",
                 input: {
-                    path: datasetConfig.path,
+                    path: preparationConfig.path,
                     source_folder_path: sourceFolderPath,
                 },
             });
             if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
-                throw new Error(`Source folder "${datasetConfig.path}" is not available.`);
+                throw new Error(`Source folder "${preparationConfig.path}" is not available.`);
             }
             this.appendJobRunEvent(job.run_id, {
                 type: "step.completed",
@@ -1781,48 +1214,28 @@ export class LocalServiceRuntime {
                 step_id: "write-config",
                 message: "Saving Preparation in the control plane config.",
                 input: {
-                    preparation: datasetConfig.name,
-                    path: datasetConfig.path,
+                    preparation: preparationConfig.name,
+                    path: preparationConfig.path,
                 },
             });
-            upsertSourceDatasetConfig(this.rootPath, datasetConfig);
+            upsertSourcePreparationConfig(this.rootPath, normalizedPreparationConfig);
             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,
+                    preparation: preparationConfig.name,
                 },
             });
             this.setJobRunResult(job.run_id, {
-                preparation: datasetConfig,
+                preparation: normalizedPreparationConfig,
                 source_folder_path: sourceFolderPath,
-                portable_context_path: compiledPath,
+                config_path: join(this.rootPath, "interf", "interf.json"),
             });
             this.appendJobRunEvent(job.run_id, {
                 type: "job.completed",
-                message: `Preparation ${datasetConfig.name} is ready for Interf runs.`,
+                message: `Preparation ${preparationConfig.name} is saved. Run prepare to build portable context.`,
             });
         }
         catch (error) {
@@ -1842,8 +1255,8 @@ export class LocalServiceRuntime {
         }
         return this.getJob(job.run_id) ?? job;
     }
-    async createWorkflowAuthoringRun(requestValue) {
-        const request = WorkflowAuthoringCreateRequestSchema.parse(requestValue);
+    async createMethodAuthoringRun(requestValue) {
+        const request = MethodAuthoringCreateRequestSchema.parse(requestValue);
         const job = this.createJobRun({
             job_type: "method-authoring",
             title: `Draft Method ${request.method_id}`,
@@ -1908,25 +1321,26 @@ export class LocalServiceRuntime {
                 task_prompt: request.task_prompt,
             },
         });
-        void this.runWorkflowAuthoringInBackground(request, job.run_id);
+        void this.runMethodAuthoringInBackground(request, job.run_id);
         return this.getJob(job.run_id) ?? job;
     }
     listPortableContexts() {
-        return this.listDatasets().map((dataset) => this.getPortableContext(dataset.dataset.name))
+        return listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))
+            .map((preparation) => this.getPortableContext(preparation.name))
             .filter((context) => context !== null);
     }
-    getPortableContext(datasetName) {
-        const dataset = findSourceDatasetConfig(loadSourceFolderConfig(this.rootPath), datasetName);
-        if (!dataset)
+    getPortableContext(preparationName) {
+        const preparation = findSourcePreparationConfig(loadSourceFolderConfig(this.rootPath), preparationName);
+        if (!preparation)
             return null;
-        const path = portableContextPath(this.rootPath, dataset.name);
+        const path = portableContextPath(this.rootPath, preparation.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);
+        const compileRuns = this.listCompileRunsForPreparation(preparation.name);
+        const testRuns = this.listTestRunsForPreparation(preparation.name);
+        const readiness = this.computePreparationReadiness(preparation);
+        const method = config?.method ?? methodIdForSourcePreparationConfig(preparation);
         return PortableContextResourceSchema.parse({
-            preparation: dataset.name,
+            preparation: preparation.name,
             path,
             exists: existsSync(path),
             readiness,
@@ -1937,10 +1351,11 @@ export class LocalServiceRuntime {
         });
     }
     listCompileRuns() {
-        return newestCompileFirst(this.listDatasets().flatMap((dataset) => this.listCompileRunsForDataset(dataset.dataset.name))).map((run) => CompileRunResourceSchema.parse({ run }));
+        return newestCompileFirst(listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))
+            .flatMap((preparation) => this.listCompileRunsForPreparation(preparation.name))).map((run) => CompileRunResourceSchema.parse({ run }));
     }
-    listCompileRunsForDataset(datasetName) {
-        const compiledPath = portableContextPath(this.rootPath, datasetName);
+    listCompileRunsForPreparation(preparationName) {
+        const compiledPath = portableContextPath(this.rootPath, preparationName);
         return newestCompileFirst(listJsonFiles(compileRunsRoot(compiledPath))
             .map(readCompileRunAt)
             .filter((run) => run !== null));
@@ -1971,47 +1386,50 @@ export class LocalServiceRuntime {
     }
     async createCompileRun(requestValue) {
         const request = CompileRunCreateRequestSchema.parse(requestValue);
-        const datasetConfig = this.resolveDatasetConfig(request.preparation, {
+        const preparationConfig = this.resolvePreparationConfig(request.preparation, {
             method: request.method,
             max_attempts: request.max_attempts,
             max_loops: request.max_loops,
         });
-        const compiledPath = this.ensureCompiledForRun(datasetConfig);
+        const compiledPath = this.ensureCompiledForRun(preparationConfig);
         const runId = createRunId("compile");
         const now = new Date().toISOString();
-        const workflow = getCompiledWorkflow(methodIdForSourcePreparationConfig(datasetConfig) ?? "interf", {
+        const method = getCompiledMethod(methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID, {
             sourcePath: this.rootPath,
         });
-        const stageTotal = workflow.stages.length;
+        const stageTotal = method.stages.length;
         const run = CompileRunSchema.parse({
             kind: "interf-compile-run",
             version: 1,
             run_id: runId,
             status: "running",
-            preparation: datasetConfig.name,
-            method: workflow.id,
+            preparation: preparationConfig.name,
+            method: method.id,
             backend: "native",
-            source_path: resolveSourceDatasetPath(this.rootPath, datasetConfig),
+            source_path: resolveSourcePreparationPath(this.rootPath, preparationConfig),
             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: {
+            stages: method.stages
+                .map((stage, index) => {
+                return {
+                    run_id: runId,
+                    stage_id: stage.id,
                     stage_label: stage.label,
                     stage_index: index,
                     stage_total: stageTotal,
-                    reads: stage.reads,
-                    writes: stage.writes,
-                    ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
-                },
-                artifacts: [],
-            })),
+                    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);
@@ -2020,8 +1438,8 @@ export class LocalServiceRuntime {
             event_id: createRunEventId("event"),
             run_id: runId,
             timestamp: now,
-            preparation: datasetConfig.name,
-            method: workflow.id,
+            preparation: preparationConfig.name,
+            method: method.id,
             portable_context_path: compiledPath,
             backend: "native",
         });
@@ -2032,17 +1450,18 @@ export class LocalServiceRuntime {
             runId,
             sourcePath: this.rootPath,
             compiledPath,
-            datasetConfig,
+            preparationConfig,
             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)));
+        return newestFirst(listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))
+            .flatMap((preparation) => this.listTestRunsForPreparation(preparation.name)));
     }
-    listTestRunsForDataset(datasetName) {
-        const compiledPath = portableContextPath(this.rootPath, datasetName);
+    listTestRunsForPreparation(preparationName) {
+        const compiledPath = portableContextPath(this.rootPath, preparationName);
         return newestFirst(listJsonFiles(testRunsRoot(compiledPath))
             .map(readTestRunAt)
             .filter((run) => run !== null));
@@ -2052,15 +1471,15 @@ export class LocalServiceRuntime {
     }
     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 preparationConfig = this.resolvePreparationConfig(request.preparation);
+        const compiledPath = portableContextPath(this.rootPath, preparationConfig.name);
+        const compiledTarget = createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID);
         const runId = createRunId("test");
         const now = new Date().toISOString();
         const initial = TestRunResourceSchema.parse({
             run_id: runId,
             status: "running",
-            preparation: datasetConfig.name,
+            preparation: preparationConfig.name,
             mode: request.mode,
             source_path: this.rootPath,
             portable_context_path: compiledTarget.eligible ? compiledPath : null,
@@ -2073,7 +1492,7 @@ export class LocalServiceRuntime {
             runId,
             sourcePath: this.rootPath,
             compiledPath,
-            datasetConfig,
+            preparationConfig,
         }, initial);
         return initial;
     }
@@ -2120,7 +1539,7 @@ export class LocalServiceRuntime {
                 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 comparison = result.comparison ?? this.readLatestComparison(context.preparationConfig.name);
             const resultEvent = comparison
                 ? this.checksEvaluatedEvent(context.runId, comparison)
                 : null;
@@ -2133,13 +1552,13 @@ export class LocalServiceRuntime {
                 ...(!result.ok ? { error: result.error ?? "Readiness check failed." } : {}),
             });
             this.writeTestRun(context.compiledPath, nextWithoutReadiness);
-            const readiness = this.computeDatasetReadiness(context.datasetConfig);
+            const readiness = this.computePreparationReadiness(context.preparationConfig);
             const next = TestRunResourceSchema.parse({
                 ...nextWithoutReadiness,
                 readiness,
                 events: [
                     ...nextWithoutReadiness.events,
-                    this.readinessUpdatedEvent(context.runId, context.datasetConfig.name, readiness),
+                    this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness),
                 ],
             });
             this.writeTestRun(context.compiledPath, next);
@@ -2152,11 +1571,11 @@ export class LocalServiceRuntime {
                 error: error instanceof Error ? error.message : String(error),
             });
             this.writeTestRun(context.compiledPath, failedWithoutReadiness);
-            const readiness = this.computeDatasetReadiness(context.datasetConfig);
+            const readiness = this.computePreparationReadiness(context.preparationConfig);
             const next = TestRunResourceSchema.parse({
                 ...failedWithoutReadiness,
                 readiness,
-                events: [this.readinessUpdatedEvent(context.runId, context.datasetConfig.name, readiness)],
+                events: [this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness)],
             });
             this.writeTestRun(context.compiledPath, next);
         }
@@ -2213,12 +1632,12 @@ export class LocalServiceRuntime {
             });
         }
     }
-    async runWorkflowAuthoringInBackground(request, runId) {
+    async runMethodAuthoringInBackground(request, runId) {
         try {
-            if (!this.handlers.createWorkflowAuthoringRun) {
+            if (!this.handlers.createMethodAuthoringRun) {
                 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)));
+            const result = MethodAuthoringResultSchema.parse(await this.handlers.createMethodAuthoringRun(request, this.jobRunContext(runId)));
             this.setJobRunResult(runId, result);
             this.appendJobRunEvent(runId, {
                 type: result.status === "executor-failed" ? "step.failed" : "step.completed",
@@ -2295,12 +1714,12 @@ export class LocalServiceRuntime {
             },
         };
     }
-    defaultDatasetName() {
-        const dataset = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath))[0];
-        if (!dataset) {
+    defaultPreparationName() {
+        const preparation = listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))[0];
+        if (!preparation) {
             throw new Error("No Preparation is saved in this control plane folder.");
         }
-        return dataset.name;
+        return preparation.name;
     }
     async planActionProposal(request) {
         if (!this.handlers.planActionProposal) {
@@ -2310,17 +1729,17 @@ export class LocalServiceRuntime {
                 assistant_message: "No local action planner is configured for this Interf Workspace.",
             });
         }
-        const datasets = listSourceDatasetConfigs(loadSourceFolderConfig(this.rootPath));
+        const preparations = listSourcePreparationConfigs(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);
+                preparations,
+                preparationHealth: preparations.map((preparation) => {
+                    const readinessChecks = preparation.checks?.length ?? 0;
+                    const portableContextReady = hasCompiledTestTarget(this.rootPath, preparation);
                     return {
-                        name: dataset.name,
+                        name: preparation.name,
                         readiness_checks: readinessChecks,
                         portable_context_ready: portableContextReady,
                         can_check_readiness: readinessChecks > 0 && portableContextReady,
@@ -2342,7 +1761,7 @@ export class LocalServiceRuntime {
                 assistant_message: ACTION_PLANNER_CLARIFICATION_MESSAGE,
             });
         }
-        const parsed = ActionProposalPlanSchema.safeParse(rawPlan);
+        const parsed = ActionProposalPlanSchema.safeParse(sanitizeActionProposalPlan(rawPlan));
         if (parsed.success)
             return parsed.data;
         return ActionProposalPlanSchema.parse({
@@ -2351,9 +1770,9 @@ export class LocalServiceRuntime {
             assistant_message: ACTION_PLANNER_CLARIFICATION_MESSAGE,
         });
     }
-    buildDatasetSetupRequest(request, plan, values) {
+    buildPreparationSetupRequest(request, plan, values) {
         const sourceFolderChoices = listSourceFolderChoices(this.rootPath);
-        const selectedPath = datasetSetupPathValue(values) ??
+        const selectedPath = preparationSetupPathValue(values) ??
             (sourceFolderChoices.length === 1 ? sourceFolderChoices[0].value : null);
         if (!selectedPath) {
             return {
@@ -2362,30 +1781,33 @@ export class LocalServiceRuntime {
         }
         let normalizedPath;
         try {
-            normalizedPath = normalizeSourceDatasetPathForConfig(this.rootPath, selectedPath);
+            normalizedPath = normalizeSourcePreparationPathForConfig(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
+        const explicitName = preparationSetupNameValue(values) ?? plan.preparation ?? request.preparation;
+        const preparationName = 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";
+            : defaultPreparationNameForPath(normalizedPath);
+        const requestMethodId = stringValue(request.values, "method");
+        const valueMethodId = stringValue(values, "method");
+        const methodId = requestMethodId ?? plan.method ?? valueMethodId ?? "interf-default";
+        const prepareAfterSetup = booleanValue(values, "prepare_after_setup") ?? false;
         try {
             return {
-                datasetName,
-                workflowId,
-                request: DatasetSetupCreateRequestSchema.parse({
+                preparationName,
+                methodId,
+                prepareAfterSetup,
+                request: PreparationSetupCreateRequestSchema.parse({
+                    prepare_after_setup: prepareAfterSetup,
                     preparation: {
-                        name: datasetName,
+                        name: preparationName,
                         path: normalizedPath,
                         about: stringValue(values, "about") ?? stringValue(values, "task_prompt") ?? request.message,
-                        method: workflowId,
+                        method: methodId,
                         checks: [],
                     },
                 }),
@@ -2399,7 +1821,9 @@ export class LocalServiceRuntime {
     }
     async buildActionProposal(request) {
         const plan = await this.planActionProposal(request);
-        const actionType = plan.action_type;
+        const structuredPreparationSetup = PreparationSetupActionValuesSchema.safeParse(request.values);
+        const actionType = structuredPreparationSetup.success ? "preparation-setup" : plan.action_type;
+        const usePlannerText = plan.action_type === actionType;
         const now = new Date().toISOString();
         if (actionType === "clarification") {
             return ActionProposalResourceSchema.parse({
@@ -2433,7 +1857,7 @@ export class LocalServiceRuntime {
             ...(request.values ?? {}),
         };
         if (actionType === "preparation-setup") {
-            const setup = this.buildDatasetSetupRequest(request, plan, proposalValues);
+            const setup = this.buildPreparationSetupRequest(request, plan, proposalValues);
             if ("error" in setup) {
                 return ActionProposalResourceSchema.parse({
                     kind: "interf-action-proposal",
@@ -2460,10 +1884,14 @@ export class LocalServiceRuntime {
                     error: null,
                 });
             }
-            const commandPreview = plan.command_preview ??
-                actionCommandPreview(actionType, setup.datasetName, setup.workflowId, {
-                    ...proposalValues,
-                    path: setup.request.preparation.path,
+            const commandValues = {
+                ...proposalValues,
+                path: setup.request.preparation.path,
+                prepare_after_setup: setup.prepareAfterSetup,
+            };
+            const commandPreview = (usePlannerText ? plan.command_preview : undefined) ??
+                actionCommandPreview(actionType, setup.preparationName, setup.methodId, {
+                    ...commandValues,
                 });
             return ActionProposalResourceSchema.parse({
                 kind: "interf-action-proposal",
@@ -2471,13 +1899,17 @@ export class LocalServiceRuntime {
                 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),
+                title: (usePlannerText ? plan.title : undefined) ?? (setup.prepareAfterSetup ? `Prepare ${setup.preparationName}` : `Create Preparation ${setup.preparationName}`),
+                summary: (usePlannerText ? plan.summary : undefined) ?? (setup.prepareAfterSetup
+                    ? "Save this source folder as a Preparation and run the selected Method."
+                    : "Save this source folder as an Interf Preparation."),
+                assistant_message: (usePlannerText ? plan.assistant_message : undefined) ?? actionAssistantMessage(actionType, setup.preparationName, commandPreview, {
+                    prepareAfterSetup: setup.prepareAfterSetup,
+                }),
                 command_preview: commandPreview,
                 message: request.message,
-                preparation: setup.datasetName,
-                method: setup.workflowId,
+                preparation: setup.preparationName,
+                method: setup.methodId,
                 request: setup.request,
                 created_at: now,
                 updated_at: now,
@@ -2488,18 +1920,16 @@ export class LocalServiceRuntime {
                 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 ??
+        const preparationConfig = this.resolvePreparationConfig(plan.preparation ?? request.preparation ?? this.defaultPreparationName());
+        const preparationPath = resolveSourcePreparationPath(this.rootPath, preparationConfig);
+        const requestedMethodId = stringValue(request.values, "method_id") ??
+            stringValue(request.values, "method");
+        const plannedMethodId = 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);
+            stringValue(plan.values, "method");
+        const methodId = actionType === "method-authoring"
+            ? requestedMethodId ?? plannedMethodId ?? methodIdForProposal(request.message, proposalValues)
+            : requestedMethodId ?? plannedMethodId ?? methodIdForSourcePreparationConfig(preparationConfig);
         const clarifyResolvedAction = (options) => ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
@@ -2510,8 +1940,8 @@ export class LocalServiceRuntime {
             summary: options.summary,
             assistant_message: options.assistantMessage,
             message: request.message,
-            preparation: datasetConfig.name,
-            method: workflowId ?? null,
+            preparation: preparationConfig.name,
+            method: methodId ?? null,
             request: {
                 message: request.message,
                 ...(proposalValues ? { values: proposalValues } : {}),
@@ -2526,65 +1956,65 @@ export class LocalServiceRuntime {
         });
         if (actionType === "test") {
             const requestedMode = testModeFromValues(proposalValues);
-            const hasReadinessChecks = (datasetConfig.checks ?? []).length > 0;
-            const portableContextReady = hasCompiledTestTarget(this.rootPath, datasetConfig);
+            const hasReadinessChecks = (preparationConfig.checks ?? []).length > 0;
+            const portableContextReady = hasCompiledTestTarget(this.rootPath, preparationConfig);
             if (!hasReadinessChecks) {
                 return clarifyResolvedAction({
-                    title: `Add readiness checks for ${datasetConfig.name}`,
+                    title: `Add readiness checks for ${preparationConfig.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.`,
+                    assistantMessage: `Preparation "${preparationConfig.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`,
+                    title: `Prepare ${preparationConfig.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.`,
+                    assistantMessage: `Preparation "${preparationConfig.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 } : {}),
+                    preparation: preparationConfig.name,
+                    ...(methodId ? { method: methodId } : {}),
                 };
             }
             if (actionType === "test") {
-                const defaultMode = hasCompiledTestTarget(this.rootPath, datasetConfig) ? "both" : "raw";
+                const defaultMode = hasCompiledTestTarget(this.rootPath, preparationConfig) ? "both" : "raw";
                 return {
-                    preparation: datasetConfig.name,
+                    preparation: preparationConfig.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,
+                    preparation: preparationConfig.name,
+                    source_folder_path: preparationPath,
+                    about: stringValue(proposalValues, "about") ?? preparationConfig.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}`,
+                preparation: preparationConfig.name,
+                source_folder_path: preparationPath,
+                method_id: methodId,
+                label: stringValue(proposalValues, "label") ?? `Custom ${preparationConfig.name}`,
                 hint: stringValue(proposalValues, "hint") ?? request.message,
                 task_prompt: actionValueMethodTaskPrompt(proposalValues) ?? stringValue(proposalValues, "task_prompt") ?? request.message,
-                checks: datasetConfig.checks ?? [],
+                checks: preparationConfig.checks ?? [],
             };
         })();
         const title = (() => {
             if (plan.title)
                 return plan.title;
             if (actionType === "compile")
-                return `Prepare ${datasetConfig.name}`;
+                return `Prepare ${preparationConfig.name}`;
             if (actionType === "test")
-                return `Check readiness for ${datasetConfig.name}`;
+                return `Check readiness for ${preparationConfig.name}`;
             if (actionType === "readiness-check-draft")
-                return `Draft readiness checks for ${datasetConfig.name}`;
-            return `Draft Method ${workflowId}`;
+                return `Draft readiness checks for ${preparationConfig.name}`;
+            return `Draft Method ${methodId}`;
         })();
         const summary = (() => {
             if (plan.summary)
@@ -2600,7 +2030,7 @@ export class LocalServiceRuntime {
         const previewValues = actionType === "test"
             ? { mode: actionRequest.mode }
             : proposalValues;
-        const commandPreview = plan.command_preview ?? actionCommandPreview(actionType, datasetConfig.name, workflowId, previewValues);
+        const commandPreview = plan.command_preview ?? actionCommandPreview(actionType, preparationConfig.name, methodId, previewValues);
         return ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
@@ -2609,11 +2039,11 @@ export class LocalServiceRuntime {
             action_type: actionType,
             title,
             summary,
-            assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, datasetConfig.name, commandPreview),
+            assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, preparationConfig.name, commandPreview),
             command_preview: commandPreview,
             message: request.message,
-            preparation: datasetConfig.name,
-            method: workflowId,
+            preparation: preparationConfig.name,
+            method: methodId,
             request: actionRequest,
             created_at: now,
             updated_at: now,
@@ -2643,7 +2073,17 @@ export class LocalServiceRuntime {
             };
         }
         if (proposal.action_type === "preparation-setup") {
-            const job = await this.createDatasetSetupRun(proposal.request);
+            const job = await this.createPreparationSetupRun(proposal.request);
+            if (proposal.request.prepare_after_setup) {
+                const resource = await this.createCompileRun({
+                    preparation: proposal.request.preparation.name,
+                    method: methodIdForSourcePreparationConfig(proposal.request.preparation) ?? DEFAULT_METHOD_ID,
+                });
+                return {
+                    runId: resource.run.run_id,
+                    runType: "compile-run",
+                };
+            }
             return {
                 runId: job.run_id,
                 runType: "job-run",
@@ -2656,29 +2096,29 @@ export class LocalServiceRuntime {
                 runType: "job-run",
             };
         }
-        const job = await this.createWorkflowAuthoringRun(proposal.request);
+        const job = await this.createMethodAuthoringRun(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.`);
+    resolvePreparationConfig(preparationName, overrides = {}) {
+        const preparation = findSourcePreparationConfig(loadSourceFolderConfig(this.rootPath), preparationName);
+        if (!preparation) {
+            throw new Error(`Preparation "${preparationName}" is not saved in this control plane folder.`);
         }
-        const method = overrides.method ?? overrides.workflow ?? methodIdForSourcePreparationConfig(dataset) ?? undefined;
+        const method = overrides.method ?? methodIdForSourcePreparationConfig(preparation) ?? undefined;
         return {
-            ...dataset,
+            ...preparation,
             ...(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);
+    ensureCompiledForRun(preparationConfig) {
+        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+        const compiledPath = ensurePortableContextScaffold(this.rootPath, preparationConfig.name, methodId);
+        syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
         return compiledPath;
     }
     readCompileRun(compiledPath, runId) {
@@ -2802,12 +2242,8 @@ export class LocalServiceRuntime {
             });
         }
     }
-    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;
+    readLatestComparison(preparationName) {
+        return readSavedReadinessCheckRun(this.rootPath, preparationName);
     }
     checksEvaluatedEvent(runId, comparison) {
         const target = comparison.compiled ?? comparison.raw;