@interf/compiler 0.6.1 → 0.6.4

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

@@ -1,14 +1,14 @@
 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 "../../packages/shared/naming.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: board-prep questions from these files, chart reads from this report, or tax review from these exports.";
+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";
 export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
@@ -19,7 +19,7 @@ function normalizeOptionalPromptText(value) {
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 }
-function findSingleDatasetFolderCandidate(cwd) {
+function listVisibleDatasetFolders(cwd) {
     const ignoredEntries = new Set([
         ".DS_Store",
         ".git",
@@ -33,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 {
@@ -44,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)) {
@@ -70,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 task should this dataset stay focused on?";
+        return "What work should this source folder stay focused on?";
     }
-    return "What task should this dataset help with?";
+    return "What work should this source folder help with?";
 }
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -97,11 +183,11 @@ export function describeCompileLoopSelection(options) {
     }
     if (mode === "retry") {
         const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
-        return `Compile retries are enabled for this dataset (${formatAttemptLabel(attempts, "total attempt")}).`;
+        return `Compile 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 for this dataset (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "workflow revision")}).`;
+    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({
@@ -118,7 +204,8 @@ async function promptCompileRetryAttempts(options) {
     });
     if (p.isCancel(maxAttempts))
         return null;
-    return compiledMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10)) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
+    return projectSourceConfig.compiledMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10))
+        ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
 }
 export async function promptCheckCases(options) {
     p.log.info(options.heading);
@@ -159,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 tests: ${checks.length}`);
     for (const [index, check] of checks.entries()) {
         console.log(`  ${index + 1}. ${check.question}`);
         console.log(`     Expected: ${check.answer ?? ""}`);
@@ -171,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));
@@ -184,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 question drafting.");
         const fallback = await p.select({
             message: "How do you want to continue?",
             options: [
                 {
                     value: "manual",
-                    label: "Add truth checks manually",
+                    label: "Add questions 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 questions",
                 },
             ],
         });
@@ -205,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 questions from the source files.");
         const drafted = await draftTruthChecks({
             datasetName: options.datasetName,
             datasetPath: resolvedDatasetPath,
@@ -214,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 questions 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",
-                        hint: "Write the checks yourself instead",
+                        label: "Add questions manually",
+                        hint: "Write the questions yourself instead",
                     },
                     {
                         value: "skip",
                         label: "Skip for now",
-                        hint: "Save this dataset without truth checks",
+                        hint: "Save this dataset without questions",
                     },
                 ],
             });
@@ -243,27 +330,27 @@ async function promptDraftTruthChecks(options) {
         }
         printDraftTruthChecks(drafted.checks);
         const nextStep = await p.select({
-            message: "Use these truth checks?",
+            message: "Use these questions?",
             options: [
                 {
                     value: "use",
                     label: "Use this draft (Recommended)",
-                    hint: "Save these checks and edit them later if needed",
+                    hint: "Save these questions and edit them later if needed",
                 },
                 {
                     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",
-                    hint: "Discard this draft and write the checks yourself",
+                    label: "Add questions manually instead",
+                    hint: "Discard this draft and write the questions yourself",
                 },
                 {
                     value: "skip",
                     label: "Skip for now",
-                    hint: "Save this dataset without truth checks",
+                    hint: "Save this dataset without questions",
                 },
             ],
         });
@@ -283,24 +370,24 @@ async function promptCompiledChecks(options) {
         if (options.initialAbout) {
             p.log.info(`About: ${options.initialAbout}`);
         }
-        p.log.info("Truth checks are the questions an agent should be able to answer from the data behind this task.");
+        p.log.info("Questions are simple question-and-answer pairs Interf uses to check accuracy later, so you can decide whether to trust the portable context.");
         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",
+                    label: "Auto-create a question draft (Recommended)",
+                    hint: "Let your chosen local agent recommend a few clear, verifiable questions from this source folder",
                 },
                 {
                     value: "manual",
-                    label: "Add them manually",
+                    label: "Add questions 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",
+                    hint: "You can save the dataset first and add questions later",
                 },
             ],
         });
@@ -319,7 +406,7 @@ async function promptCompiledChecks(options) {
                 return null;
             if (drafted === "manual") {
                 return promptCheckCases({
-                    heading: "Truth checks",
+                    heading: "Questions",
                     questionMessage: "Question 1?",
                     questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                     answerMessage: "Expected answer 1?",
@@ -330,7 +417,7 @@ async function promptCompiledChecks(options) {
             return drafted;
         }
         return promptCheckCases({
-            heading: "Truth checks",
+            heading: "Questions",
             questionMessage: "Question 1?",
             questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
             answerMessage: "Expected answer 1?",
@@ -341,34 +428,34 @@ 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 questions: ${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 questions as-is",
             },
             {
                 value: "add",
                 label: "Add more",
-                hint: "Append more truth checks",
+                hint: "Append more questions",
             },
             {
                 value: "replace",
                 label: "Replace all",
-                hint: "Rewrite the truth checks from scratch",
+                hint: "Rewrite the questions from scratch",
             },
             {
                 value: "redraft",
                 label: "Replace with auto-created draft",
-                hint: "Let a local agent rewrite the checks from the dataset files",
+                hint: "Let a local agent rewrite the questions from the dataset files",
             },
             {
                 value: "clear",
                 label: "Clear them for now",
-                hint: "Keep this dataset without saved truth checks",
+                hint: "Keep this setup without questions",
             },
         ],
     });
@@ -391,7 +478,7 @@ async function promptCompiledChecks(options) {
             return null;
         if (drafted === "manual") {
             return promptCheckCases({
-                heading: "Replace truth checks",
+                heading: "Replace questions",
                 questionMessage: "Question 1?",
                 questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
                 answerMessage: "Expected answer 1?",
@@ -402,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 questions" : "Replace questions",
         questionMessage: mode === "add"
             ? `Question ${options.initialChecks.length + 1}?`
             : "Question 1?",
@@ -433,7 +520,8 @@ 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) {
@@ -456,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 portable context once with the selected workflow",
         },
         "self-improving": {
             value: "self-improving",
@@ -468,7 +556,7 @@ export async function promptCompileLoopSelection(options) {
         retry: {
             value: "retry",
             label: "Retry same workflow",
-            hint: `Retry compile and compiled-side truth checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the 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`,
         },
     };
     const orderedModes = (hasSavedPolicy
@@ -485,7 +573,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 dataset compile?",
+        message: options.message ?? "How should this compile run work?",
         options: orderedModes.map((mode) => optionsByMode[mode]),
     });
     if (p.isCancel(selectedMode))
@@ -519,64 +607,50 @@ 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 task this dataset should help with and save a few truth checks you can verify.");
+        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.");
     }
     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 questions.");
     }
     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 questions 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}`);
     }
@@ -610,7 +684,7 @@ export async function promptSingleCompiledConfig(options = {}) {
             hasChecks: checks.length > 0,
             intro: [
                 "Compile mode",
-                "Choose whether this dataset should compile once, retry the same workflow, or try self-improving workflow variations on the same truth checks.",
+                "Choose whether Interf should compile once, retry the same workflow, or try self-improving workflow variations on the same questions.",
             ],
         });
         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 portable 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 portable contexts found."));
+                console.log(chalk.dim("  Run `interf`, save questions, and compile portable context 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 questions. Run `interf test` again."
+                : "  No saved comparison yet. Run `interf test` to measure source files and the portable context."));
         }
         console.log();
         const metricOrder = [

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

@@ -1,7 +1,8 @@
-import { type TestTargetCandidate, type TestTargetResult } from "../lib/test.js";
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
-import type { TestSandboxRetentionMode } from "../lib/test-sandbox.js";
-import type { SourceDatasetConfig, TestRunComparison, TestRunMode } from "../lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "../../packages/testing/test.js";
+import type { WorkflowExecutionProfile, WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { TestSandboxRetentionMode } from "../../packages/testing/test-sandbox.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { TestRunComparison, TestRunMode } from "../../packages/testing/lib/schema.js";
 export interface SavedTestOutcome {
     runPath: string;
     displayRunPath?: string;
@@ -15,6 +16,14 @@ export interface AgentTestMatrixRow {
 }
 export declare function questionPassRate(outcome: SavedTestOutcome): number;
 export declare function readSavedTestComparison(projectPath: string, datasetName: string): TestRunComparison | null;
+export declare function readCurrentSavedTestComparison(options: {
+    projectPath: string;
+    datasetName: string;
+    checks: SourceDatasetConfig["checks"];
+}): {
+    comparison: TestRunComparison | null;
+    stale: boolean;
+};
 export declare function printSavedTestComparisonState(payload: TestRunComparison, comparisonRunPath?: string | null): void;
 export declare function printAgentTestMatrix(rows: AgentTestMatrixRow[]): void;
 export declare function printAgentTestFailures(rows: AgentTestMatrixRow[]): void;