@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/engine/action-definitions.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { RequestedArtifactSchema, SourceProfileSchema, } from "../project/lib/schema.js";
+import { artifactRequirementsFromRequestedArtifacts, formatRequestedArtifactsForPrompt, } from "./requested-artifacts.js";
 export const ActionValueIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const ActionValueIdSchema = z.string().trim().regex(ActionValueIdPattern, "Use lowercase letters, numbers, and dashes.");
 export const OptionalActionValueIdSchema = z.string().trim().refine((value) => value === "" || ActionValueIdPattern.test(value), "Use lowercase letters, numbers, and dashes.");
@@ -6,26 +8,32 @@ export const SourceReadinessCheckActionValueSchema = z.object({
     question: z.string().trim().min(1),
     answer: z.string().trim().optional(),
 }).strict();
+export const RequestedArtifactActionValueSchema = RequestedArtifactSchema;
+export const SourceProfileActionValueSchema = SourceProfileSchema;
 export const PreparationSetupActionValuesSchema = z.object({
     name: ActionValueIdSchema,
     path: z.string().trim().min(1, "Source Folder is required."),
     about: z.string().trim().min(1, "Agent work is required."),
-    method: OptionalActionValueIdSchema.optional(),
+    build_plan: OptionalActionValueIdSchema.optional(),
     checks: z.array(SourceReadinessCheckActionValueSchema).optional(),
+    requested_artifacts: z.array(RequestedArtifactActionValueSchema).optional(),
+    source_profile: SourceProfileActionValueSchema.optional(),
     max_attempts: z.number().int().min(1).max(5).optional(),
     max_loops: z.number().int().min(1).max(3).optional(),
     readiness_notes: z.string().trim().optional(),
-    prepare_after_setup: z.boolean().optional(),
-    setup_mode: z.enum(["create", "select-method"]).optional(),
+    build_after_setup: z.boolean().optional(),
+    setup_mode: z.enum(["create", "select-build-plan"]).optional(),
 }).strict();
-export const MethodAuthoringActionValuesSchema = z.object({
-    method_id: ActionValueIdSchema.optional(),
-    base_method_id: ActionValueIdSchema.optional(),
-    reference_method_id: ActionValueIdSchema.optional(),
+export const BuildPlanAuthoringActionValuesSchema = z.object({
+    build_plan_id: ActionValueIdSchema.optional(),
+    base_build_plan_id: ActionValueIdSchema.optional(),
+    reference_build_plan_id: ActionValueIdSchema.optional(),
     label: z.string().trim().optional(),
     hint: z.string().trim().optional(),
     task_prompt: z.string().trim().min(1, "Agent work is required."),
-    portable_output: z.string().trim().optional(),
+    requested_artifacts_description: z.string().trim().optional(),
+    requested_artifacts: z.array(RequestedArtifactActionValueSchema).optional(),
+    source_profile: SourceProfileActionValueSchema.nullable().optional(),
     readiness_notes: z.string().trim().optional(),
 }).strict();
 export const INTERF_SERVICE_ACTIONS = {
@@ -33,31 +41,31 @@ export const INTERF_SERVICE_ACTIONS = {
         id: "create-preparation",
         serviceAction: "preparation-setup",
         title: "Create Preparation",
-        description: "Save a Source Folder + Method binding so future runs can be invoked by name.",
+        description: "Save a Source, requested Artifacts, Build Plan, and run history under one Preparation.",
     },
-    compileRun: {
-        id: "compile-run",
-        serviceAction: "compile",
-        title: "Compile Method",
-        description: "Run the chosen Method against this Source Folder and write portable context.",
+    buildRun: {
+        id: "build-run",
+        serviceAction: "build",
+        title: "Build Artifacts",
+        description: "Run the saved Build Plan against this Source and write verifiable context.",
     },
-    selectMethod: {
-        id: "select-method",
+    selectBuildPlan: {
+        id: "select-build-plan",
         serviceAction: "preparation-setup",
-        title: "Select Method",
-        description: "Choose which Method this saved binding should use for future runs.",
+        title: "Select Build Plan",
+        description: "Choose the Build Plan that will build this Preparation's requested Artifacts.",
     },
-    createMethod: {
-        id: "create-method",
-        serviceAction: "method-authoring",
-        title: "Draft Method",
-        description: "Draft a reusable local Method that captures a repeatable agent-work pattern.",
+    createBuildPlan: {
+        id: "build-plan-draft",
+        serviceAction: "build-plan-draft",
+        title: "Draft Build Plan",
+        description: "Draft a Build Plan for the Artifacts this Preparation should build.",
     },
-    methodChange: {
-        id: "method-change",
-        serviceAction: "method-change",
-        title: "Method Change",
-        description: "Modify, duplicate, or remove an existing Method.",
+    buildPlanChange: {
+        id: "build-plan-change",
+        serviceAction: "build-plan-change",
+        title: "Build Plan Change",
+        description: "Modify, duplicate, or remove an existing Build Plan.",
     },
     preparationChange: {
         id: "preparation-change",
@@ -85,19 +93,23 @@ export const INTERF_SERVICE_ACTIONS = {
     },
     improvePreparation: {
         id: "improve-preparation",
-        serviceAction: "method-improvement",
-        title: "Improve Method",
-        description: "Use readiness evidence to refine the Method this saved binding uses.",
+        serviceAction: "build-plan-improvement",
+        title: "Improve Build Plan",
+        description: "Use readiness evidence to refine the Build Plan this Preparation uses.",
     },
 };
 function optionalLine(label, value) {
     const trimmed = value?.trim();
     return trimmed ? `${label}: ${trimmed}` : null;
 }
-export function methodAuthoringTaskPrompt(values) {
+export function buildPlanAuthoringTaskPrompt(values) {
+    const requestedArtifacts = values.requested_artifacts?.length
+        ? formatRequestedArtifactsForPrompt(values.requested_artifacts)
+        : null;
     return [
         `Agent work: ${values.task_prompt}`,
-        optionalLine("Portable-context output", values.portable_output),
+        requestedArtifacts ? `Requested Artifacts:\n${requestedArtifacts}` : null,
+        optionalLine("Requested Artifacts", values.requested_artifacts_description),
         optionalLine("Readiness checks", values.readiness_notes),
     ].filter((line) => Boolean(line)).join("\n");
 }
@@ -151,27 +163,27 @@ export function maybeActionValue(value) {
 function inputValue(values, key) {
     return values[key] ?? "";
 }
-export function methodChoiceOptions(methods) {
+export function buildPlanChoiceOptions(buildPlans) {
     const seen = new Set();
     const options = [];
-    for (const method of [{ id: "interf-default", label: "interf-default" }, ...methods]) {
-        if (seen.has(method.id))
+    for (const buildPlan of [{ id: "interf-default", label: "interf-default" }, ...buildPlans]) {
+        if (seen.has(buildPlan.id))
             continue;
-        seen.add(method.id);
-        options.push({ label: method.label ?? method.id, value: method.id });
+        seen.add(buildPlan.id);
+        options.push({ label: buildPlan.label ?? buildPlan.id, value: buildPlan.id });
     }
     return options;
 }
-export function methodTaskPromptFromInput(values) {
-    const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
+export function buildPlanTaskPromptFromInput(values) {
+    const parsed = BuildPlanAuthoringActionValuesSchema.safeParse(values);
     if (parsed.success)
-        return methodAuthoringTaskPrompt(parsed.data);
+        return buildPlanAuthoringTaskPrompt(parsed.data);
     const taskPrompt = inputValue(values, "task_prompt");
-    const portableOutput = inputValue(values, "portable_output");
+    const requestedArtifactsDescription = inputValue(values, "requested_artifacts_description");
     const readinessNotes = inputValue(values, "readiness_notes");
     return [
         `Agent work: ${taskPrompt}`,
-        maybeActionValue(portableOutput) ? `Portable-context output: ${portableOutput}` : null,
+        maybeActionValue(requestedArtifactsDescription) ? `Requested Artifacts: ${requestedArtifactsDescription}` : null,
         maybeActionValue(readinessNotes) ? `Readiness checks: ${readinessNotes}` : null,
     ].filter((line) => Boolean(line)).join("\n");
 }
@@ -180,7 +192,7 @@ function createPreparationSchema(existingNames) {
         name: actionIdField("Preparation name"),
         path: requiredActionText("Source Folder"),
         about: requiredActionText("Agent work"),
-        method: optionalActionIdField("Method"),
+        build_plan: optionalActionIdField("Build Plan"),
         readiness_notes: optionalActionText,
     }).strict().superRefine((values, ctx) => {
         if (existingNames.has(values.name)) {
@@ -195,43 +207,43 @@ function createPreparationSchema(existingNames) {
 function prepareRunSchema() {
     return z.object({
         preparation: actionIdField("Preparation"),
-        method: optionalActionIdField("Method"),
+        build_plan: optionalActionIdField("Build Plan"),
         about: optionalActionText,
         source_folder_path: optionalActionText,
     }).strict();
 }
-function selectMethodSchema() {
+function selectBuildPlanSchema() {
     return z.object({
         name: actionIdField("Preparation"),
         path: requiredActionText("Source Folder"),
         about: requiredActionText("Agent work"),
-        current_method: optionalActionIdField("Current Method"),
-        method: optionalActionIdField("Method"),
+        current_build_plan: optionalActionIdField("Current Build Plan"),
+        build_plan: actionIdField("Build Plan"),
     }).strict();
 }
-function methodAuthoringSchema(existingMethodIds) {
+function buildPlanAuthoringSchema(existingBuildPlanIds) {
     return z.object({
-        method_id: optionalActionIdField("Method id"),
+        build_plan_id: optionalActionIdField("Build Plan id"),
         label: optionalActionText,
         hint: optionalActionText,
         task_prompt: requiredActionText("Agent work"),
-        portable_output: optionalActionText,
+        requested_artifacts_description: optionalActionText,
         readiness_notes: optionalActionText,
     }).strict().superRefine((values, ctx) => {
-        const explicitMethodId = maybeActionValue(values.method_id ?? "");
-        if (explicitMethodId && existingMethodIds.has(explicitMethodId)) {
+        const explicitBuildPlanId = maybeActionValue(values.build_plan_id ?? "");
+        if (explicitBuildPlanId && existingBuildPlanIds.has(explicitBuildPlanId)) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                path: ["method_id"],
-                message: "A Method with this id already exists.",
+                path: ["build_plan_id"],
+                message: "A Build Plan with this id already exists.",
             });
         }
     });
 }
-function methodChangeSchema(action, methodId, existingMethodIds) {
+function buildPlanChangeSchema(action, buildPlanId, existingBuildPlanIds) {
     const base = {
         action: requiredActionText("Action"),
-        method: actionIdField("Method"),
+        build_plan: actionIdField("Build Plan"),
         preparation: optionalActionIdField("Preparation"),
     };
     if (action === "modify") {
@@ -245,20 +257,20 @@ function methodChangeSchema(action, methodId, existingMethodIds) {
     if (action === "duplicate") {
         return z.object({
             ...base,
-            new_method_id: actionIdField("New Method id"),
+            new_build_plan_id: actionIdField("New Build Plan id"),
         }).strict().superRefine((values, ctx) => {
-            if (existingMethodIds.has(values.new_method_id)) {
+            if (existingBuildPlanIds.has(values.new_build_plan_id)) {
                 ctx.addIssue({
                     code: z.ZodIssueCode.custom,
-                    path: ["new_method_id"],
-                    message: "A Method with this id already exists.",
+                    path: ["new_build_plan_id"],
+                    message: "A Build Plan with this id already exists.",
                 });
             }
         });
     }
     return z.object({
         ...base,
-        confirmation: requiredActionText("Confirmation").refine((value) => value === methodId, `Type ${methodId} to confirm.`),
+        confirmation: requiredActionText("Confirmation").refine((value) => value === buildPlanId, `Type ${buildPlanId} to confirm.`),
     }).strict();
 }
 function preparationChangeSchema(action, preparation, existingNames) {
@@ -272,7 +284,7 @@ function preparationChangeSchema(action, preparation, existingNames) {
             name: actionIdField("Preparation id"),
             path: requiredActionText("Source Folder"),
             about: requiredActionText("Agent work"),
-            method: optionalActionIdField("Method"),
+            build_plan: optionalActionIdField("Build Plan"),
         }).strict().superRefine((values, ctx) => {
             if (values.name !== preparation && existingNames.has(values.name)) {
                 ctx.addIssue({
@@ -289,7 +301,7 @@ function preparationChangeSchema(action, preparation, existingNames) {
             name: actionIdField("New Preparation id"),
             path: requiredActionText("Source Folder"),
             about: requiredActionText("Agent work"),
-            method: optionalActionIdField("Method"),
+            build_plan: optionalActionIdField("Build Plan"),
         }).strict().superRefine((values, ctx) => {
             if (existingNames.has(values.name)) {
                 ctx.addIssue({
@@ -312,146 +324,154 @@ function conciseSummary(value, fallback) {
     const sentence = normalized.match(/^.{24,180}?(?:[.!?](?:\s|$)|$)/)?.[0]?.trim() ?? normalized;
     return sentence.length > 180 ? `${sentence.slice(0, 177).trim()}...` : sentence;
 }
-function normalizedMethodActionValues(values, existingMethodIds, defaultSeed) {
-    const explicitMethodId = maybeActionValue(inputValue(values, "method_id"));
+function normalizedBuildPlanActionValues(values, existingBuildPlanIds, defaultSeed) {
+    const explicitBuildPlanId = maybeActionValue(inputValue(values, "build_plan_id"));
     const taskPrompt = inputValue(values, "task_prompt").trim();
-    const methodId = explicitMethodId ?? uniqueActionId(taskPrompt || defaultSeed || "custom-method", existingMethodIds);
-    const output = maybeActionValue(inputValue(values, "portable_output"));
+    const buildPlanId = explicitBuildPlanId ?? uniqueActionId(taskPrompt || defaultSeed || "custom-build-plan", existingBuildPlanIds);
+    const output = maybeActionValue(inputValue(values, "requested_artifacts_description"));
     return {
         ...values,
-        method_id: methodId,
-        label: maybeActionValue(inputValue(values, "label")) ?? titleFromActionId(methodId),
-        hint: maybeActionValue(inputValue(values, "hint")) ?? conciseSummary(output ?? taskPrompt, "Reusable Method for preparing source files."),
+        build_plan_id: buildPlanId,
+        label: maybeActionValue(inputValue(values, "label")) ?? titleFromActionId(buildPlanId),
+        hint: maybeActionValue(inputValue(values, "hint")) ?? conciseSummary(output ?? taskPrompt, "Reusable Build Plan for building Artifacts."),
         task_prompt: taskPrompt,
     };
 }
 function createPreparationActionValues(values) {
-    const method = inputValue(values, "method");
+    const buildPlan = inputValue(values, "build_plan");
     const readinessNotes = inputValue(values, "readiness_notes");
     return {
         name: inputValue(values, "name"),
         path: inputValue(values, "path"),
         about: inputValue(values, "about"),
-        prepare_after_setup: true,
-        ...(maybeActionValue(method) ? { method } : {}),
+        build_after_setup: false,
+        ...(maybeActionValue(buildPlan) ? { build_plan: buildPlan } : {}),
         ...(maybeActionValue(readinessNotes) ? { readiness_notes: readinessNotes } : {}),
     };
 }
-function selectMethodActionValues(values) {
+function selectBuildPlanActionValues(values) {
     return {
         name: inputValue(values, "name"),
         path: inputValue(values, "path"),
         about: inputValue(values, "about"),
-        method: maybeActionValue(inputValue(values, "method")) ?? "interf-default",
-        prepare_after_setup: false,
-        setup_mode: "select-method",
+        build_plan: inputValue(values, "build_plan"),
+        build_after_setup: false,
+        setup_mode: "select-build-plan",
     };
 }
 export function preparationSetupRequestFromActionValues(input) {
     const values = PreparationSetupActionValuesSchema.parse(input);
+    const buildPlan = values.build_plan;
     return {
-        prepare_after_setup: values.prepare_after_setup ?? false,
-        setup_mode: values.setup_mode === "select-method" ? "select-method" : "create",
+        build_after_setup: values.build_after_setup ?? false,
+        setup_mode: values.setup_mode === "select-build-plan" ? "select-build-plan" : "create",
         preparation: {
             name: values.name,
             path: values.path,
             about: values.about,
-            method: values.method && values.method.length > 0 ? values.method : "interf-default",
+            ...(buildPlan && buildPlan.length > 0 ? { build_plan: buildPlan } : {}),
             checks: values.checks ?? [],
+            ...(values.requested_artifacts ? { requested_artifacts: values.requested_artifacts } : {}),
+            ...(values.source_profile ? { source_profile: values.source_profile } : {}),
             ...(typeof values.max_attempts === "number" ? { max_attempts: values.max_attempts } : {}),
             ...(typeof values.max_loops === "number" ? { max_loops: values.max_loops } : {}),
         },
     };
 }
-export function methodAuthoringRequestFromActionValues(input, context) {
-    const values = MethodAuthoringActionValuesSchema.parse(input);
-    const methodId = values.method_id;
-    if (!methodId) {
-        throw new Error("Method id is required.");
+export function buildPlanAuthoringRequestFromActionValues(input, context) {
+    const values = BuildPlanAuthoringActionValuesSchema.parse(input);
+    const buildPlanId = values.build_plan_id ?? values.build_plan_id;
+    if (!buildPlanId) {
+        throw new Error("Build Plan id is required.");
     }
-    const taskPrompt = methodAuthoringTaskPrompt(values);
+    const taskPrompt = buildPlanAuthoringTaskPrompt(values);
+    const requestedArtifacts = values.requested_artifacts ?? context.requestedArtifacts ?? [];
+    const sourceProfile = values.source_profile ?? context.sourceProfile ?? null;
     return {
         ...(context.preparation ? { preparation: context.preparation } : {}),
         source_folder_path: context.sourceFolderPath,
-        ...(values.base_method_id ? { base_method_id: values.base_method_id } : {}),
-        ...(values.reference_method_id ? { reference_method_id: values.reference_method_id } : {}),
-        method_id: methodId,
-        label: values.label ?? titleFromActionId(methodId),
-        hint: values.hint ?? conciseSummary(values.portable_output ?? values.task_prompt, "Reusable Method for preparing source files."),
+        ...(values.base_build_plan_id ?? values.base_build_plan_id ? { base_build_plan_id: values.base_build_plan_id ?? values.base_build_plan_id } : {}),
+        ...(values.reference_build_plan_id ?? values.reference_build_plan_id ? { reference_build_plan_id: values.reference_build_plan_id ?? values.reference_build_plan_id } : {}),
+        build_plan_id: buildPlanId,
+        label: values.label ?? titleFromActionId(buildPlanId),
+        hint: values.hint ?? conciseSummary(values.requested_artifacts_description ?? values.task_prompt, "Reusable Build Plan for building Artifacts."),
         task_prompt: taskPrompt,
         checks: context.checks ?? [],
+        requested_artifacts: requestedArtifacts,
+        source_profile: sourceProfile,
+        artifact_requirements: artifactRequirementsFromRequestedArtifacts(requestedArtifacts),
     };
 }
-export function methodImprovementActionValues(options) {
+export function buildPlanImprovementActionValues(options) {
     const readinessNotes = (options.checks ?? [])
         .map((check) => check.question)
         .filter((question) => question.trim().length > 0)
         .join("\n");
     return {
-        method_id: options.methodId,
-        reference_method_id: options.methodId,
+        build_plan_id: options.buildPlanId,
+        reference_build_plan_id: options.buildPlanId,
         ...(maybeActionValue(options.label ?? "") ? { label: options.label } : {}),
         ...(maybeActionValue(options.hint ?? "") ? { hint: options.hint } : {}),
-        task_prompt: `Improve Method ${options.methodId} using the latest readiness evidence for Preparation ${options.preparationName}.`,
+        task_prompt: `Improve Build Plan ${options.buildPlanId} using the latest readiness evidence for Preparation ${options.preparationName}.`,
         ...(maybeActionValue(readinessNotes) ? { readiness_notes: readinessNotes } : {}),
     };
 }
-function methodAuthoringActionValues(values) {
-    const methodId = inputValue(values, "method_id");
+function buildPlanAuthoringActionValues(values) {
+    const buildPlanId = inputValue(values, "build_plan_id");
     const label = inputValue(values, "label");
     const hint = inputValue(values, "hint");
-    const portableOutput = inputValue(values, "portable_output");
+    const requestedArtifactsDescription = inputValue(values, "requested_artifacts_description");
     const readinessNotes = inputValue(values, "readiness_notes");
     return {
-        ...(maybeActionValue(methodId) ? { method_id: methodId } : {}),
+        ...(maybeActionValue(buildPlanId) ? { build_plan_id: buildPlanId } : {}),
         ...(maybeActionValue(label) ? { label } : {}),
         ...(maybeActionValue(hint) ? { hint } : {}),
         task_prompt: inputValue(values, "task_prompt"),
-        ...(maybeActionValue(portableOutput) ? { portable_output: portableOutput } : {}),
+        ...(maybeActionValue(requestedArtifactsDescription) ? { requested_artifacts_description: requestedArtifactsDescription } : {}),
         ...(maybeActionValue(readinessNotes) ? { readiness_notes: readinessNotes } : {}),
     };
 }
-function methodChangeActionValues(action, values) {
+function buildPlanChangeActionValues(action, values) {
     if (action === "modify") {
-        const methodId = inputValue(values, "method");
+        const buildPlanId = inputValue(values, "build_plan");
         return {
-            method_id: methodId,
-            reference_method_id: methodId,
+            build_plan_id: buildPlanId,
+            reference_build_plan_id: buildPlanId,
             ...(maybeActionValue(inputValue(values, "label")) ? { label: inputValue(values, "label") } : {}),
             ...(maybeActionValue(inputValue(values, "hint")) ? { hint: inputValue(values, "hint") } : {}),
             task_prompt: [
-                `Modify Method ${methodId}.`,
+                `Modify Build Plan ${buildPlanId}.`,
                 inputValue(values, "change_request"),
             ].filter(Boolean).join("\n"),
         };
     }
     if (action === "duplicate") {
-        const newMethodId = inputValue(values, "new_method_id");
+        const newBuildPlanId = inputValue(values, "new_build_plan_id");
         return {
-            action_type: "method-change",
+            action_type: "build-plan-change",
             operation: "duplicate",
-            method: inputValue(values, "method"),
-            new_method_id: newMethodId,
-            label: titleFromActionId(newMethodId),
-            hint: `Duplicate of ${inputValue(values, "method")}`,
+            build_plan: inputValue(values, "build_plan"),
+            new_build_plan_id: newBuildPlanId,
+            label: titleFromActionId(newBuildPlanId),
+            hint: `Duplicate of ${inputValue(values, "build_plan")}`,
         };
     }
     return {
-        action_type: "method-change",
+        action_type: "build-plan-change",
         operation: "remove",
-        method: inputValue(values, "method"),
+        build_plan: inputValue(values, "build_plan"),
         confirmation: inputValue(values, "confirmation"),
     };
 }
 function duplicatePreparationActionValues(values) {
-    const method = inputValue(values, "method");
+    const buildPlan = inputValue(values, "build_plan");
     return {
         name: inputValue(values, "name"),
         path: inputValue(values, "path"),
         about: inputValue(values, "about"),
-        prepare_after_setup: false,
+        build_after_setup: false,
         setup_mode: "create",
-        ...(maybeActionValue(method) ? { method } : {}),
+        ...(maybeActionValue(buildPlan) ? { build_plan: buildPlan } : {}),
     };
 }
 function preparationChangeActionValues(action, values) {
@@ -470,13 +490,12 @@ export function buildCreatePreparationActionDefinition(context) {
     return {
         id: INTERF_SERVICE_ACTIONS.createPreparation.id,
         title: INTERF_SERVICE_ACTIONS.createPreparation.title,
-        description: "Describe the agent job. Interf saves the Preparation through the local service and starts its first compile run.",
-        submitLabel: "Confirm",
+        description: "Describe the Source and agent job. Interf saves a Preparation so a Build Plan can be drafted and reviewed before build.",
+        submitLabel: "Create",
         initialValues: {
             name,
             path: context.prepDataDir,
             about: "",
-            method: "interf-default",
             readiness_notes: "",
         },
         schema: createPreparationSchema(existingNames),
@@ -484,12 +503,11 @@ export function buildCreatePreparationActionDefinition(context) {
             name: "name",
             path: "path",
             about: "about",
-            method: "method",
+            build_plan: "build_plan",
         }),
         valuesPreview: createPreparationActionValues,
         buildDraft: (values) => {
             const actionValues = createPreparationActionValues(values);
-            const method = inputValue(values, "method");
             const readinessNotes = inputValue(values, "readiness_notes");
             return {
                 preparation: inputValue(values, "name"),
@@ -497,9 +515,9 @@ export function buildCreatePreparationActionDefinition(context) {
                 message: [
                     `Create Preparation ${inputValue(values, "name")}.`,
                     `Agent work: ${inputValue(values, "about")}`,
-                    maybeActionValue(method) ? `Method: ${method}` : null,
-                    maybeActionValue(readinessNotes) ? `Readiness checks: ${readinessNotes}` : null,
+                    maybeActionValue(readinessNotes) ? `Requested Artifacts and readiness: ${readinessNotes}` : null,
                     `Source folder: ${inputValue(values, "path")}`,
+                    "Draft or select the Build Plan after this Preparation exists. Do not build yet.",
                     "Use the attached typed action input as the source of truth.",
                 ].filter((line) => Boolean(line)).join("\n"),
             };
@@ -518,70 +536,54 @@ export function buildCreatePreparationActionDefinition(context) {
                 label: "Agent job",
                 type: "textarea",
                 rows: 4,
-                help: "The concrete work this prepared folder should enable.",
+                help: "The concrete work this Preparation should enable.",
                 context: "Saved as the Preparation intent and sent as typed action input.",
                 placeholder: "Example: Analyze every report chart, extract annual take-up by location, and produce a source data file plus markdown summary.",
             },
-            {
-                name: "method",
-                label: "Method",
-                type: "select",
-                help: "How Interf should build portable context for this Preparation.",
-                context: "Saved as the Method selected for this Preparation.",
-                options: methodChoiceOptions(context.methods),
-            },
             {
                 name: "readiness_notes",
-                label: "Ready when",
+                label: "Requested Artifacts",
                 type: "textarea",
                 rows: 3,
-                help: "Concrete checks that prove the prepared context is good enough.",
-                context: "Used as guidance when Interf proposes Preparation-level readiness checks.",
-                placeholder: "Example: Every output is source-backed, complete for the requested locations, and precise enough to verify.",
-            },
-            {
-                name: "name",
-                label: "Preparation id",
-                type: "text",
-                advanced: true,
-                help: "Auto-generated for the CLI and portable-context folder. Change only if needed.",
-                context: "Used in the CLI, saved on the Preparation, and used for the portable-context folder name.",
-                placeholder: name,
+                help: "Artifacts, coverage, and proof the agent needs before it can trust the Source.",
+                context: "Used as guidance when Interf drafts the Build Plan and readiness checks for review.",
+                placeholder: "Example: Extract every chart, produce a source data file, write a markdown summary, and show evidence for every location.",
             },
         ],
     };
 }
-export function buildCompileRunActionDefinition(context) {
+export function buildBuildRunActionDefinition(context) {
     return {
-        id: INTERF_SERVICE_ACTIONS.compileRun.id,
-        title: INTERF_SERVICE_ACTIONS.compileRun.title,
-        description: "Build portable context for this Preparation. Interf will run the saved Method against the source folder and record a visible run.",
+        id: INTERF_SERVICE_ACTIONS.buildRun.id,
+        title: INTERF_SERVICE_ACTIONS.buildRun.title,
+        description: "Build verifiable context for this Preparation. Interf will run the saved Build Plan against the Source and record a visible run.",
         submitLabel: "Run",
         initialValues: {
             preparation: context.name,
-            method: context.methodId,
+            build_plan: context.buildPlanId,
             about: context.about,
             source_folder_path: context.sourceFolderPath,
         },
         schema: prepareRunSchema(),
         valuesPreview: (values) => ({
-            action_type: INTERF_SERVICE_ACTIONS.compileRun.serviceAction,
+            action_type: INTERF_SERVICE_ACTIONS.buildRun.serviceAction,
             preparation: inputValue(values, "preparation"),
-            method: inputValue(values, "method"),
+            build_plan: inputValue(values, "build_plan"),
             source_folder_path: inputValue(values, "source_folder_path"),
             about: inputValue(values, "about"),
         }),
         buildDraft: (values) => ({
             preparation: inputValue(values, "preparation"),
             values: {
-                action_type: INTERF_SERVICE_ACTIONS.compileRun.serviceAction,
+                action_type: INTERF_SERVICE_ACTIONS.buildRun.serviceAction,
                 preparation: inputValue(values, "preparation"),
-                ...(maybeActionValue(inputValue(values, "method")) ? { method: inputValue(values, "method") } : {}),
+                ...(maybeActionValue(inputValue(values, "build_plan")) ? { build_plan: inputValue(values, "build_plan") } : {}),
             },
             message: [
-                `Compile Method ${inputValue(values, "method") || "(saved selection)"} for Preparation ${inputValue(values, "preparation")}.`,
+                `Build Artifacts for Preparation ${inputValue(values, "preparation")}.`,
                 maybeActionValue(inputValue(values, "about")) ? `Agent work: ${inputValue(values, "about")}` : null,
-                "Build portable context from the saved Source Folder and selected Method.",
+                `Build Plan: ${inputValue(values, "build_plan") || "(saved selection)"}.`,
+                "Build verifiable context from the saved Source and requested Artifacts.",
                 "Use the attached typed action input as the source of truth.",
             ].filter((line) => Boolean(line)).join("\n"),
         }),
@@ -592,15 +594,15 @@ export function buildCompileRunActionDefinition(context) {
                 type: "text",
                 readOnly: true,
                 help: "The saved Preparation that will be built.",
-                context: "Sent as the compile target.",
+                context: "Sent as the build target.",
             },
             {
-                name: "method",
-                label: "Method",
+                name: "build_plan",
+                label: "Build Plan",
                 type: "text",
                 readOnly: true,
-                help: "The Method Interf will run for this Preparation.",
-                context: "Sent as the compile Method override.",
+                help: "The Build Plan Interf will run to build the requested Artifacts.",
+                context: "Sent as the Build Plan override.",
             },
             {
                 name: "about",
@@ -609,7 +611,7 @@ export function buildCompileRunActionDefinition(context) {
                 readOnly: true,
                 advanced: true,
                 help: "The work this Preparation is meant to support.",
-                context: "Preserved as context for the compile-run proposal.",
+                context: "Preserved as context for the Build run proposal.",
                 placeholder: "No saved job description.",
             },
             {
@@ -624,61 +626,63 @@ export function buildCompileRunActionDefinition(context) {
         ],
     };
 }
-export function buildCompileRunActionDraft(context) {
-    const definition = buildCompileRunActionDefinition(context);
+export function buildBuildRunActionDraft(context) {
+    const definition = buildBuildRunActionDefinition(context);
     return definition.buildDraft(definition.initialValues);
 }
-export function buildSelectMethodActionDefinition(context) {
+export function buildSelectBuildPlanActionDefinition(context) {
     const actionValues = (values) => ({
-        ...selectMethodActionValues(values),
+        ...selectBuildPlanActionValues(values),
         checks: context.checks ?? [],
+        requested_artifacts: context.requestedArtifacts ?? [],
+        ...(context.sourceProfile ? { source_profile: context.sourceProfile } : {}),
         ...(typeof context.maxAttempts === "number" ? { max_attempts: context.maxAttempts } : {}),
         ...(typeof context.maxLoops === "number" ? { max_loops: context.maxLoops } : {}),
     });
     return {
-        id: INTERF_SERVICE_ACTIONS.selectMethod.id,
-        title: INTERF_SERVICE_ACTIONS.selectMethod.title,
-        description: "Choose which Method this Preparation uses for future compile runs. This saves the selection without running prepare.",
+        id: INTERF_SERVICE_ACTIONS.selectBuildPlan.id,
+        title: INTERF_SERVICE_ACTIONS.selectBuildPlan.title,
+        description: "Choose the Build Plan that builds this Preparation's requested Artifacts. This saves the selection without running a Build run.",
         submitLabel: "Confirm",
         initialValues: {
             name: context.name,
             path: context.sourceFolderPath,
             about: context.about,
-            current_method: context.currentMethodId,
-            method: context.currentMethodId || "interf-default",
+            current_build_plan: context.currentBuildPlanId ?? "",
+            build_plan: context.currentBuildPlanId ?? "",
         },
-        schema: selectMethodSchema(),
+        schema: selectBuildPlanSchema(),
         validateRequest: (values) => packageSchemaFieldErrors(PreparationSetupActionValuesSchema.safeParse(actionValues(values)), {
             name: "name",
             path: "path",
             about: "about",
-            method: "method",
+            build_plan: "build_plan",
         }),
         valuesPreview: actionValues,
         buildDraft: (values) => ({
             preparation: inputValue(values, "name"),
             values: actionValues(values),
             message: [
-                `Select Method ${inputValue(values, "method") || "interf-default"} for Preparation ${inputValue(values, "name")}.`,
-                "Save the selected Method. Do not run prepare yet.",
+                `Select Build Plan ${inputValue(values, "build_plan")} for Preparation ${inputValue(values, "name")}.`,
+                "Save the selected Build Plan. Do not build yet.",
                 "Use the attached typed action input as the source of truth.",
             ].join("\n"),
         }),
         fields: [
             {
-                name: "method",
-                label: "Method",
+                name: "build_plan",
+                label: "Build Plan",
                 type: "select",
-                help: "The Method future compile runs should use.",
+                help: "The Build Plan future Build runs should use to build requested Artifacts.",
                 context: "Saved on the existing Preparation.",
-                options: methodChoiceOptions(context.methods),
+                options: buildPlanChoiceOptions(context.buildPlans),
             },
             {
-                name: "current_method",
-                label: "Current Method",
+                name: "current_build_plan",
+                label: "Current Build Plan",
                 type: "text",
                 readOnly: true,
-                help: "The Method currently saved for this Preparation.",
+                help: "The Build Plan currently saved for this Preparation.",
                 context: "Shown so the change is explicit before approval.",
             },
             {
@@ -687,7 +691,7 @@ export function buildSelectMethodActionDefinition(context) {
                 type: "text",
                 readOnly: true,
                 advanced: true,
-                help: "The Preparation whose Method selection will be updated.",
+                help: "The Preparation whose Build Plan selection will be updated.",
                 context: "Sent with the setup action.",
             },
             {
@@ -697,7 +701,7 @@ export function buildSelectMethodActionDefinition(context) {
                 readOnly: true,
                 advanced: true,
                 help: "The saved job intent for this Preparation.",
-                context: "Preserved while updating the selected Method.",
+                context: "Preserved while updating the selected Build Plan.",
             },
             {
                 name: "path",
@@ -706,54 +710,54 @@ export function buildSelectMethodActionDefinition(context) {
                 readOnly: true,
                 advanced: true,
                 help: "The saved Source Folder path.",
-                context: "Preserved while updating the selected Method.",
+                context: "Preserved while updating the selected Build Plan.",
             },
         ],
     };
 }
-export function buildCreateMethodActionDefinition(context) {
-    const existingMethodIds = new Set(context.existingMethodIds);
-    const defaultSeed = context.defaultPreparation ? `${context.defaultPreparation}-method` : context.suggestedMethodId;
-    const methodId = uniqueActionId(defaultSeed, existingMethodIds);
-    const label = titleFromActionId(methodId);
+export function buildCreateBuildPlanActionDefinition(context) {
+    const existingBuildPlanIds = new Set(context.existingBuildPlanIds);
+    const defaultSeed = context.defaultPreparation ? `${context.defaultPreparation}-build-plan` : context.suggestedBuildPlanId;
+    const buildPlanId = uniqueActionId(defaultSeed, existingBuildPlanIds);
+    const label = titleFromActionId(buildPlanId);
     return {
-        id: INTERF_SERVICE_ACTIONS.createMethod.id,
-        title: INTERF_SERVICE_ACTIONS.createMethod.title,
-        description: "Describe the reusable job this Method should make possible. Interf will generate the stable Method metadata unless you override it.",
+        id: INTERF_SERVICE_ACTIONS.createBuildPlan.id,
+        title: INTERF_SERVICE_ACTIONS.createBuildPlan.title,
+        description: "Describe the Artifacts the agent needs. Interf drafts the Build Plan from this description; the Build run later proves source coverage.",
         submitLabel: "Send Request",
         initialValues: {
-            method_id: "",
+            build_plan_id: "",
             label: "",
             hint: "",
             task_prompt: "",
-            portable_output: "",
+            requested_artifacts_description: "",
             readiness_notes: "",
         },
-        normalizeValues: (values) => normalizedMethodActionValues(values, existingMethodIds, defaultSeed),
-        schema: methodAuthoringSchema(existingMethodIds),
-        validateRequest: (values) => packageSchemaFieldErrors(MethodAuthoringActionValuesSchema.safeParse(methodAuthoringActionValues(values)), {
-            method_id: "method_id",
+        normalizeValues: (values) => normalizedBuildPlanActionValues(values, existingBuildPlanIds, defaultSeed),
+        schema: buildPlanAuthoringSchema(existingBuildPlanIds),
+        validateRequest: (values) => packageSchemaFieldErrors(BuildPlanAuthoringActionValuesSchema.safeParse(buildPlanAuthoringActionValues(values)), {
+            build_plan_id: "build_plan_id",
             label: "label",
             hint: "hint",
             task_prompt: "task_prompt",
-            portable_output: "portable_output",
+            requested_artifacts_description: "requested_artifacts_description",
             readiness_notes: "readiness_notes",
         }),
         valuesPreview: (values) => ({
-            method_id: inputValue(values, "method_id"),
+            build_plan_id: inputValue(values, "build_plan_id"),
             label: inputValue(values, "label"),
             hint: inputValue(values, "hint"),
-            task_prompt: methodTaskPromptFromInput(values),
+            task_prompt: buildPlanTaskPromptFromInput(values),
         }),
         buildDraft: (values) => ({
             preparation: context.defaultPreparation,
-            values: methodAuthoringActionValues(values),
+            values: buildPlanAuthoringActionValues(values),
             message: [
-                `Create Method ${inputValue(values, "method_id")}${context.defaultPreparation ? ` for Preparation ${context.defaultPreparation}` : ""}.`,
+                `Draft Build Plan ${inputValue(values, "build_plan_id")}${context.defaultPreparation ? ` for Preparation ${context.defaultPreparation}` : ""}.`,
                 `Label: ${inputValue(values, "label")}`,
                 `Summary: ${inputValue(values, "hint")}`,
-                methodTaskPromptFromInput(values),
-                "Use the attached typed action input as the Method authoring request.",
+                buildPlanTaskPromptFromInput(values),
+                "Use the attached typed action input as the Build Plan authoring request.",
             ].join("\n"),
         }),
         fields: [
@@ -762,17 +766,17 @@ export function buildCreateMethodActionDefinition(context) {
                 label: "Agent work",
                 type: "textarea",
                 rows: 4,
-                help: "The reusable job this Method should make possible for agents.",
-                context: "Used as the main Method-authoring instruction.",
+                help: "The agent task this Preparation should unlock.",
+                context: "Used as the main Build Plan authoring instruction.",
                 placeholder: "Example: Analyze every report chart, extract annual take-up by location, and produce a source data file plus markdown summary.",
             },
             {
-                name: "portable_output",
-                label: "Portable-context output",
+                name: "requested_artifacts_description",
+                label: "Requested Artifacts",
                 type: "textarea",
                 rows: 3,
-                help: "Files, sections, or evidence agents should receive in portable context.",
-                context: "Guides the Method output shape and stage artifact plan.",
+                help: "Files, sections, or evidence agents should receive in verifiable context.",
+                context: "Guides the requested Artifact shape and Build Plan stages before a Build run proves source coverage.",
                 placeholder: "Describe the files or sections agents should receive.",
             },
             {
@@ -780,18 +784,18 @@ export function buildCreateMethodActionDefinition(context) {
                 label: "Readiness guidance",
                 type: "textarea",
                 rows: 3,
-                help: "What this Method output should be able to prove.",
-                context: "Guides readiness checks. Method Artifact checks stay separate.",
-                placeholder: "Describe the evidence that should make this Method output ready.",
+                help: "What these Artifacts should be able to prove.",
+                context: "Guides readiness checks. Artifact contract checks stay separate.",
+                placeholder: "Describe the evidence that should make these Artifacts ready.",
             },
             {
-                name: "method_id",
-                label: "Method id",
+                name: "build_plan_id",
+                label: "Build Plan id",
                 type: "text",
                 advanced: true,
                 help: "Optional. Leave blank and Interf generates a stable id from the job.",
-                context: "Saved under the Workspace methods folder and referenced by Preparations.",
-                placeholder: methodId,
+                context: "Saved as the Build Plan id and referenced by Preparations.",
+                placeholder: buildPlanId,
             },
             {
                 name: "label",
@@ -799,7 +803,7 @@ export function buildCreateMethodActionDefinition(context) {
                 type: "text",
                 advanced: true,
                 help: "Optional readable name people can choose later.",
-                context: "Shown in the UI and sent to the local agent while drafting the Method.",
+                context: "Shown in the UI and sent to the local agent while drafting the Build Plan.",
                 placeholder: label,
             },
             {
@@ -815,49 +819,49 @@ export function buildCreateMethodActionDefinition(context) {
         ],
     };
 }
-export function buildMethodChangeActionDefinition(context) {
-    const existingMethodIds = new Set(context.existingMethodIds);
+export function buildBuildPlanChangeActionDefinition(context) {
+    const existingBuildPlanIds = new Set(context.existingBuildPlanIds);
     const actionLabel = titleFromActionId(context.action);
-    const newMethodId = context.action === "duplicate"
-        ? uniqueActionId(`${context.methodId}-copy`, existingMethodIds)
+    const newBuildPlanId = context.action === "duplicate"
+        ? uniqueActionId(`${context.buildPlanId}-copy`, existingBuildPlanIds)
         : "";
     const initialValues = {
-        action: `method-${context.action}`,
-        method: context.methodId,
+        action: `build-plan-${context.action}`,
+        build_plan: context.buildPlanId,
         preparation: context.preparation,
         ...(context.action === "modify" ? { change_request: "", label: context.label ?? "", hint: context.hint ?? "" } : {}),
-        ...(context.action === "duplicate" ? { new_method_id: newMethodId } : {}),
+        ...(context.action === "duplicate" ? { new_build_plan_id: newBuildPlanId } : {}),
         ...(context.action === "remove" ? { confirmation: "" } : {}),
     };
-    const actionValues = (values) => methodChangeActionValues(context.action, values);
+    const actionValues = (values) => buildPlanChangeActionValues(context.action, values);
     const messageFor = (values) => {
         if (context.action === "modify") {
             return [
-                `Modify Method ${inputValue(values, "method")}.`,
+                `Modify Build Plan ${inputValue(values, "build_plan")}.`,
                 `Requested change: ${inputValue(values, "change_request")}`,
-                "Use the attached typed Method-authoring input as the source of truth.",
+                "Use the attached typed Build Plan authoring input as the source of truth.",
             ].join("\n");
         }
         if (context.action === "duplicate") {
             return [
-                `Duplicate Method ${inputValue(values, "method")} as ${inputValue(values, "new_method_id")}.`,
-                "Use the attached typed Method change input as the source of truth.",
+                `Duplicate Build Plan ${inputValue(values, "build_plan")} as ${inputValue(values, "new_build_plan_id")}.`,
+                "Use the attached typed Build Plan change input as the source of truth.",
             ].join("\n");
         }
         return [
-            `Remove Method ${inputValue(values, "method")}.`,
-            "The user typed the Method id to confirm removal.",
-            "Use the attached typed Method change input as the source of truth.",
+            `Remove Build Plan ${inputValue(values, "build_plan")}.`,
+            "The user typed the Build Plan id to confirm removal.",
+            "Use the attached typed Build Plan change input as the source of truth.",
         ].join("\n");
     };
     const fields = [
         {
-            name: "method",
-            label: "Method",
+            name: "build_plan",
+            label: "Build Plan",
             type: "text",
             readOnly: true,
-            help: "The Method this request targets.",
-            context: "Sent as the Method change target.",
+            help: "The Build Plan this request targets.",
+            context: "Sent as the Build Plan change target.",
         },
         {
             name: "change_request",
@@ -866,37 +870,37 @@ export function buildMethodChangeActionDefinition(context) {
             rows: 4,
             advanced: context.action === "remove",
             help: context.action === "duplicate"
-                ? "What should be different in the duplicate Method."
-                : "What should change in the existing Method.",
-            context: "Sent as the human-authored Method change request.",
+                ? "What should be different in the duplicate Build Plan."
+                : "What should change in the existing Build Plan.",
+            context: "Sent as the human-authored Build Plan change request.",
             placeholder: "Describe the concrete change Interf should make.",
         },
         {
-            name: "new_method_id",
-            label: "New Method id",
+            name: "new_build_plan_id",
+            label: "New Build Plan id",
             type: "text",
             advanced: context.action !== "duplicate",
-            help: "Stable id for the duplicated Method.",
-            context: "Used as the target Method id for the duplicate request.",
-            placeholder: newMethodId,
+            help: "Stable id for the duplicated Build Plan.",
+            context: "Used as the target Build Plan id for the duplicate request.",
+            placeholder: newBuildPlanId,
         },
         {
             name: "confirmation",
             label: "Confirm removal",
             type: "text",
             advanced: context.action !== "remove",
-            help: `Type ${context.methodId} to confirm this removal request.`,
-            context: "Prevents accidental destructive Method requests.",
-            placeholder: context.methodId,
+            help: `Type ${context.buildPlanId} to confirm this removal request.`,
+            context: "Prevents accidental destructive Build Plan requests.",
+            placeholder: context.buildPlanId,
         },
         {
             name: "label",
             label: "Label",
             type: "text",
             advanced: true,
-            help: "Readable Method name to keep while modifying this Method.",
-            context: "Sent to the Method-authoring run.",
-            placeholder: context.label ?? context.methodId,
+            help: "Readable Build Plan name to keep while modifying this Build Plan.",
+            context: "Sent to the Build Plan authoring run.",
+            placeholder: context.label ?? context.buildPlanId,
         },
         {
             name: "hint",
@@ -904,9 +908,9 @@ export function buildMethodChangeActionDefinition(context) {
             type: "textarea",
             rows: 2,
             advanced: true,
-            help: "Short Method summary to keep while modifying this Method.",
-            context: "Sent to the Method-authoring run.",
-            placeholder: context.hint ?? "Reusable Method for preparing source folders.",
+            help: "Short Build Plan summary to keep while modifying this Build Plan.",
+            context: "Sent to the Build Plan authoring run.",
+            placeholder: context.hint ?? "Reusable Build Plan for compiling Artifacts.",
         },
         {
             name: "preparation",
@@ -920,16 +924,16 @@ export function buildMethodChangeActionDefinition(context) {
         },
     ];
     return {
-        id: `${INTERF_SERVICE_ACTIONS.methodChange.id}-${context.action}`,
-        title: `${actionLabel} Method`,
+        id: `${INTERF_SERVICE_ACTIONS.buildPlanChange.id}-${context.action}`,
+        title: `${actionLabel} Build Plan`,
         description: context.action === "remove"
-            ? "Confirm the Method removal request. Interf will reject removal while any saved Preparation still uses it."
+            ? "Confirm the Build Plan removal request. Interf will reject removal while any saved Preparation still uses it."
             : context.action === "duplicate"
-                ? "Duplicate this Method through the local Interf service."
-                : "Describe the change and Interf will run a visible Method draft job.",
+                ? "Duplicate this Build Plan through the local Interf service."
+                : "Describe the change and Interf will run a visible Build Plan draft job.",
         submitLabel: context.action === "modify" ? "Send Request" : "Confirm",
         initialValues,
-        schema: methodChangeSchema(context.action, context.methodId, existingMethodIds),
+        schema: buildPlanChangeSchema(context.action, context.buildPlanId, existingBuildPlanIds),
         valuesPreview: actionValues,
         buildDraft: (values) => ({
             preparation: inputValue(values, "preparation"),
@@ -939,7 +943,7 @@ export function buildMethodChangeActionDefinition(context) {
         fields: fields.filter((field) => {
             if (field.name === "change_request")
                 return context.action === "modify";
-            if (field.name === "new_method_id")
+            if (field.name === "new_build_plan_id")
                 return context.action === "duplicate";
             if (field.name === "confirmation")
                 return context.action === "remove";
@@ -963,7 +967,7 @@ export function buildPreparationChangeActionDefinition(context) {
                 name: context.action === "duplicate" ? duplicateName : context.preparation,
                 path: context.sourceFolderPath,
                 about: context.about ?? "",
-                method: context.methodId ?? "interf-default",
+                build_plan: context.buildPlanId ?? "",
             }
             : {}),
         ...(context.action === "remove" ? { confirmation: "" } : {}),
@@ -974,7 +978,7 @@ export function buildPreparationChangeActionDefinition(context) {
             return [
                 `Modify Preparation ${inputValue(values, "preparation")}.`,
                 `Agent work: ${inputValue(values, "about")}`,
-                maybeActionValue(inputValue(values, "method")) ? `Method: ${inputValue(values, "method")}` : null,
+                maybeActionValue(inputValue(values, "build_plan")) ? `Build Plan: ${inputValue(values, "build_plan")}` : null,
                 `Source folder: ${inputValue(values, "path")}`,
                 "Use the attached typed Preparation setup input as the source of truth.",
             ].filter((line) => Boolean(line)).join("\n");
@@ -983,7 +987,7 @@ export function buildPreparationChangeActionDefinition(context) {
             return [
                 `Duplicate Preparation ${inputValue(values, "preparation")} as ${inputValue(values, "name")}.`,
                 `Agent work: ${inputValue(values, "about")}`,
-                maybeActionValue(inputValue(values, "method")) ? `Method: ${inputValue(values, "method")}` : null,
+                maybeActionValue(inputValue(values, "build_plan")) ? `Build Plan: ${inputValue(values, "build_plan")}` : null,
                 `Source folder: ${inputValue(values, "path")}`,
                 "Use the attached typed Preparation setup input as the source of truth.",
             ].filter((line) => Boolean(line)).join("\n");
@@ -1024,10 +1028,10 @@ export function buildPreparationChangeActionDefinition(context) {
             placeholder: "Describe the agent job.",
         },
         {
-            name: "method",
-            label: "Method",
+            name: "build_plan",
+            label: "Build Plan",
             type: "text",
-            help: "The Method future compile runs should use.",
+            help: "The Build Plan future Build runs should use.",
             context: "Saved on this Preparation.",
             placeholder: "interf-default",
         },
@@ -1065,7 +1069,7 @@ export function buildPreparationChangeActionDefinition(context) {
                 name: "name",
                 path: "path",
                 about: "about",
-                method: "method",
+                build_plan: "build_plan",
             })
             : undefined,
         valuesPreview: actionValues,
@@ -1075,7 +1079,7 @@ export function buildPreparationChangeActionDefinition(context) {
             message: messageFor(values),
         }),
         fields: fields.filter((field) => {
-            if (field.name === "name" || field.name === "about" || field.name === "method" || field.name === "path")
+            if (field.name === "name" || field.name === "about" || field.name === "build_plan" || field.name === "path")
                 return context.action === "modify" || context.action === "duplicate";
             if (field.name === "confirmation")
                 return context.action === "remove";
@@ -1147,7 +1151,7 @@ export function buildReadinessActionDraft(options) {
         message: `Improve ${options.preparation} using the latest readiness evidence.`,
         values: {
             action_type: INTERF_SERVICE_ACTIONS.improvePreparation.serviceAction,
-            ...(options.methodId ? { method: options.methodId } : {}),
+            ...(options.buildPlanId ? { build_plan: options.buildPlanId } : {}),
             preparation: options.preparation,
         },
     };