@interf/compiler 0.4.0 → 0.5.0

package/dist/commands/init.js

@@ -1,76 +1,94 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, resolveWorkspaceCompileMaxAttempts, resolveWorkspaceCompileMaxLoops, syncWorkspaceInterfConfigFromSourceWorkspaceConfig, upsertSourceWorkspaceConfig, } from "../lib/source-config.js";
-import { DEFAULT_WORKSPACE_NAME, describeCompileLoopSelection, promptSingleWorkspaceConfig, } from "./source-config-wizard.js";
-import { buildWorkspaceWorkflowOptions, chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { findBuiltWorkspacePath, findSavedWorkspaceConfig, listSavedWorkspaceEntries, ensureWorkspaceFromConfig, } from "./workspace-flow.js";
-import { printSavedTestOutcome, printSavedTestComparison, questionPassRate, runSavedRawTest, runSavedWorkspaceTest, } from "./test-flow.js";
+import { SOURCE_FOLDER_CONFIG_FILE, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, 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 { readSavedTestComparison } from "./test-flow.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredWorkspaceCompile } from "./compile.js";
-function describeSavedQuestions(workspace) {
-    const count = workspace.checks.length;
+import { runConfiguredCompiledCompile } from "./compile.js";
+import { runTestCommand } from "./test.js";
+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(workspace) {
-    if (workspace.checks.length === 0)
+function compileModeAlreadyRanSavedTests(dataset) {
+    if (dataset.checks.length === 0)
         return false;
-    return (resolveWorkspaceCompileMaxAttempts(workspace) != null ||
-        resolveWorkspaceCompileMaxLoops(workspace) != null);
+    return (resolveDatasetCompileMaxAttempts(dataset) != null ||
+        resolveDatasetCompileMaxLoops(dataset) != null);
 }
-function printWorkspaceSummary(options) {
-    const workspaceConfig = options.builtWorkspacePath
-        ? readInterfConfig(options.builtWorkspacePath)
+function printDatasetSummary(options) {
+    const compiledConfig = options.builtCompiledPath
+        ? readInterfConfig(options.builtCompiledPath)
         : null;
-    const workflowLabel = `${options.workspace.workflow ?? "interf"}${workspaceConfig?.workflow_origin?.local_draft === true ? " (local draft)" : ""}`;
-    p.log.info(`Workspace: ${options.workspace.name}`);
-    if (options.workspace.about) {
-        p.log.info(`Focus: ${options.workspace.about}`);
+    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}`);
+    if (options.dataset.about) {
+        p.log.info(`About: ${options.dataset.about}`);
     }
     p.log.info(`Workflow: ${workflowLabel}`);
     p.log.info(describeCompileLoopSelection({
-        maxAttempts: options.workspace.max_attempts,
-        maxLoops: options.workspace.max_loops,
+        maxAttempts: options.dataset.max_attempts,
+        maxLoops: options.dataset.max_loops,
     }));
-    p.log.info(describeSavedQuestions(options.workspace));
-    p.log.info(options.built ? "Compiled workspace is available." : "Compiled workspace has not been built yet.");
+    p.log.info(describeSavedQuestions(options.dataset));
+    p.log.info(options.built ? "Compiled dataset is available." : "Compiled dataset 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}.`);
+    }
+    else if (options.latestComparison?.raw) {
+        p.log.info(`Latest files-as-is baseline: ${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}.`);
+    }
     if (options.sourcePath !== process.cwd()) {
         p.log.info(`Source folder: ${options.sourcePath}`);
     }
 }
-async function promptWorkspaceAction(workspace, built) {
-    const options = [
-        {
-            value: "edit",
-            label: "Edit workflow, truth checks, and compile mode",
-            hint: "Update this workspace setup",
-        },
-    ];
-    if (workspace.checks.length > 0) {
-        options.push({
-            value: "raw",
-            label: "Run a baseline test on the raw files",
-            hint: "Measure current performance before compilation",
-        });
-    }
-    options.push({
-        value: "compile",
-        label: built ? "Refresh the compiled workspace" : "Compile the workspace",
-        hint: built ? "Rebuild it from the current files" : "Build it for the first time",
-    });
-    if (workspace.checks.length > 0 && built) {
+async function promptDatasetAction(dataset, built, latestComparison) {
+    const options = [];
+    const hasSavedRawBaseline = Boolean(latestComparison?.raw);
+    const rawAlreadyPasses = latestComparison?.raw &&
+        latestComparison.raw.passed_cases === latestComparison.raw.total_cases;
+    if (dataset.checks.length > 0) {
         options.push({
             value: "test",
-            label: "Run the saved test on the compiled workspace",
-            hint: "Score this workspace on its saved truth checks",
+            label: built
+                ? "Measure files-as-is and compiled accuracy (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"
+                : hasSavedRawBaseline
+                    ? "Refresh the saved raw baseline on the current checks"
+                    : "See whether the raw dataset is already good enough before compiling",
         });
     }
     options.push({
-        value: "workspace",
-        label: "Create another workspace",
-        hint: "Add a separate focus or question set",
+        value: "compile",
+        label: built ? "Rebuild the compiled dataset" : "Build the compiled dataset",
+        hint: built
+            ? "Refresh it from the current dataset 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"
+                : "Build it first, then measure it later",
+    }, {
+        value: "dataset",
+        label: "Add another dataset",
+        hint: "Add a separate folder, focus, or question set",
+    }, {
+        value: "edit",
+        label: "Edit truth checks and settings",
+        hint: "Update checks, focus, workflow, or compile mode",
     }, {
         value: "workflow",
         label: "Create workflow",
@@ -88,22 +106,42 @@ async function promptWorkspaceAction(workspace, built) {
         return null;
     return selected;
 }
-async function chooseWorkspaceForWizard(options) {
-    if (options.fixedWorkspaceName) {
-        return findSavedWorkspaceConfig(options.sourcePath, options.fixedWorkspaceName);
+function printDatasetRecommendation(dataset, built, latestComparison) {
+    if (dataset.checks.length === 0) {
+        p.log.info("Recommended first step: save a few truth 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.`);
+            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.");
+}
+async function chooseCompiledForWizard(options) {
+    if (options.fixedCompiledName) {
+        return findSavedCompiledConfig(options.sourcePath, options.fixedCompiledName);
     }
-    const savedEntries = listSavedWorkspaceEntries(options.sourcePath);
+    const savedEntries = listSavedCompiledEntries(options.sourcePath);
     if (savedEntries.length === 0)
         return null;
     if (savedEntries.length === 1)
         return savedEntries[0]?.config ?? null;
     const selected = await p.select({
-        message: "Which workspace do you want to work with?",
+        message: "Which dataset do you want to work with?",
         options: [
             ...savedEntries.map((entry) => ({
                 value: entry.config.name,
                 label: entry.config.name,
                 hint: [
+                    `path ${entry.config.path}`,
                     entry.config.about ?? describeSavedQuestions(entry.config),
                     `workflow ${entry.config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`,
                     entry.path ? "built" : "not built yet",
@@ -111,8 +149,8 @@ async function chooseWorkspaceForWizard(options) {
             })),
             {
                 value: "__new__",
-                label: "Create another workspace",
-                hint: "Add a separate focus or question set",
+                label: "Add another dataset",
+                hint: "Add a separate folder, focus, or question set",
             },
         ],
     });
@@ -120,52 +158,55 @@ async function chooseWorkspaceForWizard(options) {
         return null;
     if (selected === "__new__")
         return "__new__";
-    return findSavedWorkspaceConfig(options.sourcePath, String(selected));
+    return findSavedCompiledConfig(options.sourcePath, String(selected));
 }
-async function promptWorkspaceSetup(options) {
-    const workflowChoice = await chooseWorkspaceWorkflow(options.sourcePath, {
-        currentWorkflowId: options.initial?.workflow ?? "interf",
-        message: options.introStyle === "edit"
-            ? "Which workflow should this workspace use?"
-            : "Which workflow should this workspace start from?",
-    });
-    if (p.isCancel(workflowChoice))
-        return null;
-    const workflowId = workflowChoice;
-    const workflowLabel = buildWorkspaceWorkflowOptions(options.sourcePath)
+async function promptCompiledSetup(options) {
+    let workflowId = options.initial?.workflow ?? "interf";
+    if (options.introStyle === "edit") {
+        const workflowChoice = await chooseCompiledWorkflow(options.sourcePath, {
+            currentWorkflowId: workflowId,
+            message: "Which workflow should this dataset use?",
+        });
+        if (p.isCancel(workflowChoice))
+            return null;
+        workflowId = workflowChoice;
+    }
+    const workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
         .find((option) => option.value === workflowId)?.label ?? workflowId;
-    const workspaceConfig = await promptSingleWorkspaceConfig({
+    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,
     });
-    if (!workspaceConfig)
+    if (!compiledConfig)
         return null;
-    const workspaceConfigWithWorkflow = {
-        ...workspaceConfig,
+    const compiledConfigWithWorkflow = {
+        ...compiledConfig,
         workflow: workflowId,
     };
-    upsertSourceWorkspaceConfig(options.sourcePath, workspaceConfigWithWorkflow, {
+    upsertSourceDatasetConfig(options.sourcePath, compiledConfigWithWorkflow, {
         ...(options.fixedName ? { matchName: options.fixedName } : {}),
     });
-    const builtWorkspacePath = findBuiltWorkspacePath(options.sourcePath, workspaceConfigWithWorkflow.name);
-    if (builtWorkspacePath) {
-        syncWorkspaceInterfConfigFromSourceWorkspaceConfig(builtWorkspacePath, workspaceConfigWithWorkflow);
+    const builtCompiledPath = findBuiltCompiledPath(options.sourcePath, compiledConfigWithWorkflow.name);
+    if (builtCompiledPath) {
+        syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, compiledConfigWithWorkflow);
     }
     console.log();
-    console.log(chalk.green(`  ✓ Saved workspace setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
+    console.log(chalk.green(`  ✓ Saved dataset setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
     console.log(chalk.dim(`  Source folder: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Workspace: ${workspaceConfigWithWorkflow.name}`));
+    console.log(chalk.dim(`  Dataset: ${compiledConfigWithWorkflow.name}`));
+    console.log(chalk.dim(`  Path: ${compiledConfigWithWorkflow.path}`));
     console.log(chalk.dim(`  Workflow: ${workflowLabel}`));
     console.log(chalk.dim(`  Compile mode: ${describeCompileLoopSelection({
-        maxAttempts: workspaceConfigWithWorkflow.max_attempts,
-        maxLoops: workspaceConfigWithWorkflow.max_loops,
+        maxAttempts: compiledConfigWithWorkflow.max_attempts,
+        maxLoops: compiledConfigWithWorkflow.max_loops,
     })}`));
-    return workspaceConfigWithWorkflow;
+    return compiledConfigWithWorkflow;
 }
-async function compileSelectedWorkspace(sourcePath, workspaceConfig) {
+async function compileSelectedCompiled(sourcePath, compiledConfig) {
     const { executor, error } = await resolveOrConfigureLocalExecutor({
         purpose: "compile",
     });
@@ -177,274 +218,186 @@ async function compileSelectedWorkspace(sourcePath, workspaceConfig) {
         console.log(chalk.red(error ?? "No coding agent detected."));
         return null;
     }
-    const workspacePath = ensureWorkspaceFromConfig(sourcePath, workspaceConfig);
-    const compiled = await runConfiguredWorkspaceCompile({
+    const compiledPath = ensureCompiledFromConfig(sourcePath, compiledConfig);
+    const compiled = await runConfiguredCompiledCompile({
         executor,
-        workspacePath,
+        compiledPath,
         sourcePath,
-        workspaceConfig,
+        compiledConfig,
         maxAttemptsOverride: null,
         maxLoopsOverride: null,
     });
     if (!compiled) {
         return null;
     }
-    return workspacePath;
-}
-async function runFirstWorkspaceFlow(sourcePath, workspaceConfig) {
-    let rawOutcome = null;
-    let workspaceOutcome = null;
-    let rawOutcomeShown = false;
-    if (workspaceConfig.checks.length > 0) {
-        const runRawFirst = await p.confirm({
-            message: "Run a baseline test on the raw files now? (Recommended)",
-            initialValue: true,
-        });
-        if (p.isCancel(runRawFirst))
-            return;
-        if (runRawFirst) {
-            rawOutcome = await runSavedRawTest({
-                sourcePath,
-                workspaceConfig,
-            });
-            if (rawOutcome) {
-                console.log();
-                printSavedTestOutcome("Raw files", rawOutcome);
-                rawOutcomeShown = true;
-            }
-        }
-    }
-    else {
-        p.log.info("You can compile this workspace now and add questions later when you want to test it.");
-    }
-    const compileAndTest = workspaceConfig.checks.length > 0 && rawOutcome
-        ? await p.confirm({
-            message: "Compile the workspace with this workflow and run the same test now? (Recommended)",
-            initialValue: true,
-        })
-        : await p.confirm({
-            message: "Compile the workspace with this workflow now? (Recommended)",
-            initialValue: true,
-        });
-    if (p.isCancel(compileAndTest) || !compileAndTest) {
-        if (rawOutcome && !rawOutcomeShown) {
-            printSavedTestOutcome("Raw files", rawOutcome);
-        }
-        console.log();
-        console.log(chalk.dim("  Next:"));
-        console.log(chalk.dim("    interf compile"));
-        if (workspaceConfig.checks.length > 0) {
-            console.log(chalk.dim("    interf test"));
-        }
-        return;
-    }
-    const workspacePath = await compileSelectedWorkspace(sourcePath, workspaceConfig);
-    if (!workspacePath) {
-        if (rawOutcome && !rawOutcomeShown) {
-            printSavedTestOutcome("Raw files", rawOutcome);
-        }
-        return;
-    }
-    if (workspaceConfig.checks.length === 0) {
-        return;
-    }
-    if (compileModeAlreadyRanSavedTests(workspaceConfig)) {
-        p.log.info("Saved compile mode already ran the workspace test.");
-        return;
-    }
-    if (!rawOutcome) {
-        const runWorkspaceTest = await p.confirm({
-            message: "Run the saved test on the compiled workspace now? (Recommended)",
-            initialValue: true,
-        });
-        if (p.isCancel(runWorkspaceTest) || !runWorkspaceTest)
-            return;
-    }
-    workspaceOutcome = await runSavedWorkspaceTest({
-        sourcePath,
-        workspaceConfig,
-        workspacePath,
-    });
-    if (rawOutcomeShown) {
-        if (workspaceOutcome) {
-            console.log();
-            printSavedTestOutcome("Compiled workspace", workspaceOutcome);
-            if (rawOutcome) {
-                const rawQuestions = questionPassRate(rawOutcome);
-                const workspaceQuestions = questionPassRate(workspaceOutcome);
-                const delta = workspaceQuestions - rawQuestions;
-                const color = delta >= 0 ? chalk.green : chalk.red;
-                const direction = delta >= 0 ? "improved" : "decreased";
-                console.log();
-                console.log(color(`  Truth-check pass rate ${direction} from ${rawQuestions}% to ${workspaceQuestions}%.`));
-            }
-        }
-    }
-    else {
-        printSavedTestComparison(rawOutcome, workspaceOutcome);
-    }
+    return compiledPath;
 }
-export const initCommand = {
-    command: "init",
-    describe: "Open the root-folder wizard for this folder",
-    handler: async () => {
-        await runInitCommand();
-    },
-};
-export async function runInitCommand() {
-    p.intro(chalk.bold("Interf Compiler"));
-    p.log.info("Measure and improve how accurately your local agent answers questions from the dataset in this folder.");
-    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}`);
-    }
-    const savedEntries = listSavedWorkspaceEntries(sourcePath);
-    if (savedEntries.length === 0) {
-        const workspaceConfig = await promptWorkspaceSetup({
-            sourcePath,
-            initial: { name: DEFAULT_WORKSPACE_NAME },
-            introStyle: "first",
-        });
-        if (!workspaceConfig)
-            return;
-        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
-        return;
-    }
-    const selectedWorkspace = await chooseWorkspaceForWizard({
-        sourcePath,
-        fixedWorkspaceName: detected?.config.name ?? null,
-    });
-    if (!selectedWorkspace)
-        return;
-    if (selectedWorkspace === "__new__") {
-        const workspaceConfig = await promptWorkspaceSetup({
-            sourcePath,
-            initial: { name: DEFAULT_WORKSPACE_NAME },
-            introStyle: "additional",
-        });
-        if (!workspaceConfig)
-            return;
-        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
-        return;
-    }
-    const builtWorkspacePath = findBuiltWorkspacePath(sourcePath, selectedWorkspace.name);
-    printWorkspaceSummary({
+async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
+    const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
+    const latestComparison = readSavedTestComparison(sourcePath, compiledConfig.name);
+    printDatasetSummary({
         sourcePath,
-        workspace: selectedWorkspace,
-        built: Boolean(builtWorkspacePath),
-        builtWorkspacePath,
+        dataset: compiledConfig,
+        built: Boolean(builtCompiledPath),
+        builtCompiledPath,
+        latestComparison,
     });
-    const action = await promptWorkspaceAction(selectedWorkspace, Boolean(builtWorkspacePath));
+    printDatasetRecommendation(compiledConfig, Boolean(builtCompiledPath), latestComparison);
+    const action = await promptDatasetAction(compiledConfig, Boolean(builtCompiledPath), latestComparison);
     if (!action)
         return;
     if (action === "done") {
-        p.outro("Nothing changed.");
+        p.outro(options.justConfigured ? "Saved dataset setup." : "Nothing changed.");
         return;
     }
     if (action === "workflow") {
         await createWorkflowWizard({ sourcePath });
         return;
     }
-    if (action === "workspace") {
-        const workspaceConfig = await promptWorkspaceSetup({
+    if (action === "dataset") {
+        const nextCompiled = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_WORKSPACE_NAME },
+            initial: { name: DEFAULT_COMPILED_NAME },
             introStyle: "additional",
         });
-        if (!workspaceConfig)
+        if (!nextCompiled)
             return;
-        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
+        await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
         return;
     }
     if (action === "edit") {
-        const workspaceConfig = await promptWorkspaceSetup({
+        const nextCompiled = await promptCompiledSetup({
             sourcePath,
-            initial: selectedWorkspace,
-            fixedName: selectedWorkspace.name,
+            initial: compiledConfig,
+            fixedName: compiledConfig.name,
             introStyle: "edit",
         });
-        if (!workspaceConfig)
+        if (!nextCompiled)
             return;
-        const refreshedBuiltWorkspacePath = findBuiltWorkspacePath(sourcePath, workspaceConfig.name);
-        printWorkspaceSummary({
-            sourcePath,
-            workspace: workspaceConfig,
-            built: Boolean(refreshedBuiltWorkspacePath),
-            builtWorkspacePath: refreshedBuiltWorkspacePath,
-        });
-        p.log.info("Saved workspace setup updated.");
+        await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
         return;
     }
-    if (action === "raw") {
-        if (selectedWorkspace.checks.length === 0) {
+    if (action === "test") {
+        if (compiledConfig.checks.length === 0) {
             process.exitCode = 1;
-            console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" does not have any saved truth checks yet.`));
-            console.log(chalk.dim("  Run `interf` or `interf init` to add a few first."));
+            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.dim("  Then rerun `interf test`."));
             return;
         }
-        const rawOutcome = await runSavedRawTest({
+        const baselineRan = await runTestCommand({
             sourcePath,
-            workspaceConfig: selectedWorkspace,
+            dataset: compiledConfig.name,
+            datasetConfig: compiledConfig,
+            ...(builtCompiledPath ? {} : { target: "raw" }),
         });
-        if (!rawOutcome)
+        if (!baselineRan) {
             return;
-        const compileAndCompare = await p.confirm({
-            message: "Compile the workspace and run the same test now? (Recommended)",
-            initialValue: true,
-        });
-        if (p.isCancel(compileAndCompare) || !compileAndCompare) {
-            printSavedTestComparison(rawOutcome, null);
+        }
+        if (builtCompiledPath) {
             return;
         }
-        const workspacePath = await compileSelectedWorkspace(sourcePath, selectedWorkspace);
-        if (!workspacePath) {
-            printSavedTestComparison(rawOutcome, null);
+        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,
+            });
+            if (p.isCancel(compileAnyway) || !compileAnyway) {
+                return;
+            }
+        }
+        else {
+            const compileAndCompare = await p.confirm({
+                message: "Compile this dataset now and compare it on the same checks? (Recommended)",
+                initialValue: true,
+            });
+            if (p.isCancel(compileAndCompare) || !compileAndCompare) {
+                return;
+            }
+        }
+        const compiledPath = await compileSelectedCompiled(sourcePath, compiledConfig);
+        if (!compiledPath) {
             return;
         }
-        const workspaceOutcome = await runSavedWorkspaceTest({
+        await runTestCommand({
             sourcePath,
-            workspaceConfig: selectedWorkspace,
-            workspacePath,
+            dataset: compiledConfig.name,
+            datasetConfig: compiledConfig,
+            target: "both",
         });
-        printSavedTestComparison(rawOutcome, workspaceOutcome);
         return;
     }
     if (action === "compile") {
-        const workspacePath = await compileSelectedWorkspace(sourcePath, selectedWorkspace);
-        if (!workspacePath)
+        if (!await compileSelectedCompiled(sourcePath, compiledConfig))
             return;
-        if (selectedWorkspace.checks.length === 0)
+        if (compiledConfig.checks.length === 0)
             return;
-        if (compileModeAlreadyRanSavedTests(selectedWorkspace)) {
-            p.log.info("Saved compile mode already ran the workspace test.");
+        if (compileModeAlreadyRanSavedTests(compiledConfig)) {
+            p.log.info("Saved compile mode already ran the compiled-dataset test.");
             return;
         }
-        const runWorkspaceTest = await p.confirm({
-            message: "Run the saved test on the compiled workspace now?",
+        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?",
             initialValue: true,
         });
-        if (p.isCancel(runWorkspaceTest) || !runWorkspaceTest)
+        if (p.isCancel(runCompiledTest) || !runCompiledTest)
             return;
-        const workspaceOutcome = await runSavedWorkspaceTest({
+        await runTestCommand({
             sourcePath,
-            workspaceConfig: selectedWorkspace,
-            workspacePath,
+            dataset: compiledConfig.name,
+            datasetConfig: compiledConfig,
+            target: "both",
         });
-        printSavedTestComparison(null, workspaceOutcome);
         return;
     }
-    if (!builtWorkspacePath) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" is not compiled yet.`));
-        console.log(chalk.dim("  Run `interf compile` first."));
+}
+export const initCommand = {
+    command: "init",
+    describe: "Open the root-folder 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.");
+    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}`);
+    }
+    const savedEntries = listSavedCompiledEntries(sourcePath);
+    if (savedEntries.length === 0) {
+        const compiledConfig = await promptCompiledSetup({
+            sourcePath,
+            initial: { name: DEFAULT_COMPILED_NAME },
+            introStyle: "first",
+        });
+        if (!compiledConfig)
+            return;
+        await runCompiledActionMenu(sourcePath, compiledConfig, { justConfigured: true });
         return;
     }
-    const workspaceOutcome = await runSavedWorkspaceTest({
+    const selectedCompiled = await chooseCompiledForWizard({
         sourcePath,
-        workspaceConfig: selectedWorkspace,
-        workspacePath: builtWorkspacePath,
+        fixedCompiledName: detected?.config.name ?? null,
     });
-    printSavedTestComparison(null, workspaceOutcome);
+    if (!selectedCompiled)
+        return;
+    if (selectedCompiled === "__new__") {
+        const compiledConfig = await promptCompiledSetup({
+            sourcePath,
+            initial: { name: DEFAULT_COMPILED_NAME },
+            introStyle: "additional",
+        });
+        if (!compiledConfig)
+            return;
+        await runCompiledActionMenu(sourcePath, compiledConfig, { justConfigured: true });
+        return;
+    }
+    await runCompiledActionMenu(sourcePath, selectedCompiled);
 }