@interf/compiler 0.6.1 → 0.6.4

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

@@ -1,6 +1,5 @@
 import chalk from "chalk";
-import { resolveAgent, runAgentPreflight } from "../lib/agents.js";
-import { loadUserConfig } from "../lib/user-config.js";
+import { agents, userConfig } from "../../packages/agents/index.js";
 function iconFor(status) {
     if (status === "pass")
         return chalk.green("✓");
@@ -26,8 +25,8 @@ export const doctorCommand = {
     }),
     handler: async (argv) => {
         const checks = [];
-        const config = loadUserConfig();
-        const { agent, error } = resolveAgent();
+        const config = userConfig.loadUserConfig();
+        const { agent, error } = agents.resolveAgent();
         if (config) {
             checks.push({
                 id: "config",
@@ -73,7 +72,7 @@ export const doctorCommand = {
             message: `${agent.displayName} is configured and available as \`${agent.command}\``,
         });
         if (argv.live) {
-            const preflight = runAgentPreflight(agent);
+            const preflight = agents.runAgentPreflight(agent);
             checks.push({
                 id: "live",
                 label: "Live executor preflight",
@@ -98,7 +97,7 @@ export const doctorCommand = {
                 id: "live",
                 label: "Live executor preflight",
                 status: "skipped",
-                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a truth-check draft, workflow authoring run, test, or compile.",
+                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a check draft, workflow authoring run, test, or compile.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");

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

@@ -1,4 +1,4 @@
-import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../lib/executors.js";
+import { type WorkflowExecutionProfile, type WorkflowExecutor } from "../../packages/agents/index.js";
 export interface RunAgentOption {
     name: string;
     displayName: string;

package/dist/{commands → cli/commands}/executor-flow.js

@@ -1,27 +1,24 @@
 import * as p from "@clack/prompts";
-import { AGENTS } from "../lib/agent-constants.js";
-import { detectAgents, ensureAgentAutomatedRunReady, supportsAutomatedRuns } from "../lib/agents.js";
-import { createLocalAgentExecutor, resolveLocalExecutor, } from "../lib/executors.js";
-import { loadUserConfig, saveUserConfig } from "../lib/user-config.js";
+import { constants, agents, executors, userConfig } from "../../packages/agents/index.js";
 const promptedPurposes = new Set();
 function supportedDetectedAgents() {
-    return detectAgents().filter((agent) => AGENTS.some((candidate) => candidate.name === agent.name) && supportsAutomatedRuns(agent));
+    return agents.detectAgents().filter((agent) => constants.AGENTS.some((candidate) => candidate.name === agent.name) && agents.supportsAutomatedRuns(agent));
 }
 export function resolvedConfiguredAgentName() {
-    const current = loadUserConfig();
+    const current = userConfig.loadUserConfig();
     if (!current)
         return null;
-    const configured = AGENTS.find((agent) => agent.command === current.agentCommand) ??
-        AGENTS.find((agent) => agent.name === current.agent) ??
-        AGENTS.find((agent) => agent.displayName === current.agent);
+    const configured = constants.AGENTS.find((agent) => agent.command === current.agentCommand) ??
+        constants.AGENTS.find((agent) => agent.name === current.agent) ??
+        constants.AGENTS.find((agent) => agent.displayName === current.agent);
     return configured?.name ?? null;
 }
 function persistSelectedAgent(selectedName) {
     const selected = supportedDetectedAgents().find((agent) => agent.name === selectedName);
     if (!selected)
         return;
-    const current = loadUserConfig();
-    saveUserConfig({
+    const current = userConfig.loadUserConfig();
+    userConfig.saveUserConfig({
         agent: selected.name,
         agentCommand: selected.command,
         skillsInstalled: current?.skillsInstalled ?? false,
@@ -43,13 +40,13 @@ export function resolveNamedLocalExecutor(agentName, options = {}) {
         return { executor: null, error: `Local agent \"${agentName}\" is not detected.` };
     }
     if (options.preflight !== false) {
-        const readiness = ensureAgentAutomatedRunReady(agent);
+        const readiness = agents.ensureAgentAutomatedRunReady(agent);
         if (!readiness.ok) {
             return { executor: null, error: readiness.error };
         }
     }
     return {
-        executor: createLocalAgentExecutor(agent, options.executionProfile),
+        executor: executors.createLocalAgentExecutor(agent, options.executionProfile),
     };
 }
 export async function promptForTestAgents() {
@@ -89,7 +86,7 @@ export async function promptForTestAgents() {
 }
 async function promptForRunAgent(purpose) {
     const purposeLabel = purpose === "draft"
-        ? "truth-check draft"
+        ? "check draft"
         : purpose === "workflow"
             ? "workflow authoring"
             : purpose;
@@ -147,7 +144,7 @@ export async function resolveOrConfigureLocalExecutor(options = {}) {
             return { executor: null, error: "No local agent detected." };
         }
     }
-    const resolved = resolveLocalExecutor(options);
+    const resolved = executors.resolveLocalExecutor(options);
     if (resolved.executor)
         return resolved;
     const needsChoice = typeof resolved.error === "string" &&
@@ -162,5 +159,5 @@ export async function resolveOrConfigureLocalExecutor(options = {}) {
     if (!configured.selected) {
         return resolved;
     }
-    return resolveLocalExecutor(options);
+    return executors.resolveLocalExecutor(options);
 }

package/dist/{commands → cli/commands}/init.d.ts

@@ -1,6 +1,9 @@
 import type { CommandModule } from "yargs";
-import type { SourceDatasetConfig } from "../lib/schema.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import { type AgentTestMatrixRow } from "./test-flow.js";
 import { runCompileCommand } from "./compile.js";
+export type CurrentRunTargetStatus = "pass" | "mixed" | "fail" | "missing";
+export declare function currentRunTargetStatus(rows: AgentTestMatrixRow[], target: "raw" | "compiled"): CurrentRunTargetStatus;
 export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourceDatasetConfig, deps?: {
     runCompileCommand?: typeof runCompileCommand;
 }): Promise<import("./compile.js").CompileCommandResult | null>;

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

@@ -1,19 +1,32 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { resolve } from "node:path";
-import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { SOURCE_FOLDER_CONFIG_FILE, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
 import { DEFAULT_COMPILED_NAME, describeCompileLoopSelection, promptSingleCompiledConfig, } from "./source-config-wizard.js";
 import { buildCompiledWorkflowOptions, chooseCompiledWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
 import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, } from "./compiled-flow.js";
-import { readSavedTestComparison } from "./test-flow.js";
+import { readCurrentSavedTestComparison, } from "./test-flow.js";
 import { runCompileCommand } from "./compile.js";
 import { runTestCommand } from "./test.js";
+export function currentRunTargetStatus(rows, target) {
+    const outcomes = rows
+        .map((row) => (target === "raw" ? row.rawOutcome : row.compiledOutcome))
+        .filter((outcome) => Boolean(outcome));
+    if (outcomes.length === 0)
+        return "missing";
+    const passFlags = outcomes.map((outcome) => outcome.result.totalCases > 0 && outcome.result.passedCases === outcome.result.totalCases);
+    if (passFlags.every(Boolean))
+        return "pass";
+    if (passFlags.some(Boolean))
+        return "mixed";
+    return "fail";
+}
 function describeSavedQuestions(dataset) {
     const count = dataset.checks.length;
     if (count === 0)
-        return "No saved truth checks yet";
-    return `${count} saved truth check${count === 1 ? "" : "s"}`;
+        return "No questions yet";
+    return `${count} question${count === 1 ? "" : "s"}`;
 }
 function printDatasetSummary(options) {
     const compiledConfig = options.builtCompiledPath
@@ -21,7 +34,7 @@ function printDatasetSummary(options) {
         : null;
     const workflowLabel = `${options.dataset.workflow ?? "interf"}${compiledConfig?.workflow_origin?.local_draft === true ? " (local draft)" : ""}`;
     p.log.info(`Dataset: ${options.dataset.name}`);
-    p.log.info(`Path: ${options.dataset.path === "." ? "source folder" : options.dataset.path}`);
+    p.log.info(`Source folder: ${options.dataset.path}`);
     if (options.dataset.about) {
         p.log.info(`About: ${options.dataset.about}`);
     }
@@ -31,58 +44,63 @@ function printDatasetSummary(options) {
         maxLoops: options.dataset.max_loops,
     }));
     p.log.info(describeSavedQuestions(options.dataset));
-    p.log.info(options.built ? "Compiled dataset is available." : "Compiled dataset has not been built yet.");
+    p.log.info(options.built ? "Portable context is available." : "Portable context has not been built yet.");
     if (options.latestComparison?.raw && options.latestComparison?.compiled) {
-        p.log.info(`Latest saved comparison: files-as-is ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}, compiled ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+        p.log.info(`Latest saved comparison: source files ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}, portable context ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
     }
     else if (options.latestComparison?.raw) {
-        p.log.info(`Latest files-as-is baseline: ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}.`);
+        p.log.info(`Latest saved source-files run: ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}.`);
     }
     else if (options.latestComparison?.compiled) {
-        p.log.info(`Latest compiled run: ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+        p.log.info(`Latest portable-context run: ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+    }
+    else if (options.latestComparisonStale) {
+        p.log.info("Saved test results are stale for the current questions.");
     }
     if (options.sourcePath !== process.cwd()) {
-        p.log.info(`Source folder: ${options.sourcePath}`);
+        p.log.info(`Project folder: ${options.sourcePath}`);
     }
 }
 async function promptDatasetAction(dataset, built, latestComparison) {
     const options = [];
     const hasSavedRawBaseline = Boolean(latestComparison?.raw);
-    const rawAlreadyPasses = latestComparison?.raw &&
+    const latestRawPasses = latestComparison?.raw &&
         latestComparison.raw.passed_cases === latestComparison.raw.total_cases;
     if (dataset.checks.length > 0) {
         options.push({
             value: "test",
             label: built
-                ? "Compare files-as-is and compiled dataset (Recommended)"
+                ? "Compare source files and portable context (Recommended)"
                 : hasSavedRawBaseline
-                    ? "Rerun the files-as-is baseline"
-                    : "Measure the files-as-is baseline (Recommended)",
+                    ? "Rerun the source-files baseline"
+                    : "Measure the source-files baseline (Recommended)",
             hint: built
-                ? "See whether preparation helps on the saved checks"
+                ? "See whether the portable context helps on the saved questions"
                 : hasSavedRawBaseline
-                    ? "Refresh the saved raw baseline on the current checks"
-                    : "See whether the raw dataset is already good enough before compiling",
+                    ? "Refresh the saved source-files baseline on the current questions"
+                    : "See whether the source files are already good enough before compiling",
         });
     }
     options.push({
         value: "compile",
-        label: built ? "Rebuild the compiled dataset" : "Build the compiled dataset",
+        label: built ? "Rebuild portable context" : "Build portable context",
         hint: built
-            ? "Refresh it from the current dataset files"
+            ? "Refresh it from the current source files"
             : dataset.checks.length > 0
-                ? rawAlreadyPasses
-                    ? "Optional: compare a compiled dataset against the already-passing baseline"
-                    : "Compile only if the baseline is not good enough"
+                ? latestRawPasses
+                    ? "Optional: build portable context for a side-by-side comparison with the latest saved source-files run"
+                    : hasSavedRawBaseline
+                        ? "Some questions still fail on the source files. Build portable context and compare it on the same questions"
+                        : "Build portable context and compare it on the same questions"
                 : "Build it first, then measure it later",
     }, {
         value: "dataset",
-        label: "Add another dataset",
+        label: "Add another setup",
         hint: "Add a separate folder, focus, or question set",
     }, {
         value: "edit",
-        label: "Edit truth checks and settings",
-        hint: "Update checks, focus, workflow, or compile mode",
+        label: "Edit questions and settings",
+        hint: "Update questions, focus, workflow, or compile mode",
     }, {
         value: "workflow",
         label: "Create workflow",
@@ -102,22 +120,68 @@ async function promptDatasetAction(dataset, built, latestComparison) {
 }
 function printDatasetRecommendation(dataset, built, latestComparison) {
     if (dataset.checks.length === 0) {
-        p.log.info("Recommended first step: save a few truth checks for this dataset.");
+        p.log.info("Recommended first step: save a few questions for this dataset.");
         return;
     }
     if (!built) {
         if (latestComparison?.raw) {
-            if (latestComparison.raw.passed_cases === latestComparison.raw.total_cases) {
-                p.log.info("Files-as-is already passes the saved checks. Compile only if you want a side-by-side comparison or a stronger compiled surface.");
-                return;
-            }
-            p.log.info(`Latest files-as-is baseline: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Compile if you want to improve it.`);
+            p.log.info(latestComparison.raw.passed_cases === latestComparison.raw.total_cases
+                ? `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Rerun the baseline if you want current numbers for a different agent set, or build portable context if you want a side-by-side comparison.`
+                : `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Some questions still fail on the source files. Build portable context if you want Interf to prepare context for this work and compare it on the same questions.`);
             return;
         }
-        p.log.info("Recommended first step: measure the files-as-is baseline before compiling.");
+        p.log.info("Recommended first step: measure the source-files baseline before compiling.");
         return;
     }
-    p.log.info("Recommended first step: compare the files-as-is baseline and the compiled dataset.");
+    p.log.info("Recommended first step: compare the source-files baseline and the portable context.");
+}
+async function promptPostBaselineAction(rows) {
+    const status = currentRunTargetStatus(rows, "raw");
+    const subject = rows.length === 1 ? "selected agent" : "selected agents";
+    if (status === "pass") {
+        p.log.info(`Source files passed on all ${subject} in this run.`);
+    }
+    else if (status === "mixed") {
+        p.log.info(`Source files were mixed across the ${subject} in this run.`);
+    }
+    else if (status === "fail") {
+        p.log.info(`Source files did not pass on the ${subject} in this run.`);
+    }
+    const compileRecommended = status !== "pass";
+    const selected = await p.select({
+        message: "What do you want to do next?",
+        options: [
+            {
+                value: "compile",
+                label: compileRecommended
+                    ? "Build portable context (Recommended)"
+                    : "Build portable context",
+                hint: compileRecommended
+                    ? status === "mixed"
+                        ? "Some selected agents still failed on the source files. Build portable context and compare it on the same questions"
+                        : "Build portable context and compare it on the same questions"
+                    : "Build portable context and compare it on the same questions",
+            },
+            {
+                value: "edit",
+                label: "Change questions and settings",
+                hint: "Revise the questions or setup settings before the next run",
+            },
+            {
+                value: "rerun",
+                label: "Rerun the source-files baseline",
+                hint: "Run the same questions again, including different local agents if you want",
+            },
+            {
+                value: "done",
+                label: "Stop here",
+                hint: "Leave the dataset as-is for now",
+            },
+        ],
+    });
+    if (p.isCancel(selected))
+        return null;
+    return selected;
 }
 async function chooseCompiledForWizard(options) {
     if (options.fixedCompiledName) {
@@ -129,7 +193,7 @@ async function chooseCompiledForWizard(options) {
     if (savedEntries.length === 1)
         return savedEntries[0]?.config ?? null;
     const selected = await p.select({
-        message: "Which dataset do you want to work with?",
+        message: "Which source folder setup do you want to work with?",
         options: [
             ...savedEntries.map((entry) => ({
                 value: entry.config.name,
@@ -143,7 +207,7 @@ async function chooseCompiledForWizard(options) {
             })),
             {
                 value: "__new__",
-                label: "Add another dataset",
+                label: "Add another setup",
                 hint: "Add a separate folder, focus, or question set",
             },
         ],
@@ -173,7 +237,6 @@ async function promptCompiledSetup(options) {
         projectPath: options.sourcePath,
         initial: options.initial,
         ...(options.fixedName ? { fixedName: options.fixedName } : {}),
-        skipNamePrompt: !options.fixedName && options.introStyle === "first",
         introStyle: options.introStyle,
         selectedWorkflowLabel: workflowLabel,
     });
@@ -191,10 +254,10 @@ async function promptCompiledSetup(options) {
         syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, compiledConfigWithWorkflow);
     }
     console.log();
-    console.log(chalk.green(`  ✓ Saved dataset setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
-    console.log(chalk.dim(`  Source folder: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Dataset: ${compiledConfigWithWorkflow.name}`));
-    console.log(chalk.dim(`  Path: ${compiledConfigWithWorkflow.path}`));
+    console.log(chalk.green(`  ✓ Saved setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
+    console.log(chalk.dim(`  Project folder: ${options.sourcePath}`));
+    console.log(chalk.dim(`  Setup: ${compiledConfigWithWorkflow.name}`));
+    console.log(chalk.dim(`  Source folder: ${compiledConfigWithWorkflow.path}`));
     console.log(chalk.dim(`  Workflow: ${workflowLabel}`));
     console.log(chalk.dim(`  Compile mode: ${describeCompileLoopSelection({
         maxAttempts: compiledConfigWithWorkflow.max_attempts,
@@ -213,13 +276,18 @@ export async function compileSelectedCompiled(sourcePath, compiledConfig, deps =
 }
 async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
-    const latestComparison = readSavedTestComparison(sourcePath, compiledConfig.name);
+    const { comparison: latestComparison, stale: latestComparisonStale, } = readCurrentSavedTestComparison({
+        projectPath: sourcePath,
+        datasetName: compiledConfig.name,
+        checks: compiledConfig.checks,
+    });
     printDatasetSummary({
         sourcePath,
         dataset: compiledConfig,
         built: Boolean(builtCompiledPath),
         builtCompiledPath,
         latestComparison,
+        latestComparisonStale,
     });
     printDatasetRecommendation(compiledConfig, Boolean(builtCompiledPath), latestComparison);
     const action = await promptDatasetAction(compiledConfig, Boolean(builtCompiledPath), latestComparison);
@@ -234,9 +302,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             sourcePath,
             datasetContext: {
                 config: compiledConfig,
-                datasetPath: compiledConfig.path === "."
-                    ? sourcePath
-                    : resolve(sourcePath, compiledConfig.path),
+                datasetPath: resolve(sourcePath, compiledConfig.path),
             },
         });
         if (typeof workflowId === "string") {
@@ -282,48 +348,66 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     if (action === "test") {
         if (compiledConfig.checks.length === 0) {
             process.exitCode = 1;
-            console.log(chalk.red(`  Dataset "${compiledConfig.name}" does not have any saved truth checks yet.`));
-            console.log(chalk.dim("  Run `interf`, edit this dataset, and add a few truth checks first."));
+            console.log(chalk.red(`  Setup "${compiledConfig.name}" does not have any questions yet.`));
+            console.log(chalk.dim("  Run `interf`, edit this setup, and add a few questions first."));
             console.log(chalk.dim("  Then rerun `interf test`."));
             return;
         }
-        const baselineRan = await runTestCommand({
-            sourcePath,
-            dataset: compiledConfig.name,
-            datasetConfig: compiledConfig,
-            ...(builtCompiledPath ? {} : { target: "raw" }),
-        });
-        if (!baselineRan) {
-            return;
-        }
         if (builtCompiledPath) {
-            return;
-        }
-        const latestComparison = readSavedTestComparison(sourcePath, compiledConfig.name);
-        if (latestComparison?.raw?.passed_cases === latestComparison?.raw?.total_cases) {
-            const compileAnyway = await p.confirm({
-                message: "The files-as-is baseline already passed. Compile this dataset anyway?",
-                initialValue: false,
+            const baselineRan = await runTestCommand({
+                sourcePath,
+                dataset: compiledConfig.name,
+                datasetConfig: compiledConfig,
+                target: "both",
             });
-            if (p.isCancel(compileAnyway) || !compileAnyway) {
+            if (!baselineRan) {
                 return;
             }
+            return;
         }
-        else {
-            const compileAndCompare = await p.confirm({
-                message: "Compile this dataset now and compare it on the same checks? (Recommended)",
-                initialValue: true,
+        while (true) {
+            const baselineCapture = { result: null };
+            const baselineRan = await runTestCommand({
+                sourcePath,
+                dataset: compiledConfig.name,
+                datasetConfig: compiledConfig,
+                target: "raw",
+                onComplete(result) {
+                    baselineCapture.result = result;
+                },
             });
-            if (p.isCancel(compileAndCompare) || !compileAndCompare) {
+            const baselineResult = baselineCapture.result;
+            if (!baselineRan || !baselineResult) {
+                return;
+            }
+            const nextAction = await promptPostBaselineAction(baselineResult.rows);
+            if (!nextAction || nextAction === "done") {
                 return;
             }
+            if (nextAction === "rerun") {
+                continue;
+            }
+            if (nextAction === "edit") {
+                const nextCompiled = await promptCompiledSetup({
+                    sourcePath,
+                    initial: compiledConfig,
+                    fixedName: compiledConfig.name,
+                    introStyle: "edit",
+                });
+                if (!nextCompiled) {
+                    return;
+                }
+                await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
+                return;
+            }
+            break;
         }
         const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
         if (!compileResult) {
             return;
         }
         if (compileResult.testedDuringCompile) {
-            p.log.info("This compile run already tested the compiled dataset on the saved checks.");
+            p.log.info("This compile run already checked the portable context on the saved questions.");
             p.log.info("Run `interf test` later if you want a fresh side-by-side comparison summary.");
             return;
         }
@@ -342,13 +426,14 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         if (compiledConfig.checks.length === 0)
             return;
         if (compileResult.testedDuringCompile) {
-            p.log.info("This compile run already ran the compiled-dataset test.");
-            return;
+            p.log.info("This compile run already checked the portable context on the compile agent.");
         }
         const runCompiledTest = await p.confirm({
-            message: builtCompiledPath
-                ? "Run files-as-is and compiled on the saved checks now?"
-                : "Compare files-as-is and compiled on the saved checks now?",
+            message: compileResult.testedDuringCompile
+                ? "Run a fresh source-files versus portable-context comparison now?"
+                : builtCompiledPath
+                    ? "Run source files and portable context on the saved questions now?"
+                    : "Compare source files and portable context on the saved questions now?",
             initialValue: true,
         });
         if (p.isCancel(runCompiledTest) || !runCompiledTest)
@@ -371,12 +456,12 @@ export const initCommand = {
 };
 export async function runInitCommand() {
     p.intro(chalk.bold("Interf"));
-    p.log.info("Measure whether your local agents can answer the questions your task depends on from the data in this folder, then prepare the dataset only if the raw files are not good enough.");
+    p.log.info("Interf prepares context for your agents from the source folder you choose. Start with the work, review the suggested questions, check the source files first, and build a local folder when the files need more structure.");
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
     const sourcePath = detected ? resolveSourceControlPath(detected.path) : cwd;
     if (detected) {
-        p.log.info(`Working from the source folder: ${sourcePath}`);
+        p.log.info(`Working from the project folder: ${sourcePath}`);
     }
     const savedEntries = listSavedCompiledEntries(sourcePath);
     if (savedEntries.length === 0) {

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

@@ -1,28 +1,28 @@
 import chalk from "chalk";
-import { detectInterf, resolveSourceControlPath, } from "../lib/interf.js";
+import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 import { listSavedCompiledEntries } from "./compiled-flow.js";
 export const listCommand = {
     command: "list",
-    describe: "List datasets in this project",
+    describe: "List saved setups in this project",
     handler: async () => {
         const detected = detectInterf(process.cwd());
         const sourcePath = detected ? resolveSourceControlPath(detected.path) : process.cwd();
         const datasets = listSavedCompiledEntries(sourcePath);
         if (datasets.length === 0) {
-            console.log(chalk.dim("  Nothing found. Start with `interf` or `interf init` to define a dataset and save truth checks."));
+            console.log(chalk.dim("  Nothing found. Start with `interf` or `interf init` to define a setup and save questions."));
             return;
         }
         console.log();
-        console.log(chalk.bold("  Datasets"));
+        console.log(chalk.bold("  Saved setups"));
         console.log();
         for (const dataset of datasets) {
             console.log(`  ${dataset.config.name}`);
             if (dataset.config.about) {
                 console.log(chalk.dim(`    task: ${dataset.config.about}`));
             }
-            console.log(chalk.dim(`    ${dataset.path ? "built" : "not built yet"} · path: ${dataset.config.path}`));
+            console.log(chalk.dim(`    ${dataset.path ? "built" : "not built yet"} · source folder: ${dataset.config.path}`));
             console.log(chalk.dim(`    workflow: ${dataset.config.workflow ?? "interf"}${dataset.localDraft ? " (local draft)" : ""}`));
-            console.log(chalk.dim(`    checks: ${dataset.config.checks.length}`));
+            console.log(chalk.dim(`    questions: ${dataset.config.checks.length}`));
         }
     },
 };

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

@@ -1,6 +1,6 @@
 import chalk from "chalk";
-import { detectInterf } from "../lib/interf.js";
-import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
+import { detectInterf } from "../../packages/project-model/interf.js";
+import { resetCompiledGeneratedState } from "../../packages/compiler/reset.js";
 export const resetCommand = {
     command: "reset <scope>",
     describe: "Reset generated compiled state while keeping `raw/` and the local workflow package",
@@ -12,11 +12,11 @@ export const resetCommand = {
         const detected = detectInterf(process.cwd());
         if (!detected) {
             process.exitCode = 1;
-            console.log(chalk.red("Run this from inside a compiled dataset."));
+            console.log(chalk.red("Run this from inside a compiled context."));
             return;
         }
         const compiledPath = detected.path;
         resetCompiledGeneratedState(compiledPath, argv.scope);
-        console.log(chalk.green("  Compiled reset complete."));
+        console.log(chalk.green("  Compiled-context reset complete."));
     },
 };

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

@@ -1,8 +1,8 @@
-import type { SourceTruthCheck, SourceDatasetConfig } from "../lib/schema.js";
+import { type SourceDatasetConfig, type SourceTruthCheck } from "../../packages/project-model/index.js";
 export declare const DEFAULT_COMPILED_NAME = "dataset1";
-export declare const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
+export declare const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this source folder";
 export declare const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board-prep questions from these files, chart reads from this report, or tax review from these exports.";
+export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
 export declare const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
 export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export declare const DEFAULT_SELF_IMPROVING_LOOPS = 3;
@@ -11,6 +11,12 @@ export interface CompileLoopSelection {
     max_attempts?: number;
     max_loops?: number;
 }
+export declare function normalizeDatasetPathForConfig(projectPath: string, value: string): string;
+export declare function listDatasetFolderChoices(cwd?: string): Array<{
+    value: string;
+    label: string;
+    hint: string;
+}>;
 export declare function defaultDatasetPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", cwd?: string): string;
 export declare function datasetAboutPromptMessage(introStyle: "first" | "additional" | "edit"): string;
 export declare function resolveCompileLoopMode(maxAttempts?: number | null, maxLoops?: number | null): CompileLoopMode;
@@ -41,7 +47,6 @@ export declare function promptSingleCompiledConfig(options?: {
     initial?: Partial<Pick<SourceDatasetConfig, "name" | "path" | "about" | "checks" | "max_attempts" | "max_loops">>;
     fixedName?: string;
     skipAboutPrompt?: boolean;
-    skipNamePrompt?: boolean;
     introStyle?: "first" | "additional" | "edit";
     selectedWorkflowLabel?: string;
 }): Promise<SourceDatasetConfig | null>;