@interf/compiler 0.6.1 → 0.6.3

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 checks yet";
+    return `${count} check${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,57 +44,62 @@ 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 ? "Compiled context is available." : "Compiled 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: files-as-is ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}, compiled 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 files-as-is 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 compiled-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 checks.");
     }
     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 files-as-is and compiled context (Recommended)"
                 : hasSavedRawBaseline
                     ? "Rerun the files-as-is baseline"
                     : "Measure the files-as-is baseline (Recommended)",
             hint: built
-                ? "See whether preparation helps on the saved checks"
+                ? "See whether the compiled context helps on the checks"
                 : hasSavedRawBaseline
                     ? "Refresh the saved raw baseline on the current checks"
-                    : "See whether the raw dataset is already good enough before compiling",
+                    : "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 the compiled context" : "Build the compiled 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 the compiled context for a side-by-side comparison with the latest saved raw run"
+                    : hasSavedRawBaseline
+                        ? "Some checks still fail on the source files. Build a context folder and compare it on the same checks"
+                        : "Build a context folder and compare it on the same checks"
                 : "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",
+        label: "Edit checks and settings",
         hint: "Update checks, focus, workflow, or compile mode",
     }, {
         value: "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 checks 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 files-as-is run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Rerun the baseline if you want current numbers for a different agent set, or build the context folder if you want a side-by-side comparison.`
+                : `Latest files-as-is run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Some checks still fail on the source files. Build the context folder if you want Interf to prepare the task context and compare it on the same checks.`);
             return;
         }
         p.log.info("Recommended first step: measure the files-as-is 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 files-as-is baseline and the compiled 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(`Files-as-is passed on all ${subject} in this run.`);
+    }
+    else if (status === "mixed") {
+        p.log.info(`Files-as-is was mixed across the ${subject} in this run.`);
+    }
+    else if (status === "fail") {
+        p.log.info(`Files-as-is 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 the compiled context (Recommended)"
+                    : "Build the compiled context",
+                hint: compileRecommended
+                    ? status === "mixed"
+                        ? "Some selected agents still failed on the raw files. Build the compiled context and compare it on the same checks"
+                        : "Build a compiled context and compare it on the same checks"
+                    : "Build a compiled context and compare it on the same checks",
+            },
+            {
+                value: "edit",
+                label: "Change checks and settings",
+                hint: "Revise the checks or setup settings before the next run",
+            },
+            {
+                value: "rerun",
+                label: "Rerun the files-as-is baseline",
+                hint: "Run the same checks 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 checks yet.`));
+            console.log(chalk.dim("  Run `interf`, edit this setup, and add a few checks 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 tested the compiled context on the checks.");
             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 tested the compiled 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 files-as-is versus compiled-context comparison now?"
+                : builtCompiledPath
+                    ? "Run files-as-is and the compiled context on the checks now?"
+                    : "Compare files-as-is and the compiled context on the checks 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 task context for your agents from the source folder you choose. Start with the task and a few checks, test the source files first, and compile a context folder when the current context is not good enough.");
     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,26 +1,26 @@
 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 checks."));
             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}`));
         }

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/project-model/compiled-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,6 +1,6 @@
-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_DATASET_PATH_PLACEHOLDER = "./dataset1";
@@ -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>;