@interf/compiler 0.3.4 → 0.4.1

package/dist/commands/init.js

@@ -1,9 +1,9 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, resolveSourceControlPath, } from "../lib/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, listSourceWorkspaceConfigs, loadSourceFolderConfig, upsertSourceWorkspaceConfig, } from "../lib/source-config.js";
-import { DEFAULT_WORKSPACE_NAME, promptSingleWorkspaceConfig, } from "./source-config-wizard.js";
-import { createWorkflowWizard } from "./create-workflow-wizard.js";
+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 { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
@@ -14,11 +14,26 @@ function describeSavedQuestions(workspace) {
         return "No saved truth checks yet";
     return `${count} saved truth check${count === 1 ? "" : "s"}`;
 }
+function compileModeAlreadyRanSavedTests(workspace) {
+    if (workspace.checks.length === 0)
+        return false;
+    return (resolveWorkspaceCompileMaxAttempts(workspace) != null ||
+        resolveWorkspaceCompileMaxLoops(workspace) != null);
+}
 function printWorkspaceSummary(options) {
+    const workspaceConfig = options.builtWorkspacePath
+        ? readInterfConfig(options.builtWorkspacePath)
+        : 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}`);
     }
+    p.log.info(`Workflow: ${workflowLabel}`);
+    p.log.info(describeCompileLoopSelection({
+        maxAttempts: options.workspace.max_attempts,
+        maxLoops: options.workspace.max_loops,
+    }));
     p.log.info(describeSavedQuestions(options.workspace));
     p.log.info(options.built ? "Compiled workspace is available." : "Compiled workspace has not been built yet.");
     if (options.sourcePath !== process.cwd()) {
@@ -29,7 +44,7 @@ async function promptWorkspaceAction(workspace, built) {
     const options = [
         {
             value: "edit",
-            label: "Edit truth checks and focus",
+            label: "Edit workflow, truth checks, and compile mode",
             hint: "Update this workspace setup",
         },
     ];
@@ -90,6 +105,7 @@ async function chooseWorkspaceForWizard(options) {
                 label: entry.config.name,
                 hint: [
                     entry.config.about ?? describeSavedQuestions(entry.config),
+                    `workflow ${entry.config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`,
                     entry.path ? "built" : "not built yet",
                 ].join(" · "),
             })),
@@ -107,22 +123,47 @@ async function chooseWorkspaceForWizard(options) {
     return findSavedWorkspaceConfig(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)
+        .find((option) => option.value === workflowId)?.label ?? workflowId;
     const workspaceConfig = await promptSingleWorkspaceConfig({
         initial: options.initial,
         ...(options.fixedName ? { fixedName: options.fixedName } : {}),
         skipNamePrompt: !options.fixedName && options.introStyle === "first",
         introStyle: options.introStyle,
+        selectedWorkflowLabel: workflowLabel,
     });
     if (!workspaceConfig)
         return null;
-    upsertSourceWorkspaceConfig(options.sourcePath, workspaceConfig, {
+    const workspaceConfigWithWorkflow = {
+        ...workspaceConfig,
+        workflow: workflowId,
+    };
+    upsertSourceWorkspaceConfig(options.sourcePath, workspaceConfigWithWorkflow, {
         ...(options.fixedName ? { matchName: options.fixedName } : {}),
     });
+    const builtWorkspacePath = findBuiltWorkspacePath(options.sourcePath, workspaceConfigWithWorkflow.name);
+    if (builtWorkspacePath) {
+        syncWorkspaceInterfConfigFromSourceWorkspaceConfig(builtWorkspacePath, workspaceConfigWithWorkflow);
+    }
     console.log();
     console.log(chalk.green(`  ✓ Saved workspace setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
     console.log(chalk.dim(`  Source folder: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Workspace: ${workspaceConfig.name}`));
-    return workspaceConfig;
+    console.log(chalk.dim(`  Workspace: ${workspaceConfigWithWorkflow.name}`));
+    console.log(chalk.dim(`  Workflow: ${workflowLabel}`));
+    console.log(chalk.dim(`  Compile mode: ${describeCompileLoopSelection({
+        maxAttempts: workspaceConfigWithWorkflow.max_attempts,
+        maxLoops: workspaceConfigWithWorkflow.max_loops,
+    })}`));
+    return workspaceConfigWithWorkflow;
 }
 async function compileSelectedWorkspace(sourcePath, workspaceConfig) {
     const { executor, error } = await resolveOrConfigureLocalExecutor({
@@ -143,6 +184,7 @@ async function compileSelectedWorkspace(sourcePath, workspaceConfig) {
         sourcePath,
         workspaceConfig,
         maxAttemptsOverride: null,
+        maxLoopsOverride: null,
     });
     if (!compiled) {
         return null;
@@ -177,11 +219,11 @@ async function runFirstWorkspaceFlow(sourcePath, workspaceConfig) {
     }
     const compileAndTest = workspaceConfig.checks.length > 0 && rawOutcome
         ? await p.confirm({
-            message: "Compile the workspace and run the same test now? (Recommended)",
+            message: "Compile the workspace with this workflow and run the same test now? (Recommended)",
             initialValue: true,
         })
         : await p.confirm({
-            message: "Compile the workspace now? (Recommended)",
+            message: "Compile the workspace with this workflow now? (Recommended)",
             initialValue: true,
         });
     if (p.isCancel(compileAndTest) || !compileAndTest) {
@@ -206,6 +248,10 @@ async function runFirstWorkspaceFlow(sourcePath, workspaceConfig) {
     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)",
@@ -254,8 +300,8 @@ export async function runInitCommand() {
     if (detected) {
         p.log.info(`Working from the dataset control plane: ${sourcePath}`);
     }
-    const currentConfig = loadSourceFolderConfig(sourcePath);
-    if (!currentConfig || listSourceWorkspaceConfigs(currentConfig).length === 0) {
+    const savedEntries = listSavedWorkspaceEntries(sourcePath);
+    if (savedEntries.length === 0) {
         const workspaceConfig = await promptWorkspaceSetup({
             sourcePath,
             initial: { name: DEFAULT_WORKSPACE_NAME },
@@ -288,6 +334,7 @@ export async function runInitCommand() {
         sourcePath,
         workspace: selectedWorkspace,
         built: Boolean(builtWorkspacePath),
+        builtWorkspacePath,
     });
     const action = await promptWorkspaceAction(selectedWorkspace, Boolean(builtWorkspacePath));
     if (!action)
@@ -320,7 +367,14 @@ export async function runInitCommand() {
         });
         if (!workspaceConfig)
             return;
-        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
+        const refreshedBuiltWorkspacePath = findBuiltWorkspacePath(sourcePath, workspaceConfig.name);
+        printWorkspaceSummary({
+            sourcePath,
+            workspace: workspaceConfig,
+            built: Boolean(refreshedBuiltWorkspacePath),
+            builtWorkspacePath: refreshedBuiltWorkspacePath,
+        });
+        p.log.info("Saved workspace setup updated.");
         return;
     }
     if (action === "raw") {
@@ -363,6 +417,10 @@ export async function runInitCommand() {
             return;
         if (selectedWorkspace.checks.length === 0)
             return;
+        if (compileModeAlreadyRanSavedTests(selectedWorkspace)) {
+            p.log.info("Saved compile mode already ran the workspace test.");
+            return;
+        }
         const runWorkspaceTest = await p.confirm({
             message: "Run the saved test on the compiled workspace now?",
             initialValue: true,
@@ -390,4 +448,3 @@ export async function runInitCommand() {
     });
     printSavedTestComparison(null, workspaceOutcome);
 }
-//# sourceMappingURL=init.js.map

package/dist/commands/list.d.ts

@@ -1,3 +1,2 @@
 import type { CommandModule } from "yargs";
 export declare const listCommand: CommandModule;
-//# sourceMappingURL=list.d.ts.map

package/dist/commands/list.js

@@ -19,4 +19,3 @@ export const listCommand = {
         }
     },
 };
-//# sourceMappingURL=list.js.map

package/dist/commands/reset.d.ts

@@ -1,3 +1,2 @@
 import type { CommandModule } from "yargs";
 export declare const resetCommand: CommandModule;
-//# sourceMappingURL=reset.d.ts.map

package/dist/commands/reset.js

@@ -20,4 +20,3 @@ export const resetCommand = {
         console.log(chalk.green("  Workspace reset complete."));
     },
 };
-//# sourceMappingURL=reset.js.map

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

@@ -1,8 +1,20 @@
-import type { SourceEvalCase, SourceWorkspaceConfig } from "../lib/schema.js";
+import type { SourceTruthCheck, SourceWorkspaceConfig } from "../lib/schema.js";
 export declare const DEFAULT_WORKSPACE_NAME = "my-workspace";
-export declare const DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER = "What was Central London under offers in Q1 2021?";
-export declare const DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER = "About 2.0 to 2.1 million sq ft.";
-export declare const DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER = "Quarterly results workspace for finance reporting and strategy questions.";
+export declare const DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
+export declare const DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
+export declare const DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER = "Focused workspace for the dataset questions that matter most here.";
+export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+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 resolveCompileLoopMode(maxAttempts?: number | null, maxLoops?: number | null): CompileLoopMode;
+export declare function describeCompileLoopSelection(options: {
+    maxAttempts?: number | null;
+    maxLoops?: number | null;
+}): string;
 export declare function promptCheckCases(options: {
     heading: string;
     questionMessage: string;
@@ -11,12 +23,21 @@ export declare function promptCheckCases(options: {
     answerPlaceholder: string;
     addAnotherMessage: string;
     startIndex?: number;
-}): Promise<SourceEvalCase[] | null>;
+}): Promise<SourceTruthCheck[] | null>;
+export declare function promptCompileLoopSelection(options: {
+    hasChecks: boolean;
+    initialMaxAttempts?: number;
+    initialMaxLoops?: number;
+    message?: string;
+    intro?: string[];
+    includeCompileOnce?: boolean;
+    recommendedMode?: CompileLoopMode;
+}): Promise<CompileLoopSelection | null>;
 export declare function promptSingleWorkspaceConfig(options?: {
-    initial?: Partial<Pick<SourceWorkspaceConfig, "name" | "about" | "checks" | "max_attempts">>;
+    initial?: Partial<Pick<SourceWorkspaceConfig, "name" | "about" | "checks" | "max_attempts" | "max_loops">>;
     fixedName?: string;
     skipAboutPrompt?: boolean;
     skipNamePrompt?: boolean;
     introStyle?: "first" | "additional" | "edit";
+    selectedWorkflowLabel?: string;
 }): Promise<SourceWorkspaceConfig | null>;
-//# sourceMappingURL=source-config-wizard.d.ts.map

package/dist/commands/source-config-wizard.js

@@ -1,10 +1,34 @@
 import * as p from "@clack/prompts";
-import { workspaceMaxAttempts } from "../lib/source-config.js";
+import { workspaceMaxAttempts, workspaceMaxLoops } from "../lib/source-config.js";
 import { slugify } from "../lib/util.js";
 export const DEFAULT_WORKSPACE_NAME = "my-workspace";
-export const DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER = "What was Central London under offers in Q1 2021?";
-export const DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER = "About 2.0 to 2.1 million sq ft.";
-export const DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER = "Quarterly results workspace for finance reporting and strategy questions.";
+export const DEFAULT_WORKSPACE_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
+export const DEFAULT_WORKSPACE_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
+export const DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER = "Focused workspace for the dataset questions that matter most here.";
+export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
+function formatAttemptLabel(count, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+export function resolveCompileLoopMode(maxAttempts, maxLoops) {
+    if ((maxLoops ?? 0) > 0)
+        return "self-improving";
+    if ((maxAttempts ?? 0) > 1)
+        return "retry";
+    return "once";
+}
+export function describeCompileLoopSelection(options) {
+    const mode = resolveCompileLoopMode(options.maxAttempts, options.maxLoops);
+    if (mode === "once") {
+        return "Run a single compile attempt without workflow edits.";
+    }
+    if (mode === "retry") {
+        return `Retry the same workflow up to ${formatAttemptLabel(options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS, "attempt")}.`;
+    }
+    const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
+    const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
+    return `Run ${formatAttemptLabel(attempts, "attempt")} per workflow variation and allow up to ${formatAttemptLabel(loops, "self-improving workflow loop")}.`;
+}
 export async function promptCheckCases(options) {
     p.log.info(options.heading);
     const cases = [];
@@ -47,11 +71,11 @@ async function promptWorkspaceChecks(options) {
         if (options.initialAbout) {
             p.log.info(`Focus: ${options.initialAbout}`);
         }
-        p.log.info("Truth checks");
-        p.log.info("A truth check is a question plus the expected correct answer for this dataset.");
+        p.log.info("Truth checks define what should hold for this dataset.");
+        p.log.info("Each truth check is a question plus the expected correct answer.");
         p.log.info("Start with simple facts, comparisons, or conclusions you can verify in the source material.");
         const addNow = await p.confirm({
-            message: "Add a few truth checks you already know for this dataset? (Recommended)",
+            message: "Add a few truth checks for this dataset now? (Recommended)",
             initialValue: true,
         });
         if (p.isCancel(addNow))
@@ -121,65 +145,122 @@ async function promptWorkspaceChecks(options) {
         return null;
     return mode === "add" ? [...options.initialChecks, ...nextChecks] : nextChecks;
 }
-async function promptWorkspaceRetryPolicy(options) {
-    if (!options.hasChecks) {
-        return undefined;
-    }
-    const currentMaxAttempts = options.initialMaxAttempts ?? null;
-    if (currentMaxAttempts) {
-        p.log.info(`Self-improving workflow loop: up to ${currentMaxAttempts} attempts.`);
-        const mode = await p.select({
-            message: "What do you want to do with the compile loop?",
-            options: [
-                {
-                    value: "keep",
-                    label: "Keep it",
-                    hint: "Reuse the current attempt budget",
-                },
-                {
-                    value: "change",
-                    label: "Change it",
-                    hint: "Use a different attempt budget",
-                },
-                {
-                    value: "disable",
-                    label: "Turn it off",
-                    hint: "Compile once without the retry loop",
-                },
-            ],
-        });
-        if (p.isCancel(mode))
-            return null;
-        if (mode === "keep")
-            return currentMaxAttempts;
-        if (mode === "disable")
-            return undefined;
-    }
-    else {
-        const enable = await p.confirm({
-            message: "Keep rerunning the workflow and test until this workspace passes or reaches the attempt limit? (optional)",
-            initialValue: false,
-        });
-        if (p.isCancel(enable))
-            return null;
-        if (!enable)
-            return undefined;
-    }
+async function promptRetryAttempts(options) {
+    const minimum = options.minimum ?? 1;
     const maxAttempts = await p.text({
-        message: "Maximum compile attempts?",
-        placeholder: "3",
-        initialValue: String(currentMaxAttempts ?? 3),
+        message: options.message,
+        placeholder: String(Math.max(minimum, DEFAULT_COMPILE_RETRY_ATTEMPTS)),
+        initialValue: String(Math.max(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS, minimum)),
         validate: (value) => {
             const parsed = Number.parseInt(value.trim(), 10);
-            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 5) {
-                return "Enter a whole number from 1 to 5";
+            if (!Number.isInteger(parsed) || parsed < minimum || parsed > 5) {
+                return `Enter a whole number from ${minimum} to 5`;
             }
             return undefined;
         },
     });
     if (p.isCancel(maxAttempts))
         return null;
-    return workspaceMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10));
+    return workspaceMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10)) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
+}
+async function promptSelfImprovingLoops(options) {
+    const maxLoops = await p.text({
+        message: options.message,
+        placeholder: String(DEFAULT_SELF_IMPROVING_LOOPS),
+        initialValue: String(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS),
+        validate: (value) => {
+            const parsed = Number.parseInt(value.trim(), 10);
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 3) {
+                return "Enter a whole number from 1 to 3";
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(maxLoops))
+        return null;
+    return workspaceMaxLoops(Number.parseInt(String(maxLoops).trim(), 10)) ?? DEFAULT_SELF_IMPROVING_LOOPS;
+}
+export async function promptCompileLoopSelection(options) {
+    if (!options.hasChecks) {
+        return {};
+    }
+    const currentMode = resolveCompileLoopMode(options.initialMaxAttempts, options.initialMaxLoops);
+    const recommendedMode = options.recommendedMode ?? "self-improving";
+    const includeCompileOnce = options.includeCompileOnce !== false;
+    const hasSavedPolicy = typeof options.initialMaxAttempts === "number" ||
+        typeof options.initialMaxLoops === "number";
+    for (const line of options.intro ?? []) {
+        p.log.info(line);
+    }
+    p.log.info(`Current mode: ${describeCompileLoopSelection({
+        maxAttempts: options.initialMaxAttempts,
+        maxLoops: options.initialMaxLoops,
+    })}`);
+    const optionsByMode = {
+        once: {
+            value: "once",
+            label: "Single attempt",
+            hint: "No retries or workflow edits",
+        },
+        retry: {
+            value: "retry",
+            label: "Retry the same workflow",
+            hint: `Run compile + test up to ${formatAttemptLabel(Math.max(options.initialMaxAttempts ?? 2, 2), "attempt")}`,
+        },
+        "self-improving": {
+            value: "self-improving",
+            label: recommendedMode === "self-improving"
+                ? "Self-improving loops (Recommended)"
+                : "Self-improving loops",
+            hint: `Retry each variation, then edit the workflow and retest up to ${options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS} loop${(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS) === 1 ? "" : "s"}`,
+        },
+    };
+    const orderedModes = (hasSavedPolicy
+        ? [
+            currentMode,
+            ...(recommendedMode !== currentMode ? [recommendedMode] : []),
+            "retry",
+            "once",
+        ]
+        : [
+            recommendedMode,
+            "retry",
+            "once",
+        ]).filter((mode, index, list) => list.indexOf(mode) === index)
+        .filter((mode) => includeCompileOnce || mode !== "once");
+    const selectedMode = await p.select({
+        message: options.message ?? "How should this workspace compile?",
+        options: orderedModes.map((mode) => optionsByMode[mode]),
+    });
+    if (p.isCancel(selectedMode))
+        return null;
+    if (selectedMode === "once") {
+        return {};
+    }
+    const maxAttempts = await promptRetryAttempts({
+        initialMaxAttempts: options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
+        minimum: selectedMode === "retry" ? 2 : 1,
+        message: selectedMode === "retry"
+            ? "Maximum compile attempts for the same workflow?"
+            : "Attempts per workflow variation?",
+    });
+    if (maxAttempts === null)
+        return null;
+    if (selectedMode === "retry") {
+        return {
+            max_attempts: maxAttempts,
+        };
+    }
+    const maxLoops = await promptSelfImprovingLoops({
+        initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
+        message: "Maximum self-improving workflow loops?",
+    });
+    if (maxLoops === null)
+        return null;
+    return {
+        max_attempts: maxAttempts,
+        max_loops: maxLoops,
+    };
 }
 export async function promptSingleWorkspaceConfig(options = {}) {
     const initial = options.initial;
@@ -224,7 +305,10 @@ export async function promptSingleWorkspaceConfig(options = {}) {
     }
     let about = initial?.about ?? "";
     let checks = null;
-    let maxAttempts = initial?.max_attempts;
+    let compileLoopSelection = {
+        ...(typeof initial?.max_attempts === "number" ? { max_attempts: initial.max_attempts } : {}),
+        ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
+    };
     if (collectChecksFirst) {
         checks = await promptWorkspaceChecks({
             initialChecks: initial?.checks,
@@ -234,7 +318,7 @@ export async function promptSingleWorkspaceConfig(options = {}) {
     }
     if (!(options.skipAboutPrompt && initial?.about)) {
         about = await p.text({
-            message: "Anything specific you want this workspace to be especially good at? (optional)",
+            message: "Optional focus for this workspace?",
             placeholder: DEFAULT_WORKSPACE_ABOUT_PLACEHOLDER,
             initialValue: initial?.about,
         });
@@ -249,17 +333,29 @@ export async function promptSingleWorkspaceConfig(options = {}) {
         if (checks === null)
             return null;
     }
-    maxAttempts = await promptWorkspaceRetryPolicy({
+    compileLoopSelection = await promptCompileLoopSelection({
         initialMaxAttempts: initial?.max_attempts,
+        initialMaxLoops: initial?.max_loops,
         hasChecks: checks.length > 0,
+        intro: [
+            ...(options.selectedWorkflowLabel
+                ? [`Workflow: ${options.selectedWorkflowLabel}`]
+                : []),
+            "Compile mode",
+            "Choose whether this workspace should compile once, retry the same workflow, or run self-improving loops that edit the workflow and retest it on the same truth checks.",
+        ],
     });
-    if (maxAttempts === null)
+    if (compileLoopSelection === null)
         return null;
     return {
         name,
         ...(String(about).trim().length > 0 ? { about: String(about).trim() } : {}),
-        ...(typeof maxAttempts === "number" ? { max_attempts: maxAttempts } : {}),
+        ...(typeof compileLoopSelection.max_attempts === "number"
+            ? { max_attempts: compileLoopSelection.max_attempts }
+            : {}),
+        ...(typeof compileLoopSelection.max_loops === "number"
+            ? { max_loops: compileLoopSelection.max_loops }
+            : {}),
         checks,
     };
 }
-//# sourceMappingURL=source-config-wizard.js.map

package/dist/commands/status.d.ts

@@ -1,3 +1,2 @@
 import type { CommandModule } from "yargs";
 export declare const statusCommand: CommandModule;
-//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.js

@@ -68,4 +68,3 @@ export const statusCommand = {
         console.log(chalk.dim(`  errors: ${health.metrics.errors}`));
     },
 };
-//# sourceMappingURL=status.js.map

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

@@ -1,26 +1,36 @@
-import { type BenchmarkTargetCandidate, type BenchmarkTargetResult } from "../lib/benchmark.js";
-import type { WorkflowExecutionProfile } from "../lib/executors.js";
-import type { BenchmarkSandboxRetentionMode } from "../lib/benchmark-sandbox.js";
-import type { SourceWorkspaceConfig } from "../lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "../lib/test.js";
+import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
+import type { TestSandboxRetentionMode } from "../lib/test-sandbox.js";
+import type { SourceWorkspaceConfig, TestRunMode } from "../lib/schema.js";
 export interface SavedTestOutcome {
     runPath: string;
-    target: BenchmarkTargetCandidate;
-    result: BenchmarkTargetResult;
+    target: TestTargetCandidate;
+    result: TestTargetResult;
 }
 export declare function questionPassRate(outcome: SavedTestOutcome): number;
 export declare function printSavedTestOutcome(prefix: string, outcome: SavedTestOutcome): void;
-export declare function printSavedTestComparison(rawOutcome: SavedTestOutcome | null, workspaceOutcome: SavedTestOutcome | null): void;
+export declare function printSavedTestComparison(rawOutcome: SavedTestOutcome | null, workspaceOutcome: SavedTestOutcome | null, comparisonRunPath?: string | null): void;
+export declare function saveTestComparisonRun(options: {
+    sourcePath: string;
+    workspacePath: string;
+    workspaceName: string;
+    mode: TestRunMode;
+    rawOutcome: SavedTestOutcome | null;
+    workspaceOutcome: SavedTestOutcome | null;
+}): string;
 export declare function runSavedRawTest(options: {
     sourcePath: string;
     workspaceConfig: SourceWorkspaceConfig;
+    workspacePath?: string | null;
+    executor?: WorkflowExecutor | null;
     executionProfile?: WorkflowExecutionProfile;
-    preserveSandboxes?: BenchmarkSandboxRetentionMode;
+    preserveSandboxes?: TestSandboxRetentionMode;
 }): Promise<SavedTestOutcome | null>;
 export declare function runSavedWorkspaceTest(options: {
     sourcePath: string;
     workspaceConfig: SourceWorkspaceConfig;
+    executor?: WorkflowExecutor | null;
     executionProfile?: WorkflowExecutionProfile;
     workspacePath?: string | null;
-    preserveSandboxes?: BenchmarkSandboxRetentionMode;
+    preserveSandboxes?: TestSandboxRetentionMode;
 }): Promise<SavedTestOutcome | null>;
-//# sourceMappingURL=test-flow.d.ts.map