@interf/compiler 0.7.2 → 0.9.1

package/dist/cli/commands/compiled-flow.js

@@ -7,12 +7,12 @@ import { formatWorkflowExecutionProfile } from "../../packages/agents/lib/execut
 function formatSavedDatasetHint(entry) {
     const config = entry.config;
     const checkCount = config.checks.length;
-    const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
+    const workflowHint = `Method ${config.method ?? config.workflow ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`;
     if (config.about)
         return `${config.path} · ${config.about} · ${workflowHint}`;
     if (checkCount === 0)
-        return `${config.path} · No questions yet · ${workflowHint}`;
-    return `${config.path} · ${checkCount} question${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+        return `${config.path} · No readiness checks yet · ${workflowHint}`;
+    return `${config.path} · ${checkCount} readiness check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
 }
 export function listSavedCompiledEntries(sourcePath) {
     const builtEntries = new Map();
@@ -57,7 +57,7 @@ export async function chooseCompiledConfigToBuild(options) {
             label: entry.config.name,
             hint: [
                 formatSavedDatasetHint(entry),
-                entry.path ? "built" : "not built yet",
+                entry.path ? "Portable Context available" : "Portable Context not built yet",
             ].join(" · "),
         })),
     });
@@ -66,7 +66,7 @@ export async function chooseCompiledConfigToBuild(options) {
     return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
 }
 export function createCompiledFromConfig(sourcePath, datasetConfig) {
-    const workflowId = datasetConfig.workflow ?? "interf";
+    const workflowId = datasetConfig.method ?? datasetConfig.workflow ?? "interf-default";
     const datasetSourcePath = resolveSourceDatasetPath(sourcePath, datasetConfig);
     const compiledPath = createCompiled(datasetConfig.name, sourcePath, workflowId, datasetConfig.about, datasetSourcePath);
     syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig);
@@ -82,7 +82,7 @@ export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
 }
 export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
     console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building portable context..."}`));
+    console.log(chalk.bold(`  ${options.heading ?? "Building Portable Context..."}`));
     const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
@@ -97,11 +97,13 @@ export async function compileCompiledWithReporter(executor, compiledPath, option
         compiledPath,
         reporter,
         preserveStageShells: options.preserveStageShells,
+        runId: options.runId,
+        events: options.events,
     });
     if (!result.ok) {
         return result;
     }
     console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Portable context ready."}`));
+    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Portable Context ready."}`));
     return result;
 }

package/dist/cli/commands/control-path.d.ts

@@ -0,0 +1,11 @@
+export declare function hasInterfInstanceConfig(controlPath: string): boolean;
+export declare function findNearestInterfInstanceConfig(cwd?: string): string | null;
+export declare function defaultInterfInstanceRoot(sourceFolderPath: string): string;
+export declare function resolveCommandControlPath(cwd?: string): string;
+export interface InterfInstanceContext {
+    controlPath: string;
+    defaultSourceFolderPath: string | null;
+    defaultPreparationPath: string | null;
+}
+export declare function relativeSourceFolderPath(controlPath: string, sourceFolderPath: string): string;
+export declare function resolveInterfInstanceContext(cwd?: string): InterfInstanceContext;

package/dist/cli/commands/control-path.js

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { assertCompiledContainer } from "../../packages/project-model/interf.js";
+import { sourceFolderConfigPath } from "../../packages/project-model/source-config.js";
+function canUseInterfInstanceRoot(controlPath) {
+    try {
+        assertCompiledContainer(controlPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasInterfInstanceConfig(controlPath) {
+    return existsSync(sourceFolderConfigPath(controlPath)) && canUseInterfInstanceRoot(controlPath);
+}
+export function findNearestInterfInstanceConfig(cwd = process.cwd()) {
+    let cursor = resolve(cwd);
+    while (true) {
+        if (hasInterfInstanceConfig(cursor))
+            return cursor;
+        const parentPath = dirname(cursor);
+        if (parentPath === cursor)
+            return null;
+        cursor = parentPath;
+    }
+}
+function fallbackInterfInstanceRoot(sourceFolderPath) {
+    return join(homedir(), ".interf", basename(sourceFolderPath) || "source-folder");
+}
+export function defaultInterfInstanceRoot(sourceFolderPath) {
+    const parentPath = dirname(sourceFolderPath);
+    if (parentPath !== sourceFolderPath && canUseInterfInstanceRoot(parentPath)) {
+        return parentPath;
+    }
+    return fallbackInterfInstanceRoot(sourceFolderPath);
+}
+export function resolveCommandControlPath(cwd = process.cwd()) {
+    const currentPath = resolve(cwd);
+    return findNearestInterfInstanceConfig(currentPath) ?? currentPath;
+}
+export function relativeSourceFolderPath(controlPath, sourceFolderPath) {
+    const relativePath = relative(controlPath, sourceFolderPath).split(sep).join("/") || ".";
+    if (relativePath.startsWith(".."))
+        return sourceFolderPath;
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+export function resolveInterfInstanceContext(cwd = process.cwd()) {
+    const currentPath = resolve(cwd);
+    const existingControlPath = findNearestInterfInstanceConfig(currentPath);
+    if (existingControlPath) {
+        if (existingControlPath !== currentPath) {
+            return {
+                controlPath: existingControlPath,
+                defaultSourceFolderPath: currentPath,
+                defaultPreparationPath: relativeSourceFolderPath(existingControlPath, currentPath),
+            };
+        }
+        return {
+            controlPath: currentPath,
+            defaultSourceFolderPath: null,
+            defaultPreparationPath: null,
+        };
+    }
+    const controlPath = defaultInterfInstanceRoot(currentPath);
+    return {
+        controlPath,
+        defaultSourceFolderPath: currentPath,
+        defaultPreparationPath: relativeSourceFolderPath(controlPath, currentPath),
+    };
+}

package/dist/cli/commands/create-workflow-wizard.d.ts

@@ -29,6 +29,7 @@ export interface WorkflowWizardDatasetContext {
     datasetPath: string;
 }
 export declare const clackWorkflowPrompts: WorkflowWizardPrompts;
+type WorkflowCreationMode = "draft-from-scratch" | "fork-existing" | "draft" | "manual";
 export declare function formatWorkflowLabel(workflow: {
     id: string;
     label: string;
@@ -48,17 +49,28 @@ export declare function chooseCompiledWorkflow(sourcePath: string, options?: {
     currentWorkflowId?: string;
     message?: string;
 }): Promise<string | symbol>;
+export declare function chooseOrCreateCompiledWorkflowForDataset(sourcePath: string, datasetConfig: SourceDatasetConfig, options?: {
+    currentWorkflowId?: string;
+    executionProfile?: WorkflowExecutionProfile;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runWorkflowAuthoringDraft;
+}, prompts?: WorkflowWizardPrompts): Promise<string | symbol | null>;
 export declare function createWorkflowWizard(options?: {
     intro?: boolean;
     sourcePath?: string;
     executionProfile?: WorkflowExecutionProfile;
+    baseWorkflowId?: string;
+    creationMode?: WorkflowCreationMode;
     datasetContext?: WorkflowWizardDatasetContext;
     resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
     runDraft?: typeof runWorkflowAuthoringDraft;
 }, prompts?: WorkflowWizardPrompts): Promise<string | symbol | null>;
 export declare function createCompiledWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts, options?: {
     executionProfile?: WorkflowExecutionProfile;
+    baseWorkflowId?: string;
+    creationMode?: WorkflowCreationMode;
     datasetContext?: WorkflowWizardDatasetContext;
     resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
     runDraft?: typeof runWorkflowAuthoringDraft;
 }): Promise<string | symbol | null>;
+export {};

package/dist/cli/commands/create-workflow-wizard.js

@@ -4,11 +4,12 @@ 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 { rmSync } from "node:fs";
-import { isWorkflowId, loadWorkflowDefinitionFromDir, } from "../../packages/workflow-package/local-workflows.js";
+import { isWorkflowId, loadWorkflowDefinitionFromDir, seedLocalDefaultWorkflow, } from "../../packages/workflow-package/local-workflows.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 { 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 = {
     intro: p.intro,
@@ -20,6 +21,13 @@ export const clackWorkflowPrompts = {
         error: p.log.error,
     },
 };
+function normalizeWorkflowCreationMode(mode) {
+    if (mode === "draft")
+        return "draft-from-scratch";
+    if (mode === "manual")
+        return "fork-existing";
+    return mode;
+}
 function findMatchingDatasetConfig(sourcePath, datasetPath) {
     const config = loadSourceFolderConfig(sourcePath);
     for (const dataset of listSourceDatasetConfigs(config)) {
@@ -32,36 +40,46 @@ function findMatchingDatasetConfig(sourcePath, datasetPath) {
 function describeSavedDataset(dataset) {
     return dataset.about
         ? `${dataset.path} · ${dataset.about}`
-        : `${dataset.path} · ${dataset.checks.length} test${dataset.checks.length === 1 ? "" : "s"}`;
+        : `${dataset.path} · ${dataset.checks.length} readiness check${dataset.checks.length === 1 ? "" : "s"}`;
 }
 async function promptWorkflowDatasetFolder(sourcePath, prompts) {
+    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
     const folderChoices = listDatasetFolderChoices(sourcePath);
     if (folderChoices.length > 0) {
         const selected = await prompts.select({
-            message: "Which source folder should shape this workflow?",
+            message: "Which Source Folder should shape this Method?",
             options: [
+                ...savedDatasets.map((dataset) => ({
+                    value: dataset.name,
+                    label: dataset.name,
+                    hint: describeSavedDataset(dataset),
+                })),
                 ...folderChoices,
                 {
                     value: "__manual__",
                     label: "Enter a different path",
-                    hint: "Use a relative path if the source folder is not listed here",
+                    hint: "Use a relative path if the Source Folder is not listed here",
                 },
             ],
         });
         if (prompts.isCancel(selected))
             return selected;
         if (selected !== "__manual__") {
+            const savedDataset = savedDatasets.find((dataset) => dataset.name === selected);
+            if (savedDataset) {
+                return resolveSourceDatasetPath(sourcePath, savedDataset);
+            }
             return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(selected)));
         }
     }
     const datasetFolder = await prompts.text({
-        message: "Which source folder should shape this workflow?",
+        message: "Which Source Folder should shape this Method?",
         placeholder: DEFAULT_DATASET_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";
+                return "Source Folder is required";
             try {
                 normalizeDatasetPathForConfig(sourcePath, trimmed);
                 return undefined;
@@ -85,6 +103,15 @@ export function formatWorkflowLabel(workflow) {
 export function buildCompiledWorkflowOptions(sourcePath) {
     return listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel);
 }
+function workflowUseLabel(workflow) {
+    if (workflow.value === "interf-default" || workflow.value === "interf") {
+        return "built-in Method";
+    }
+    return workflow.label.replace(/ \(Local\)$/, "");
+}
+function workflowForkLabel(workflow) {
+    return `Fork ${workflowUseLabel(workflow)}`;
+}
 export async function chooseCompiledWorkflow(sourcePath, options = {}) {
     const currentWorkflowId = options.currentWorkflowId;
     const workflowOptions = buildCompiledWorkflowOptions(sourcePath);
@@ -107,50 +134,137 @@ export async function chooseCompiledWorkflow(sourcePath, options = {}) {
         return orderedOptions[0]?.value ?? "interf";
     }
     return p.select({
-        message: options.message ?? "Dataset workflow?",
+        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];
+    const selected = await prompts.select({
+        message: "Which Method should Interf use for this Preparation?",
+        options: [
+            {
+                value: "__draft_from_scratch__",
+                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
+                ? [{
+                        value: "__current__",
+                        label: `Use ${workflowUseLabel(currentWorkflow)}`,
+                        hint: currentWorkflow.value === "interf-default"
+                            ? "Use the built-in Method without drafting a custom package"
+                            : currentWorkflow.hint,
+                    }]
+                : []),
+            ...(currentWorkflow
+                ? [{
+                        value: "__fork_existing__",
+                        label: workflowForkLabel(currentWorkflow),
+                        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)}`,
+            })),
+        ],
+    });
+    if (prompts.isCancel(selected))
+        return selected;
+    if (selected === "__current__") {
+        if (currentWorkflow?.value === "interf-default") {
+            seedLocalDefaultWorkflow({ sourcePath });
+        }
+        return currentWorkflow?.value ?? currentWorkflowId;
+    }
+    if (selected === "__draft_from_scratch__" || selected === "__fork_existing__") {
+        if (selected === "__fork_existing__" && currentWorkflow?.value === "interf-default") {
+            seedLocalDefaultWorkflow({ sourcePath });
+        }
+        const workflowId = await createWorkflowWizard({
+            intro: false,
+            sourcePath,
+            baseWorkflowId: selected === "__fork_existing__"
+                ? currentWorkflow?.value ?? currentWorkflowId
+                : 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),
+            },
+        }, prompts);
+        return workflowId;
+    }
+    return String(selected);
+}
 export async function createWorkflowWizard(options = {}, prompts = clackWorkflowPrompts) {
     if (options.intro !== false) {
-        prompts.intro(chalk.bold("Create a workflow"));
+        prompts.intro(chalk.bold("Create a Method"));
     }
     const sourcePath = options.sourcePath ?? process.cwd();
     return createCompiledWorkflowWizard(sourcePath, prompts, {
         executionProfile: options.executionProfile,
+        baseWorkflowId: options.baseWorkflowId,
+        creationMode: options.creationMode,
         datasetContext: options.datasetContext,
         resolveExecutor: options.resolveExecutor,
         runDraft: options.runDraft,
     });
 }
 export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts, options = {}) {
-    const baseWorkflow = await prompts.select({
-        message: "Start from which existing workflow?",
-        options: listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel),
-    });
-    if (prompts.isCancel(baseWorkflow))
-        return baseWorkflow;
-    const resolvedBaseWorkflow = getCompiledWorkflow(String(baseWorkflow), { sourcePath });
-    const creationMode = await prompts.select({
+    const creationMode = options.creationMode ?? await prompts.select({
         message: "How do you want to create it?",
         options: [
             {
-                value: "draft",
-                label: "Draft a workflow from this source folder (Recommended)",
-                hint: "Seed a workflow, build a preview, then let a local agent draft a reusable method for this kind of work",
+                value: "draft-from-scratch",
+                label: "Draft a new Method from scratch (Recommended)",
+                hint: "Start from a neutral scaffold and let a local agent design a reusable Method for this kind of agent work",
             },
             {
-                value: "manual",
-                label: "Copy an existing workflow",
-                hint: "Start from an existing workflow and edit stage guidance directly",
+                value: "fork-existing",
+                label: "Fork an existing Method and edit stage guidance",
+                hint: "Copy an existing topology; choose this when the stages are right but their emphasis should change",
             },
         ],
     });
     if (prompts.isCancel(creationMode))
         return creationMode;
+    const creationModeValue = normalizeWorkflowCreationMode(creationMode);
+    const baseWorkflow = creationModeValue === "fork-existing"
+        ? options.baseWorkflowId ?? await prompts.select({
+            message: "Which existing Method should Interf fork?",
+            options: listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+        })
+        : null;
+    if (prompts.isCancel(baseWorkflow))
+        return baseWorkflow;
+    const baseWorkflowId = typeof baseWorkflow === "string" ? baseWorkflow : null;
+    const resolvedBaseWorkflow = baseWorkflowId
+        ? getCompiledWorkflow(baseWorkflowId, { sourcePath })
+        : null;
     const rawName = await prompts.text({
-        message: "New workflow name?",
-        placeholder: "founder-research",
+        message: "New Method name?",
+        placeholder: "customer-research",
         validate: (value) => {
             if (value.trim().length === 0)
                 return "Name is required";
@@ -158,7 +272,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             if (!isWorkflowId(workflowId))
                 return "Use letters, numbers, and dashes only";
             if (listCompiledWorkflowChoices(sourcePath).some((workflow) => workflow.id === workflowId)) {
-                return "That workflow name already exists";
+                return "That Method name already exists";
             }
             return undefined;
         },
@@ -168,20 +282,20 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     const workflowId = slugify(rawName);
     const label = rawName.trim();
     const hint = await prompts.text({
-        message: "One-line workflow description?",
+        message: "One-line Method description?",
         placeholder: "Bias toward evidence-backed summaries and strong retrieval structure",
         validate: (value) => (value.trim().length === 0 ? "Description is required" : undefined),
     });
     if (prompts.isCancel(hint))
         return hint;
-    if (creationMode === "draft") {
+    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({
-                    message: "Which source folder setup should shape this workflow?",
+                    message: "Which saved Preparation should shape this Method?",
                     options: [
                         ...savedDatasets.map((dataset) => ({
                             value: dataset.name,
@@ -191,7 +305,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                         {
                             value: "__manual__",
                             label: "Enter folder path manually",
-                            hint: "Use a folder that is not saved as a dataset yet",
+                            hint: "Use a folder that is not saved as a Preparation yet",
                         },
                     ],
                 });
@@ -215,48 +329,97 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
         }
         const taskPrompt = await prompts.text({
-            message: "How do you want to organize your files?",
-            placeholder: "Research interview transcripts. Agent produces per-interview summaries and a themes list with supporting quotes. Flow: summarize each, group by theme, collect evidence across interviews.",
+            message: "What should this Method prepare for agents, and what evidence should show the data is ready?",
+            placeholder: "Data: research interviews. Output: per-file summaries, themes, entities, claims, and source links. Evidence: every file processed, evidence linked to sources, required outputs created.",
             validate: (value) => (value.trim().length === 0 ? "A description is required" : undefined),
         });
         if (prompts.isCancel(taskPrompt))
             return taskPrompt;
         if (matchedDataset) {
-            prompts.log.info(`Shaping this workflow from setup "${matchedDataset.name}".`);
+            prompts.log.info(`Shaping this Method from Preparation "${matchedDataset.name}".`);
         }
         if (matchedDataset?.checks.length) {
-            prompts.log.info(`Using ${matchedDataset.checks.length} saved question${matchedDataset.checks.length === 1 ? "" : "s"} from setup "${matchedDataset.name}" as authoring context.`);
+            prompts.log.info(`Using ${matchedDataset.checks.length} saved readiness check${matchedDataset.checks.length === 1 ? "" : "s"} from Preparation "${matchedDataset.name}" as authoring context.`);
         }
-        const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
-        const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
-        const { executor, error } = await resolveExecutor({
-            executionProfile: options.executionProfile,
-            purpose: "workflow",
+        prompts.log.info("Preparing a Method-authoring shell from the Source Folder, then drafting the package.");
+        let lastServiceStatus = "";
+        const serviceRun = await submitWorkflowAuthoringRunToLocalService({
+            projectPath: sourcePath,
+            request: {
+                preparation: matchedDataset?.name ?? null,
+                source_folder_path: datasetPath,
+                method_id: workflowId,
+                label,
+                hint: hint.trim(),
+                task_prompt: taskPrompt.trim(),
+                checks: matchedDataset?.checks ?? [],
+            },
+            onSubmitted: (submission) => {
+                prompts.log.info(`Visible in Interf: ${submission.serviceUrl}/`);
+            },
+            onUpdate: (job) => {
+                const activeStep = job.steps.find((step) => step.status === "running")
+                    ?? [...job.steps].reverse().find((step) => step.status === "succeeded" || step.status === "failed")
+                    ?? null;
+                const statusKey = `${job.status}:${activeStep?.id ?? ""}:${activeStep?.status ?? ""}`;
+                if (statusKey === lastServiceStatus)
+                    return;
+                lastServiceStatus = statusKey;
+                prompts.log.info(activeStep
+                    ? `${activeStep.label}: ${activeStep.status}`
+                    : `Method draft run: ${job.status}`);
+            },
         });
-        if (!executor && !error) {
-            return null;
-        }
-        if (!executor) {
-            process.exitCode = 1;
-            (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
+        const result = serviceRun
+            ? serviceRun.result
+                ? {
+                    status: serviceRun.result.status,
+                    changed: serviceRun.result.changed,
+                    summary: serviceRun.result.summary,
+                    validation: serviceRun.result.validation ?? null,
+                    workflowPath: serviceRun.result.method_path,
+                    shellPath: serviceRun.result.shell_path,
+                }
+                : {
+                    status: "executor-failed",
+                    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),
+                }
+            : await (async () => {
+                const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
+                const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
+                const { executor, error } = await resolveExecutor({
+                    executionProfile: options.executionProfile,
+                    purpose: "workflow",
+                });
+                if (!executor && !error) {
+                    return null;
+                }
+                if (!executor) {
+                    process.exitCode = 1;
+                    (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
+                    return null;
+                }
+                return runDraft({
+                    sourcePath,
+                    datasetPath,
+                    workflowId,
+                    label,
+                    hint: hint.trim(),
+                    taskPrompt: taskPrompt.trim(),
+                    checks: matchedDataset?.checks ?? [],
+                    executor,
+                    onStatus: (line) => prompts.log.info(line),
+                });
+            })();
+        if (!result)
             return null;
-        }
-        prompts.log.info("Preparing a workflow-authoring preview from the source folder, then drafting the package.");
-        const result = await runDraft({
-            sourcePath,
-            datasetPath,
-            baseWorkflowId: baseWorkflow,
-            workflowId,
-            label,
-            hint: hint.trim(),
-            taskPrompt: taskPrompt.trim(),
-            checks: matchedDataset?.checks ?? [],
-            executor,
-            preparePreview: true,
-        });
         if (result.status === "updated") {
             const draft = loadWorkflowDefinitionFromDir(result.workflowPath);
-            const stageList = draft?.stages?.map((stage) => stage.id).join(" → ") ?? "—";
+            const stageList = draft?.stages?.map((stage) => stage.id).join(" -> ") ?? "-";
             prompts.log.info(`Draft ready at ${result.workflowPath}`);
             prompts.log.info(`  Name: ${draft?.label ?? label}`);
             prompts.log.info(`  Description: ${draft?.hint ?? hint.trim()}`);
@@ -264,9 +427,9 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                 prompts.log.info(`  Purpose: ${draft.purpose}`);
             prompts.log.info(`  Stages: ${stageList}`);
             const confirmChoice = await prompts.select({
-                message: "Save this workflow?",
+                message: "Save this Method?",
                 options: [
-                    { value: "save", label: "Save", hint: "Keep the draft as your new compilation workflow" },
+                    { value: "save", label: "Save", hint: "Keep the draft as your new Method package" },
                     { value: "cancel", label: "Discard", hint: "Remove the draft folder and exit without saving" },
                 ],
             });
@@ -275,17 +438,20 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
                 prompts.log.info(`Discarded draft at ${result.workflowPath}`);
                 return null;
             }
-            prompts.log.info(`Saved local workflow: ${result.workflowPath}`);
+            prompts.log.info(`Saved local Method: ${result.workflowPath}`);
             return workflowId;
         }
         process.exitCode = 1;
         (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
-            ? `${result.summary} Draft mode only succeeds when it produces a work-specific package change.`
+            ? `${result.summary} Draft mode only succeeds when it produces an agent-work-specific package change.`
             : result.summary);
-        prompts.log.info(`Workflow shell kept at: ${result.shellPath}`);
+        prompts.log.info(`Method shell kept at: ${result.shellPath}`);
         return null;
     }
     const stagePolicyNotes = {};
+    if (!baseWorkflowId || !resolvedBaseWorkflow) {
+        throw new Error("Fork-existing Method creation needs a base Method.");
+    }
     for (const stage of resolvedBaseWorkflow.stages) {
         const stagePrompt = await prompts.text({
             message: `What should ${stage.id} (${stage.label}) emphasize?`,
@@ -298,12 +464,12 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     }
     const workflowPath = createLocalWorkflowPackageFromTemplate({
         sourcePath,
-        baseWorkflowId: baseWorkflow,
+        baseWorkflowId,
         workflowId,
         label,
         hint: hint.trim(),
         stagePolicyNotes,
     });
-    prompts.log.info(`Saved local workflow: ${workflowPath}`);
+    prompts.log.info(`Saved local Method: ${workflowPath}`);
     return workflowId;
 }