@interf/compiler 0.5.1 → 0.6.3

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

@@ -1,25 +1,32 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { resolve } from "node:path";
+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, ensureCompiledFromConfig, } from "./compiled-flow.js";
-import { readSavedTestComparison } from "./test-flow.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredCompiledCompile } from "./compile.js";
+import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, } from "./compiled-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"}`;
-}
-function compileModeAlreadyRanSavedTests(dataset) {
-    if (dataset.checks.length === 0)
-        return false;
-    return (resolveDatasetCompileMaxAttempts(dataset) != null ||
-        resolveDatasetCompileMaxLoops(dataset) != null);
+        return "No checks yet";
+    return `${count} check${count === 1 ? "" : "s"}`;
 }
 function printDatasetSummary(options) {
     const compiledConfig = options.builtCompiledPath
@@ -27,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 === "." ? "project root" : options.dataset.path}`);
+    p.log.info(`Source folder: ${options.dataset.path}`);
     if (options.dataset.about) {
         p.log.info(`About: ${options.dataset.about}`);
     }
@@ -37,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
-                ? "Measure files-as-is and compiled accuracy (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
-                ? "Compare whether the compiled dataset is actually better 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",
@@ -108,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) {
@@ -135,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,
@@ -149,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",
             },
         ],
@@ -162,6 +220,8 @@ async function chooseCompiledForWizard(options) {
 }
 async function promptCompiledSetup(options) {
     let workflowId = options.initial?.workflow ?? "interf";
+    let workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
+        .find((option) => option.value === workflowId)?.label ?? workflowId;
     if (options.introStyle === "edit") {
         const workflowChoice = await chooseCompiledWorkflow(options.sourcePath, {
             currentWorkflowId: workflowId,
@@ -170,14 +230,13 @@ async function promptCompiledSetup(options) {
         if (p.isCancel(workflowChoice))
             return null;
         workflowId = workflowChoice;
+        workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
+            .find((option) => option.value === workflowId)?.label ?? workflowId;
     }
-    const workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
-        .find((option) => option.value === workflowId)?.label ?? workflowId;
     const compiledConfig = await promptSingleCompiledConfig({
         projectPath: options.sourcePath,
         initial: options.initial,
         ...(options.fixedName ? { fixedName: options.fixedName } : {}),
-        skipNamePrompt: !options.fixedName && options.introStyle === "first",
         introStyle: options.introStyle,
         selectedWorkflowLabel: workflowLabel,
     });
@@ -195,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,
@@ -206,41 +265,29 @@ async function promptCompiledSetup(options) {
     })}`));
     return compiledConfigWithWorkflow;
 }
-async function compileSelectedCompiled(sourcePath, compiledConfig) {
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
-        purpose: "compile",
-    });
-    if (!executor && !error) {
-        return null;
-    }
-    if (!executor) {
-        process.exitCode = 1;
-        console.log(chalk.red(error ?? "No coding agent detected."));
-        return null;
-    }
-    const compiledPath = ensureCompiledFromConfig(sourcePath, compiledConfig);
-    const compiled = await runConfiguredCompiledCompile({
-        executor,
-        compiledPath,
+export async function compileSelectedCompiled(sourcePath, compiledConfig, deps = {}) {
+    return (deps.runCompileCommand ?? runCompileCommand)({
         sourcePath,
-        compiledConfig,
-        maxAttemptsOverride: null,
-        maxLoopsOverride: null,
+        dataset: compiledConfig.name,
+        datasetConfig: compiledConfig,
+        skipConfirm: true,
+        skipDatasetBanner: true,
     });
-    if (!compiled) {
-        return null;
-    }
-    return compiledPath;
 }
 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);
@@ -251,7 +298,28 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         return;
     }
     if (action === "workflow") {
-        await createWorkflowWizard({ sourcePath });
+        const workflowId = await createWorkflowWizard({
+            sourcePath,
+            datasetContext: {
+                config: compiledConfig,
+                datasetPath: resolve(sourcePath, compiledConfig.path),
+            },
+        });
+        if (typeof workflowId === "string") {
+            const nextConfig = {
+                ...compiledConfig,
+                workflow: workflowId,
+            };
+            upsertSourceDatasetConfig(sourcePath, nextConfig, {
+                matchName: compiledConfig.name,
+            });
+            const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
+            if (builtCompiledPath) {
+                syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+            }
+            p.log.info(`Assigned workflow "${workflowId}" to dataset "${compiledConfig.name}".`);
+            p.log.info("Next: run `interf compile`, then `interf test`.");
+        }
         return;
     }
     if (action === "dataset") {
@@ -280,44 +348,67 @@ 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 compiledPath = await compileSelectedCompiled(sourcePath, compiledConfig);
-        if (!compiledPath) {
+        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
+        if (!compileResult) {
+            return;
+        }
+        if (compileResult.testedDuringCompile) {
+            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;
         }
         await runTestCommand({
@@ -329,18 +420,20 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         return;
     }
     if (action === "compile") {
-        if (!await compileSelectedCompiled(sourcePath, compiledConfig))
+        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
+        if (!compileResult)
             return;
         if (compiledConfig.checks.length === 0)
             return;
-        if (compileModeAlreadyRanSavedTests(compiledConfig)) {
-            p.log.info("Saved compile mode already ran the compiled-dataset test.");
-            return;
+        if (compileResult.testedDuringCompile) {
+            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)
@@ -356,19 +449,19 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
 }
 export const initCommand = {
     command: "init",
-    describe: "Open the root-folder wizard for this folder",
+    describe: "Open the dataset wizard for this folder",
     handler: async () => {
         await runInitCommand();
     },
 };
 export async function runInitCommand() {
-    p.intro(chalk.bold("Interf Compiler"));
-    p.log.info("Measure how accurately your local agents answer from the dataset in this folder, then compile only if it helps.");
+    p.intro(chalk.bold("Interf"));
+    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 dataset control plane: ${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,24 +1,27 @@
 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`, run `interf test`, then compile a dataset when needed."));
+            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}`);
-            console.log(chalk.dim(`    ${dataset.path ?? "not built yet"}`));
-            console.log(chalk.dim(`    workflow: ${dataset.config.workflow ?? "interf"}`));
+            if (dataset.config.about) {
+                console.log(chalk.dim(`    task: ${dataset.config.about}`));
+            }
+            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,9 +1,9 @@
 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 source files",
+    describe: "Reset generated compiled state while keeping `raw/` and the local workflow package",
     builder: (yargs) => yargs.positional("scope", {
         type: "string",
         choices: ["compile", "all"],
@@ -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,16 +1,22 @@
-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: forward-demand metrics, board-prep questions, or chart reads from this dataset.";
+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";
-export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export declare const DEFAULT_SELF_IMPROVING_LOOPS = 3;
 export type CompileLoopMode = "once" | "retry" | "self-improving";
 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>;