@interf/compiler 0.5.1 → 0.6.1

package/dist/commands/create.js

@@ -1,15 +1,13 @@
 import chalk from "chalk";
 import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, } from "../lib/interf.js";
+import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, resolveSourceControlPath, } from "../lib/interf.js";
 import { slugify } from "../lib/util.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { listSourceDatasetConfigs, loadSourceFolderConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
 import { createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { findBuiltCompiledPath, } from "./compiled-flow.js";
 import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredCompiledCompile } from "./compile.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
@@ -41,6 +39,56 @@ async function selectCreateTarget() {
         ],
     });
 }
+async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
+    const config = loadSourceFolderConfig(sourcePath);
+    const datasets = listSourceDatasetConfigs(config);
+    if (datasets.length === 0) {
+        p.log.info(`Created workflow "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, add a dataset, then assign workflow "${workflowId}" from that dataset menu.`);
+        return;
+    }
+    const assignNow = await p.confirm({
+        message: "Assign this workflow to a dataset now? (Recommended)",
+        initialValue: true,
+    });
+    if (p.isCancel(assignNow) || !assignNow) {
+        p.log.info(`Created workflow "${workflowId}".`);
+        p.log.info(`Next: run \`interf\`, open a dataset, and assign workflow "${workflowId}" from that dataset menu.`);
+        return;
+    }
+    let targetDataset = datasets[0] ?? null;
+    if (datasets.length > 1) {
+        const selected = await p.select({
+            message: "Which dataset should use this workflow?",
+            options: datasets.map((dataset) => ({
+                value: dataset.name,
+                label: dataset.name,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} saved truth check${dataset.checks.length === 1 ? "" : "s"}`}`,
+            })),
+        });
+        if (p.isCancel(selected))
+            return;
+        targetDataset = datasets.find((dataset) => dataset.name === selected) ?? null;
+    }
+    if (!targetDataset)
+        return;
+    const nextConfig = {
+        ...targetDataset,
+        workflow: workflowId,
+    };
+    upsertSourceDatasetConfig(sourcePath, nextConfig, {
+        matchName: targetDataset.name,
+    });
+    const builtCompiledPath = findBuiltCompiledPath(sourcePath, targetDataset.name);
+    if (builtCompiledPath) {
+        syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+    }
+    p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
+    if (builtCompiledPath) {
+        p.log.info("The active local copy for that built dataset lives under `.interf/workflow/`.");
+    }
+    p.log.info("Next: run `interf compile`, then `interf test`.");
+}
 export const createCommand = {
     command: "create [type]",
     describe: "Create a dataset entry or reusable workflow",
@@ -65,7 +113,14 @@ export const createCommand = {
             type = selected;
         }
         if (type === "workflow") {
-            await createWorkflowWizard({ sourcePath: process.cwd() });
+            const detected = detectInterf(process.cwd());
+            const workflowId = await createWorkflowWizard({
+                sourcePath: detected ? resolveSourceControlPath(detected.path) : process.cwd(),
+                executionProfile,
+            });
+            if (typeof workflowId === "string") {
+                await maybeAssignWorkflowToDataset(detected ? resolveSourceControlPath(detected.path) : process.cwd(), workflowId);
+            }
             return;
         }
         await createCompiledWizard({ executionProfile });
@@ -86,10 +141,9 @@ export async function createCompiledWizard(options = {}) {
     if (existing.length > 0) {
         p.log.info(`This project already has ${existing.length} compiled dataset${existing.length === 1 ? "" : "s"}. Add another only when you need a separate folder, truth checks, or focus.`);
     }
-    p.log.info("Interf Compiler measures one dataset at a time. Start with truth checks and a baseline, then build a compiled dataset only when you need it.");
+    p.log.info("Interf works one dataset at a time. Start with the task, truth checks, and a baseline, then build a compiled dataset only when you need it.");
     const existingConfig = loadSourceFolderConfig(cwd);
     const suggestedName = slugify(defaultCompiledNameForSource(cwd) || basename(cwd)) || DEFAULT_COMPILED_NAME;
-    const workflowId = "interf";
     const draft = await promptSingleCompiledConfig({
         projectPath: cwd,
         initial: { name: suggestedName },
@@ -99,7 +153,7 @@ export async function createCompiledWizard(options = {}) {
         return;
     const configToSave = {
         ...draft,
-        workflow: workflowId,
+        workflow: "interf",
     };
     const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
     if (existingNames.has(configToSave.name)) {
@@ -108,55 +162,8 @@ export async function createCompiledWizard(options = {}) {
         return;
     }
     upsertSourceDatasetConfig(cwd, configToSave);
-    const compileNow = await p.confirm({
-        message: "Build the compiled dataset now? (Recommended)",
-        initialValue: true,
-    });
-    if (p.isCancel(compileNow) || !compileNow) {
-        p.outro(configToSave.checks.length > 0
-            ? "Next:\n  interf test\n  interf compile"
-            : "Next:\n  interf or interf init");
-        return;
-    }
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
-        executionProfile: options.executionProfile,
-        purpose: "compile",
-    });
-    if (!executor && !error) {
-        return;
-    }
-    if (!executor) {
-        process.exitCode = 1;
-        p.log.error(error ?? "No coding agent detected.");
-        return;
-    }
-    const spinner = p.spinner();
-    spinner.start("Preparing compiled dataset...");
-    let compiledPath = "";
-    try {
-        compiledPath = ensureCompiledFromConfig(cwd, configToSave);
-        spinner.stop("Compiled dataset target ready.");
-    }
-    catch (error) {
-        spinner.stop("Compiled dataset target preparation failed.");
-        process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : String(error));
-        return;
-    }
-    await compileCompiledAfterCreate(executor, cwd, configToSave, compiledPath, options.executionProfile);
-}
-async function compileCompiledAfterCreate(executor, sourcePath, datasetConfig, compiledPath, executionProfile) {
-    const compiled = await runConfiguredCompiledCompile({
-        executor,
-        compiledPath,
-        sourcePath,
-        compiledConfig: datasetConfig,
-        executionProfile,
-        maxAttemptsOverride: null,
-        maxLoopsOverride: null,
-    });
-    if (!compiled)
-        process.exitCode = 1;
-    return compiled;
+    p.outro(configToSave.checks.length > 0
+        ? "Saved dataset.\nNext:\n  interf test\n  interf compile"
+        : "Saved dataset.\nNext:\n  interf or interf init");
 }
-export { formatWorkflowLabel, chooseCompiledWorkflow, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";
+export { formatWorkflowLabel, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";

package/dist/commands/dataset-selection.d.ts

@@ -0,0 +1,6 @@
+import type { SourceDatasetConfig } from "../lib/schema.js";
+export declare function resolveConfiguredDatasetSelection(options: {
+    sourcePath: string;
+    requestedDatasetName?: string | null;
+    hintedDatasetConfig?: SourceDatasetConfig | null;
+}): SourceDatasetConfig | null;

package/dist/commands/dataset-selection.js

@@ -0,0 +1,11 @@
+import { findSavedCompiledConfig } from "./compiled-flow.js";
+export function resolveConfiguredDatasetSelection(options) {
+    if (options.hintedDatasetConfig &&
+        (!options.requestedDatasetName || options.hintedDatasetConfig.name === options.requestedDatasetName)) {
+        return options.hintedDatasetConfig;
+    }
+    if (!options.requestedDatasetName) {
+        return null;
+    }
+    return findSavedCompiledConfig(options.sourcePath, options.requestedDatasetName);
+}

package/dist/commands/default.js

@@ -4,8 +4,8 @@ import { runInitCommand } from "./init.js";
 function printStaticLanding() {
     const config = loadUserConfig();
     console.log();
-    console.log(chalk.bold("  Interf Compiler"));
-    console.log(chalk.dim("  Define truth checks, measure files-as-is, then compile only if it improves accuracy."));
+    console.log(chalk.bold("  Interf"));
+    console.log(chalk.dim("  Define the task, save truth checks, measure raw files first, then compile only if they are not good enough."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));
@@ -20,7 +20,7 @@ function printStaticLanding() {
     console.log(chalk.dim("  More:"));
     console.log(chalk.dim("    interf init"));
     console.log(chalk.dim("    interf create workflow"));
-    console.log(chalk.dim("    interf doctor"));
+    console.log(chalk.dim("    interf doctor --live"));
     console.log(chalk.dim("    interf --help"));
     console.log();
 }

package/dist/commands/doctor.js

@@ -12,7 +12,7 @@ function iconFor(status) {
 }
 export const doctorCommand = {
     command: "doctor",
-    describe: "Check local executor setup before a real compile",
+    describe: "Check local executor setup before a real local run",
     builder: (yargs) => yargs
         .option("live", {
         type: "boolean",
@@ -31,7 +31,7 @@ export const doctorCommand = {
         if (config) {
             checks.push({
                 id: "config",
-                label: "Interf Compiler setup",
+                label: "Interf setup",
                 status: "pass",
                 message: `Configured default agent: ${config.agent}`,
             });
@@ -39,9 +39,9 @@ export const doctorCommand = {
         else {
             checks.push({
                 id: "config",
-                label: "Interf Compiler setup",
+                label: "Interf setup",
                 status: "warn",
-                message: "No saved Interf Compiler setup found. `interf` or `interf init` is recommended for deterministic local runs.",
+                message: "No saved Interf setup found. `interf` or `interf init` is recommended for deterministic local runs.",
             });
         }
         if (!agent) {
@@ -56,7 +56,7 @@ export const doctorCommand = {
             }
             else {
                 console.log();
-                console.log(chalk.bold("  Interf Compiler doctor"));
+                console.log(chalk.bold("  Interf doctor"));
                 console.log();
                 for (const check of checks) {
                     console.log(`  ${iconFor(check.status)} ${check.label}: ${check.message}`);
@@ -79,7 +79,7 @@ export const doctorCommand = {
                 label: "Live executor preflight",
                 status: preflight.ok ? "pass" : "fail",
                 message: preflight.ok
-                    ? `${agent.displayName} accepted Interf Compiler's automated run invocation`
+                    ? `${agent.displayName} accepted Interf's automated run invocation`
                     : preflight.timedOut
                         ? `${agent.displayName} timed out during preflight`
                         : preflight.error ?? `${agent.displayName} could not complete the preflight run`,
@@ -98,7 +98,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 compile.",
+                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a truth-check draft, workflow authoring run, test, or compile.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");
@@ -115,7 +115,7 @@ export const doctorCommand = {
         }
         else {
             console.log();
-            console.log(chalk.bold("  Interf Compiler doctor"));
+            console.log(chalk.bold("  Interf doctor"));
             console.log();
             for (const check of checks) {
                 console.log(`  ${iconFor(check.status)} ${check.label}: ${check.message}`);

package/dist/commands/executor-flow.d.ts

@@ -21,7 +21,7 @@ export declare function promptForTestAgents(): Promise<{
 export declare function resolveOrConfigureLocalExecutor(options?: {
     preflight?: boolean;
     executionProfile?: WorkflowExecutionProfile;
-    purpose?: "compile" | "test" | "draft";
+    purpose?: "compile" | "test" | "draft" | "workflow";
 }): Promise<{
     executor: WorkflowExecutor | null;
     error?: string;

package/dist/commands/executor-flow.js

@@ -25,7 +25,6 @@ function persistSelectedAgent(selectedName) {
         agent: selected.name,
         agentCommand: selected.command,
         skillsInstalled: current?.skillsInstalled ?? false,
-        ...(current?.viewer ? { viewer: current.viewer } : {}),
         initialized: current?.initialized ?? new Date().toISOString(),
     });
 }
@@ -89,7 +88,11 @@ export async function promptForTestAgents() {
     return { agents, cancelled: false };
 }
 async function promptForRunAgent(purpose) {
-    const purposeLabel = purpose === "draft" ? "truth-check draft" : purpose;
+    const purposeLabel = purpose === "draft"
+        ? "truth-check draft"
+        : purpose === "workflow"
+            ? "workflow authoring"
+            : purpose;
     const detected = supportedDetectedAgents();
     if (detected.length === 0)
         return { selected: false, cancelled: false };

package/dist/commands/init.d.ts

@@ -1,3 +1,8 @@
 import type { CommandModule } from "yargs";
+import type { SourceDatasetConfig } from "../lib/schema.js";
+import { runCompileCommand } from "./compile.js";
+export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourceDatasetConfig, deps?: {
+    runCompileCommand?: typeof runCompileCommand;
+}): Promise<import("./compile.js").CompileCommandResult | null>;
 export declare const initCommand: CommandModule;
 export declare function runInitCommand(): Promise<void>;

package/dist/commands/init.js

@@ -1,13 +1,13 @@
 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, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { SOURCE_FOLDER_CONFIG_FILE, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/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 { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, } from "./compiled-flow.js";
 import { readSavedTestComparison } from "./test-flow.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredCompiledCompile } from "./compile.js";
+import { runCompileCommand } from "./compile.js";
 import { runTestCommand } from "./test.js";
 function describeSavedQuestions(dataset) {
     const count = dataset.checks.length;
@@ -15,19 +15,13 @@ function describeSavedQuestions(dataset) {
         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);
-}
 function printDatasetSummary(options) {
     const compiledConfig = options.builtCompiledPath
         ? readInterfConfig(options.builtCompiledPath)
         : 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(`Path: ${options.dataset.path === "." ? "source folder" : options.dataset.path}`);
     if (options.dataset.about) {
         p.log.info(`About: ${options.dataset.about}`);
     }
@@ -60,12 +54,12 @@ async function promptDatasetAction(dataset, built, latestComparison) {
         options.push({
             value: "test",
             label: built
-                ? "Measure files-as-is and compiled accuracy (Recommended)"
+                ? "Compare files-as-is and compiled dataset (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 preparation helps on the saved checks"
                 : hasSavedRawBaseline
                     ? "Refresh the saved raw baseline on the current checks"
                     : "See whether the raw dataset is already good enough before compiling",
@@ -162,6 +156,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,9 +166,9 @@ 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,
@@ -206,31 +202,14 @@ 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);
@@ -251,7 +230,30 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         return;
     }
     if (action === "workflow") {
-        await createWorkflowWizard({ sourcePath });
+        const workflowId = await createWorkflowWizard({
+            sourcePath,
+            datasetContext: {
+                config: compiledConfig,
+                datasetPath: compiledConfig.path === "."
+                    ? sourcePath
+                    : 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") {
@@ -316,8 +318,13 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
                 return;
             }
         }
-        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 dataset on the saved checks.");
+            p.log.info("Run `interf test` later if you want a fresh side-by-side comparison summary.");
             return;
         }
         await runTestCommand({
@@ -329,12 +336,13 @@ 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.");
+        if (compileResult.testedDuringCompile) {
+            p.log.info("This compile run already ran the compiled-dataset test.");
             return;
         }
         const runCompiledTest = await p.confirm({
@@ -356,19 +364,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("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.");
     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 source folder: ${sourcePath}`);
     }
     const savedEntries = listSavedCompiledEntries(sourcePath);
     if (savedEntries.length === 0) {

package/dist/commands/list.js

@@ -9,7 +9,7 @@ export const listCommand = {
         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 dataset and save truth checks."));
             return;
         }
         console.log();
@@ -17,8 +17,11 @@ export const listCommand = {
         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"} · path: ${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/reset.js

@@ -3,7 +3,7 @@ import { detectInterf } from "../lib/interf.js";
 import { resetCompiledGeneratedState } from "../lib/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"],

package/dist/commands/source-config-wizard.d.ts

@@ -2,9 +2,9 @@ import type { SourceTruthCheck, SourceDatasetConfig } from "../lib/schema.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_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 {