@interf/compiler 0.5.1 → 0.6.3

package/dist/{commands → cli/commands}/compile.js

@@ -1,19 +1,20 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { sourceDatasetConfigFromInterfConfig, } from "../lib/source-config.js";
-import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
+import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { loadCompiledDatasetConfig, sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { resolveConfiguredDatasetSelection } from "./dataset-selection.js";
 import { promptCompileLoopSelection, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build the compiled dataset for the selected dataset",
+    describe: "Build a compiled context and optionally run retry or self-improving compile loops",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
         type: "number",
-        describe: "Retry compile + test for the same workflow until the dataset passes or reaches this total attempt limit",
+        describe: "Retry compile + check for the same workflow until the dataset passes or reaches this total attempt limit",
     }).option("max-loops", {
         type: "number",
         describe: "After retries fail, let Interf edit the workflow and test new workflow variations for this dataset up to this loop limit",
@@ -26,48 +27,106 @@ export const compileCommand = {
         await runCompileCommand(argv);
     },
 };
-export async function runCompileCommand(argv = {}) {
+const defaultCompileCommandDeps = {
+    chooseCompiledConfigToBuild,
+    confirm: p.confirm,
+    detectInterf,
+    ensureCompiledFromConfig,
+    resolveInteractiveCompileLoopOverrides,
+    resolveOrConfigureLocalExecutor,
+    runConfiguredCompiledCompile,
+};
+function readHintedSourcePath(argv) {
+    return typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
+        ? argv.sourcePath.trim()
+        : null;
+}
+function readRequestedDatasetName(argv) {
+    return typeof argv.dataset === "string" && argv.dataset.trim().length > 0
+        ? argv.dataset.trim()
+        : null;
+}
+function shouldSkipCompileConfirm(argv) {
+    return argv.skipConfirm === true;
+}
+function shouldSkipDatasetBanner(argv) {
+    return argv.skipDatasetBanner === true;
+}
+function compileRunTests(options) {
+    const checks = options.compiledConfig?.checks ?? [];
+    if (checks.length === 0)
+        return false;
+    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
+    return maxAttempts != null;
+}
+export async function runCompileCommand(argv = {}, deps = {}) {
+    const helpers = {
+        ...defaultCompileCommandDeps,
+        ...deps,
+    };
     let compiledPath = null;
-    let sourcePath = process.cwd();
+    const hintedSourcePath = readHintedSourcePath(argv);
+    const detected = hintedSourcePath ? null : helpers.detectInterf(process.cwd());
+    let sourcePath = hintedSourcePath ?? process.cwd();
     let compiledConfig = null;
-    const detected = detectInterf(process.cwd());
+    const requestedDatasetName = readRequestedDatasetName(argv);
+    const hintedDatasetConfig = (argv.datasetConfig ?? null);
+    const skipConfirm = shouldSkipCompileConfirm(argv);
+    const skipDatasetBanner = shouldSkipDatasetBanner(argv);
     if (detected) {
         compiledPath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
-        compiledConfig = sourceDatasetConfigFromInterfConfig(detected.config);
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            const confirmed = await p.confirm({
+        compiledConfig = loadCompiledDatasetConfig(detected.path)
+            ?? sourceDatasetConfigFromInterfConfig(detected.config);
+        if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
+            const confirmed = await helpers.confirm({
                 message: `Compile dataset "${detected.config.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
-                return;
+                return null;
         }
     }
     else {
-        const selectedCompiled = await chooseCompiledConfigToBuild({
-            sourcePath: process.cwd(),
-            selectMessage: "Which dataset do you want to compile?",
-        });
+        const selectedCompiled = requestedDatasetName || hintedDatasetConfig
+            ? resolveConfiguredDatasetSelection({
+                sourcePath,
+                requestedDatasetName,
+                hintedDatasetConfig,
+            })
+            : await helpers.chooseCompiledConfigToBuild({
+                sourcePath,
+                selectMessage: "Which source folder setup do you want to compile?",
+            });
         if (selectedCompiled === undefined)
-            return;
+            return null;
         if (!selectedCompiled) {
             process.exitCode = 1;
-            console.log(chalk.red("  No datasets are set up for this folder yet."));
-            console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
-            return;
+            if (requestedDatasetName) {
+                console.log(chalk.red(`  Setup "${requestedDatasetName}" is not set up in this project.`));
+                console.log(chalk.dim("  Run `interf list` to see the saved setups."));
+            }
+            else {
+                console.log(chalk.red("  No saved setups are configured for this folder yet."));
+                console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
+            }
+            return null;
         }
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            const confirmed = await p.confirm({
+        if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
+            const confirmed = await helpers.confirm({
                 message: `Compile dataset "${selectedCompiled.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
-                return;
+                return null;
         }
         compiledConfig = selectedCompiled;
-        compiledPath = ensureCompiledFromConfig(process.cwd(), selectedCompiled);
-        console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
+        compiledPath = helpers.ensureCompiledFromConfig(sourcePath, selectedCompiled);
+        if (!skipDatasetBanner) {
+            console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
+        }
     }
     let maxAttemptsOverride = null;
     let maxLoopsOverride = null;
@@ -78,32 +137,37 @@ export async function runCompileCommand(argv = {}) {
     catch (error) {
         process.exitCode = 1;
         console.log(chalk.red(error instanceof Error ? error.message : String(error)));
-        return;
+        return null;
     }
-    const interactiveOverrides = await resolveInteractiveCompileLoopOverrides({
+    const interactiveOverrides = await helpers.resolveInteractiveCompileLoopOverrides({
         compiledPath,
         compiledConfig,
         maxAttemptsOverride,
         maxLoopsOverride,
     });
     if (!interactiveOverrides)
-        return;
+        return null;
     compiledConfig = interactiveOverrides.compiledConfig;
     maxAttemptsOverride = interactiveOverrides.maxAttemptsOverride;
     maxLoopsOverride = interactiveOverrides.maxLoopsOverride;
+    const testedDuringCompile = compileRunTests({
+        compiledConfig,
+        maxAttemptsOverride,
+        maxLoopsOverride,
+    });
     const executionProfile = executionProfileFromArgv(argv);
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
+    const { executor, error } = await helpers.resolveOrConfigureLocalExecutor({
         executionProfile,
         purpose: "compile",
     });
     if (!executor && !error)
-        return;
+        return null;
     if (!executor) {
         process.exitCode = 1;
         console.log(chalk.red(error ?? "No coding agent detected."));
-        return;
+        return null;
     }
-    await runConfiguredCompiledCompile({
+    const compiled = await helpers.runConfiguredCompiledCompile({
         executor,
         compiledPath,
         sourcePath,
@@ -113,6 +177,13 @@ export async function runCompileCommand(argv = {}) {
         maxLoopsOverride,
         preserveStageShells: readStageShellRetentionMode(argv),
     });
+    if (!compiled) {
+        return null;
+    }
+    return {
+        compiledPath,
+        testedDuringCompile,
+    };
 }
 export async function resolveInteractiveCompileLoopOverrides(options) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -141,7 +212,10 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         };
     }
     const savedCompiledConfig = options.compiledConfig
-        ?? (currentConfig ? sourceDatasetConfigFromInterfConfig(currentConfig) : null);
+        ?? (currentConfig
+            ? (loadCompiledDatasetConfig(options.compiledPath)
+                ?? sourceDatasetConfigFromInterfConfig(currentConfig))
+            : null);
     if (!savedCompiledConfig) {
         return {
             compiledConfig: options.compiledConfig,

package/dist/{commands → cli/commands}/compiled-flow.d.ts

@@ -1,7 +1,6 @@
-import type { SourceDatasetConfig } from "../lib/schema.js";
-import { type StageShellRetentionMode } from "../lib/workflows.js";
-import type { WorkflowExecutor } from "../lib/executors.js";
-import type { CompiledCompileResult } from "../lib/workflows.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import { type StageShellRetentionMode, type CompiledCompileResult } from "../../packages/compiler/workflows.js";
+import type { WorkflowExecutor } from "../../packages/agents/lib/executors.js";
 export interface SavedDatasetEntry {
     config: SourceDatasetConfig;
     path: string | null;

package/dist/{commands → cli/commands}/compiled-flow.js

@@ -1,18 +1,18 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listCompiledDatasetsForSourceFolder } from "../lib/interf.js";
-import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../lib/source-config.js";
-import { compileCompiled, createCompiled, } from "../lib/workflows.js";
-import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
+import { listCompiledDatasetsForSourceFolder } from "../../packages/project-model/interf.js";
+import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { compileCompiled, createCompiled, } from "../../packages/compiler/workflows.js";
+import { formatWorkflowExecutionProfile } from "../../packages/agents/lib/execution-profile.js";
 function formatSavedDatasetHint(entry) {
     const config = entry.config;
     const checkCount = config.checks.length;
     const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
     if (config.about)
-        return `${config.about} · ${workflowHint}`;
+        return `${config.path} · ${config.about} · ${workflowHint}`;
     if (checkCount === 0)
-        return "No saved truth checks yet";
-    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+        return `${config.path} · No checks yet · ${workflowHint}`;
+    return `${config.path} · ${checkCount} check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
 }
 export function listSavedCompiledEntries(sourcePath) {
     const builtEntries = new Map();
@@ -34,11 +34,6 @@ export function listSavedCompiledEntries(sourcePath) {
             localDraft: built?.localDraft ?? false,
         });
     }
-    for (const [name, built] of builtEntries.entries()) {
-        if (entries.has(name))
-            continue;
-        entries.set(name, built);
-    }
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
 export function findBuiltCompiledPath(sourcePath, compiledName) {
@@ -87,7 +82,7 @@ export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
 }
 export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
     console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building compiled dataset..."}`));
+    console.log(chalk.bold(`  ${options.heading ?? "Building compiled context..."}`));
     const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
@@ -107,6 +102,6 @@ export async function compileCompiledWithReporter(executor, compiledPath, option
         return result;
     }
     console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled dataset ready."}`));
+    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled context ready."}`));
     return result;
 }

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

@@ -1,3 +1,7 @@
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runWorkflowAuthoringDraft } from "../../packages/workflow-authoring/workflow-authoring.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { WorkflowExecutionProfile } from "../../packages/agents/lib/executors.js";
 export interface WorkflowWizardPrompts {
     intro(message: string): void;
     select(options: {
@@ -17,8 +21,13 @@ export interface WorkflowWizardPrompts {
     isCancel(value: unknown): value is symbol;
     log: {
         info(message: string): void;
+        error?(message: string): void;
     };
 }
+export interface WorkflowWizardDatasetContext {
+    config: SourceDatasetConfig;
+    datasetPath: string;
+}
 export declare const clackWorkflowPrompts: WorkflowWizardPrompts;
 export declare function formatWorkflowLabel(workflow: {
     id: string;
@@ -42,5 +51,14 @@ export declare function chooseCompiledWorkflow(sourcePath: string, options?: {
 export declare function createWorkflowWizard(options?: {
     intro?: boolean;
     sourcePath?: string;
-}, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
-export declare function createCompiledWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
+    executionProfile?: WorkflowExecutionProfile;
+    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;
+    datasetContext?: WorkflowWizardDatasetContext;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runWorkflowAuthoringDraft;
+}): Promise<string | symbol | null>;

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

@@ -0,0 +1,288 @@
+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 { isWorkflowId, } 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 "../../lib/util.js";
+import { DEFAULT_DATASET_PATH_PLACEHOLDER, listDatasetFolderChoices, normalizeDatasetPathForConfig, } from "./source-config-wizard.js";
+export const clackWorkflowPrompts = {
+    intro: p.intro,
+    select: (options) => p.select(options),
+    text: (options) => p.text(options),
+    isCancel: p.isCancel,
+    log: {
+        info: p.log.info,
+        error: p.log.error,
+    },
+};
+function findMatchingDatasetConfig(sourcePath, datasetPath) {
+    const config = loadSourceFolderConfig(sourcePath);
+    for (const dataset of listSourceDatasetConfigs(config)) {
+        if (resolveSourceDatasetPath(sourcePath, dataset) === datasetPath) {
+            return dataset;
+        }
+    }
+    return null;
+}
+function describeSavedDataset(dataset) {
+    return dataset.about
+        ? `${dataset.path} · ${dataset.about}`
+        : `${dataset.path} · ${dataset.checks.length} check${dataset.checks.length === 1 ? "" : "s"}`;
+}
+async function promptWorkflowDatasetFolder(sourcePath, prompts) {
+    const folderChoices = listDatasetFolderChoices(sourcePath);
+    if (folderChoices.length > 0) {
+        const selected = await prompts.select({
+            message: "Which source folder should shape this workflow?",
+            options: [
+                ...folderChoices,
+                {
+                    value: "__manual__",
+                    label: "Enter a different path",
+                    hint: "Use a relative path if the source folder is not listed here",
+                },
+            ],
+        });
+        if (prompts.isCancel(selected))
+            return selected;
+        if (selected !== "__manual__") {
+            return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(selected)));
+        }
+    }
+    const datasetFolder = await prompts.text({
+        message: "Which source folder should shape this workflow?",
+        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";
+            try {
+                normalizeDatasetPathForConfig(sourcePath, trimmed);
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    });
+    if (prompts.isCancel(datasetFolder))
+        return datasetFolder;
+    return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(datasetFolder)));
+}
+export function formatWorkflowLabel(workflow) {
+    return {
+        value: workflow.id,
+        label: workflow.scope === "local" ? `${workflow.label} (Local)` : workflow.label,
+        hint: workflow.hint,
+    };
+}
+export function buildCompiledWorkflowOptions(sourcePath) {
+    return listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel);
+}
+export async function chooseCompiledWorkflow(sourcePath, options = {}) {
+    const currentWorkflowId = options.currentWorkflowId;
+    const workflowOptions = buildCompiledWorkflowOptions(sourcePath);
+    const orderedOptions = workflowOptions
+        .map((option) => option.value === currentWorkflowId
+        ? {
+            ...option,
+            label: `${option.label} (Current)`,
+            hint: option.hint,
+        }
+        : option)
+        .sort((left, right) => {
+        if (left.value === currentWorkflowId)
+            return -1;
+        if (right.value === currentWorkflowId)
+            return 1;
+        return 0;
+    });
+    if (orderedOptions.length === 1) {
+        return orderedOptions[0]?.value ?? "interf";
+    }
+    return p.select({
+        message: options.message ?? "Dataset workflow?",
+        options: orderedOptions,
+    });
+}
+export async function createWorkflowWizard(options = {}, prompts = clackWorkflowPrompts) {
+    if (options.intro !== false) {
+        prompts.intro(chalk.bold("Create a workflow"));
+    }
+    const sourcePath = options.sourcePath ?? process.cwd();
+    return createCompiledWorkflowWizard(sourcePath, prompts, {
+        executionProfile: options.executionProfile,
+        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({
+        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 task",
+            },
+            {
+                value: "manual",
+                label: "Copy an existing workflow",
+                hint: "Start from an existing workflow and edit stage guidance directly",
+            },
+        ],
+    });
+    if (prompts.isCancel(creationMode))
+        return creationMode;
+    const rawName = await prompts.text({
+        message: "New workflow name?",
+        placeholder: "founder-research",
+        validate: (value) => {
+            if (value.trim().length === 0)
+                return "Name is required";
+            const workflowId = slugify(value);
+            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 undefined;
+        },
+    });
+    if (prompts.isCancel(rawName))
+        return rawName;
+    const workflowId = slugify(rawName);
+    const label = rawName.trim();
+    const hint = await prompts.text({
+        message: "One-line workflow 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") {
+        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?",
+                    options: [
+                        ...savedDatasets.map((dataset) => ({
+                            value: dataset.name,
+                            label: dataset.name,
+                            hint: describeSavedDataset(dataset),
+                        })),
+                        {
+                            value: "__manual__",
+                            label: "Enter folder path manually",
+                            hint: "Use a folder that is not saved as a dataset yet",
+                        },
+                    ],
+                });
+                if (prompts.isCancel(datasetChoice))
+                    return datasetChoice;
+                if (datasetChoice !== "__manual__") {
+                    matchedDataset = savedDatasets.find((dataset) => dataset.name === datasetChoice) ?? null;
+                    datasetPath = matchedDataset
+                        ? resolveSourceDatasetPath(sourcePath, matchedDataset)
+                        : null;
+                }
+            }
+        }
+        if (!datasetPath) {
+            const datasetFolder = await promptWorkflowDatasetFolder(sourcePath, prompts);
+            if (prompts.isCancel(datasetFolder))
+                return datasetFolder;
+            if (!datasetFolder)
+                return null;
+            datasetPath = String(datasetFolder);
+            matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
+        }
+        const taskPrompt = await prompts.text({
+            message: "What task should this workflow help with?",
+            placeholder: "Example: chart reads, board-prep questions, or latest planned launch status",
+            validate: (value) => (value.trim().length === 0 ? "Task focus is required" : undefined),
+        });
+        if (prompts.isCancel(taskPrompt))
+            return taskPrompt;
+        if (matchedDataset) {
+            prompts.log.info(`Shaping this workflow from setup "${matchedDataset.name}".`);
+        }
+        if (matchedDataset?.checks.length) {
+            prompts.log.info(`Using ${matchedDataset.checks.length} check${matchedDataset.checks.length === 1 ? "" : "s"} from setup "${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",
+        });
+        if (!executor && !error) {
+            return null;
+        }
+        if (!executor) {
+            process.exitCode = 1;
+            (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
+            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") {
+            prompts.log.info(`Saved local workflow: ${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 task-specific package change.`
+            : result.summary);
+        prompts.log.info(`Workflow shell kept at: ${result.shellPath}`);
+        return null;
+    }
+    const stagePolicyNotes = {};
+    for (const stage of resolvedBaseWorkflow.stages) {
+        const stagePrompt = await prompts.text({
+            message: `What should ${stage.id} (${stage.label}) emphasize?`,
+            placeholder: stage.description,
+            validate: (value) => (value.trim().length === 0 ? `${stage.label} guidance is required` : undefined),
+        });
+        if (prompts.isCancel(stagePrompt))
+            return stagePrompt;
+        stagePolicyNotes[stage.id] = [String(stagePrompt).trim()];
+    }
+    const workflowPath = createLocalWorkflowPackageFromTemplate({
+        sourcePath,
+        baseWorkflowId: baseWorkflow,
+        workflowId,
+        label,
+        hint: hint.trim(),
+        stagePolicyNotes,
+    });
+    prompts.log.info(`Saved local workflow: ${workflowPath}`);
+    return workflowId;
+}

package/dist/{commands → cli/commands}/create.d.ts

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