@interf/compiler 0.9.3 → 0.9.5

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { CompileRunSchema, } from "../execution/lib/schema.js";
 import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
@@ -7,18 +7,21 @@ import { loadState, } from "../compiler/state.js";
 import { RuntimeRunSchema, } from "../compiler/lib/schema.js";
 import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
 import { discoverSourceFiles, } from "../compiler/discovery.js";
+import { resetCompiledGeneratedState, } from "../compiler/reset.js";
 import { ensurePortableContextScaffold, readInterfConfig, } from "../project-model/interf.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 { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, removeSourcePreparationConfig, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project-model/source-config.js";
+import { listSourceFolderChoices, } 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 { contextInterfaceArtifactPath, } from "../method-package/context-interface.js";
+import { methodDefinitionPath, resolveMethodPackageSourcePath, } from "../method-package/local-methods.js";
+import { seedLocalMethodPackageFromBase, } from "../method-package/interf-method-package.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 { readSavedReadinessCheckRun, } from "../testing/readiness-check-run.js";
 import { createCompiledTestTarget, } from "../testing/test-targets.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 { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalPlanActionTypeSchema, ActionProposalTypeSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, MethodResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, PreparationReadinessStateSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, PreparationResourceSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, 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";
@@ -317,6 +320,12 @@ function applyEventToCompileRun(run, event) {
                 finished_at: run.finished_at ?? now,
                 events: [...run.events, event],
             };
+        case "readiness.updated":
+            return {
+                ...run,
+                readiness: event.readiness,
+                events: [...run.events, event],
+            };
         default:
             break;
     }
@@ -409,10 +418,46 @@ function slugFromText(value) {
         .replace(/-+$/g, "");
     return slug || "custom";
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function stringValue(values, key) {
     const value = values?.[key];
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function actionTypeFromValues(values) {
+    const explicit = stringValue(values, "action_type") ?? stringValue(values, "service_action");
+    if (explicit) {
+        const parsed = ActionProposalPlanActionTypeSchema.safeParse(explicit);
+        if (parsed.success && parsed.data !== "clarification")
+            return parsed.data;
+    }
+    const action = stringValue(values, "action");
+    if (action === "compile" || action === "prepare-run" || action === "run-preparation")
+        return "compile";
+    if (action === "test" || action === "check-readiness")
+        return "test";
+    if (action === "draft-readiness-checks" || action === "readiness-check-draft")
+        return "readiness-check-draft";
+    if (action === "create-method" || action === "method-authoring")
+        return "method-authoring";
+    if (action === "method-duplicate" || action === "method-remove" || action === "method-change")
+        return "method-change";
+    if (action === "preparation-remove" || action === "preparation-change")
+        return "preparation-change";
+    if (action === "improve-preparation" || action === "method-improvement")
+        return "method-improvement";
+    return null;
+}
+function directServiceEndpointForAction(actionType) {
+    if (actionType === "preparation-setup")
+        return "/v1/preparation-setups";
+    if (actionType === "method-change")
+        return "/v1/method-changes";
+    if (actionType === "preparation-change")
+        return "/v1/preparation-changes";
+    return null;
+}
 function numberValue(values, key) {
     const value = values?.[key];
     return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -438,31 +483,88 @@ function testModeCliTarget(mode) {
 function methodIdForProposal(message, values) {
     const explicit = stringValue(values, "method_id") ??
         stringValue(values, "method");
-    return explicit ?? `custom-${slugFromText(message)}`;
+    const fromMessage = message.match(/\b(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\s+([a-z0-9][a-z0-9-]{0,79})\b/i)?.[1];
+    return explicit ?? fromMessage ?? `custom-${slugFromText(message)}`;
 }
 function actionValueMethodTaskPrompt(values) {
     const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
     return parsed.success ? methodAuthoringTaskPrompt(parsed.data) : null;
 }
-function preparationSetupPathValue(values) {
-    return stringValue(values, "path") ??
-        stringValue(values, "source_folder_path") ??
-        stringValue(values, "source_path") ??
-        stringValue(values, "source_folder") ??
-        stringValue(values, "folder");
+const METHOD_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as the Method authoring request before proposing the action\.?/gi;
+const METHOD_AUTHORING_LABELS = [
+    "Agent work",
+    "Portable-context output",
+    "Readiness checks",
+    "CLI preview",
+];
+function normalizeMethodAuthoringText(value) {
+    return value
+        .replace(/[│]+/g, " ")
+        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function extractMethodAuthoringSection(value, label) {
+    const otherLabels = METHOD_AUTHORING_LABELS
+        .filter((candidate) => candidate !== label)
+        .map(escapeRegExp)
+        .join("|");
+    const match = value.match(new RegExp(`${escapeRegExp(label)}\\s*:\\s*([\\s\\S]*?)(?=\\s*(?:${otherLabels})\\s*:|$)`, "i"));
+    return match?.[1] ? normalizeMethodAuthoringText(match[1]) : null;
+}
+function stripMethodCommandPrefix(value, methodId) {
+    const specific = new RegExp(`^(?:create|reate|eate|draft|author|build|make)\\s+(?:a\\s+new\\s+)?(?:interf\\s+)?method\\s+${escapeRegExp(methodId)}\\.?\\s*`, "i");
+    const generic = /^(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\b[^.]{0,180}\.\s*/i;
+    const stripped = normalizeMethodAuthoringText(value)
+        .replace(specific, "")
+        .replace(generic, "")
+        .trim();
+    return stripped || normalizeMethodAuthoringText(value);
 }
-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 methodAuthoringPromptFallback(message, methodId) {
+    const cleaned = message
+        .replace(/[│]+/g, " ")
+        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .trim();
+    const agentWork = extractMethodAuthoringSection(cleaned, "Agent work");
+    const portableOutput = extractMethodAuthoringSection(cleaned, "Portable-context output");
+    const readinessNotes = extractMethodAuthoringSection(cleaned, "Readiness checks");
+    const lines = [
+        agentWork ? `Agent work: ${stripMethodCommandPrefix(agentWork, methodId)}` : null,
+        portableOutput ? `Portable-context output: ${portableOutput}` : null,
+        readinessNotes ? `Readiness checks: ${readinessNotes}` : null,
+    ].filter((line) => Boolean(line));
+    if (lines.length > 0)
+        return lines.join("\n");
+    return stripMethodCommandPrefix(cleaned, methodId);
+}
+function methodAuthoringHintFromPrompt(prompt) {
+    const plain = normalizeMethodAuthoringText(prompt.replace(/\b(?:Agent work|Portable-context output|Readiness checks)\s*:/gi, " "));
+    if (plain.length <= 180)
+        return plain || "Custom Method";
+    const clipped = plain.slice(0, 177).replace(/\s+\S*$/, "").trim();
+    return `${clipped || plain.slice(0, 177)}...`;
+}
+function methodLabelFromId(methodId) {
+    return methodId
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(" ") || methodId;
+}
+function detachMethodFromPreparation(preparation, methodId) {
+    if (methodIdForSourcePreparationConfig(preparation) !== methodId)
+        return preparation;
+    const { method: _removedMethod, ...detachedPreparation } = preparation;
+    return detachedPreparation;
+}
+function requireSelectedMethod(preparation) {
+    const methodId = methodIdForSourcePreparationConfig(preparation);
+    if (methodId)
+        return methodId;
+    throw new Error(`Select a Method for Preparation "${preparation.name}" before preparing it.`);
 }
 function actionCommandPreview(actionType, preparationName, methodId, values) {
-    if (actionType === "preparation-setup") {
-        const preparationPart = preparationName ? ` # Preparation: ${preparationName}` : "";
-        const pathPart = preparationSetupPathValue(values);
-        return pathPart ? `interf init # source: ${pathPart}${preparationPart}` : `interf init${preparationPart}`;
-    }
     if (actionType === "compile") {
         const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
         return preparationName
@@ -491,9 +593,6 @@ function hasCompiledTestTarget(sourcePath, preparationConfig) {
 }
 function actionAssistantMessage(actionType, preparationName, commandPreview) {
     const preparationSuffix = preparationName ? ` for Preparation "${preparationName}"` : "";
-    if (actionType === "preparation-setup") {
-        return `Interf prepared a Preparation setup proposal${preparationSuffix}. Approve to save the source folder and create the portable-context scaffold. CLI equivalent: ${commandPreview}`;
-    }
     if (actionType === "compile") {
         return `Interf prepared a prepare-run proposal${preparationSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
     }
@@ -501,7 +600,7 @@ function actionAssistantMessage(actionType, preparationName, 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${preparationSuffix}. Approve to ask the configured local executor to draft checks as a visible run. CLI equivalent: ${commandPreview}`;
+        return `Interf prepared a proposal to draft readiness checks${preparationSuffix}. Approve to ask the configured local executor to draft saved checks as a visible run. CLI equivalent: ${commandPreview}`;
     }
     if (actionType === "method-authoring" || actionType === "method-improvement") {
         return `Interf prepared a Method draft proposal${preparationSuffix}. Approve to draft a reusable local Method as a visible run. CLI equivalent: ${commandPreview}`;
@@ -513,10 +612,10 @@ function passRate(passed, total) {
         return null;
     return Math.round((passed / total) * 100);
 }
-function readinessTargetResult(summary, currentFingerprint, comparisonFingerprint) {
+function readinessTargetResult(summary, currentFingerprint, readinessRunFingerprint) {
     if (!summary)
         return null;
-    const resultFingerprint = comparisonFingerprint ?? null;
+    const resultFingerprint = readinessRunFingerprint ?? null;
     return {
         passed: summary.passed_cases,
         total: summary.total_cases,
@@ -589,6 +688,7 @@ function buildMethodResource(resource) {
         source_kind: resource.source_kind,
         built_in: resource.built_in,
         active_for_preparations: resource.active_for_preparations,
+        output_paths: resource.output_paths,
         stages: resource.stages,
     });
 }
@@ -657,13 +757,13 @@ export class LocalServiceRuntime {
         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 readinessRun = this.readLatestReadinessRun(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);
-        const checksStale = Boolean(currentFingerprint && comparisonFingerprint && currentFingerprint !== comparisonFingerprint);
+        const readinessRunFingerprint = readinessRun?.checks_fingerprint ?? null;
+        const sourceResult = readinessTargetResult(readinessRun?.raw, currentFingerprint, readinessRunFingerprint);
+        const contextResult = readinessTargetResult(readinessRun?.compiled, currentFingerprint, readinessRunFingerprint);
+        const checksStale = Boolean(currentFingerprint && readinessRunFingerprint && currentFingerprint !== readinessRunFingerprint);
         const compileCheck = (() => {
             if (!compileRun) {
                 return {
@@ -775,7 +875,6 @@ export class LocalServiceRuntime {
                 fingerprint: currentFingerprint,
                 source_files: sourceResult,
                 portable_context: contextResult,
-                delta: comparison?.summary.pass_rate_delta ?? null,
             },
             checks,
         });
@@ -838,7 +937,7 @@ export class LocalServiceRuntime {
         const choices = listCompiledMethodChoices(this.rootPath);
         return choices.map((method) => {
             const activeForPreparations = preparations
-                .filter((preparation) => (methodIdForSourcePreparationConfig(preparation) ?? DEFAULT_METHOD_ID) === method.id)
+                .filter((preparation) => methodIdForSourcePreparationConfig(preparation) === method.id)
                 .map((preparation) => preparation.name);
             return buildMethodResource({
                 id: method.id,
@@ -848,6 +947,10 @@ export class LocalServiceRuntime {
                 source_kind: method.scope === "builtin" ? "builtin" : "local",
                 built_in: method.scope === "builtin",
                 active_for_preparations: activeForPreparations,
+                output_paths: (method.contextInterface?.zones ?? [])
+                    .filter((zone) => zone.role === "output")
+                    .map((zone) => contextInterfaceArtifactPath(zone))
+                    .sort(),
                 stages: method.stages.map((stage) => ({
                     id: stage.id,
                     label: stage.label,
@@ -953,7 +1056,10 @@ export class LocalServiceRuntime {
     }
     async createActionProposal(requestValue) {
         const request = ActionProposalCreateRequestSchema.parse(requestValue);
-        const proposal = await this.buildActionProposal(request);
+        const proposal = ActionProposalResourceSchema.parse({
+            ...(await this.buildActionProposal(request)),
+            client_origin: request.client_origin,
+        });
         this.writeActionProposal(proposal);
         return proposal;
     }
@@ -1113,7 +1219,7 @@ export class LocalServiceRuntime {
         this.appendJobRunEvent(job.run_id, {
             type: "step.completed",
             step_id: "read-source",
-            message: "Source folder is ready for readiness-check drafting.",
+            message: "Source folder is ready for drafting readiness checks.",
             output: {
                 preparation: request.preparation,
                 source_folder_path: request.source_folder_path,
@@ -1131,144 +1237,146 @@ export class LocalServiceRuntime {
         void this.runReadinessCheckDraftInBackground(request, job.run_id);
         return this.getJob(job.run_id) ?? job;
     }
-    async createPreparationSetupRun(requestValue) {
+    applyMethodChange(requestValue) {
+        const request = MethodChangeCreateRequestSchema.parse(requestValue);
+        const outputPath = request.operation === "duplicate"
+            ? methodDefinitionPath(this.rootPath, request.new_method_id)
+            : methodDefinitionPath(this.rootPath, request.method);
+        if (request.operation === "duplicate") {
+            if (resolveMethodPackageSourcePath(this.rootPath, request.new_method_id)) {
+                throw new Error(`Method "${request.new_method_id}" already exists.`);
+            }
+            if (!resolveMethodPackageSourcePath(this.rootPath, request.method)) {
+                throw new Error(`Method "${request.method}" does not exist.`);
+            }
+            const label = request.label ?? methodLabelFromId(request.new_method_id);
+            const hint = request.hint ?? `Duplicate of ${request.method}`;
+            const methodPath = seedLocalMethodPackageFromBase({
+                sourcePath: this.rootPath,
+                baseMethodId: request.method,
+                methodId: request.new_method_id,
+                label,
+                hint,
+            });
+            return MethodChangeResultSchema.parse({
+                kind: "interf-method-change-result",
+                version: 1,
+                operation: "duplicate",
+                method: request.method,
+                new_method_id: request.new_method_id,
+                updated_preparations: [],
+                method_path: methodPath,
+                changed: true,
+                message: `Duplicated Method ${request.method} as ${request.new_method_id}.`,
+            });
+        }
+        if (request.confirmation !== request.method) {
+            throw new Error(`Type ${request.method} to confirm Method removal.`);
+        }
+        const localMethodPath = methodDefinitionPath(this.rootPath, request.method);
+        if (request.method === DEFAULT_METHOD_ID || !existsSync(localMethodPath)) {
+            throw new Error(`Method "${request.method}" is not a removable local Method.`);
+        }
+        const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath));
+        const updatedPreparations = preparations
+            .filter((preparation) => methodIdForSourcePreparationConfig(preparation) === request.method);
+        if (updatedPreparations.length > 0) {
+            saveSourceFolderConfig(this.rootPath, {
+                preparations: preparations.map((preparation) => detachMethodFromPreparation(preparation, request.method)),
+            });
+        }
+        rmSync(outputPath, { recursive: true, force: true });
+        return MethodChangeResultSchema.parse({
+            kind: "interf-method-change-result",
+            version: 1,
+            operation: "remove",
+            method: request.method,
+            updated_preparations: updatedPreparations.map((preparation) => preparation.name),
+            method_path: outputPath,
+            changed: true,
+            message: updatedPreparations.length > 0
+                ? `Removed Method ${request.method} and cleared it from ${updatedPreparations.length} Preparation(s).`
+                : `Removed Method ${request.method}.`,
+        });
+    }
+    applyPreparationSetup(requestValue) {
         const request = PreparationSetupCreateRequestSchema.parse(requestValue);
         const preparationConfig = request.preparation;
-        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? "interf-default";
+        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
         const normalizedPreparationConfig = {
             ...preparationConfig,
             method: methodId,
         };
-        const sourceFolderPath = resolveSourcePreparationPath(this.rootPath, preparationConfig);
-        const outputPath = portableContextPath(this.rootPath, preparationConfig.name);
-        const job = this.createJobRun({
-            job_type: "preparation-setup",
-            title: `Create Preparation ${preparationConfig.name}`,
-            preparation: preparationConfig.name,
+        const sourceFolderPath = resolveSourcePreparationPath(this.rootPath, normalizedPreparationConfig);
+        if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
+            throw new Error(`Source folder "${preparationConfig.path}" is not available.`);
+        }
+        upsertSourcePreparationConfig(this.rootPath, normalizedPreparationConfig);
+        const operation = request.setup_mode === "select-method" ? "select-method" : "create";
+        return PreparationSetupResultSchema.parse({
+            kind: "interf-preparation-setup-result",
+            version: 1,
+            operation,
+            preparation: normalizedPreparationConfig.name,
             method: methodId,
-            source_path: sourceFolderPath,
-            output_path: outputPath,
-            agent: this.getExecutorStatus().executor,
-            steps: [
-                {
-                    id: "validate-source",
-                    label: "Validate source folder",
-                    input: {
-                        preparation: preparationConfig.name,
-                        path: preparationConfig.path,
-                    },
-                },
-                {
-                    id: "write-config",
-                    label: "Save Preparation config",
-                    input: {
-                        config_path: join(this.rootPath, "interf", "interf.json"),
-                    },
-                },
-                {
-                    id: "prepare-scaffold",
-                    label: "Prepare portable context",
-                    input: {
-                        output_path: outputPath,
-                        method: methodId,
-                    },
-                },
-            ],
+            source_folder_path: sourceFolderPath,
+            config_path: join(this.rootPath, "interf", "interf.json"),
+            portable_context_path: portableContextPath(this.rootPath, normalizedPreparationConfig.name),
+            changed: true,
+            message: operation === "select-method"
+                ? `Preparation ${normalizedPreparationConfig.name} now uses Method ${methodId}.`
+                : `Preparation ${normalizedPreparationConfig.name} is saved.`,
         });
-        let activeStep = "validate-source";
-        try {
-            this.appendJobRunEvent(job.run_id, {
-                type: "step.started",
-                step_id: "validate-source",
-                message: "Validating source folder.",
-                input: {
-                    path: preparationConfig.path,
-                    source_folder_path: sourceFolderPath,
-                },
-            });
-            if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
-                throw new Error(`Source folder "${preparationConfig.path}" is not available.`);
-            }
-            this.appendJobRunEvent(job.run_id, {
-                type: "step.completed",
-                step_id: "validate-source",
-                message: "Source folder is available.",
-                output: {
-                    source_folder_path: sourceFolderPath,
-                },
-            });
-            activeStep = "write-config";
-            this.appendJobRunEvent(job.run_id, {
-                type: "step.started",
-                step_id: "write-config",
-                message: "Saving Preparation in the control plane config.",
-                input: {
-                    preparation: preparationConfig.name,
-                    path: preparationConfig.path,
-                },
-            });
-            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: preparationConfig.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, normalizedPreparationConfig.name, methodId);
-            syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, normalizedPreparationConfig);
-            this.appendJobRunEvent(job.run_id, {
-                type: "step.completed",
-                step_id: "prepare-scaffold",
-                message: "Portable-context scaffold is ready.",
-                output: {
-                    portable_context_path: compiledPath,
-                },
-            });
-            this.setJobRunResult(job.run_id, {
-                preparation: normalizedPreparationConfig,
-                source_folder_path: sourceFolderPath,
-                portable_context_path: compiledPath,
-            });
-            this.appendJobRunEvent(job.run_id, {
-                type: "job.completed",
-                message: `Preparation ${preparationConfig.name} is ready for Interf runs.`,
-            });
+    }
+    applyPreparationChange(requestValue) {
+        const request = PreparationChangeCreateRequestSchema.parse(requestValue);
+        if (request.confirmation !== request.preparation) {
+            throw new Error(`Type ${request.preparation} to confirm Preparation removal.`);
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.appendJobRunEvent(job.run_id, {
-                type: "step.failed",
-                step_id: activeStep,
-                message,
-                output: {
-                    error: message,
-                },
-            });
-            this.appendJobRunEvent(job.run_id, {
-                type: "job.failed",
-                message,
-            });
+        const preparation = findSourcePreparationConfig(loadSourceFolderConfig(this.rootPath), request.preparation);
+        if (!preparation) {
+            throw new Error(`Preparation "${request.preparation}" is not saved.`);
         }
-        return this.getJob(job.run_id) ?? job;
+        removeSourcePreparationConfig(this.rootPath, request.preparation);
+        return PreparationChangeResultSchema.parse({
+            kind: "interf-preparation-change-result",
+            version: 1,
+            operation: "remove",
+            preparation: request.preparation,
+            config_path: join(this.rootPath, "interf", "interf.json"),
+            portable_context_path: portableContextPath(this.rootPath, request.preparation),
+            portable_context_retained: true,
+            changed: true,
+            message: `Removed Preparation ${request.preparation}. Portable Context files were retained.`,
+        });
+    }
+    applyReset(requestValue) {
+        const request = ResetRequestSchema.parse(requestValue);
+        const preparation = findSourcePreparationConfig(loadSourceFolderConfig(this.rootPath), request.preparation);
+        if (!preparation) {
+            throw new Error(`Preparation "${request.preparation}" is not saved.`);
+        }
+        const compiledPath = portableContextPath(this.rootPath, request.preparation);
+        if (!existsSync(compiledPath)) {
+            throw new Error(`Portable Context for Preparation "${request.preparation}" does not exist.`);
+        }
+        resetCompiledGeneratedState(compiledPath, request.scope);
+        return ResetResultSchema.parse({
+            kind: "interf-reset-result",
+            version: 1,
+            preparation: request.preparation,
+            scope: request.scope,
+            portable_context_path: compiledPath,
+            changed: true,
+            message: `Reset ${request.scope} state for Preparation ${request.preparation}.`,
+        });
     }
-    async createMethodAuthoringRun(requestValue) {
+    async createMethodAuthoringRun(requestValue, jobType = "method-authoring") {
         const request = MethodAuthoringCreateRequestSchema.parse(requestValue);
+        const isImprovement = jobType === "method-improvement";
         const job = this.createJobRun({
-            job_type: "method-authoring",
-            title: `Draft Method ${request.method_id}`,
+            job_type: jobType,
+            title: isImprovement ? `Improve Method ${request.method_id}` : `Draft Method ${request.method_id}`,
             preparation: request.preparation ?? null,
             method: request.method_id,
             source_path: request.source_folder_path,
@@ -1285,7 +1393,7 @@ export class LocalServiceRuntime {
                 },
                 {
                     id: "draft-package",
-                    label: "Draft Method package",
+                    label: isImprovement ? "Improve Method package" : "Draft Method package",
                     input: {
                         method_id: request.method_id,
                         label: request.label,
@@ -1304,7 +1412,7 @@ export class LocalServiceRuntime {
         this.appendJobRunEvent(job.run_id, {
             type: "step.started",
             step_id: "inspect-source",
-            message: "Inspecting source files for Method drafting.",
+            message: isImprovement ? "Inspecting source files for Method improvement." : "Inspecting source files for Method drafting.",
             input: {
                 preparation: request.preparation ?? null,
                 source_folder_path: request.source_folder_path,
@@ -1323,7 +1431,7 @@ export class LocalServiceRuntime {
         this.appendJobRunEvent(job.run_id, {
             type: "step.started",
             step_id: "draft-package",
-            message: "Drafting Method package.",
+            message: isImprovement ? "Improving Method package." : "Drafting Method package.",
             input: {
                 method_id: request.method_id,
                 label: request.label,
@@ -1403,7 +1511,7 @@ export class LocalServiceRuntime {
         const compiledPath = this.ensureCompiledForRun(preparationConfig);
         const runId = createRunId("compile");
         const now = new Date().toISOString();
-        const method = getCompiledMethod(methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID, {
+        const method = getCompiledMethod(requireSelectedMethod(preparationConfig), {
             sourcePath: this.rootPath,
         });
         const stageTotal = method.stages.length;
@@ -1493,7 +1601,7 @@ export class LocalServiceRuntime {
             source_path: this.rootPath,
             portable_context_path: compiledTarget.eligible ? compiledPath : null,
             started_at: now,
-            comparison: null,
+            readiness_run: null,
             events: [],
         });
         this.writeTestRun(compiledPath, initial);
@@ -1531,6 +1639,7 @@ export class LocalServiceRuntime {
                     summary: "Portable context ready.",
                 });
             }
+            await this.recordCompileRunEvent(context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(context.preparationConfig)));
         }
         catch (error) {
             await this.recordCompileRunEvent(context.compiledPath, context.runId, {
@@ -1540,6 +1649,7 @@ export class LocalServiceRuntime {
                 timestamp: createRunEventTimestamp(),
                 error: error instanceof Error ? error.message : String(error),
             });
+            await this.recordCompileRunEvent(context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(context.preparationConfig)));
         }
     }
     async runTestInBackground(request, context, initial) {
@@ -1548,15 +1658,15 @@ 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 = result.comparison ?? this.readLatestComparison(context.preparationConfig.name);
-            const resultEvent = comparison
-                ? this.checksEvaluatedEvent(context.runId, comparison)
+            const readinessRun = result.readiness_run ?? this.readLatestReadinessRun(context.preparationConfig.name);
+            const resultEvent = readinessRun
+                ? this.checksEvaluatedEvent(context.runId, readinessRun)
                 : null;
             const nextWithoutReadiness = TestRunResourceSchema.parse({
                 ...initial,
                 status: result.ok ? "succeeded" : "failed",
                 finished_at: new Date().toISOString(),
-                comparison,
+                readiness_run: readinessRun,
                 events: resultEvent ? [resultEvent] : [],
                 ...(!result.ok ? { error: result.error ?? "Readiness check failed." } : {}),
             });
@@ -1606,7 +1716,7 @@ export class LocalServiceRuntime {
             this.appendJobRunEvent(runId, {
                 type: "step.started",
                 step_id: "normalize-checks",
-                message: "Normalizing readiness-check draft into saved check records.",
+                message: "Normalizing drafted readiness checks into saved check records.",
                 input: {
                     checks: result.checks.length,
                 },
@@ -1779,55 +1889,84 @@ export class LocalServiceRuntime {
             assistant_message: ACTION_PLANNER_CLARIFICATION_MESSAGE,
         });
     }
-    buildPreparationSetupRequest(request, plan, values) {
-        const sourceFolderChoices = listSourceFolderChoices(this.rootPath);
-        const selectedPath = preparationSetupPathValue(values) ??
-            (sourceFolderChoices.length === 1 ? sourceFolderChoices[0].value : null);
-        if (!selectedPath) {
-            return {
-                error: "Tell Interf which source folder to use for the Preparation.",
-            };
-        }
-        let normalizedPath;
-        try {
-            normalizedPath = normalizeSourcePreparationPathForConfig(this.rootPath, selectedPath);
-        }
-        catch (error) {
-            return {
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-        const explicitName = preparationSetupNameValue(values) ?? plan.preparation ?? request.preparation;
-        const preparationName = explicitName
-            ? slugFromText(explicitName)
-            : defaultPreparationNameForPath(normalizedPath);
-        const requestMethodId = stringValue(request.values, "method");
-        const valueMethodId = stringValue(values, "method");
-        const methodId = requestMethodId ?? plan.method ?? valueMethodId ?? "interf-default";
-        try {
-            return {
-                preparationName,
-                methodId,
-                request: PreparationSetupCreateRequestSchema.parse({
-                    preparation: {
-                        name: preparationName,
-                        path: normalizedPath,
-                        about: stringValue(values, "about") ?? stringValue(values, "task_prompt") ?? request.message,
-                        method: methodId,
-                        checks: [],
-                    },
-                }),
-            };
-        }
-        catch (error) {
-            return {
-                error: error instanceof Error ? error.message : String(error),
-            };
+    directServiceActionClarification(options) {
+        const endpoint = directServiceEndpointForAction(options.actionType);
+        if (!endpoint) {
+            throw new Error(`Action "${options.actionType}" is not a direct deterministic service action.`);
         }
+        const label = options.actionType === "preparation-setup"
+            ? "Preparation setup"
+            : options.actionType === "method-change"
+                ? "Method change"
+                : "Preparation change";
+        const now = new Date().toISOString();
+        return ActionProposalResourceSchema.parse({
+            kind: "interf-action-proposal",
+            version: 1,
+            proposal_id: createActionProposalId(),
+            status: "needs_clarification",
+            action_type: "clarification",
+            title: `${label} uses a direct service endpoint`,
+            summary: `${label} is deterministic and is not accepted through action proposals.`,
+            assistant_message: `${label} must be submitted directly to ${endpoint}. Action proposals are only for freeform planning or async local-agent-backed work.`,
+            message: options.message,
+            preparation: options.preparation ?? null,
+            method: options.method ?? null,
+            request: {
+                message: options.message,
+                endpoint,
+                action_type: options.actionType,
+                ...(options.values ? { values: options.values } : {}),
+            },
+            created_at: now,
+            updated_at: now,
+            proposed_by_executor: this.getExecutorStatus().executor,
+            approval: null,
+            submitted_run_id: null,
+            submitted_run_type: null,
+            error: null,
+        });
     }
     async buildActionProposal(request) {
-        const plan = await this.planActionProposal(request);
-        const actionType = plan.action_type;
+        const structuredPreparationSetup = PreparationSetupActionValuesSchema.safeParse(request.values);
+        const structuredMethodAuthoring = MethodAuthoringActionValuesSchema.safeParse(request.values);
+        const structuredActionType = actionTypeFromValues(request.values);
+        const structuredDirectActionType = structuredPreparationSetup.success
+            ? "preparation-setup"
+            : structuredActionType && directServiceEndpointForAction(structuredActionType)
+                ? structuredActionType
+                : null;
+        if (structuredDirectActionType) {
+            return this.directServiceActionClarification({
+                actionType: structuredDirectActionType,
+                message: request.message,
+                method: stringValue(request.values, "method") ?? stringValue(request.values, "new_method_id"),
+                preparation: request.preparation ?? stringValue(request.values, "preparation") ?? stringValue(request.values, "name"),
+                values: request.values,
+            });
+        }
+        const structuredPlanActionType = structuredMethodAuthoring.success ? "method-authoring" : structuredActionType;
+        // Typed UI/CLI actions already carry the service contract; only freeform chat needs planner inference.
+        const plan = structuredPlanActionType
+            ? ActionProposalPlanSchema.parse({
+                action_type: structuredPlanActionType,
+                ...(request.preparation ? { preparation: request.preparation } : {}),
+            })
+            : await this.planActionProposal(request);
+        const actionType = structuredPlanActionType ?? plan.action_type;
+        if (directServiceEndpointForAction(actionType)) {
+            return this.directServiceActionClarification({
+                actionType,
+                message: request.message,
+                method: plan.method ?? stringValue(plan.values, "method") ?? stringValue(request.values, "method"),
+                preparation: plan.preparation ?? request.preparation ?? stringValue(plan.values, "preparation") ?? stringValue(request.values, "preparation"),
+                values: {
+                    ...(plan.values ?? {}),
+                    ...(request.values ?? {}),
+                },
+            });
+        }
+        const usePlannerText = !structuredPlanActionType && plan.action_type === actionType;
         const now = new Date().toISOString();
         if (actionType === "clarification") {
             return ActionProposalResourceSchema.parse({
@@ -1860,53 +1999,55 @@ export class LocalServiceRuntime {
             ...(plan.values ?? {}),
             ...(request.values ?? {}),
         };
-        if (actionType === "preparation-setup") {
-            const setup = this.buildPreparationSetupRequest(request, plan, proposalValues);
-            if ("error" in setup) {
-                return ActionProposalResourceSchema.parse({
-                    kind: "interf-action-proposal",
-                    version: 1,
-                    proposal_id: createActionProposalId(),
-                    status: "needs_clarification",
-                    action_type: "clarification",
-                    title: "Clarify Preparation setup",
-                    summary: "Interf needs a source folder before it can save a Preparation.",
-                    assistant_message: setup.error,
-                    message: request.message,
-                    preparation: plan.preparation ?? request.preparation ?? null,
-                    method: plan.method ?? null,
-                    request: {
-                        message: request.message,
-                        ...(proposalValues ? { values: proposalValues } : {}),
-                    },
-                    created_at: now,
-                    updated_at: now,
-                    proposed_by_executor: this.getExecutorStatus().executor,
-                    approval: null,
-                    submitted_run_id: null,
-                    submitted_run_type: null,
-                    error: null,
-                });
-            }
-            const commandPreview = plan.command_preview ??
-                actionCommandPreview(actionType, setup.preparationName, setup.methodId, {
-                    ...proposalValues,
-                    path: setup.request.preparation.path,
-                });
+        if (actionType === "method-authoring" || actionType === "method-improvement") {
+            const requestedPreparationName = plan.preparation ?? request.preparation ?? null;
+            const fallbackPreparation = requestedPreparationName
+                ? null
+                : listSourcePreparationConfigs(loadSourceFolderConfig(this.rootPath))[0] ?? null;
+            const preparationConfig = requestedPreparationName
+                ? this.resolvePreparationConfig(requestedPreparationName)
+                : fallbackPreparation;
+            const preparationPath = preparationConfig
+                ? resolveSourcePreparationPath(this.rootPath, preparationConfig)
+                : resolveConfiguredSourceFolderPath(this.rootPath) ?? this.rootPath;
+            const requestedMethodId = stringValue(request.values, "method_id") ??
+                stringValue(request.values, "method");
+            const plannedMethodId = plan.method ??
+                stringValue(plan.values, "method_id") ??
+                stringValue(plan.values, "method");
+            const methodId = requestedMethodId ?? plannedMethodId ?? methodIdForProposal(request.message, proposalValues);
+            const taskPrompt = actionValueMethodTaskPrompt(proposalValues) ??
+                stringValue(proposalValues, "task_prompt") ??
+                methodAuthoringPromptFallback(request.message, methodId);
+            const hint = stringValue(proposalValues, "hint") ?? methodAuthoringHintFromPrompt(taskPrompt);
+            const actionRequest = {
+                preparation: preparationConfig?.name ?? null,
+                source_folder_path: preparationPath,
+                method_id: methodId,
+                ...(stringValue(proposalValues, "base_method_id") ? { base_method_id: stringValue(proposalValues, "base_method_id") } : {}),
+                ...(stringValue(proposalValues, "reference_method_id") ? { reference_method_id: stringValue(proposalValues, "reference_method_id") } : {}),
+                label: stringValue(proposalValues, "label") ?? methodLabelFromId(methodId),
+                hint,
+                task_prompt: taskPrompt,
+                checks: preparationConfig?.checks ?? [],
+            };
+            const commandPreview = (usePlannerText ? plan.command_preview : undefined) ??
+                actionCommandPreview(actionType, preparationConfig?.name ?? null, methodId, proposalValues);
             return ActionProposalResourceSchema.parse({
                 kind: "interf-action-proposal",
                 version: 1,
                 proposal_id: createActionProposalId(),
                 status: "awaiting_approval",
                 action_type: actionType,
-                title: plan.title ?? `Create Preparation ${setup.preparationName}`,
-                summary: plan.summary ?? "Save this source folder as an Interf Preparation.",
-                assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, setup.preparationName, commandPreview),
+                title: (usePlannerText ? plan.title : undefined) ?? `Draft Method ${methodId}`,
+                summary: (usePlannerText ? plan.summary : undefined) ?? "Ask the configured local executor to create a reusable local Method.",
+                assistant_message: (usePlannerText ? plan.assistant_message : undefined) ??
+                    actionAssistantMessage(actionType, preparationConfig?.name ?? null, commandPreview),
                 command_preview: commandPreview,
                 message: request.message,
-                preparation: setup.preparationName,
-                method: setup.methodId,
-                request: setup.request,
+                preparation: preparationConfig?.name ?? null,
+                method: methodId,
+                request: actionRequest,
                 created_at: now,
                 updated_at: now,
                 proposed_by_executor: this.getExecutorStatus().executor,
@@ -1917,15 +2058,14 @@ export class LocalServiceRuntime {
             });
         }
         const preparationConfig = this.resolvePreparationConfig(plan.preparation ?? request.preparation ?? this.defaultPreparationName());
+        const proposalActionType = ActionProposalTypeSchema.parse(actionType);
         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");
-        const methodId = actionType === "method-authoring"
-            ? requestedMethodId ?? plannedMethodId ?? methodIdForProposal(request.message, proposalValues)
-            : requestedMethodId ?? plannedMethodId ?? methodIdForSourcePreparationConfig(preparationConfig);
+        const methodId = requestedMethodId ?? plannedMethodId ?? methodIdForSourcePreparationConfig(preparationConfig);
         const clarifyResolvedAction = (options) => ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
@@ -1991,51 +2131,58 @@ export class LocalServiceRuntime {
                     target_count: Math.max(1, Math.min(8, Math.round(numberValue(proposalValues, "target_count") ?? 4))),
                 };
             }
+            const fallbackMethodId = methodId ?? methodIdForProposal(request.message, proposalValues);
+            const taskPrompt = actionValueMethodTaskPrompt(proposalValues) ??
+                stringValue(proposalValues, "task_prompt") ??
+                methodAuthoringPromptFallback(request.message, fallbackMethodId);
+            const hint = stringValue(proposalValues, "hint") ?? methodAuthoringHintFromPrompt(taskPrompt);
             return {
                 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,
+                method_id: fallbackMethodId,
+                ...(stringValue(proposalValues, "base_method_id") ? { base_method_id: stringValue(proposalValues, "base_method_id") } : {}),
+                ...(stringValue(proposalValues, "reference_method_id") ? { reference_method_id: stringValue(proposalValues, "reference_method_id") } : {}),
+                label: stringValue(proposalValues, "label") ?? methodLabelFromId(fallbackMethodId),
+                hint,
+                task_prompt: taskPrompt,
                 checks: preparationConfig.checks ?? [],
             };
         })();
         const title = (() => {
             if (plan.title)
                 return plan.title;
-            if (actionType === "compile")
+            if (proposalActionType === "compile")
                 return `Prepare ${preparationConfig.name}`;
-            if (actionType === "test")
+            if (proposalActionType === "test")
                 return `Check readiness for ${preparationConfig.name}`;
-            if (actionType === "readiness-check-draft")
+            if (proposalActionType === "readiness-check-draft")
                 return `Draft readiness checks for ${preparationConfig.name}`;
             return `Draft Method ${methodId}`;
         })();
         const summary = (() => {
             if (plan.summary)
                 return plan.summary;
-            if (actionType === "compile")
+            if (proposalActionType === "compile")
                 return "Build portable context agents can use.";
-            if (actionType === "test")
+            if (proposalActionType === "test")
                 return "Run readiness checks against source files and portable context.";
-            if (actionType === "readiness-check-draft")
+            if (proposalActionType === "readiness-check-draft")
                 return "Ask the configured local executor to draft saved readiness checks.";
             return "Ask the configured local executor to create a reusable local Method.";
         })();
-        const previewValues = actionType === "test"
+        const previewValues = proposalActionType === "test"
             ? { mode: actionRequest.mode }
             : proposalValues;
-        const commandPreview = plan.command_preview ?? actionCommandPreview(actionType, preparationConfig.name, methodId, previewValues);
+        const commandPreview = plan.command_preview ?? actionCommandPreview(proposalActionType, preparationConfig.name, methodId, previewValues);
         return ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
             version: 1,
             proposal_id: createActionProposalId(),
             status: "awaiting_approval",
-            action_type: actionType,
+            action_type: proposalActionType,
             title,
             summary,
-            assistant_message: plan.assistant_message ?? actionAssistantMessage(actionType, preparationConfig.name, commandPreview),
+            assistant_message: plan.assistant_message ?? actionAssistantMessage(proposalActionType, preparationConfig.name, commandPreview),
             command_preview: commandPreview,
             message: request.message,
             preparation: preparationConfig.name,
@@ -2068,13 +2215,6 @@ export class LocalServiceRuntime {
                 runType: "test-run",
             };
         }
-        if (proposal.action_type === "preparation-setup") {
-            const job = await this.createPreparationSetupRun(proposal.request);
-            return {
-                runId: job.run_id,
-                runType: "job-run",
-            };
-        }
         if (proposal.action_type === "readiness-check-draft") {
             const job = await this.createReadinessCheckDraftRun(proposal.request);
             return {
@@ -2082,7 +2222,11 @@ export class LocalServiceRuntime {
                 runType: "job-run",
             };
         }
-        const job = await this.createMethodAuthoringRun(proposal.request);
+        const directEndpoint = directServiceEndpointForAction(proposal.action_type);
+        if (directEndpoint) {
+            throw new Error(`Action "${proposal.action_type}" must be submitted directly to ${directEndpoint}.`);
+        }
+        const job = await this.createMethodAuthoringRun(proposal.request, proposal.action_type === "method-improvement" ? "method-improvement" : "method-authoring");
         return {
             runId: job.run_id,
             runType: "job-run",
@@ -2102,7 +2246,7 @@ export class LocalServiceRuntime {
         };
     }
     ensureCompiledForRun(preparationConfig) {
-        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+        const methodId = requireSelectedMethod(preparationConfig);
         const compiledPath = ensurePortableContextScaffold(this.rootPath, preparationConfig.name, methodId);
         syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
         return compiledPath;
@@ -2228,11 +2372,11 @@ export class LocalServiceRuntime {
             });
         }
     }
-    readLatestComparison(preparationName) {
+    readLatestReadinessRun(preparationName) {
         return readSavedReadinessCheckRun(this.rootPath, preparationName);
     }
-    checksEvaluatedEvent(runId, comparison) {
-        const target = comparison.compiled ?? comparison.raw;
+    checksEvaluatedEvent(runId, readinessRun) {
+        const target = readinessRun.compiled ?? readinessRun.raw;
         return {
             type: "checks.evaluated",
             event_id: createRunEventId("event"),