@interf/compiler 0.7.3 → 0.9.1

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

@@ -1,12 +1,11 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join, relative, sep } from "node:path";
 import * as p from "@clack/prompts";
-import { sourceConfig as projectSourceConfig, } from "../../packages/project-model/index.js";
+import { sourceConfig as projectSourceConfig, sourceFolders as projectSourceFolders, } from "../../packages/project-model/index.js";
 import { slugify } from "../../packages/shared/naming.js";
+import { submitReadinessCheckDraftToLocalService, } from "../../packages/local-service/index.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { draftTruthChecks } from "./check-draft.js";
+import { draftReadinessChecks } 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 source folder";
+export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
 export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
 export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
 export const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
@@ -19,108 +18,29 @@ function normalizeOptionalPromptText(value) {
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 }
-function listVisibleDatasetFolders(cwd) {
-    const ignoredEntries = new Set([
-        ".DS_Store",
-        ".git",
-        ".interf",
-        "interf",
-        "interf.json",
-        "node_modules",
-    ]);
-    let rootEntries = [];
-    try {
-        rootEntries = readdirSync(cwd);
-    }
-    catch {
-        return [];
-    }
-    const visibleEntries = rootEntries.filter((entry) => !ignoredEntries.has(entry) && !entry.startsWith("."));
-    const visibleDirectories = [];
-    for (const entry of visibleEntries) {
-        try {
-            const entryPath = join(cwd, entry);
-            if (statSync(entryPath).isDirectory()) {
-                visibleDirectories.push(entry);
-            }
-        }
-        catch {
-            // ignore unreadable entries
-        }
-    }
-    return visibleDirectories.sort((left, right) => left.localeCompare(right));
-}
-function isReservedDatasetPath(relativePath) {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
-    return normalized === "interf" || normalized.startsWith("interf/") || normalized === ".interf" || normalized.startsWith(".interf/");
-}
 export function normalizeDatasetPathForConfig(projectPath, value) {
-    const resolvedPath = projectSourceConfig.resolveSourceDatasetPath(projectPath, { path: value.trim() });
-    const relativePath = relative(projectPath, resolvedPath).split(sep).join("/") || ".";
-    if (relativePath === ".") {
-        throw new Error("Pick a source folder inside this project, not the project root.");
-    }
-    if (isReservedDatasetPath(relativePath)) {
-        throw new Error("Pick an existing source folder under the project root, not `interf/` or `.interf/`.");
-    }
-    if (!existsSync(resolvedPath)) {
-        throw new Error("Pick an existing source folder under the project root.");
-    }
-    if (!statSync(resolvedPath).isDirectory()) {
-        throw new Error("Source folder must be a directory.");
-    }
-    return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+    return projectSourceFolders.normalizeSourceDatasetPathForConfig(projectPath, value);
 }
 function defaultDatasetNameForPath(datasetPath) {
-    const segments = datasetPath
-        .replace(/\\/g, "/")
-        .replace(/\/+$/g, "")
-        .split("/")
-        .filter((segment) => segment.length > 0 && segment !== ".");
-    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_COMPILED_NAME;
-}
-function findSingleDatasetFolderCandidate(cwd) {
-    const visibleDirectories = listVisibleDatasetFolders(cwd);
-    if (visibleDirectories.length !== 1) {
-        return null;
-    }
-    return `./${visibleDirectories[0]}`;
+    return projectSourceFolders.defaultDatasetNameForPath(datasetPath);
 }
 export function listDatasetFolderChoices(cwd = process.cwd()) {
-    return listVisibleDatasetFolders(cwd).map((entry) => ({
-        value: `./${entry}`,
-        label: entry,
-        hint: `Use ./${entry} as the source folder`,
-    }));
+    return projectSourceFolders.listSourceFolderChoices(cwd);
 }
 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) ?? `./${name}`;
-    }
-    return `./${name}`;
+    return projectSourceFolders.defaultSourceDatasetPathForPrompt(name, introStyle, cwd);
 }
 async function promptDatasetFolderPath(options) {
     const folderChoices = listDatasetFolderChoices(options.projectPath);
     if (folderChoices.length > 0) {
         const selected = await p.select({
-            message: "Which source folder should Interf use?",
+            message: "Which Source Folder should Interf use?",
             options: [
                 ...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",
                 },
             ],
             initialValue: folderChoices.some((choice) => choice.value === options.initialPath)
@@ -140,13 +60,13 @@ async function promptDatasetFolderPath(options) {
         }
     }
     const datasetPath = await p.text({
-        message: "Which source folder should Interf use?",
+        message: "Which Source Folder should Interf use?",
         placeholder: DEFAULT_DATASET_PATH_PLACEHOLDER,
         initialValue: options.initialPath,
         validate: (value) => {
             const normalized = value.trim();
             if (normalized.length === 0)
-                return "Source folder is required";
+                return "Source Folder is required";
             try {
                 normalizeDatasetPathForConfig(options.projectPath, normalized);
                 return undefined;
@@ -162,9 +82,9 @@ async function promptDatasetFolderPath(options) {
 }
 export function datasetAboutPromptMessage(introStyle) {
     if (introStyle === "edit") {
-        return "What work should this source folder stay focused on?";
+        return "What agent work should this Preparation stay focused on?";
     }
-    return "What work should this source folder help with?";
+    return "What agent work should this Preparation help with?";
 }
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -179,15 +99,15 @@ export function resolveCompileLoopMode(maxAttempts, maxLoops) {
 export function describeCompileLoopSelection(options) {
     const mode = resolveCompileLoopMode(options.maxAttempts, options.maxLoops);
     if (mode === "once") {
-        return "Compile once.";
+        return "Prepare once.";
     }
     if (mode === "retry") {
         const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
-        return `Compile retries are enabled here (${formatAttemptLabel(attempts, "total attempt")}).`;
+        return `Prepare retries are enabled here (${formatAttemptLabel(attempts, "total attempt")}).`;
     }
     const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
     const attempts = options.maxAttempts ?? DEFAULT_SELF_IMPROVING_ATTEMPTS;
-    return `Self-improving loops are enabled here (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "workflow revision")}).`;
+    return `Self-improving loops are enabled here (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "Method revision")}).`;
 }
 async function promptCompileRetryAttempts(options) {
     const maxAttempts = await p.text({
@@ -215,9 +135,9 @@ export async function promptCheckCases(options) {
         const question = await p.text({
             message: cases.length === 0
                 ? options.questionMessage
-                : `Question ${startIndex + cases.length}?`,
+                : `Check ${startIndex + cases.length}?`,
             placeholder: options.questionPlaceholder,
-            validate: (value) => (value.trim().length === 0 ? "Question is required" : undefined),
+            validate: (value) => (value.trim().length === 0 ? "Check is required" : undefined),
         });
         if (p.isCancel(question))
             return null;
@@ -244,15 +164,15 @@ export async function promptCheckCases(options) {
             return cases;
     }
 }
-function printDraftTruthChecks(checks) {
+function printDraftReadinessChecks(checks) {
     console.log();
-    p.log.info(`Draft tests: ${checks.length}`);
+    p.log.info(`Draft readiness 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) {
+async function promptDraftReadinessChecks(options) {
     let resolvedDatasetPath;
     try {
         const datasetConfig = {
@@ -264,61 +184,101 @@ async function promptDraftTruthChecks(options) {
         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 question drafting.");
-        const fallback = await p.select({
-            message: "How do you want to continue?",
-            options: [
-                {
-                    value: "manual",
-                    label: "Add questions manually",
-                    hint: "Write the questions and expected answers yourself",
-                },
-                {
-                    value: "skip",
-                    label: "Skip for now",
-                    hint: "Save this dataset without questions",
-                },
-            ],
-        });
-        if (p.isCancel(fallback))
-            return null;
-        return fallback === "manual" ? "manual" : [];
-    }
     while (true) {
-        p.log.info("Drafting questions from the source files.");
-        const drafted = await draftTruthChecks({
-            datasetName: options.datasetName,
-            datasetPath: resolvedDatasetPath,
-            about: options.about,
-            executor: resolved.executor,
-            targetCount: 4,
+        p.log.info("Drafting readiness checks from the source files.");
+        let lastServiceStatus = "";
+        const serviceRun = await submitReadinessCheckDraftToLocalService({
+            projectPath: options.projectPath,
+            request: {
+                preparation: options.datasetName,
+                source_folder_path: resolvedDatasetPath,
+                about: options.about,
+                target_count: 4,
+            },
+            onSubmitted: (submission) => {
+                p.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;
+                p.log.info(activeStep
+                    ? `${activeStep.label}: ${activeStep.status}`
+                    : `Readiness-check draft run: ${job.status}`);
+            },
         });
+        const drafted = serviceRun
+            ? {
+                checks: serviceRun.result?.checks ?? null,
+                error: serviceRun.error,
+            }
+            : await (async () => {
+                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 readiness-check drafting.");
+                    const manualChoice = await p.select({
+                        message: "How do you want to continue?",
+                        options: [
+                            {
+                                value: "manual",
+                                label: "Add readiness checks manually",
+                                hint: "Write the checks and expected answers yourself",
+                            },
+                            {
+                                value: "skip",
+                                label: "Skip for now",
+                                hint: "Save this Preparation without readiness checks",
+                            },
+                        ],
+                    });
+                    if (p.isCancel(manualChoice))
+                        return null;
+                    return manualChoice === "manual"
+                        ? "manual"
+                        : "skip";
+                }
+                return draftReadinessChecks({
+                    datasetName: options.datasetName,
+                    datasetPath: resolvedDatasetPath,
+                    about: options.about,
+                    executor: resolved.executor,
+                    targetCount: 4,
+                });
+            })();
+        if (drafted === null)
+            return null;
+        if (drafted === "manual")
+            return "manual";
+        if (drafted === "skip")
+            return [];
         if (!drafted.checks) {
-            p.log.error(drafted.error ?? "Could not draft questions from this source folder.");
+            p.log.error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
             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 source folder",
+                        hint: "Run the same local agent again on the Source Folder",
                     },
                     {
                         value: "manual",
-                        label: "Add questions manually",
-                        hint: "Write the questions yourself instead",
+                        label: "Add readiness checks manually",
+                        hint: "Write the checks yourself instead",
                     },
                     {
                         value: "skip",
                         label: "Skip for now",
-                        hint: "Save this dataset without questions",
+                        hint: "Save this Preparation without readiness checks",
                     },
                 ],
             });
@@ -328,29 +288,29 @@ async function promptDraftTruthChecks(options) {
                 continue;
             return retryMode === "manual" ? "manual" : [];
         }
-        printDraftTruthChecks(drafted.checks);
+        printDraftReadinessChecks(drafted.checks);
         const nextStep = await p.select({
-            message: "Use these questions?",
+            message: "Use these readiness checks?",
             options: [
                 {
                     value: "use",
                     label: "Use this draft (Recommended)",
-                    hint: "Save these questions and edit them later if needed",
+                    hint: "Save these checks and edit them later if needed",
                 },
                 {
                     value: "retry",
                     label: "Draft again",
-                    hint: "Run the same local agent again on the source folder",
+                    hint: "Run the same local agent again on the Source Folder",
                 },
                 {
                     value: "manual",
-                    label: "Add questions manually instead",
-                    hint: "Discard this draft and write the questions yourself",
+                    label: "Add readiness checks manually instead",
+                    hint: "Discard this draft and write the checks yourself",
                 },
                 {
                     value: "skip",
                     label: "Skip for now",
-                    hint: "Save this dataset without questions",
+                    hint: "Save this Preparation without readiness checks",
                 },
             ],
         });
@@ -370,24 +330,24 @@ async function promptCompiledChecks(options) {
         if (options.initialAbout) {
             p.log.info(`About: ${options.initialAbout}`);
         }
-        p.log.info("Questions are simple question-and-answer pairs Interf uses to check accuracy, so you can decide whether to trust the portable context.");
+        p.log.info("Readiness checks are small agent-work-critical checks from your files that define when this data is ready for agent work.");
         const mode = await p.select({
             message: "How should Interf create them?",
             options: [
                 {
                     value: "draft",
-                    label: "Auto-create a question draft (Recommended)",
-                    hint: "Let your chosen local agent recommend a few clear, verifiable questions from this source folder",
+                    label: "Auto-create readiness checks (Recommended)",
+                    hint: "Let your chosen local agent recommend a few clear, verifiable checks from this Source Folder",
                 },
                 {
                     value: "manual",
-                    label: "Add questions manually",
-                    hint: "Write the questions and expected answers yourself",
+                    label: "Add readiness checks manually",
+                    hint: "Write the checks and expected answers yourself",
                 },
                 {
                     value: "skip",
                     label: "Skip for now",
-                    hint: "You can save the dataset first and add questions later",
+                    hint: "You can save the Preparation first and add readiness checks later",
                 },
             ],
         });
@@ -396,7 +356,7 @@ async function promptCompiledChecks(options) {
         if (mode === "skip")
             return [];
         if (mode === "draft") {
-            const drafted = await promptDraftTruthChecks({
+            const drafted = await promptDraftReadinessChecks({
                 projectPath: options.projectPath,
                 datasetName: options.datasetName,
                 datasetPath: options.datasetPath,
@@ -406,56 +366,56 @@ async function promptCompiledChecks(options) {
                 return null;
             if (drafted === "manual") {
                 return promptCheckCases({
-                    heading: "Questions",
-                    questionMessage: "Question 1?",
+                    heading: "Readiness checks",
+                    questionMessage: "Check 1?",
                     questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                     answerMessage: "Expected answer 1?",
                     answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-                    addAnotherMessage: "Add another question?",
+                    addAnotherMessage: "Add another readiness check?",
                 });
             }
             return drafted;
         }
         return promptCheckCases({
-            heading: "Questions",
-            questionMessage: "Question 1?",
+            heading: "Readiness checks",
+            questionMessage: "Check 1?",
             questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
             answerMessage: "Expected answer 1?",
             answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-            addAnotherMessage: "Add another question?",
+            addAnotherMessage: "Add another readiness check?",
         });
     }
     if (options.initialAbout) {
         p.log.info(`About: ${options.initialAbout}`);
     }
-    p.log.info(`Current questions: ${options.initialChecks.length}`);
+    p.log.info(`Current readiness checks: ${options.initialChecks.length}`);
     const mode = await p.select({
         message: "What do you want to do with them?",
         options: [
             {
                 value: "keep",
                 label: "Keep them",
-                hint: "Leave the current questions as-is",
+                hint: "Leave the current readiness checks as-is",
             },
             {
                 value: "add",
                 label: "Add more",
-                hint: "Append more questions",
+                hint: "Append more readiness checks",
             },
             {
                 value: "replace",
                 label: "Replace all",
-                hint: "Rewrite the questions from scratch",
+                hint: "Rewrite the readiness checks from scratch",
             },
             {
                 value: "redraft",
                 label: "Replace with auto-created draft",
-                hint: "Let a local agent rewrite the questions from the dataset files",
+                hint: "Let a local agent rewrite the readiness checks from the Preparation files",
             },
             {
                 value: "clear",
                 label: "Clear them for now",
-                hint: "Keep this setup without questions",
+                hint: "Keep this Preparation without readiness checks",
             },
         ],
     });
@@ -468,7 +428,7 @@ async function promptCompiledChecks(options) {
         return [];
     }
     if (mode === "redraft") {
-        const drafted = await promptDraftTruthChecks({
+        const drafted = await promptDraftReadinessChecks({
             projectPath: options.projectPath,
             datasetName: options.datasetName,
             datasetPath: options.datasetPath,
@@ -478,27 +438,27 @@ async function promptCompiledChecks(options) {
             return null;
         if (drafted === "manual") {
             return promptCheckCases({
-                heading: "Replace questions",
-                questionMessage: "Question 1?",
+                heading: "Replace readiness checks",
+                questionMessage: "Check 1?",
                 questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                 answerMessage: "Expected answer 1?",
                 answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-                addAnotherMessage: "Add another question?",
+                addAnotherMessage: "Add another readiness check?",
             });
         }
         return drafted;
     }
     const nextChecks = await promptCheckCases({
-        heading: mode === "add" ? "Add more questions" : "Replace questions",
+        heading: mode === "add" ? "Add more readiness checks" : "Replace readiness checks",
         questionMessage: mode === "add"
-            ? `Question ${options.initialChecks.length + 1}?`
-            : "Question 1?",
+            ? `Check ${options.initialChecks.length + 1}?`
+            : "Check 1?",
         questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
         answerMessage: mode === "add"
             ? `Expected answer ${options.initialChecks.length + 1}?`
             : "Expected answer 1?",
         answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-        addAnotherMessage: "Add another question?",
+        addAnotherMessage: "Add another readiness check?",
         startIndex: mode === "add" ? options.initialChecks.length + 1 : 1,
     });
     if (nextChecks === null)
@@ -543,20 +503,20 @@ export async function promptCompileLoopSelection(options) {
     const optionsByMode = {
         once: {
             value: "once",
-            label: "Compile once",
-            hint: "Build portable context agents can use once with the selected workflow",
+            label: "Prepare once",
+            hint: "Run the selected Method once and write Portable Context",
         },
         "self-improving": {
             value: "self-improving",
             label: recommendedMode === "self-improving"
                 ? "Self-improving loops (Recommended)"
                 : "Self-improving loops",
-            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"}`,
+            hint: `Let Interf revise the Method and retry up to ${options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS} time${(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS) === 1 ? "" : "s"}`,
         },
         retry: {
             value: "retry",
-            label: "Retry same workflow",
-            hint: `Retry compile and portable-context checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the workflow`,
+            label: "Retry same Method",
+            hint: `Retry the same Method and readiness checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the Method`,
         },
     };
     const orderedModes = (hasSavedPolicy
@@ -573,7 +533,7 @@ export async function promptCompileLoopSelection(options) {
         ]).filter((mode, index, list) => list.indexOf(mode) === index)
         .filter((mode) => includeCompileOnce || mode !== "once");
     const selectedMode = await p.select({
-        message: options.message ?? "How should this compile run work?",
+        message: options.message ?? "How should this prepare run work?",
         options: orderedModes.map((mode) => optionsByMode[mode]),
     });
     if (p.isCancel(selectedMode))
@@ -594,7 +554,7 @@ export async function promptCompileLoopSelection(options) {
     }
     const maxLoops = await promptSelfImprovingLoops({
         initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
-        message: "How many workflow revisions should Interf try?",
+        message: "How many Method revisions should Interf try?",
     });
     if (maxLoops === null)
         return null;
@@ -607,48 +567,66 @@ export async function promptSingleCompiledConfig(options = {}) {
     const initial = options.initial;
     const introStyle = options.introStyle ?? "first";
     if (introStyle === "first") {
-        p.log.info("Pick the source folder for this work.");
-        p.log.info("Then say what work this source folder should help with and review the recommended questions.");
+        if (options.fixedPath) {
+            p.log.info("Describe the agent work this Preparation should help with and review the recommended readiness checks.");
+        }
+        else {
+            p.log.info("Pick the Source Folder for this Preparation.");
+            p.log.info("Then say what agent work this Preparation should help with and review the recommended readiness checks.");
+        }
     }
     else if (introStyle === "additional") {
-        p.log.info("Add another setup only if this project needs a separate folder or set of questions.");
+        p.log.info("Add another Preparation only if this Source Folder needs a separate folder, agent-work focus, or readiness-check set.");
     }
     const fixedName = options.fixedName ? slugify(String(options.fixedName)) : undefined;
     if (options.fixedName && !fixedName) {
-        p.log.error("Current dataset name needs letters, numbers, or dashes.");
+        p.log.error("Current Preparation name needs letters, numbers, or dashes.");
         return null;
     }
     let name = fixedName;
     if (name && options.fixedName) {
-        p.log.info(`Editing questions for dataset "${name}".`);
+        p.log.info(`Editing readiness checks for Preparation "${name}".`);
     }
     let about = normalizeOptionalPromptText(initial?.about);
     const projectPath = options.projectPath ?? process.cwd();
     const defaultNameSeed = slugify(String(initial?.name ?? DEFAULT_COMPILED_NAME)) || DEFAULT_COMPILED_NAME;
     const defaultDatasetPath = initial?.path ?? defaultDatasetPathForPrompt(defaultNameSeed, introStyle, projectPath);
-    const normalizedDatasetPath = await promptDatasetFolderPath({
-        projectPath,
-        initialPath: defaultDatasetPath,
-    });
+    const normalizedDatasetPath = options.fixedPath
+        ? (() => {
+            try {
+                return normalizeDatasetPathForConfig(projectPath, options.fixedPath);
+            }
+            catch (error) {
+                p.log.error(error instanceof Error ? error.message : String(error));
+                return null;
+            }
+        })()
+        : await promptDatasetFolderPath({
+            projectPath,
+            initialPath: defaultDatasetPath,
+        });
     if (!normalizedDatasetPath)
         return null;
+    if (options.fixedPath) {
+        p.log.info(`Source Folder: ${normalizedDatasetPath}`);
+    }
     if (!name) {
         const suggestedName = defaultDatasetNameForPath(normalizedDatasetPath);
         const rawName = await p.text({
-            message: "Dataset name?",
+            message: "Preparation name?",
             placeholder: suggestedName,
             initialValue: suggestedName,
-            validate: (value) => (value.trim().length === 0 ? "Dataset name is required" : undefined),
+            validate: (value) => (value.trim().length === 0 ? "Preparation name is required" : undefined),
         });
         if (p.isCancel(rawName))
             return null;
         name = slugify(String(rawName));
         if (!name) {
-            p.log.error("Dataset name needs letters, numbers, or dashes.");
+            p.log.error("Preparation name needs letters, numbers, or dashes.");
             return null;
         }
         if (name !== rawName) {
-            p.log.info(`Dataset name: ${name}`);
+            p.log.info(`Preparation name: ${name}`);
         }
     }
     let compileLoopSelection = {
@@ -680,8 +658,8 @@ export async function promptSingleCompiledConfig(options = {}) {
             initialMaxLoops: initial?.max_loops,
             hasChecks: checks.length > 0,
             intro: [
-                "Compile mode",
-                "Choose whether Interf should compile once, retry the same workflow, or try self-improving workflow variations on the same questions.",
+                "Prepare mode",
+                "Choose whether Interf should prepare once, retry the same Method, or try self-improving Method variations against the same readiness checks.",
             ],
         });
         if (compileLoopSelection === null)