@interf/compiler 0.4.0 → 0.5.0

package/dist/commands/source-config-wizard.js

@@ -1,12 +1,84 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
 import * as p from "@clack/prompts";
-import { workspaceMaxAttempts, workspaceMaxLoops } from "../lib/source-config.js";
+import { compiledMaxAttempts, compiledMaxLoops, resolveSourceDatasetPath, } from "../lib/source-config.js";
 import { slugify } from "../lib/util.js";
-export const DEFAULT_WORKSPACE_NAME = "my-workspace";
-export const DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
-export const DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export const DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER = "Focused workspace for the dataset questions that matter most here.";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { draftTruthChecks } from "./check-draft.js";
+export const DEFAULT_COMPILED_NAME = "dataset1";
+export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
+export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
+export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: forward-demand metrics, board-prep questions, or chart reads from this dataset.";
+export const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
 export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
+function normalizeOptionalPromptText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function findSingleDatasetFolderCandidate(cwd) {
+    const ignoredEntries = new Set([
+        ".DS_Store",
+        ".git",
+        ".interf",
+        "interf",
+        "interf.json",
+        "node_modules",
+    ]);
+    let rootEntries = [];
+    try {
+        rootEntries = readdirSync(cwd);
+    }
+    catch {
+        return null;
+    }
+    const visibleEntries = rootEntries.filter((entry) => !ignoredEntries.has(entry));
+    const visibleFiles = [];
+    const visibleDirectories = [];
+    for (const entry of visibleEntries) {
+        try {
+            const entryPath = join(cwd, entry);
+            if (statSync(entryPath).isDirectory()) {
+                visibleDirectories.push(entry);
+            }
+            else {
+                visibleFiles.push(entry);
+            }
+        }
+        catch {
+            // ignore unreadable entries
+        }
+    }
+    if (visibleFiles.length > 0 || visibleDirectories.length !== 1) {
+        return null;
+    }
+    return `./${visibleDirectories[0]}`;
+}
+export function defaultDatasetPathForPrompt(name, introStyle, cwd = process.cwd()) {
+    const namedFolderPath = join(cwd, name);
+    if (existsSync(namedFolderPath)) {
+        try {
+            if (statSync(namedFolderPath).isDirectory()) {
+                return `./${name}`;
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    if (introStyle === "first") {
+        return findSingleDatasetFolderCandidate(cwd) ?? ".";
+    }
+    return `./${name}`;
+}
+export function datasetAboutPromptMessage(introStyle) {
+    if (introStyle === "edit") {
+        return "What should this dataset stay accurate about?";
+    }
+    return "What should this dataset be accurate about?";
+}
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -20,14 +92,13 @@ export function resolveCompileLoopMode(maxAttempts, maxLoops) {
 export function describeCompileLoopSelection(options) {
     const mode = resolveCompileLoopMode(options.maxAttempts, options.maxLoops);
     if (mode === "once") {
-        return "Run a single compile attempt without workflow edits.";
+        return "Compile once.";
     }
     if (mode === "retry") {
-        return `Retry the same workflow up to ${formatAttemptLabel(options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS, "attempt")}.`;
+        return "Compile retries are enabled for this dataset.";
     }
-    const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
     const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
-    return `Run ${formatAttemptLabel(attempts, "attempt")} per workflow variation and allow up to ${formatAttemptLabel(loops, "self-improving workflow loop")}.`;
+    return `Self-improving loops are enabled for this dataset (${formatAttemptLabel(loops, "workflow revision")}).`;
 }
 export async function promptCheckCases(options) {
     p.log.info(options.heading);
@@ -66,33 +137,189 @@ export async function promptCheckCases(options) {
             return cases;
     }
 }
-async function promptWorkspaceChecks(options) {
+function printDraftTruthChecks(checks) {
+    console.log();
+    p.log.info(`Draft truth checks: ${checks.length}`);
+    for (const [index, check] of checks.entries()) {
+        console.log(`  ${index + 1}. ${check.question}`);
+        console.log(`     Expected: ${check.answer ?? ""}`);
+    }
+}
+async function promptDraftTruthChecks(options) {
+    let resolvedDatasetPath;
+    try {
+        const datasetConfig = {
+            path: options.datasetPath,
+        };
+        resolvedDatasetPath = resolveSourceDatasetPath(options.projectPath, datasetConfig);
+    }
+    catch (error) {
+        p.log.error(error instanceof Error ? error.message : String(error));
+        return "manual";
+    }
+    const resolved = await resolveOrConfigureLocalExecutor({
+        preflight: true,
+        purpose: "draft",
+    });
+    if (!resolved.executor) {
+        if (resolved.cancelled)
+            return null;
+        p.log.error(resolved.error ?? "No local agent detected for truth-check drafting.");
+        const fallback = await p.select({
+            message: "How do you want to continue?",
+            options: [
+                {
+                    value: "manual",
+                    label: "Add truth checks manually",
+                    hint: "Write the questions and expected answers yourself",
+                },
+                {
+                    value: "skip",
+                    label: "Skip for now",
+                    hint: "Save this dataset without truth checks",
+                },
+            ],
+        });
+        if (p.isCancel(fallback))
+            return null;
+        return fallback === "manual" ? "manual" : [];
+    }
+    while (true) {
+        p.log.info("Drafting truth checks from the dataset files.");
+        const drafted = await draftTruthChecks({
+            datasetName: options.datasetName,
+            datasetPath: resolvedDatasetPath,
+            about: options.about,
+            executor: resolved.executor,
+            targetCount: 4,
+        });
+        if (!drafted.checks) {
+            p.log.error(drafted.error ?? "Could not draft truth checks from this dataset.");
+            const retryMode = await p.select({
+                message: "How do you want to continue?",
+                options: [
+                    {
+                        value: "retry",
+                        label: "Try auto-create again",
+                        hint: "Run the same local agent again on the dataset folder",
+                    },
+                    {
+                        value: "manual",
+                        label: "Add truth checks manually",
+                        hint: "Write the checks yourself instead",
+                    },
+                    {
+                        value: "skip",
+                        label: "Skip for now",
+                        hint: "Save this dataset without truth checks",
+                    },
+                ],
+            });
+            if (p.isCancel(retryMode))
+                return null;
+            if (retryMode === "retry")
+                continue;
+            return retryMode === "manual" ? "manual" : [];
+        }
+        printDraftTruthChecks(drafted.checks);
+        const nextStep = await p.select({
+            message: "Use these truth checks?",
+            options: [
+                {
+                    value: "use",
+                    label: "Use this draft (Recommended)",
+                    hint: "Save these checks and edit them later if needed",
+                },
+                {
+                    value: "retry",
+                    label: "Draft again",
+                    hint: "Run the same local agent again on the dataset folder",
+                },
+                {
+                    value: "manual",
+                    label: "Add them manually instead",
+                    hint: "Discard this draft and write the checks yourself",
+                },
+                {
+                    value: "skip",
+                    label: "Skip for now",
+                    hint: "Save this dataset without truth checks",
+                },
+            ],
+        });
+        if (p.isCancel(nextStep))
+            return null;
+        if (nextStep === "retry")
+            continue;
+        if (nextStep === "manual")
+            return "manual";
+        if (nextStep === "skip")
+            return [];
+        return drafted.checks;
+    }
+}
+async function promptCompiledChecks(options) {
     if (!options.initialChecks?.length) {
         if (options.initialAbout) {
-            p.log.info(`Focus: ${options.initialAbout}`);
+            p.log.info(`About: ${options.initialAbout}`);
         }
-        p.log.info("Truth checks define what should hold for this dataset.");
-        p.log.info("Each truth check is a question plus the expected correct answer.");
-        p.log.info("Start with simple facts, comparisons, or conclusions you can verify in the source material.");
-        const addNow = await p.confirm({
-            message: "Add a few truth checks for this dataset now? (Recommended)",
-            initialValue: true,
+        p.log.info("Truth checks are the questions this dataset should already answer correctly.");
+        const mode = await p.select({
+            message: "How do you want to create them?",
+            options: [
+                {
+                    value: "draft",
+                    label: "Auto-create a draft (Recommended)",
+                    hint: "Let a local agent draft a few clear, verifiable checks from this dataset",
+                },
+                {
+                    value: "manual",
+                    label: "Add them manually",
+                    hint: "Write the questions and expected answers yourself",
+                },
+                {
+                    value: "skip",
+                    label: "Skip for now",
+                    hint: "You can save the dataset first and add checks later",
+                },
+            ],
         });
-        if (p.isCancel(addNow))
+        if (p.isCancel(mode))
             return null;
-        if (!addNow)
+        if (mode === "skip")
             return [];
+        if (mode === "draft") {
+            const drafted = await promptDraftTruthChecks({
+                projectPath: options.projectPath,
+                datasetName: options.datasetName,
+                datasetPath: options.datasetPath,
+                about: options.initialAbout,
+            });
+            if (drafted === null)
+                return null;
+            if (drafted === "manual") {
+                return promptCheckCases({
+                    heading: "Truth checks",
+                    questionMessage: "Question 1?",
+                    questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
+                    answerMessage: "Expected answer 1?",
+                    answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
+                    addAnotherMessage: "Add another question?",
+                });
+            }
+            return drafted;
+        }
         return promptCheckCases({
             heading: "Truth checks",
             questionMessage: "Question 1?",
-            questionPlaceholder: DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER,
+            questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
             answerMessage: "Expected answer 1?",
-            answerPlaceholder: DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER,
+            answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
             addAnotherMessage: "Add another question?",
         });
     }
     if (options.initialAbout) {
-        p.log.info(`Focus: ${options.initialAbout}`);
+        p.log.info(`About: ${options.initialAbout}`);
     }
     p.log.info(`Current truth checks: ${options.initialChecks.length}`);
     const mode = await p.select({
@@ -113,10 +340,15 @@ async function promptWorkspaceChecks(options) {
                 label: "Replace all",
                 hint: "Rewrite the truth checks from scratch",
             },
+            {
+                value: "redraft",
+                label: "Replace with auto-created draft",
+                hint: "Let a local agent rewrite the checks from the dataset files",
+            },
             {
                 value: "clear",
                 label: "Clear them for now",
-                hint: "Keep this workspace without saved truth checks",
+                hint: "Keep this dataset without saved truth checks",
             },
         ],
     });
@@ -128,16 +360,37 @@ async function promptWorkspaceChecks(options) {
     if (mode === "clear") {
         return [];
     }
+    if (mode === "redraft") {
+        const drafted = await promptDraftTruthChecks({
+            projectPath: options.projectPath,
+            datasetName: options.datasetName,
+            datasetPath: options.datasetPath,
+            about: options.initialAbout,
+        });
+        if (drafted === null)
+            return null;
+        if (drafted === "manual") {
+            return promptCheckCases({
+                heading: "Replace truth checks",
+                questionMessage: "Question 1?",
+                questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
+                answerMessage: "Expected answer 1?",
+                answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
+                addAnotherMessage: "Add another question?",
+            });
+        }
+        return drafted;
+    }
     const nextChecks = await promptCheckCases({
         heading: mode === "add" ? "Add more truth checks" : "Replace truth checks",
         questionMessage: mode === "add"
             ? `Question ${options.initialChecks.length + 1}?`
             : "Question 1?",
-        questionPlaceholder: DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER,
+        questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
         answerMessage: mode === "add"
             ? `Expected answer ${options.initialChecks.length + 1}?`
             : "Expected answer 1?",
-        answerPlaceholder: DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER,
+        answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
         addAnotherMessage: "Add another question?",
         startIndex: mode === "add" ? options.initialChecks.length + 1 : 1,
     });
@@ -145,24 +398,6 @@ async function promptWorkspaceChecks(options) {
         return null;
     return mode === "add" ? [...options.initialChecks, ...nextChecks] : nextChecks;
 }
-async function promptRetryAttempts(options) {
-    const minimum = options.minimum ?? 1;
-    const maxAttempts = await p.text({
-        message: options.message,
-        placeholder: String(Math.max(minimum, DEFAULT_COMPILE_RETRY_ATTEMPTS)),
-        initialValue: String(Math.max(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS, minimum)),
-        validate: (value) => {
-            const parsed = Number.parseInt(value.trim(), 10);
-            if (!Number.isInteger(parsed) || parsed < minimum || parsed > 5) {
-                return `Enter a whole number from ${minimum} to 5`;
-            }
-            return undefined;
-        },
-    });
-    if (p.isCancel(maxAttempts))
-        return null;
-    return workspaceMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10)) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
-}
 async function promptSelfImprovingLoops(options) {
     const maxLoops = await p.text({
         message: options.message,
@@ -178,13 +413,14 @@ async function promptSelfImprovingLoops(options) {
     });
     if (p.isCancel(maxLoops))
         return null;
-    return workspaceMaxLoops(Number.parseInt(String(maxLoops).trim(), 10)) ?? DEFAULT_SELF_IMPROVING_LOOPS;
+    return compiledMaxLoops(Number.parseInt(String(maxLoops).trim(), 10)) ?? DEFAULT_SELF_IMPROVING_LOOPS;
 }
 export async function promptCompileLoopSelection(options) {
     if (!options.hasChecks) {
         return {};
     }
     const currentMode = resolveCompileLoopMode(options.initialMaxAttempts, options.initialMaxLoops);
+    const currentPromptMode = currentMode === "self-improving" ? "self-improving" : "once";
     const recommendedMode = options.recommendedMode ?? "self-improving";
     const includeCompileOnce = options.includeCompileOnce !== false;
     const hasSavedPolicy = typeof options.initialMaxAttempts === "number" ||
@@ -199,37 +435,35 @@ export async function promptCompileLoopSelection(options) {
     const optionsByMode = {
         once: {
             value: "once",
-            label: "Single attempt",
-            hint: "No retries or workflow edits",
-        },
-        retry: {
-            value: "retry",
-            label: "Retry the same workflow",
-            hint: `Run compile + test up to ${formatAttemptLabel(Math.max(options.initialMaxAttempts ?? 2, 2), "attempt")}`,
+            label: "Compile once",
+            hint: "Build the compiled dataset once with the selected workflow",
         },
         "self-improving": {
             value: "self-improving",
             label: recommendedMode === "self-improving"
                 ? "Self-improving loops (Recommended)"
                 : "Self-improving loops",
-            hint: `Retry each variation, then edit the workflow and retest up to ${options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS} loop${(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS) === 1 ? "" : "s"}`,
+            hint: `Let Interf revise the workflow and retry up to ${options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS} time${(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS) === 1 ? "" : "s"}`,
+        },
+        retry: {
+            value: "retry",
+            label: "Compile once",
+            hint: "Build the compiled dataset once with the selected workflow",
         },
     };
     const orderedModes = (hasSavedPolicy
         ? [
-            currentMode,
-            ...(recommendedMode !== currentMode ? [recommendedMode] : []),
-            "retry",
+            currentPromptMode,
+            ...(recommendedMode !== currentPromptMode ? [recommendedMode] : []),
             "once",
         ]
         : [
             recommendedMode,
-            "retry",
             "once",
         ]).filter((mode, index, list) => list.indexOf(mode) === index)
         .filter((mode) => includeCompileOnce || mode !== "once");
     const selectedMode = await p.select({
-        message: options.message ?? "How should this workspace compile?",
+        message: options.message ?? "How should this dataset compile?",
         options: orderedModes.map((mode) => optionsByMode[mode]),
     });
     if (p.isCancel(selectedMode))
@@ -237,57 +471,42 @@ export async function promptCompileLoopSelection(options) {
     if (selectedMode === "once") {
         return {};
     }
-    const maxAttempts = await promptRetryAttempts({
-        initialMaxAttempts: options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
-        minimum: selectedMode === "retry" ? 2 : 1,
-        message: selectedMode === "retry"
-            ? "Maximum compile attempts for the same workflow?"
-            : "Attempts per workflow variation?",
-    });
-    if (maxAttempts === null)
-        return null;
-    if (selectedMode === "retry") {
-        return {
-            max_attempts: maxAttempts,
-        };
-    }
     const maxLoops = await promptSelfImprovingLoops({
         initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
-        message: "Maximum self-improving workflow loops?",
+        message: "How many workflow revisions should Interf try?",
     });
     if (maxLoops === null)
         return null;
     return {
-        max_attempts: maxAttempts,
+        max_attempts: compiledMaxAttempts(DEFAULT_COMPILE_RETRY_ATTEMPTS) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
         max_loops: maxLoops,
     };
 }
-export async function promptSingleWorkspaceConfig(options = {}) {
+export async function promptSingleCompiledConfig(options = {}) {
     const initial = options.initial;
     const introStyle = options.introStyle ?? "first";
-    const collectChecksFirst = introStyle === "first" && options.skipNamePrompt && !options.fixedName;
     if (introStyle === "first") {
-        p.log.info("Set a few truth checks you already know should hold for this dataset.");
-        p.log.info("Add an optional focus only if you want this workspace especially good at one job on the dataset.");
+        p.log.info("Pick the dataset folder you want to measure.");
+        p.log.info("Then say what this dataset should be accurate about and save a few truth checks you can verify.");
     }
     else if (introStyle === "additional") {
-        p.log.info("Add another workspace only if this dataset needs a separate focus or a separate set of truth checks.");
+        p.log.info("Add another dataset only if this project needs a separate folder or set of truth checks.");
     }
     const fixedName = options.fixedName ? slugify(String(options.fixedName)) : undefined;
     if (options.fixedName && !fixedName) {
-        p.log.error("Current workspace folder name needs letters, numbers, or dashes.");
+        p.log.error("Current dataset id needs letters, numbers, or dashes.");
         return null;
     }
-    let name = fixedName ?? (options.skipNamePrompt ? slugify(String(initial?.name ?? DEFAULT_WORKSPACE_NAME)) : undefined);
+    let name = fixedName ?? (options.skipNamePrompt ? slugify(String(initial?.name ?? DEFAULT_COMPILED_NAME)) : undefined);
     if (name) {
         if (options.fixedName) {
-            p.log.info(`Editing truth checks for workspace "${name}".`);
+            p.log.info(`Editing truth checks for dataset "${name}".`);
         }
     }
     else {
-        const suggestedName = initial?.name ?? slugify(String(initial?.about ?? "")) ?? DEFAULT_WORKSPACE_NAME;
+        const suggestedName = initial?.name ?? slugify(String(initial?.about ?? "")) ?? DEFAULT_COMPILED_NAME;
         const rawName = await p.text({
-            message: "Workspace name?",
+            message: "Dataset id?",
             placeholder: suggestedName,
             initialValue: suggestedName,
             validate: (value) => (value.trim().length === 0 ? "Name is required" : undefined),
@@ -296,60 +515,78 @@ export async function promptSingleWorkspaceConfig(options = {}) {
             return null;
         name = slugify(String(rawName));
         if (!name) {
-            p.log.error("Workspace name needs letters, numbers, or dashes.");
+            p.log.error("Dataset id needs letters, numbers, or dashes.");
             return null;
         }
         if (name !== rawName) {
-            p.log.info(`Workspace name: ${name}`);
+            p.log.info(`Dataset id: ${name}`);
         }
     }
-    let about = initial?.about ?? "";
-    let checks = null;
+    let about = normalizeOptionalPromptText(initial?.about);
+    const defaultDatasetPath = initial?.path ?? defaultDatasetPathForPrompt(name, introStyle, options.projectPath ?? process.cwd());
+    const datasetPath = await p.text({
+        message: "Dataset folder?",
+        placeholder: DEFAULT_DATASET_PATH_PLACEHOLDER,
+        initialValue: defaultDatasetPath,
+        validate: (value) => {
+            const normalized = value.trim();
+            if (normalized.length === 0)
+                return "Dataset folder is required";
+            try {
+                resolveSourceDatasetPath(options.projectPath ?? process.cwd(), { path: normalized });
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    });
+    if (p.isCancel(datasetPath))
+        return null;
+    const normalizedDatasetPath = String(datasetPath).trim();
     let compileLoopSelection = {
         ...(typeof initial?.max_attempts === "number" ? { max_attempts: initial.max_attempts } : {}),
         ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
     };
-    if (collectChecksFirst) {
-        checks = await promptWorkspaceChecks({
-            initialChecks: initial?.checks,
-        });
-        if (checks === null)
-            return null;
-    }
     if (!(options.skipAboutPrompt && initial?.about)) {
-        about = await p.text({
-            message: "Optional focus for this workspace?",
-            placeholder: DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER,
-            initialValue: initial?.about,
+        const aboutInput = await p.text({
+            message: datasetAboutPromptMessage(introStyle),
+            placeholder: DEFAULT_COMPILED_ABOUT_PLACEHOLDER,
+            initialValue: about ?? "",
         });
-        if (p.isCancel(about))
+        if (p.isCancel(aboutInput))
             return null;
+        about = normalizeOptionalPromptText(aboutInput);
     }
-    if (!checks) {
-        checks = await promptWorkspaceChecks({
-            initialAbout: String(about).trim(),
-            initialChecks: initial?.checks,
+    const checks = await promptCompiledChecks({
+        projectPath: options.projectPath ?? process.cwd(),
+        datasetName: name,
+        datasetPath: normalizedDatasetPath,
+        initialAbout: about,
+        initialChecks: initial?.checks,
+    });
+    if (checks === null)
+        return null;
+    if (introStyle === "edit") {
+        compileLoopSelection = await promptCompileLoopSelection({
+            initialMaxAttempts: initial?.max_attempts,
+            initialMaxLoops: initial?.max_loops,
+            hasChecks: checks.length > 0,
+            intro: [
+                ...(options.selectedWorkflowLabel
+                    ? [`Workflow: ${options.selectedWorkflowLabel}`]
+                    : []),
+                "Compile mode",
+                "Choose whether this dataset should compile once or keep revising the workflow until it passes the same truth checks.",
+            ],
         });
-        if (checks === null)
+        if (compileLoopSelection === null)
             return null;
     }
-    compileLoopSelection = await promptCompileLoopSelection({
-        initialMaxAttempts: initial?.max_attempts,
-        initialMaxLoops: initial?.max_loops,
-        hasChecks: checks.length > 0,
-        intro: [
-            ...(options.selectedWorkflowLabel
-                ? [`Workflow: ${options.selectedWorkflowLabel}`]
-                : []),
-            "Compile mode",
-            "Choose whether this workspace should compile once, retry the same workflow, or run self-improving loops that edit the workflow and retest it on the same truth checks.",
-        ],
-    });
-    if (compileLoopSelection === null)
-        return null;
     return {
         name,
-        ...(String(about).trim().length > 0 ? { about: String(about).trim() } : {}),
+        path: normalizedDatasetPath,
+        ...(about ? { about } : {}),
         ...(typeof compileLoopSelection.max_attempts === "number"
             ? { max_attempts: compileLoopSelection.max_attempts }
             : {}),