@interf/compiler 0.5.1 → 0.6.3

package/dist/{commands → cli/commands}/source-config-wizard.js

@@ -1,24 +1,25 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative, sep } from "node:path";
 import * as p from "@clack/prompts";
-import { compiledMaxAttempts, compiledMaxLoops, resolveSourceDatasetPath, } from "../lib/source-config.js";
-import { slugify } from "../lib/util.js";
+import { sourceConfig as projectSourceConfig, } from "../../packages/project-model/index.js";
+import { slugify } from "../../lib/util.js";
 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_QUESTION_PLACEHOLDER = "A question 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: forward-demand metrics, board-prep questions, or chart reads from this dataset.";
+export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board-prep questions from these files, chart reads from this report, or tax review from these exports.";
 export const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
-export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
+const DEFAULT_SELF_IMPROVING_ATTEMPTS = 1;
 function normalizeOptionalPromptText(value) {
     if (typeof value !== "string")
         return undefined;
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 }
-function findSingleDatasetFolderCandidate(cwd) {
+function listVisibleDatasetFolders(cwd) {
     const ignoredEntries = new Set([
         ".DS_Store",
         ".git",
@@ -32,10 +33,9 @@ function findSingleDatasetFolderCandidate(cwd) {
         rootEntries = readdirSync(cwd);
     }
     catch {
-        return null;
+        return [];
     }
-    const visibleEntries = rootEntries.filter((entry) => !ignoredEntries.has(entry));
-    const visibleFiles = [];
+    const visibleEntries = rootEntries.filter((entry) => !ignoredEntries.has(entry) && !entry.startsWith("."));
     const visibleDirectories = [];
     for (const entry of visibleEntries) {
         try {
@@ -43,19 +43,56 @@ function findSingleDatasetFolderCandidate(cwd) {
             if (statSync(entryPath).isDirectory()) {
                 visibleDirectories.push(entry);
             }
-            else {
-                visibleFiles.push(entry);
-            }
         }
         catch {
             // ignore unreadable entries
         }
     }
-    if (visibleFiles.length > 0 || visibleDirectories.length !== 1) {
+    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}`;
+}
+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]}`;
 }
+export function listDatasetFolderChoices(cwd = process.cwd()) {
+    return listVisibleDatasetFolders(cwd).map((entry) => ({
+        value: `./${entry}`,
+        label: entry,
+        hint: `Use ./${entry} as the source folder`,
+    }));
+}
 export function defaultDatasetPathForPrompt(name, introStyle, cwd = process.cwd()) {
     const namedFolderPath = join(cwd, name);
     if (existsSync(namedFolderPath)) {
@@ -69,15 +106,65 @@ export function defaultDatasetPathForPrompt(name, introStyle, cwd = process.cwd(
         }
     }
     if (introStyle === "first") {
-        return findSingleDatasetFolderCandidate(cwd) ?? ".";
+        return findSingleDatasetFolderCandidate(cwd) ?? `./${name}`;
     }
     return `./${name}`;
 }
+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?",
+            options: [
+                ...folderChoices,
+                {
+                    value: "__manual__",
+                    label: "Enter a different path",
+                    hint: "Use a relative path if the source folder is not listed here",
+                },
+            ],
+            initialValue: folderChoices.some((choice) => choice.value === options.initialPath)
+                ? options.initialPath
+                : undefined,
+        });
+        if (p.isCancel(selected))
+            return null;
+        if (selected !== "__manual__") {
+            try {
+                return normalizeDatasetPathForConfig(options.projectPath, String(selected));
+            }
+            catch (error) {
+                p.log.error(error instanceof Error ? error.message : String(error));
+                return null;
+            }
+        }
+    }
+    const datasetPath = await p.text({
+        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";
+            try {
+                normalizeDatasetPathForConfig(options.projectPath, normalized);
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    });
+    if (p.isCancel(datasetPath))
+        return null;
+    return normalizeDatasetPathForConfig(options.projectPath, String(datasetPath));
+}
 export function datasetAboutPromptMessage(introStyle) {
     if (introStyle === "edit") {
-        return "What should this dataset stay accurate about?";
+        return "What task should this source folder stay focused on?";
     }
-    return "What should this dataset be accurate about?";
+    return "What task should this source folder help with?";
 }
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -95,10 +182,30 @@ export function describeCompileLoopSelection(options) {
         return "Compile once.";
     }
     if (mode === "retry") {
-        return "Compile retries are enabled for this dataset.";
+        const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
+        return `Compile retries are enabled here (${formatAttemptLabel(attempts, "total attempt")}).`;
     }
     const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
-    return `Self-improving loops are enabled for this dataset (${formatAttemptLabel(loops, "workflow revision")}).`;
+    const attempts = options.maxAttempts ?? DEFAULT_SELF_IMPROVING_ATTEMPTS;
+    return `Self-improving loops are enabled here (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "workflow revision")}).`;
+}
+async function promptCompileRetryAttempts(options) {
+    const maxAttempts = await p.text({
+        message: options.message,
+        placeholder: String(DEFAULT_COMPILE_RETRY_ATTEMPTS),
+        initialValue: String(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS),
+        validate: (value) => {
+            const parsed = Number.parseInt(value.trim(), 10);
+            if (!Number.isInteger(parsed) || parsed < 2 || parsed > 5) {
+                return "Enter a whole number from 2 to 5";
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(maxAttempts))
+        return null;
+    return projectSourceConfig.compiledMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10))
+        ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
 }
 export async function promptCheckCases(options) {
     p.log.info(options.heading);
@@ -139,7 +246,7 @@ export async function promptCheckCases(options) {
 }
 function printDraftTruthChecks(checks) {
     console.log();
-    p.log.info(`Draft truth checks: ${checks.length}`);
+    p.log.info(`Draft checks: ${checks.length}`);
     for (const [index, check] of checks.entries()) {
         console.log(`  ${index + 1}. ${check.question}`);
         console.log(`     Expected: ${check.answer ?? ""}`);
@@ -151,7 +258,7 @@ async function promptDraftTruthChecks(options) {
         const datasetConfig = {
             path: options.datasetPath,
         };
-        resolvedDatasetPath = resolveSourceDatasetPath(options.projectPath, datasetConfig);
+        resolvedDatasetPath = projectSourceConfig.resolveSourceDatasetPath(options.projectPath, datasetConfig);
     }
     catch (error) {
         p.log.error(error instanceof Error ? error.message : String(error));
@@ -164,19 +271,19 @@ async function promptDraftTruthChecks(options) {
     if (!resolved.executor) {
         if (resolved.cancelled)
             return null;
-        p.log.error(resolved.error ?? "No local agent detected for truth-check drafting.");
+        p.log.error(resolved.error ?? "No local agent detected for check drafting.");
         const fallback = await p.select({
             message: "How do you want to continue?",
             options: [
                 {
                     value: "manual",
-                    label: "Add truth checks manually",
+                    label: "Add checks manually",
                     hint: "Write the questions and expected answers yourself",
                 },
                 {
                     value: "skip",
                     label: "Skip for now",
-                    hint: "Save this dataset without truth checks",
+                    hint: "Save this dataset without checks",
                 },
             ],
         });
@@ -185,7 +292,7 @@ async function promptDraftTruthChecks(options) {
         return fallback === "manual" ? "manual" : [];
     }
     while (true) {
-        p.log.info("Drafting truth checks from the dataset files.");
+        p.log.info("Drafting checks from the source files.");
         const drafted = await draftTruthChecks({
             datasetName: options.datasetName,
             datasetPath: resolvedDatasetPath,
@@ -194,24 +301,24 @@ async function promptDraftTruthChecks(options) {
             targetCount: 4,
         });
         if (!drafted.checks) {
-            p.log.error(drafted.error ?? "Could not draft truth checks from this dataset.");
+            p.log.error(drafted.error ?? "Could not draft 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 dataset folder",
+                        hint: "Run the same local agent again on the source folder",
                     },
                     {
                         value: "manual",
-                        label: "Add truth checks manually",
+                        label: "Add checks manually",
                         hint: "Write the checks yourself instead",
                     },
                     {
                         value: "skip",
                         label: "Skip for now",
-                        hint: "Save this dataset without truth checks",
+                        hint: "Save this dataset without checks",
                     },
                 ],
             });
@@ -223,7 +330,7 @@ async function promptDraftTruthChecks(options) {
         }
         printDraftTruthChecks(drafted.checks);
         const nextStep = await p.select({
-            message: "Use these truth checks?",
+            message: "Use these checks?",
             options: [
                 {
                     value: "use",
@@ -233,17 +340,17 @@ async function promptDraftTruthChecks(options) {
                 {
                     value: "retry",
                     label: "Draft again",
-                    hint: "Run the same local agent again on the dataset folder",
+                    hint: "Run the same local agent again on the source folder",
                 },
                 {
                     value: "manual",
-                    label: "Add them manually instead",
+                    label: "Add checks manually instead",
                     hint: "Discard this draft and write the checks yourself",
                 },
                 {
                     value: "skip",
                     label: "Skip for now",
-                    hint: "Save this dataset without truth checks",
+                    hint: "Save this dataset without checks",
                 },
             ],
         });
@@ -263,18 +370,18 @@ async function promptCompiledChecks(options) {
         if (options.initialAbout) {
             p.log.info(`About: ${options.initialAbout}`);
         }
-        p.log.info("Truth checks are the questions this dataset should already answer correctly.");
+        p.log.info("Checks are the questions your agents should be able to answer from the files behind this task.");
         const mode = await p.select({
-            message: "How do you want to create them?",
+            message: "How should Interf 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",
+                    hint: "Let your chosen local agent draft a few clear, verifiable checks from this source folder",
                 },
                 {
                     value: "manual",
-                    label: "Add them manually",
+                    label: "Add checks manually",
                     hint: "Write the questions and expected answers yourself",
                 },
                 {
@@ -299,7 +406,7 @@ async function promptCompiledChecks(options) {
                 return null;
             if (drafted === "manual") {
                 return promptCheckCases({
-                    heading: "Truth checks",
+                    heading: "Checks",
                     questionMessage: "Question 1?",
                     questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                     answerMessage: "Expected answer 1?",
@@ -310,7 +417,7 @@ async function promptCompiledChecks(options) {
             return drafted;
         }
         return promptCheckCases({
-            heading: "Truth checks",
+            heading: "Checks",
             questionMessage: "Question 1?",
             questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
             answerMessage: "Expected answer 1?",
@@ -321,24 +428,24 @@ async function promptCompiledChecks(options) {
     if (options.initialAbout) {
         p.log.info(`About: ${options.initialAbout}`);
     }
-    p.log.info(`Current truth checks: ${options.initialChecks.length}`);
+    p.log.info(`Current 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 truth checks as-is",
+                hint: "Leave the current checks as-is",
             },
             {
                 value: "add",
                 label: "Add more",
-                hint: "Append more truth checks",
+                hint: "Append more checks",
             },
             {
                 value: "replace",
                 label: "Replace all",
-                hint: "Rewrite the truth checks from scratch",
+                hint: "Rewrite the checks from scratch",
             },
             {
                 value: "redraft",
@@ -348,7 +455,7 @@ async function promptCompiledChecks(options) {
             {
                 value: "clear",
                 label: "Clear them for now",
-                hint: "Keep this dataset without saved truth checks",
+                hint: "Keep this setup without checks",
             },
         ],
     });
@@ -371,7 +478,7 @@ async function promptCompiledChecks(options) {
             return null;
         if (drafted === "manual") {
             return promptCheckCases({
-                heading: "Replace truth checks",
+                heading: "Replace checks",
                 questionMessage: "Question 1?",
                 questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                 answerMessage: "Expected answer 1?",
@@ -382,7 +489,7 @@ async function promptCompiledChecks(options) {
         return drafted;
     }
     const nextChecks = await promptCheckCases({
-        heading: mode === "add" ? "Add more truth checks" : "Replace truth checks",
+        heading: mode === "add" ? "Add more checks" : "Replace checks",
         questionMessage: mode === "add"
             ? `Question ${options.initialChecks.length + 1}?`
             : "Question 1?",
@@ -413,15 +520,16 @@ async function promptSelfImprovingLoops(options) {
     });
     if (p.isCancel(maxLoops))
         return null;
-    return compiledMaxLoops(Number.parseInt(String(maxLoops).trim(), 10)) ?? DEFAULT_SELF_IMPROVING_LOOPS;
+    return projectSourceConfig.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 currentPromptMode = currentMode;
+    const recommendedMode = options.recommendedMode ?? "once";
     const includeCompileOnce = options.includeCompileOnce !== false;
     const hasSavedPolicy = typeof options.initialMaxAttempts === "number" ||
         typeof options.initialMaxLoops === "number";
@@ -436,7 +544,7 @@ export async function promptCompileLoopSelection(options) {
         once: {
             value: "once",
             label: "Compile once",
-            hint: "Build the compiled dataset once with the selected workflow",
+            hint: "Build the compiled context once with the selected workflow",
         },
         "self-improving": {
             value: "self-improving",
@@ -447,23 +555,25 @@ export async function promptCompileLoopSelection(options) {
         },
         retry: {
             value: "retry",
-            label: "Compile once",
-            hint: "Build the compiled dataset once with the selected workflow",
+            label: "Retry same workflow",
+            hint: `Retry compile and compiled-context checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the workflow`,
         },
     };
     const orderedModes = (hasSavedPolicy
         ? [
             currentPromptMode,
             ...(recommendedMode !== currentPromptMode ? [recommendedMode] : []),
+            "retry",
             "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 dataset compile?",
+        message: options.message ?? "How should this compile run work?",
         options: orderedModes.map((mode) => optionsByMode[mode]),
     });
     if (p.isCancel(selectedMode))
@@ -471,6 +581,17 @@ export async function promptCompileLoopSelection(options) {
     if (selectedMode === "once") {
         return {};
     }
+    if (selectedMode === "retry") {
+        const maxAttempts = await promptCompileRetryAttempts({
+            initialMaxAttempts: options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
+            message: "How many total attempts should Interf try before stopping?",
+        });
+        if (maxAttempts === null)
+            return null;
+        return {
+            max_attempts: maxAttempts,
+        };
+    }
     const maxLoops = await promptSelfImprovingLoops({
         initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
         message: "How many workflow revisions should Interf try?",
@@ -478,7 +599,7 @@ export async function promptCompileLoopSelection(options) {
     if (maxLoops === null)
         return null;
     return {
-        max_attempts: compiledMaxAttempts(DEFAULT_COMPILE_RETRY_ATTEMPTS) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
+        max_attempts: DEFAULT_SELF_IMPROVING_ATTEMPTS,
         max_loops: maxLoops,
     };
 }
@@ -486,64 +607,53 @@ export async function promptSingleCompiledConfig(options = {}) {
     const initial = options.initial;
     const introStyle = options.introStyle ?? "first";
     if (introStyle === "first") {
-        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.");
+        p.log.info("Pick the source folder for this task.");
+        p.log.info("Then say what task this source folder should help with and save a few checks you can verify.");
     }
     else if (introStyle === "additional") {
-        p.log.info("Add another dataset only if this project needs a separate folder or set of truth checks.");
+        p.log.info("Add another setup only if this project needs a separate folder or set of checks.");
     }
     const fixedName = options.fixedName ? slugify(String(options.fixedName)) : undefined;
     if (options.fixedName && !fixedName) {
-        p.log.error("Current dataset id needs letters, numbers, or dashes.");
+        p.log.error("Current dataset name needs letters, numbers, or dashes.");
         return null;
     }
-    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 dataset "${name}".`);
-        }
+    let name = fixedName;
+    if (name && options.fixedName) {
+        p.log.info(`Editing checks for dataset "${name}".`);
     }
-    else {
-        const suggestedName = initial?.name ?? slugify(String(initial?.about ?? "")) ?? DEFAULT_COMPILED_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,
+    });
+    if (!normalizedDatasetPath)
+        return null;
+    if (!name) {
+        const suggestedName = defaultDatasetNameForPath(normalizedDatasetPath);
         const rawName = await p.text({
-            message: "Dataset id?",
+            message: "Dataset name?",
             placeholder: suggestedName,
             initialValue: suggestedName,
-            validate: (value) => (value.trim().length === 0 ? "Name is required" : undefined),
+            validate: (value) => (value.trim().length === 0 ? "Dataset name is required" : undefined),
         });
         if (p.isCancel(rawName))
             return null;
         name = slugify(String(rawName));
         if (!name) {
-            p.log.error("Dataset id needs letters, numbers, or dashes.");
+            p.log.error("Dataset name needs letters, numbers, or dashes.");
             return null;
         }
         if (name !== rawName) {
-            p.log.info(`Dataset id: ${name}`);
+            p.log.info(`Dataset name: ${name}`);
         }
     }
-    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();
+    if (options.selectedWorkflowLabel) {
+        p.log.info(`Workflow: ${options.selectedWorkflowLabel}`);
+    }
     let compileLoopSelection = {
         ...(typeof initial?.max_attempts === "number" ? { max_attempts: initial.max_attempts } : {}),
         ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
@@ -573,11 +683,8 @@ export async function promptSingleCompiledConfig(options = {}) {
             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.",
+                "Choose whether Interf should compile once, retry the same workflow, or try self-improving workflow variations on the same checks.",
             ],
         });
         if (compileLoopSelection === null)

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

@@ -1,8 +1,9 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, listCompiledDatasetsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { computeCompiledHealth } from "../lib/state.js";
-import { readSavedTestComparison, printSavedTestComparisonState } from "./test-flow.js";
+import { detectInterf, listCompiledDatasetsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { computeCompiledHealth } from "../../packages/compiler/state.js";
+import { sourceDatasetConfigFromInterfConfig, loadCompiledDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { printSavedTestComparisonState, readCurrentSavedTestComparison } from "./test-flow.js";
 function statusColor(status) {
     switch (status) {
         case "compiled":
@@ -17,7 +18,7 @@ function statusColor(status) {
 }
 export const statusCommand = {
     command: "status",
-    describe: "Show deterministic health for a compiled dataset",
+    describe: "Show deterministic health for a compiled context",
     handler: async () => {
         let compiledPath = null;
         const detected = detectInterf(process.cwd());
@@ -32,8 +33,8 @@ export const statusCommand = {
             }));
             if (local.length === 0) {
                 process.exitCode = 1;
-                console.log(chalk.red("  No compiled datasets found."));
-                console.log(chalk.dim("  Run `interf`, save truth checks, and compile a dataset first."));
+                console.log(chalk.red("  No compiled contexts found."));
+                console.log(chalk.dim("  Run `interf`, save checks, and compile a context folder first."));
                 return;
             }
             if (local.length === 1) {
@@ -41,7 +42,7 @@ export const statusCommand = {
             }
             else {
                 const selected = await p.select({
-                    message: "Which dataset?",
+                    message: "Which setup?",
                     options: local.map((entry) => ({ value: entry.path, label: entry.name })),
                 });
                 if (p.isCancel(selected))
@@ -58,15 +59,23 @@ export const statusCommand = {
         console.log(chalk.dim(`  ${health.summary}`));
         const compiledConfig = readInterfConfig(compiledPath);
         const sourcePath = resolveSourceControlPath(compiledPath);
-        const latestComparison = compiledConfig
-            ? readSavedTestComparison(sourcePath, compiledConfig.name)
-            : null;
+        const latestComparisonState = compiledConfig
+            ? readCurrentSavedTestComparison({
+                projectPath: sourcePath,
+                datasetName: compiledConfig.name,
+                checks: (loadCompiledDatasetConfig(compiledPath)
+                    ?? sourceDatasetConfigFromInterfConfig(compiledConfig)).checks,
+            })
+            : { comparison: null, stale: false };
+        const latestComparison = latestComparisonState.comparison;
         if (latestComparison) {
             printSavedTestComparisonState(latestComparison);
         }
         else {
             console.log();
-            console.log(chalk.dim("  No saved test result yet. Run `interf test` to measure files as-is and the compiled dataset."));
+            console.log(chalk.dim(latestComparisonState.stale
+                ? "  Saved test results are stale for the current checks. Run `interf test` again."
+                : "  No saved test result yet. Run `interf test` to measure files as-is and the compiled context."));
         }
         console.log();
         const metricOrder = [