@interf/compiler 0.4.1 → 0.5.1

package/dist/commands/check-draft.js

@@ -0,0 +1,110 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+const DraftTruthCheckSchema = z.object({
+    question: z.string().min(1),
+    answer: z.string().min(1),
+}).strict();
+const DraftTruthChecksSchema = z.array(DraftTruthCheckSchema).min(1).max(8);
+export function buildTruthCheckDraftPrompt(options) {
+    const normalizedAbout = options.about?.trim();
+    const taskLines = normalizedAbout
+        ? [
+            `Primary task: ${normalizedAbout}`,
+            "Draft checks that directly measure whether a local agent would be accurate on that task.",
+            "Prefer checks that would make a human confident the dataset is useful for that exact job.",
+        ]
+        : [
+            "No primary task was provided.",
+            "Prefer broad, representative checks that reflect the most useful questions this dataset should answer.",
+        ];
+    return [
+        "You are drafting Interf truth checks for a local dataset.",
+        "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
+        "Do not ask follow-up questions.",
+        "Keep the checks concrete, explicit, and useful for measuring agent accuracy on this dataset.",
+        "",
+        `Dataset id: ${options.datasetName}`,
+        `Dataset folder: ${options.datasetPath}`,
+        ...taskLines,
+        "",
+        `Write exactly one JSON array to ${JSON.stringify(options.outputPath)}.`,
+        `Draft ${options.targetCount} checks unless the dataset is too small; in that case write fewer.`,
+        "Each array item must be an object with exactly these keys:",
+        '- "question": a plain-English question answerable from this dataset',
+        '- "answer": the expected correct answer in plain English',
+        "",
+        "Quality bar:",
+        "- If a primary task was provided, make most checks directly relevant to that task.",
+        "- Prefer facts, comparisons, or small derived calculations with clear expected answers.",
+        "- Prefer values that are easy for a human to cross-check in the source files.",
+        "- Prefer explicit chart labels, table cells, headings, totals, and directly stated comparisons.",
+        "- Avoid unstable superlatives unless the source itself clearly states the ranking in one place.",
+        "- Avoid checks where the expected answer depends on scanning many pages for a hidden exception or a larger outlier.",
+        "- Avoid vague essay questions, open-ended opinions, or anything requiring outside knowledge.",
+        "- Avoid duplicate checks that test the same fact in slightly different words.",
+        "",
+        "Output rules:",
+        "- JSON only in the output file.",
+        "- No markdown fences.",
+        "- Do not print the JSON to stdout.",
+        "- Stop after writing the file.",
+    ].join("\n");
+}
+export async function draftTruthChecks(options) {
+    const tempDir = mkdtempSync(join(tmpdir(), "interf-draft-checks-"));
+    const outputPath = join(tempDir, "checks.json");
+    const promptPath = join(tempDir, "prompt.txt");
+    const prompt = buildTruthCheckDraftPrompt({
+        datasetName: options.datasetName,
+        datasetPath: options.datasetPath,
+        about: options.about,
+        outputPath,
+        targetCount: options.targetCount ?? 4,
+    });
+    writeFileSync(promptPath, `${prompt}\n`);
+    try {
+        const code = await options.executor.execute(options.datasetPath, prompt, {
+            completionCheck: () => existsSync(outputPath),
+        });
+        if (!existsSync(outputPath)) {
+            return {
+                checks: null,
+                error: code === 0
+                    ? "The local agent finished without writing draft truth checks."
+                    : "The local agent did not produce draft truth checks.",
+            };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(outputPath, "utf8"));
+        }
+        catch (error) {
+            return {
+                checks: null,
+                error: `Draft truth checks were not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        const validated = DraftTruthChecksSchema.safeParse(parsed);
+        if (!validated.success) {
+            const detail = validated.error.issues[0]?.message ?? "invalid draft truth checks";
+            return {
+                checks: null,
+                error: `Draft truth checks did not match the required shape: ${detail}`,
+            };
+        }
+        return {
+            checks: validated.data,
+        };
+    }
+    catch (error) {
+        return {
+            checks: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/commands/compile-controller.d.ts

@@ -1,12 +1,12 @@
 import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
-import type { SourceWorkspaceConfig } from "../lib/schema.js";
+import type { SourceDatasetConfig } from "../lib/schema.js";
 import type { StageShellRetentionMode } from "../lib/workflows.js";
-export declare function runConfiguredWorkspaceCompile(options: {
+export declare function runConfiguredCompiledCompile(options: {
     executor: WorkflowExecutor;
     testExecutor?: WorkflowExecutor | null;
-    workspacePath: string;
+    compiledPath: string;
     sourcePath: string;
-    workspaceConfig: SourceWorkspaceConfig | null;
+    compiledConfig: SourceDatasetConfig | null;
     executionProfile?: WorkflowExecutionProfile;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;

package/dist/commands/compile-controller.js

@@ -3,43 +3,49 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../lib/interf.js";
-import { resetWorkspaceGeneratedState } from "../lib/workspace-reset.js";
-import { formatActiveWorkspaceWorkflowStageStep, resolveWorkspaceWorkflowFromConfig, } from "../lib/workflow-definitions.js";
-import { resolveWorkspaceCompileMaxAttempts, resolveWorkspaceCompileMaxLoops, } from "../lib/source-config.js";
+import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
+import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
-import { stageExecutionShellsRoot, workflowPackagePathForWorkspace, } from "../lib/workspace-paths.js";
-import { compileWorkspaceWithReporter } from "./workspace-flow.js";
-import { printSavedTestOutcome, questionPassRate, runSavedWorkspaceTest, } from "./test-flow.js";
-function printCompileFailure(workspacePath, failedStage) {
-    const workflowId = resolveWorkspaceWorkflowFromConfig(readInterfConfig(workspacePath));
-    const failedStageLabel = formatActiveWorkspaceWorkflowStageStep(workspacePath, workflowId, failedStage ?? "compile");
+import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
+import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
+import { compileCompiledWithReporter } from "./compiled-flow.js";
+import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
+function printCompileFailure(compiledPath, failedStage) {
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
+    const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, workflowId, failedStage ?? "compile");
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
-const BEST_VARIATION_RESTORE_PATHS = [
-    "AGENTS.md",
-    "CLAUDE.md",
-    "home.md",
-    "summaries",
-    "knowledge",
-    ".claude",
-    ".codex",
-    ".agents",
-    ".cursor",
-    ".obsidian",
-    ".interf/interf.json",
-    ".interf/workflow",
+const BEST_VARIATION_RUNTIME_RESTORE_PATHS = [
     ".interf/runtime/state.json",
     ".interf/runtime/health.json",
     ".interf/runtime/view-spec.json",
     ".interf/runtime/inventory.json",
     ".interf/runtime/run.json",
     ".interf/runtime/raw-snapshot.json",
-    ".interf/runtime/stage-contract.json",
-    ".interf/runtime/summarize-targets.json",
 ];
+function bestVariationRestorePaths(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const zonePaths = (schema?.zones ?? [])
+        .filter((zone) => zone.id !== "raw" && zone.kind !== "runtime")
+        .map((zone) => zone.path);
+    return [
+        "AGENTS.md",
+        "CLAUDE.md",
+        ".claude",
+        ".codex",
+        ".agents",
+        ".cursor",
+        ".obsidian",
+        ".interf/interf.json",
+        ".interf/workflow",
+        ...BEST_VARIATION_RUNTIME_RESTORE_PATHS,
+        ...zonePaths,
+    ];
+}
 function copyRelativePathIfPresent(sourceRoot, targetRoot, relativePath) {
     const sourcePath = join(sourceRoot, relativePath);
     if (!existsSync(sourcePath))
@@ -52,18 +58,18 @@ function copyRelativePathIfPresent(sourceRoot, targetRoot, relativePath) {
         errorOnExist: false,
     });
 }
-function snapshotWorkspaceBestState(workspacePath) {
+function snapshotCompiledBestState(compiledPath) {
     const snapshotRoot = mkdtempSync(join(tmpdir(), "interf-compile-attempt-"));
-    const snapshotPath = join(snapshotRoot, "workspace");
-    for (const relativePath of BEST_VARIATION_RESTORE_PATHS) {
-        copyRelativePathIfPresent(workspacePath, snapshotPath, relativePath);
+    const snapshotPath = join(snapshotRoot, "compiled");
+    for (const relativePath of bestVariationRestorePaths(compiledPath)) {
+        copyRelativePathIfPresent(compiledPath, snapshotPath, relativePath);
     }
     return snapshotPath;
 }
-function restoreWorkspaceBestState(snapshotPath, workspacePath) {
-    for (const relativePath of BEST_VARIATION_RESTORE_PATHS) {
-        rmSync(join(workspacePath, relativePath), { recursive: true, force: true });
-        copyRelativePathIfPresent(snapshotPath, workspacePath, relativePath);
+function restoreCompiledBestState(snapshotPath, compiledPath) {
+    for (const relativePath of bestVariationRestorePaths(compiledPath)) {
+        rmSync(join(compiledPath, relativePath), { recursive: true, force: true });
+        copyRelativePathIfPresent(snapshotPath, compiledPath, relativePath);
     }
 }
 async function runWorkflowVariation(options) {
@@ -79,21 +85,21 @@ async function runWorkflowVariation(options) {
                 const resetTarget = attempt > 1
                     ? `attempt ${attempt}/${options.maxAttempts}`
                     : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated workspace state before ${resetTarget}...`));
-                resetWorkspaceGeneratedState(options.workspacePath, "compile");
+                console.log(chalk.dim(`  Resetting generated compiled state before ${resetTarget}...`));
+                resetCompiledGeneratedState(options.compiledPath, "compile");
             }
-            const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
+            const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building compiled workspace (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building compiled workspace (${options.variationLabel})...`,
+                    ? `Building compiled dataset (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building compiled dataset (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Compiled workspace ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Compiled workspace ready for ${options.variationLabel}.`,
+                    ? `Compiled dataset ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Compiled dataset ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
             });
             if (!result.ok) {
-                printCompileFailure(options.workspacePath, result.failedStage);
-                printStageShellReviewHint(options.workspacePath, options.preserveStageShells);
+                printCompileFailure(options.compiledPath, result.failedStage);
+                printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "failure");
                 if (attempt < options.maxAttempts) {
                     console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} failed. Retrying with a fresh compile.`));
                     continue;
@@ -108,12 +114,12 @@ async function runWorkflowVariation(options) {
                     fatalError: null,
                 };
             }
-            const outcome = await runSavedWorkspaceTest({
+            const outcome = await runSavedCompiledTest({
                 sourcePath: options.sourcePath,
-                workspaceConfig: options.workspaceConfig,
+                datasetConfig: options.compiledConfig,
                 executor: options.testExecutor,
                 executionProfile: options.executionProfile,
-                workspacePath: options.workspacePath,
+                compiledPath: options.compiledPath,
                 preserveSandboxes: options.preserveStageShells === "always" ? "always" : "on-failure",
             });
             if (!outcome) {
@@ -124,7 +130,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved workspace test after compile.",
+                    fatalError: "Could not run the saved compiled-dataset test after compile.",
                 };
             }
             console.log();
@@ -134,13 +140,13 @@ async function runWorkflowVariation(options) {
                     rmSync(bestSnapshotPath, { recursive: true, force: true });
                 }
                 bestOutcome = outcome;
-                bestSnapshotPath = snapshotWorkspaceBestState(options.workspacePath);
+                bestSnapshotPath = snapshotCompiledBestState(options.compiledPath);
                 bestAttempt = attempt;
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Workspace passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
-                printStageShellReviewHint(options.workspacePath, options.preserveStageShells);
+                console.log(chalk.green(`  Compiled passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
                     attemptsRun,
@@ -203,13 +209,27 @@ function summarizeWorkflowVariation(options) {
         summary,
     };
 }
-function printStageShellReviewHint(workspacePath, preserveStageShells) {
-    const reviewRoot = stageExecutionShellsRoot(workspacePath);
+function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
+    const reviewRoot = stageExecutionShellsRoot(compiledPath);
     if (preserveStageShells === "always") {
-        console.log(chalk.dim(`  Preserved stage shells: ${reviewRoot}`));
+        console.log(chalk.dim(`  Stage shells are saved under: ${reviewRoot}`));
         return;
     }
-    console.log(chalk.dim(`  Failed stage shells remain under: ${reviewRoot}`));
+    if (result === "failure") {
+        console.log(chalk.dim(`  Review failed stage shells under: ${reviewRoot}`));
+    }
+}
+function printPostCompileNextStep(options) {
+    console.log(chalk.dim(`  Compiled dataset: ${options.compiledPath}`));
+    if (options.checks === 0) {
+        console.log(chalk.dim("  Next: run `interf` to add truth checks, then `interf test`."));
+        return;
+    }
+    if (options.testedDuringCompile) {
+        console.log(chalk.dim("  Next: inspect the compiled dataset or rerun `interf test` for a fresh comparison."));
+        return;
+    }
+    console.log(chalk.dim("  Next: run `interf test` to compare the raw files and the compiled dataset."));
 }
 function formatVariationQuestionSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -226,28 +246,28 @@ function printWorkflowVariationSummary(summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
     }
 }
-function printWorkspaceLocalWorkflowOwnership(workspacePath, bestVariation) {
+function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
     if (bestVariation <= 1)
         return;
     console.log();
-    console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForWorkspace(workspacePath)}`));
-    console.log(chalk.dim("  Source-folder workflow selection was not changed automatically."));
-    console.log(chalk.dim("  Recompiling this existing workspace reuses that workspace-local workflow draft."));
+    console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForCompiled(compiledPath)}`));
+    console.log(chalk.dim("  The project-level workflow selection was not changed automatically."));
+    console.log(chalk.dim("  Recompiling this existing compiled dataset reuses that local workflow draft."));
 }
-export async function runConfiguredWorkspaceCompile(options) {
+export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
-    const configuredMaxAttempts = resolveWorkspaceCompileMaxAttempts(options.workspaceConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const maxLoops = resolveWorkspaceCompileMaxLoops(options.workspaceConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
     const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
     const loopEnabled = maxAttempts != null;
-    const checks = options.workspaceConfig?.checks ?? [];
+    const checks = options.compiledConfig?.checks ?? [];
     if (loopEnabled && checks.length === 0) {
         console.log(chalk.yellow("  Retry and self-improving modes need saved truth checks. Building once without those loops."));
     }
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the workspace, and stop early if it passes."));
+            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
@@ -258,16 +278,21 @@ export async function runConfiguredWorkspaceCompile(options) {
         }
     }
     if (!loopEnabled || checks.length === 0) {
-        const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
+        const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
             preserveStageShells,
         });
         if (!result.ok) {
             process.exitCode = 1;
-            printCompileFailure(options.workspacePath, result.failedStage);
-            printStageShellReviewHint(options.workspacePath, preserveStageShells);
+            printCompileFailure(options.compiledPath, result.failedStage);
+            printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
             return false;
         }
-        printStageShellReviewHint(options.workspacePath, preserveStageShells);
+        printStageShellReviewHint(options.compiledPath, preserveStageShells, "success");
+        printPostCompileNextStep({
+            compiledPath: options.compiledPath,
+            checks: checks.length,
+            testedDuringCompile: false,
+        });
         return true;
     }
     let bestOutcome = null;
@@ -277,8 +302,9 @@ export async function runConfiguredWorkspaceCompile(options) {
     const previousVariations = [];
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
-        const workspaceConfig = options.workspaceConfig ?? {
-            name: readInterfConfig(options.workspacePath)?.name ?? "workspace",
+        const compiledConfig = options.compiledConfig ?? {
+            name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
+            path: ".",
             checks: [],
         };
         const adoptVariationBest = (variation, result) => {
@@ -300,9 +326,9 @@ export async function runConfiguredWorkspaceCompile(options) {
         const baseline = await runWorkflowVariation({
             executor: options.executor,
             testExecutor: options.testExecutor,
-            workspacePath: options.workspacePath,
+            compiledPath: options.compiledPath,
             sourcePath: options.sourcePath,
-            workspaceConfig,
+            compiledConfig,
             executionProfile: options.executionProfile,
             preserveStageShells,
             maxAttempts,
@@ -322,6 +348,11 @@ export async function runConfiguredWorkspaceCompile(options) {
         }));
         if (baseline.passed) {
             printWorkflowVariationSummary(previousVariations);
+            printPostCompileNextStep({
+                compiledPath: options.compiledPath,
+                checks: checks.length,
+                testedDuringCompile: true,
+            });
             return true;
         }
         if (maxLoops != null) {
@@ -330,9 +361,9 @@ export async function runConfiguredWorkspaceCompile(options) {
                 console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the workflow.`));
                 const improvement = await runWorkflowImprovementLoop({
                     executor: options.executor,
-                    workspacePath: options.workspacePath,
-                    workflowId: resolveWorkspaceWorkflowFromConfig(readInterfConfig(options.workspacePath)),
-                    workspaceConfig,
+                    compiledPath: options.compiledPath,
+                    workflowId: resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
+                    compiledConfig,
                     runId: improvementRunId,
                     loopIndex,
                     maxLoops,
@@ -352,9 +383,9 @@ export async function runConfiguredWorkspaceCompile(options) {
                 const variation = await runWorkflowVariation({
                     executor: options.executor,
                     testExecutor: options.testExecutor,
-                    workspacePath: options.workspacePath,
+                    compiledPath: options.compiledPath,
                     sourcePath: options.sourcePath,
-                    workspaceConfig,
+                    compiledConfig,
                     executionProfile: options.executionProfile,
                     preserveStageShells,
                     maxAttempts,
@@ -375,30 +406,35 @@ export async function runConfiguredWorkspaceCompile(options) {
                 }));
                 if (variation.passed) {
                     printWorkflowVariationSummary(previousVariations);
-                    printWorkspaceLocalWorkflowOwnership(options.workspacePath, bestVariation);
+                    printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
+                    printPostCompileNextStep({
+                        compiledPath: options.compiledPath,
+                        checks: checks.length,
+                        testedDuringCompile: true,
+                    });
                     return true;
                 }
             }
         }
         if (bestSnapshotPath && bestVariation > 0) {
-            restoreWorkspaceBestState(bestSnapshotPath, options.workspacePath);
+            restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing compiled workspace from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing compiled dataset from variation ${bestVariation}, attempt ${bestAttempt}.`));
         }
         process.exitCode = 1;
         console.log();
         printWorkflowVariationSummary(previousVariations);
-        printWorkspaceLocalWorkflowOwnership(options.workspacePath, bestVariation);
+        printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
         if (maxLoops != null) {
-            console.log(chalk.red(`  Workspace did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Compiled did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }
         else {
-            console.log(chalk.red(`  Workspace did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Compiled did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
             console.log(chalk.dim(`  Best attempt truth-check pass rate: ${questionPassRate(bestOutcome)}%.`));
         }
-        printStageShellReviewHint(options.workspacePath, preserveStageShells);
+        printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;
     }
     finally {

package/dist/commands/compile.d.ts

@@ -1,15 +1,15 @@
-import type { SourceWorkspaceConfig } from "../lib/schema.js";
+import type { SourceDatasetConfig } from "../lib/schema.js";
 import type { CommandModule } from "yargs";
-export { runConfiguredWorkspaceCompile } from "./compile-controller.js";
+export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export declare const compileCommand: CommandModule;
 export declare function runCompileCommand(argv?: Record<string, unknown>): Promise<void>;
 export declare function resolveInteractiveCompileLoopOverrides(options: {
-    workspacePath: string;
-    workspaceConfig: SourceWorkspaceConfig | null;
+    compiledPath: string;
+    compiledConfig: SourceDatasetConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 }): Promise<{
-    workspaceConfig: SourceWorkspaceConfig | null;
+    compiledConfig: SourceDatasetConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 } | null>;