@interf/compiler 0.5.1 → 0.6.1

package/builtin-workflows/interf/{compiled.schema.json → workflow.schema.json}

@@ -1,11 +1,12 @@
 {
-  "kind": "compiled-schema",
+  "kind": "workflow-schema",
   "version": 1,
   "target_type": "compiled",
-  "label": "Interf Compiler (Recommended) compiled dataset schema",
+  "label": "Interf built-in workflow schema",
   "zones": [
     {
       "id": "raw",
+      "role": "input",
       "path": "raw",
       "kind": "directory",
       "required": true,
@@ -14,6 +15,7 @@
     },
     {
       "id": "summaries",
+      "role": "working",
       "path": "summaries",
       "kind": "directory",
       "required": true,
@@ -24,6 +26,7 @@
     },
     {
       "id": "knowledge-entities",
+      "role": "output",
       "path": "knowledge/entities",
       "kind": "directory",
       "required": true,
@@ -34,6 +37,7 @@
     },
     {
       "id": "knowledge-claims",
+      "role": "output",
       "path": "knowledge/claims",
       "kind": "directory",
       "required": true,
@@ -44,6 +48,7 @@
     },
     {
       "id": "knowledge-indexes",
+      "role": "output",
       "path": "knowledge/indexes",
       "kind": "directory",
       "required": true,
@@ -55,6 +60,7 @@
     },
     {
       "id": "home",
+      "role": "output",
       "path": "home.md",
       "kind": "file",
       "required": true,
@@ -65,6 +71,7 @@
     },
     {
       "id": "runtime",
+      "role": "runtime",
       "path": ".interf/runtime",
       "kind": "runtime",
       "required": true,

package/dist/commands/check-draft.js

@@ -12,18 +12,18 @@ export function buildTruthCheckDraftPrompt(options) {
     const taskLines = normalizedAbout
         ? [
             `Primary task: ${normalizedAbout}`,
-            "Draft checks that directly measure whether a local agent would be accurate on that task.",
+            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that task.",
             "Prefer checks that would make a human confident the dataset is useful for that exact job.",
         ]
         : [
             "No primary task was provided.",
-            "Prefer broad, representative checks that reflect the most useful questions this dataset should answer.",
+            "Prefer broad, representative checks that reflect the most useful questions a human would verify from this dataset.",
         ];
     return [
         "You are drafting Interf truth checks for a local dataset.",
         "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
         "Do not ask follow-up questions.",
-        "Keep the checks concrete, explicit, and useful for measuring agent accuracy on this dataset.",
+        "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the data in this dataset.",
         "",
         `Dataset id: ${options.datasetName}`,
         `Dataset folder: ${options.datasetPath}`,

package/dist/commands/compile-controller.js

@@ -3,12 +3,13 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../lib/interf.js";
-import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
+import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../lib/compiled-reset.js";
 import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
 import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
 import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
 import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
+import { initializeCompiledRuntimeState } from "../lib/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
 import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
@@ -19,14 +20,6 @@ function printCompileFailure(compiledPath, failedStage) {
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
-const BEST_VARIATION_RUNTIME_RESTORE_PATHS = [
-    ".interf/runtime/state.json",
-    ".interf/runtime/health.json",
-    ".interf/runtime/view-spec.json",
-    ".interf/runtime/inventory.json",
-    ".interf/runtime/run.json",
-    ".interf/runtime/raw-snapshot.json",
-];
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
@@ -39,10 +32,8 @@ function bestVariationRestorePaths(compiledPath) {
         ".codex",
         ".agents",
         ".cursor",
-        ".obsidian",
         ".interf/interf.json",
         ".interf/workflow",
-        ...BEST_VARIATION_RUNTIME_RESTORE_PATHS,
         ...zonePaths,
     ];
 }
@@ -71,6 +62,8 @@ function restoreCompiledBestState(snapshotPath, compiledPath) {
         rmSync(join(compiledPath, relativePath), { recursive: true, force: true });
         copyRelativePathIfPresent(snapshotPath, compiledPath, relativePath);
     }
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
 }
 async function runWorkflowVariation(options) {
     let bestOutcome = null;
@@ -267,14 +260,14 @@ export async function runConfiguredCompiledCompile(options) {
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
         }
         if (maxLoops != null) {
             console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
-            console.log(chalk.dim("  Interf Compiler will review failed runs, edit the workflow package, and test new workflow variations."));
+            console.log(chalk.dim("  Interf will review failed runs, edit the workflow, and test new workflow variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {

package/dist/commands/compile.d.ts

@@ -1,8 +1,26 @@
+import * as p from "@clack/prompts";
+import { detectInterf } from "../lib/interf.js";
 import type { SourceDatasetConfig } from "../lib/schema.js";
 import type { CommandModule } from "yargs";
+import { chooseCompiledConfigToBuild, ensureCompiledFromConfig } from "./compiled-flow.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export declare const compileCommand: CommandModule;
-export declare function runCompileCommand(argv?: Record<string, unknown>): Promise<void>;
+interface CompileCommandDeps {
+    chooseCompiledConfigToBuild: typeof chooseCompiledConfigToBuild;
+    confirm: typeof p.confirm;
+    detectInterf: typeof detectInterf;
+    ensureCompiledFromConfig: typeof ensureCompiledFromConfig;
+    resolveInteractiveCompileLoopOverrides: typeof resolveInteractiveCompileLoopOverrides;
+    resolveOrConfigureLocalExecutor: typeof resolveOrConfigureLocalExecutor;
+    runConfiguredCompiledCompile: typeof runConfiguredCompiledCompile;
+}
+export interface CompileCommandResult {
+    compiledPath: string;
+    testedDuringCompile: boolean;
+}
+export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
 export declare function resolveInteractiveCompileLoopOverrides(options: {
     compiledPath: string;
     compiledConfig: SourceDatasetConfig | null;

package/dist/commands/compile.js

@@ -1,16 +1,17 @@
 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 { sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../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 dataset 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",
@@ -26,48 +27,105 @@ 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({
+        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 dataset 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(`  Dataset "${requestedDatasetName}" is not set up in this project.`));
+                console.log(chalk.dim("  Run `interf list` to see the saved datasets."));
+            }
+            else {
+                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 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 +136,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 +176,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) {

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

@@ -1,3 +1,7 @@
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
+import type { SourceDatasetConfig } from "../lib/schema.js";
+import type { WorkflowExecutionProfile } from "../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/commands/create-workflow-wizard.js

@@ -1,8 +1,13 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listCompiledWorkflowChoices, } from "../lib/workflow-definitions.js";
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { listCompiledWorkflowChoices, getCompiledWorkflow, } from "../lib/workflow-definitions.js";
 import { createLocalWorkflowPackageFromTemplate } from "../lib/interf-workflow-package.js";
 import { isWorkflowId, } from "../lib/local-workflows.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../lib/source-config.js";
 import { slugify } from "../lib/util.js";
 export const clackWorkflowPrompts = {
     intro: p.intro,
@@ -11,8 +16,22 @@ export const clackWorkflowPrompts = {
     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.checks.length} saved truth check${dataset.checks.length === 1 ? "" : "s"} · path ${dataset.path}`;
+}
 export function formatWorkflowLabel(workflow) {
     return {
         value: workflow.id,
@@ -54,15 +73,38 @@ export async function createWorkflowWizard(options = {}, prompts = clackWorkflow
         prompts.intro(chalk.bold("Create a workflow"));
     }
     const sourcePath = options.sourcePath ?? process.cwd();
-    return createCompiledWorkflowWizard(sourcePath, prompts);
+    return createCompiledWorkflowWizard(sourcePath, prompts, {
+        executionProfile: options.executionProfile,
+        datasetContext: options.datasetContext,
+        resolveExecutor: options.resolveExecutor,
+        runDraft: options.runDraft,
+    });
 }
-export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts) {
+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 dataset (Recommended)",
+                hint: "Seed a workflow, prepare 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",
@@ -89,36 +131,130 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
     });
     if (prompts.isCancel(hint))
         return hint;
-    const summarizeBias = await prompts.text({
-        message: "What should summarize emphasize?",
-        placeholder: "Preserve evidence tiers, decision context, and source metadata",
-        validate: (value) => (value.trim().length === 0 ? "Summarize guidance is required" : undefined),
-    });
-    if (prompts.isCancel(summarizeBias))
-        return summarizeBias;
-    const structureBias = await prompts.text({
-        message: "What should structure emphasize?",
-        placeholder: "Build retrieval-ready entities, claims, timelines, and indexes",
-        validate: (value) => (value.trim().length === 0 ? "Structure guidance is required" : undefined),
-    });
-    if (prompts.isCancel(structureBias))
-        return structureBias;
-    const shapeBias = await prompts.text({
-        message: "What should shape emphasize?",
-        placeholder: "Bias home.md and navigation toward the questions this dataset should answer best",
-        validate: (value) => (value.trim().length === 0 ? "Shape guidance is required" : undefined),
-    });
-    if (prompts.isCancel(shapeBias))
-        return shapeBias;
+    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 dataset 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 prompts.text({
+                message: "Which dataset folder should shape this workflow?",
+                placeholder: ".",
+                initialValue: ".",
+                validate: (value) => {
+                    const trimmed = value.trim();
+                    if (trimmed.length === 0)
+                        return "Dataset folder is required";
+                    const absolutePath = resolve(sourcePath, trimmed);
+                    try {
+                        const stat = statSync(absolutePath);
+                        return stat.isDirectory() ? undefined : "Dataset folder must be a directory";
+                    }
+                    catch {
+                        return "Dataset folder was not found";
+                    }
+                },
+            });
+            if (prompts.isCancel(datasetFolder))
+                return datasetFolder;
+            datasetPath = resolve(sourcePath, String(datasetFolder).trim());
+            matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
+        }
+        const taskPrompt = await prompts.text({
+            message: "What task should this workflow prepare the dataset for?",
+            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 dataset "${matchedDataset.name}".`);
+        }
+        if (matchedDataset?.checks.length) {
+            prompts.log.info(`Using ${matchedDataset.checks.length} saved truth check${matchedDataset.checks.length === 1 ? "" : "s"} from dataset "${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 dataset, 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(),
-        summarizeBias: summarizeBias.trim(),
-        structureBias: structureBias.trim(),
-        shapeBias: shapeBias.trim(),
+        stagePolicyNotes,
     });
     prompts.log.info(`Saved local workflow: ${workflowPath}`);
     return workflowId;

package/dist/commands/create.d.ts

@@ -5,4 +5,4 @@ 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";