@interf/compiler 0.9.1 → 0.9.3

package/dist/cli/commands/{create-workflow-wizard.js → create-method-wizard.js}

@@ -1,17 +1,17 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { resolve } from "node:path";
-import { listCompiledWorkflowChoices, getCompiledWorkflow, } from "../../packages/workflow-package/workflow-definitions.js";
-import { createLocalWorkflowPackageFromTemplate } from "../../packages/workflow-package/interf-workflow-package.js";
+import { listCompiledMethodChoices, getCompiledMethod, } from "../../packages/method-package/method-definitions.js";
+import { createLocalMethodPackageFromTemplate } from "../../packages/method-package/interf-method-package.js";
 import { rmSync } from "node:fs";
-import { isWorkflowId, loadWorkflowDefinitionFromDir, seedLocalDefaultWorkflow, } from "../../packages/workflow-package/local-workflows.js";
+import { isMethodId, loadMethodDefinitionFromDir, seedLocalDefaultMethod, } from "../../packages/method-package/local-methods.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runWorkflowAuthoringDraft } from "../../packages/workflow-authoring/workflow-authoring.js";
-import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../../packages/project-model/source-config.js";
+import { runMethodAuthoringDraft } from "../../packages/method-authoring/method-authoring.js";
+import { listSourcePreparationConfigs, loadSourceFolderConfig, resolveSourcePreparationPath, } from "../../packages/project-model/source-config.js";
 import { slugify } from "../../packages/shared/naming.js";
-import { submitWorkflowAuthoringRunToLocalService } from "../../packages/local-service/index.js";
-import { DEFAULT_DATASET_PATH_PLACEHOLDER, listDatasetFolderChoices, normalizeDatasetPathForConfig, } from "./source-config-wizard.js";
-export const clackWorkflowPrompts = {
+import { submitMethodAuthoringRunToLocalService } from "../../packages/local-service/index.js";
+import { DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER, listSourceFolderChoices, normalizeSourceFolderPathForConfig, } from "./source-config-wizard.js";
+export const clackMethodPrompts = {
     intro: p.intro,
     select: (options) => p.select(options),
     text: (options) => p.text(options),
@@ -21,38 +21,38 @@ export const clackWorkflowPrompts = {
         error: p.log.error,
     },
 };
-function normalizeWorkflowCreationMode(mode) {
+function normalizeMethodCreationMode(mode) {
     if (mode === "draft")
         return "draft-from-scratch";
     if (mode === "manual")
         return "fork-existing";
     return mode;
 }
-function findMatchingDatasetConfig(sourcePath, datasetPath) {
+function findMatchingPreparationConfig(sourcePath, sourceFolderPath) {
     const config = loadSourceFolderConfig(sourcePath);
-    for (const dataset of listSourceDatasetConfigs(config)) {
-        if (resolveSourceDatasetPath(sourcePath, dataset) === datasetPath) {
-            return dataset;
+    for (const preparation of listSourcePreparationConfigs(config)) {
+        if (resolveSourcePreparationPath(sourcePath, preparation) === sourceFolderPath) {
+            return preparation;
         }
     }
     return null;
 }
-function describeSavedDataset(dataset) {
-    return dataset.about
-        ? `${dataset.path} · ${dataset.about}`
-        : `${dataset.path} · ${dataset.checks.length} readiness check${dataset.checks.length === 1 ? "" : "s"}`;
+function describeSavedPreparation(preparation) {
+    return preparation.about
+        ? `${preparation.path} · ${preparation.about}`
+        : `${preparation.path} · ${preparation.checks.length} readiness check${preparation.checks.length === 1 ? "" : "s"}`;
 }
-async function promptWorkflowDatasetFolder(sourcePath, prompts) {
-    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
-    const folderChoices = listDatasetFolderChoices(sourcePath);
+async function promptMethodSourceFolder(sourcePath, prompts) {
+    const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
+    const folderChoices = listSourceFolderChoices(sourcePath);
     if (folderChoices.length > 0) {
         const selected = await prompts.select({
             message: "Which Source Folder should shape this Method?",
             options: [
-                ...savedDatasets.map((dataset) => ({
-                    value: dataset.name,
-                    label: dataset.name,
-                    hint: describeSavedDataset(dataset),
+                ...savedPreparations.map((preparation) => ({
+                    value: preparation.name,
+                    label: preparation.name,
+                    hint: describeSavedPreparation(preparation),
                 })),
                 ...folderChoices,
                 {
@@ -65,23 +65,23 @@ async function promptWorkflowDatasetFolder(sourcePath, prompts) {
         if (prompts.isCancel(selected))
             return selected;
         if (selected !== "__manual__") {
-            const savedDataset = savedDatasets.find((dataset) => dataset.name === selected);
-            if (savedDataset) {
-                return resolveSourceDatasetPath(sourcePath, savedDataset);
+            const savedPreparation = savedPreparations.find((preparation) => preparation.name === selected);
+            if (savedPreparation) {
+                return resolveSourcePreparationPath(sourcePath, savedPreparation);
             }
-            return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(selected)));
+            return resolve(sourcePath, normalizeSourceFolderPathForConfig(sourcePath, String(selected)));
         }
     }
-    const datasetFolder = await prompts.text({
+    const sourceFolderPrompt = await prompts.text({
         message: "Which Source Folder should shape this Method?",
-        placeholder: DEFAULT_DATASET_PATH_PLACEHOLDER,
+        placeholder: DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER,
         initialValue: folderChoices.length === 1 ? folderChoices[0]?.value : undefined,
         validate: (value) => {
             const trimmed = value.trim();
             if (trimmed.length === 0)
                 return "Source Folder is required";
             try {
-                normalizeDatasetPathForConfig(sourcePath, trimmed);
+                normalizeSourceFolderPathForConfig(sourcePath, trimmed);
                 return undefined;
             }
             catch (error) {
@@ -89,34 +89,34 @@ async function promptWorkflowDatasetFolder(sourcePath, prompts) {
             }
         },
     });
-    if (prompts.isCancel(datasetFolder))
-        return datasetFolder;
-    return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(datasetFolder)));
+    if (prompts.isCancel(sourceFolderPrompt))
+        return sourceFolderPrompt;
+    return resolve(sourcePath, normalizeSourceFolderPathForConfig(sourcePath, String(sourceFolderPrompt)));
 }
-export function formatWorkflowLabel(workflow) {
+export function formatMethodLabel(method) {
     return {
-        value: workflow.id,
-        label: workflow.scope === "local" ? `${workflow.label} (Local)` : workflow.label,
-        hint: workflow.hint,
+        value: method.id,
+        label: method.scope === "local" ? `${method.label} (Local)` : method.label,
+        hint: method.hint,
     };
 }
-export function buildCompiledWorkflowOptions(sourcePath) {
-    return listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel);
+export function buildCompiledMethodOptions(sourcePath) {
+    return listCompiledMethodChoices(sourcePath).map(formatMethodLabel);
 }
-function workflowUseLabel(workflow) {
-    if (workflow.value === "interf-default" || workflow.value === "interf") {
+function methodUseLabel(method) {
+    if (method.value === "interf-default") {
         return "built-in Method";
     }
-    return workflow.label.replace(/ \(Local\)$/, "");
+    return method.label.replace(/ \(Local\)$/, "");
 }
-function workflowForkLabel(workflow) {
-    return `Fork ${workflowUseLabel(workflow)}`;
+function methodForkLabel(method) {
+    return `Fork ${methodUseLabel(method)}`;
 }
-export async function chooseCompiledWorkflow(sourcePath, options = {}) {
-    const currentWorkflowId = options.currentWorkflowId;
-    const workflowOptions = buildCompiledWorkflowOptions(sourcePath);
-    const orderedOptions = workflowOptions
-        .map((option) => option.value === currentWorkflowId
+export async function chooseCompiledMethod(sourcePath, options = {}) {
+    const currentMethodId = options.currentMethodId;
+    const methodOptions = buildCompiledMethodOptions(sourcePath);
+    const orderedOptions = methodOptions
+        .map((option) => option.value === currentMethodId
         ? {
             ...option,
             label: `${option.label} (Current)`,
@@ -124,36 +124,26 @@ export async function chooseCompiledWorkflow(sourcePath, options = {}) {
         }
         : option)
         .sort((left, right) => {
-        if (left.value === currentWorkflowId)
+        if (left.value === currentMethodId)
             return -1;
-        if (right.value === currentWorkflowId)
+        if (right.value === currentMethodId)
             return 1;
         return 0;
     });
     if (orderedOptions.length === 1) {
-        return orderedOptions[0]?.value ?? "interf";
+        return orderedOptions[0]?.value ?? "interf-default";
     }
     return p.select({
         message: options.message ?? "Preparation Method?",
         options: orderedOptions,
     });
 }
-export async function chooseOrCreateCompiledWorkflowForDataset(sourcePath, datasetConfig, options = {}, prompts = clackWorkflowPrompts) {
-    const currentWorkflowId = options.currentWorkflowId ?? datasetConfig.workflow ?? "interf-default";
-    const allWorkflowOptions = buildCompiledWorkflowOptions(sourcePath);
-    const workflowOptions = allWorkflowOptions.filter((workflow) => workflow.value !== "interf");
-    const builtinDefault = allWorkflowOptions.find((workflow) => workflow.value === "interf");
-    const virtualDefaultWorkflow = builtinDefault
-        ? {
-            value: "interf-default",
-            label: "built-in Method",
-            hint: "Use the built-in Method without drafting a custom package",
-        }
-        : undefined;
-    const currentWorkflow = workflowOptions.find((workflow) => workflow.value === currentWorkflowId) ??
-        workflowOptions.find((workflow) => workflow.value === "interf-default") ??
-        (currentWorkflowId === "interf-default" ? virtualDefaultWorkflow : undefined) ??
-        workflowOptions[0];
+export async function chooseOrCreateCompiledMethodForPreparation(sourcePath, preparationConfig, options = {}, prompts = clackMethodPrompts) {
+    const currentMethodId = options.currentMethodId ?? preparationConfig.method ?? "interf-default";
+    const methodOptions = buildCompiledMethodOptions(sourcePath);
+    const currentMethod = methodOptions.find((method) => method.value === currentMethodId) ??
+        methodOptions.find((method) => method.value === "interf-default") ??
+        methodOptions[0];
     const selected = await prompts.select({
         message: "Which Method should Interf use for this Preparation?",
         options: [
@@ -162,76 +152,76 @@ export async function chooseOrCreateCompiledWorkflowForDataset(sourcePath, datas
                 label: "Draft a new Method from scratch (Recommended)",
                 hint: "Start from a neutral scaffold; an agent designs stages, outputs, and proof for this Preparation",
             },
-            ...(currentWorkflow
+            ...(currentMethod
                 ? [{
                         value: "__current__",
-                        label: `Use ${workflowUseLabel(currentWorkflow)}`,
-                        hint: currentWorkflow.value === "interf-default"
+                        label: `Use ${methodUseLabel(currentMethod)}`,
+                        hint: currentMethod.value === "interf-default"
                             ? "Use the built-in Method without drafting a custom package"
-                            : currentWorkflow.hint,
+                            : currentMethod.hint,
                     }]
                 : []),
-            ...(currentWorkflow
+            ...(currentMethod
                 ? [{
                         value: "__fork_existing__",
-                        label: workflowForkLabel(currentWorkflow),
+                        label: methodForkLabel(currentMethod),
                         hint: "Copy its existing stage topology, then write the per-stage guidance yourself",
                     }]
                 : []),
-            ...workflowOptions
-                .filter((workflow) => workflow.value !== currentWorkflow?.value)
-                .map((workflow) => ({
-                ...workflow,
-                label: `Use ${workflowUseLabel(workflow)}`,
+            ...methodOptions
+                .filter((method) => method.value !== currentMethod?.value)
+                .map((method) => ({
+                ...method,
+                label: `Use ${methodUseLabel(method)}`,
             })),
         ],
     });
     if (prompts.isCancel(selected))
         return selected;
     if (selected === "__current__") {
-        if (currentWorkflow?.value === "interf-default") {
-            seedLocalDefaultWorkflow({ sourcePath });
+        if (currentMethod?.value === "interf-default") {
+            seedLocalDefaultMethod({ sourcePath });
         }
-        return currentWorkflow?.value ?? currentWorkflowId;
+        return currentMethod?.value ?? currentMethodId;
     }
     if (selected === "__draft_from_scratch__" || selected === "__fork_existing__") {
-        if (selected === "__fork_existing__" && currentWorkflow?.value === "interf-default") {
-            seedLocalDefaultWorkflow({ sourcePath });
+        if (selected === "__fork_existing__" && currentMethod?.value === "interf-default") {
+            seedLocalDefaultMethod({ sourcePath });
         }
-        const workflowId = await createWorkflowWizard({
+        const methodId = await createMethodWizard({
             intro: false,
             sourcePath,
-            baseWorkflowId: selected === "__fork_existing__"
-                ? currentWorkflow?.value ?? currentWorkflowId
+            baseMethodId: selected === "__fork_existing__"
+                ? currentMethod?.value ?? currentMethodId
                 : undefined,
             creationMode: selected === "__draft_from_scratch__" ? "draft-from-scratch" : "fork-existing",
             executionProfile: options.executionProfile,
             resolveExecutor: options.resolveExecutor,
             runDraft: options.runDraft,
-            datasetContext: {
-                config: datasetConfig,
-                datasetPath: resolveSourceDatasetPath(sourcePath, datasetConfig),
+            preparationContext: {
+                config: preparationConfig,
+                sourceFolderPath: resolveSourcePreparationPath(sourcePath, preparationConfig),
             },
         }, prompts);
-        return workflowId;
+        return methodId;
     }
     return String(selected);
 }
-export async function createWorkflowWizard(options = {}, prompts = clackWorkflowPrompts) {
+export async function createMethodWizard(options = {}, prompts = clackMethodPrompts) {
     if (options.intro !== false) {
         prompts.intro(chalk.bold("Create a Method"));
     }
     const sourcePath = options.sourcePath ?? process.cwd();
-    return createCompiledWorkflowWizard(sourcePath, prompts, {
+    return createCompiledMethodWizard(sourcePath, prompts, {
         executionProfile: options.executionProfile,
-        baseWorkflowId: options.baseWorkflowId,
+        baseMethodId: options.baseMethodId,
         creationMode: options.creationMode,
-        datasetContext: options.datasetContext,
+        preparationContext: options.preparationContext,
         resolveExecutor: options.resolveExecutor,
         runDraft: options.runDraft,
     });
 }
-export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts, options = {}) {
+export async function createCompiledMethodWizard(sourcePath, prompts = clackMethodPrompts, options = {}) {
     const creationMode = options.creationMode ?? await prompts.select({
         message: "How do you want to create it?",
         options: [
@@ -249,18 +239,18 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     });
     if (prompts.isCancel(creationMode))
         return creationMode;
-    const creationModeValue = normalizeWorkflowCreationMode(creationMode);
-    const baseWorkflow = creationModeValue === "fork-existing"
-        ? options.baseWorkflowId ?? await prompts.select({
+    const creationModeValue = normalizeMethodCreationMode(creationMode);
+    const baseMethod = creationModeValue === "fork-existing"
+        ? options.baseMethodId ?? await prompts.select({
             message: "Which existing Method should Interf fork?",
-            options: listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+            options: listCompiledMethodChoices(sourcePath).map(formatMethodLabel),
         })
         : null;
-    if (prompts.isCancel(baseWorkflow))
-        return baseWorkflow;
-    const baseWorkflowId = typeof baseWorkflow === "string" ? baseWorkflow : null;
-    const resolvedBaseWorkflow = baseWorkflowId
-        ? getCompiledWorkflow(baseWorkflowId, { sourcePath })
+    if (prompts.isCancel(baseMethod))
+        return baseMethod;
+    const baseMethodId = typeof baseMethod === "string" ? baseMethod : null;
+    const resolvedBaseMethod = baseMethodId
+        ? getCompiledMethod(baseMethodId, { sourcePath })
         : null;
     const rawName = await prompts.text({
         message: "New Method name?",
@@ -268,10 +258,10 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         validate: (value) => {
             if (value.trim().length === 0)
                 return "Name is required";
-            const workflowId = slugify(value);
-            if (!isWorkflowId(workflowId))
+            const methodId = slugify(value);
+            if (!isMethodId(methodId))
                 return "Use letters, numbers, and dashes only";
-            if (listCompiledWorkflowChoices(sourcePath).some((workflow) => workflow.id === workflowId)) {
+            if (listCompiledMethodChoices(sourcePath).some((method) => method.id === methodId)) {
                 return "That Method name already exists";
             }
             return undefined;
@@ -279,7 +269,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     });
     if (prompts.isCancel(rawName))
         return rawName;
-    const workflowId = slugify(rawName);
+    const methodId = slugify(rawName);
     const label = rawName.trim();
     const hint = await prompts.text({
         message: "One-line Method description?",
@@ -289,18 +279,18 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     if (prompts.isCancel(hint))
         return hint;
     if (creationModeValue === "draft-from-scratch") {
-        let datasetPath = options.datasetContext?.datasetPath ?? null;
-        let matchedDataset = options.datasetContext?.config ?? null;
-        if (!datasetPath) {
-            const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
-            if (savedDatasets.length > 0) {
-                const datasetChoice = await prompts.select({
+        let sourceFolderPath = options.preparationContext?.sourceFolderPath ?? null;
+        let matchedPreparation = options.preparationContext?.config ?? null;
+        if (!sourceFolderPath) {
+            const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
+            if (savedPreparations.length > 0) {
+                const preparationChoice = await prompts.select({
                     message: "Which saved Preparation should shape this Method?",
                     options: [
-                        ...savedDatasets.map((dataset) => ({
-                            value: dataset.name,
-                            label: dataset.name,
-                            hint: describeSavedDataset(dataset),
+                        ...savedPreparations.map((preparation) => ({
+                            value: preparation.name,
+                            label: preparation.name,
+                            hint: describeSavedPreparation(preparation),
                         })),
                         {
                             value: "__manual__",
@@ -309,24 +299,24 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                         },
                     ],
                 });
-                if (prompts.isCancel(datasetChoice))
-                    return datasetChoice;
-                if (datasetChoice !== "__manual__") {
-                    matchedDataset = savedDatasets.find((dataset) => dataset.name === datasetChoice) ?? null;
-                    datasetPath = matchedDataset
-                        ? resolveSourceDatasetPath(sourcePath, matchedDataset)
+                if (prompts.isCancel(preparationChoice))
+                    return preparationChoice;
+                if (preparationChoice !== "__manual__") {
+                    matchedPreparation = savedPreparations.find((preparation) => preparation.name === preparationChoice) ?? null;
+                    sourceFolderPath = matchedPreparation
+                        ? resolveSourcePreparationPath(sourcePath, matchedPreparation)
                         : null;
                 }
             }
         }
-        if (!datasetPath) {
-            const datasetFolder = await promptWorkflowDatasetFolder(sourcePath, prompts);
-            if (prompts.isCancel(datasetFolder))
-                return datasetFolder;
-            if (!datasetFolder)
+        if (!sourceFolderPath) {
+            const sourceFolderPrompt = await promptMethodSourceFolder(sourcePath, prompts);
+            if (prompts.isCancel(sourceFolderPrompt))
+                return sourceFolderPrompt;
+            if (!sourceFolderPrompt)
                 return null;
-            datasetPath = String(datasetFolder);
-            matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
+            sourceFolderPath = String(sourceFolderPrompt);
+            matchedPreparation = matchedPreparation ?? findMatchingPreparationConfig(sourcePath, sourceFolderPath);
         }
         const taskPrompt = await prompts.text({
             message: "What should this Method prepare for agents, and what evidence should show the data is ready?",
@@ -335,24 +325,24 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         });
         if (prompts.isCancel(taskPrompt))
             return taskPrompt;
-        if (matchedDataset) {
-            prompts.log.info(`Shaping this Method from Preparation "${matchedDataset.name}".`);
+        if (matchedPreparation) {
+            prompts.log.info(`Shaping this Method from Preparation "${matchedPreparation.name}".`);
         }
-        if (matchedDataset?.checks.length) {
-            prompts.log.info(`Using ${matchedDataset.checks.length} saved readiness check${matchedDataset.checks.length === 1 ? "" : "s"} from Preparation "${matchedDataset.name}" as authoring context.`);
+        if (matchedPreparation?.checks.length) {
+            prompts.log.info(`Using ${matchedPreparation.checks.length} saved readiness check${matchedPreparation.checks.length === 1 ? "" : "s"} from Preparation "${matchedPreparation.name}" as authoring context.`);
         }
         prompts.log.info("Preparing a Method-authoring shell from the Source Folder, then drafting the package.");
         let lastServiceStatus = "";
-        const serviceRun = await submitWorkflowAuthoringRunToLocalService({
+        const serviceRun = await submitMethodAuthoringRunToLocalService({
             projectPath: sourcePath,
             request: {
-                preparation: matchedDataset?.name ?? null,
-                source_folder_path: datasetPath,
-                method_id: workflowId,
+                preparation: matchedPreparation?.name ?? null,
+                source_folder_path: sourceFolderPath,
+                method_id: methodId,
                 label,
                 hint: hint.trim(),
                 task_prompt: taskPrompt.trim(),
-                checks: matchedDataset?.checks ?? [],
+                checks: matchedPreparation?.checks ?? [],
             },
             onSubmitted: (submission) => {
                 prompts.log.info(`Visible in Interf: ${submission.serviceUrl}/`);
@@ -377,7 +367,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                     changed: serviceRun.result.changed,
                     summary: serviceRun.result.summary,
                     validation: serviceRun.result.validation ?? null,
-                    workflowPath: serviceRun.result.method_path,
+                    methodPath: serviceRun.result.method_path,
                     shellPath: serviceRun.result.shell_path,
                 }
                 : {
@@ -385,15 +375,15 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                     changed: false,
                     summary: serviceRun.error ?? "Method authoring failed in the local Interf service.",
                     validation: null,
-                    workflowPath: resolve(sourcePath, "interf", "methods", workflowId),
-                    shellPath: resolve(sourcePath, "interf", "methods", workflowId),
+                    methodPath: resolve(sourcePath, "interf", "methods", methodId),
+                    shellPath: resolve(sourcePath, "interf", "methods", methodId),
                 }
             : await (async () => {
                 const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
-                const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
+                const runDraft = options.runDraft ?? runMethodAuthoringDraft;
                 const { executor, error } = await resolveExecutor({
                     executionProfile: options.executionProfile,
-                    purpose: "workflow",
+                    purpose: "method",
                 });
                 if (!executor && !error) {
                     return null;
@@ -405,12 +395,12 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                 }
                 return runDraft({
                     sourcePath,
-                    datasetPath,
-                    workflowId,
+                    sourceFolderPath,
+                    methodId,
                     label,
                     hint: hint.trim(),
                     taskPrompt: taskPrompt.trim(),
-                    checks: matchedDataset?.checks ?? [],
+                    checks: matchedPreparation?.checks ?? [],
                     executor,
                     onStatus: (line) => prompts.log.info(line),
                 });
@@ -418,9 +408,9 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         if (!result)
             return null;
         if (result.status === "updated") {
-            const draft = loadWorkflowDefinitionFromDir(result.workflowPath);
+            const draft = loadMethodDefinitionFromDir(result.methodPath);
             const stageList = draft?.stages?.map((stage) => stage.id).join(" -> ") ?? "-";
-            prompts.log.info(`Draft ready at ${result.workflowPath}`);
+            prompts.log.info(`Draft ready at ${result.methodPath}`);
             prompts.log.info(`  Name: ${draft?.label ?? label}`);
             prompts.log.info(`  Description: ${draft?.hint ?? hint.trim()}`);
             if (draft?.purpose)
@@ -434,12 +424,12 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                 ],
             });
             if (prompts.isCancel(confirmChoice) || confirmChoice === "cancel") {
-                rmSync(result.workflowPath, { recursive: true, force: true });
-                prompts.log.info(`Discarded draft at ${result.workflowPath}`);
+                rmSync(result.methodPath, { recursive: true, force: true });
+                prompts.log.info(`Discarded draft at ${result.methodPath}`);
                 return null;
             }
-            prompts.log.info(`Saved local Method: ${result.workflowPath}`);
-            return workflowId;
+            prompts.log.info(`Saved local Method: ${result.methodPath}`);
+            return methodId;
         }
         process.exitCode = 1;
         (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
@@ -449,10 +439,10 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         return null;
     }
     const stagePolicyNotes = {};
-    if (!baseWorkflowId || !resolvedBaseWorkflow) {
+    if (!baseMethodId || !resolvedBaseMethod) {
         throw new Error("Fork-existing Method creation needs a base Method.");
     }
-    for (const stage of resolvedBaseWorkflow.stages) {
+    for (const stage of resolvedBaseMethod.stages) {
         const stagePrompt = await prompts.text({
             message: `What should ${stage.id} (${stage.label}) emphasize?`,
             placeholder: stage.description,
@@ -462,14 +452,14 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             return stagePrompt;
         stagePolicyNotes[stage.id] = [String(stagePrompt).trim()];
     }
-    const workflowPath = createLocalWorkflowPackageFromTemplate({
+    const methodPath = createLocalMethodPackageFromTemplate({
         sourcePath,
-        baseWorkflowId,
-        workflowId,
+        baseMethodId,
+        methodId,
         label,
         hint: hint.trim(),
         stagePolicyNotes,
     });
-    prompts.log.info(`Saved local Method: ${workflowPath}`);
-    return workflowId;
+    prompts.log.info(`Saved local Method: ${methodPath}`);
+    return methodId;
 }

package/dist/cli/commands/create.d.ts

@@ -1,8 +1,8 @@
 import type { CommandModule } from "yargs";
-import type { WorkflowExecutionProfile } from "../../packages/agents/lib/executors.js";
+import type { MethodExecutionProfile } from "../../packages/agents/lib/executors.js";
 export declare const createCommand: CommandModule;
 export declare function createCompiledWizard(options?: {
     intro?: boolean;
-    executionProfile?: WorkflowExecutionProfile;
+    executionProfile?: MethodExecutionProfile;
 }): Promise<void>;
-export { type WorkflowWizardPrompts, formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";
+export { type MethodWizardPrompts, formatMethodLabel, createMethodWizard, createCompiledMethodWizard, } from "./create-method-wizard.js";