@interf/compiler 0.3.4 → 0.4.0

package/dist/commands/compile.js

@@ -1,27 +1,27 @@
-import { cpSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { findSourceWorkspaceConfig, loadSourceFolderConfig, resolveWorkspaceCompileMaxAttempts, } from "../lib/source-config.js";
-import { resetWorkspaceGeneratedState } from "../lib/workspace-reset.js";
-import { formatWorkspaceWorkflowStageStep, resolveWorkspaceWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { sourceWorkspaceConfigFromInterfConfig, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { chooseWorkspaceConfigToBuild, compileWorkspaceWithReporter, ensureWorkspaceFromConfig, } from "./workspace-flow.js";
+import { chooseWorkspaceConfigToBuild, ensureWorkspaceFromConfig, } from "./workspace-flow.js";
+import { promptCompileLoopSelection, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { printSavedTestOutcome, questionPassRate, runSavedWorkspaceTest } from "./test-flow.js";
+import { runConfiguredWorkspaceCompile } from "./compile-controller.js";
+export { runConfiguredWorkspaceCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
     describe: "Build a workspace for this dataset",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
         alias: "max-retries",
         type: "number",
-        describe: "Compile, test, and retry until the workspace passes or reaches this total attempt limit",
+        describe: "Retry compile + test for the same workflow until the workspace passes or reaches this total attempt limit",
+    }).option("max-loops", {
+        type: "number",
+        describe: "After retries fail, let Interf edit the workflow and test new workflow variations up to this loop limit",
     }).option("keep-stage-shells", {
         type: "boolean",
         default: false,
-        describe: "Keep every executed stage shell under .interf/execution-shells for review instead of pruning successful shells",
+        describe: "Keep every executed stage shell under .interf/runtime/execution-shells for review instead of pruning successful shells",
     }),
     handler: async (argv) => {
         await runCompileCommand(argv);
@@ -35,12 +35,7 @@ export async function runCompileCommand(argv = {}) {
     if (detected) {
         workspacePath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
-        workspaceConfig = findSourceWorkspaceConfig(loadSourceFolderConfig(sourcePath), detected.config.name) ?? {
-            name: detected.config.name,
-            ...(detected.config.about ? { about: detected.config.about } : {}),
-            ...(detected.config.workflow ? { workflow: detected.config.workflow } : {}),
-            checks: [],
-        };
+        workspaceConfig = sourceWorkspaceConfigFromInterfConfig(detected.config);
         if (process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await p.confirm({
                 message: `Compile workspace "${detected.config.name}" now?`,
@@ -76,14 +71,27 @@ export async function runCompileCommand(argv = {}) {
         console.log(chalk.dim(`  Workspace: ${selectedWorkspace.name}`));
     }
     let maxAttemptsOverride = null;
+    let maxLoopsOverride = null;
     try {
         maxAttemptsOverride = readCompileMaxAttemptsOverride(argv);
+        maxLoopsOverride = readCompileMaxLoopsOverride(argv);
     }
     catch (error) {
         process.exitCode = 1;
         console.log(chalk.red(error instanceof Error ? error.message : String(error)));
         return;
     }
+    const interactiveOverrides = await resolveInteractiveCompileLoopOverrides({
+        workspacePath,
+        workspaceConfig,
+        maxAttemptsOverride,
+        maxLoopsOverride,
+    });
+    if (!interactiveOverrides)
+        return;
+    workspaceConfig = interactiveOverrides.workspaceConfig;
+    maxAttemptsOverride = interactiveOverrides.maxAttemptsOverride;
+    maxLoopsOverride = interactiveOverrides.maxLoopsOverride;
     const executionProfile = executionProfileFromArgv(argv);
     const { executor, error } = await resolveOrConfigureLocalExecutor({
         executionProfile,
@@ -103,9 +111,127 @@ export async function runCompileCommand(argv = {}) {
         workspaceConfig,
         executionProfile,
         maxAttemptsOverride,
+        maxLoopsOverride,
         preserveStageShells: readStageShellRetentionMode(argv),
     });
 }
+export async function resolveInteractiveCompileLoopOverrides(options) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return {
+            workspaceConfig: options.workspaceConfig,
+            maxAttemptsOverride: options.maxAttemptsOverride,
+            maxLoopsOverride: options.maxLoopsOverride,
+        };
+    }
+    if (options.maxAttemptsOverride != null || options.maxLoopsOverride != null) {
+        return {
+            workspaceConfig: options.workspaceConfig,
+            maxAttemptsOverride: options.maxAttemptsOverride,
+            maxLoopsOverride: options.maxLoopsOverride,
+        };
+    }
+    const currentConfig = readInterfConfig(options.workspacePath);
+    const checks = options.workspaceConfig?.checks.length
+        ? options.workspaceConfig.checks
+        : (currentConfig?.checks ?? []);
+    if (checks.length === 0) {
+        return {
+            workspaceConfig: options.workspaceConfig,
+            maxAttemptsOverride: options.maxAttemptsOverride,
+            maxLoopsOverride: options.maxLoopsOverride,
+        };
+    }
+    const savedWorkspaceConfig = options.workspaceConfig
+        ?? (currentConfig ? sourceWorkspaceConfigFromInterfConfig(currentConfig) : null);
+    if (!savedWorkspaceConfig) {
+        return {
+            workspaceConfig: options.workspaceConfig,
+            maxAttemptsOverride: options.maxAttemptsOverride,
+            maxLoopsOverride: options.maxLoopsOverride,
+        };
+    }
+    const hasSavedPolicy = typeof savedWorkspaceConfig.max_attempts === "number" ||
+        typeof savedWorkspaceConfig.max_loops === "number";
+    if (!hasSavedPolicy) {
+        const overrideSelection = await promptCompileLoopSelection({
+            hasChecks: true,
+            initialMaxAttempts: savedWorkspaceConfig.max_attempts,
+            initialMaxLoops: savedWorkspaceConfig.max_loops,
+            intro: [
+                `Workflow: ${savedWorkspaceConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
+                "This selection applies to this compile run only. It does not change the saved workspace setup.",
+            ],
+            message: "How should this compile run?",
+        });
+        if (overrideSelection === null)
+            return null;
+        return {
+            workspaceConfig: {
+                ...savedWorkspaceConfig,
+                max_attempts: undefined,
+                max_loops: undefined,
+            },
+            maxAttemptsOverride: overrideSelection.max_attempts ?? null,
+            maxLoopsOverride: overrideSelection.max_loops ?? null,
+        };
+    }
+    const savedMode = await p.select({
+        message: "Which compile mode should this run use?",
+        options: [
+            {
+                value: "saved",
+                label: "Use saved compile mode (Recommended)",
+                hint: `${savedWorkspaceConfig.max_loops ? "Self-improving" : savedWorkspaceConfig.max_attempts && savedWorkspaceConfig.max_attempts > 1 ? "Retry" : "Single attempt"} · ${formatCompileModeHint(savedWorkspaceConfig)}`,
+            },
+            {
+                value: "override",
+                label: "Change it for this run only",
+                hint: "Keep the saved workspace setup unchanged",
+            },
+        ],
+    });
+    if (p.isCancel(savedMode))
+        return null;
+    if (savedMode === "saved") {
+        return {
+            workspaceConfig: savedWorkspaceConfig,
+            maxAttemptsOverride: null,
+            maxLoopsOverride: null,
+        };
+    }
+    const selection = await promptCompileLoopSelection({
+        hasChecks: true,
+        initialMaxAttempts: savedWorkspaceConfig.max_attempts,
+        initialMaxLoops: savedWorkspaceConfig.max_loops,
+        intro: [
+            `Workflow: ${savedWorkspaceConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
+            "This applies to this compile run only. It does not change the saved workspace setup.",
+        ],
+        message: "Override the compile mode for this run",
+    });
+    if (selection === null)
+        return null;
+    return {
+        ...savedWorkspaceConfig,
+        workspaceConfig: {
+            ...savedWorkspaceConfig,
+            max_attempts: undefined,
+            max_loops: undefined,
+        },
+        maxAttemptsOverride: selection.max_attempts ?? null,
+        maxLoopsOverride: selection.max_loops ?? null,
+    };
+}
+function formatCompileModeHint(workspaceConfig) {
+    if (typeof workspaceConfig.max_loops === "number" && workspaceConfig.max_loops > 0) {
+        const attempts = workspaceConfig.max_attempts ?? 1;
+        return `${attempts} attempt${attempts === 1 ? "" : "s"} per variation, ${workspaceConfig.max_loops} loop${workspaceConfig.max_loops === 1 ? "" : "s"}`;
+    }
+    if (typeof workspaceConfig.max_attempts === "number" && workspaceConfig.max_attempts > 1) {
+        return `${workspaceConfig.max_attempts} attempts`;
+    }
+    return "1 attempt";
+}
 function readCompileMaxAttemptsOverride(argv) {
     const raw = argv["max-attempts"] ??
         argv.maxAttempts ??
@@ -125,142 +251,14 @@ function readStageShellRetentionMode(argv) {
         false;
     return enabled ? "always" : "on-failure";
 }
-function printCompileFailure(workspacePath, failedStage) {
-    const workflowId = resolveWorkspaceWorkflowFromConfig(readInterfConfig(workspacePath));
-    const failedStageLabel = formatWorkspaceWorkflowStageStep(workflowId, failedStage ?? "compile", {
-        sourcePath: resolveSourceControlPath(workspacePath),
-    });
-    console.log(chalk.red(`  ${failedStageLabel} failed.`));
-}
-function testScore(outcome) {
-    return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
-}
-function snapshotWorkspace(workspacePath) {
-    const snapshotRoot = mkdtempSync(join(tmpdir(), "interf-compile-attempt-"));
-    const snapshotPath = join(snapshotRoot, "workspace");
-    cpSync(workspacePath, snapshotPath, { recursive: true });
-    return snapshotPath;
-}
-function restoreWorkspaceSnapshot(snapshotPath, workspacePath) {
-    rmSync(workspacePath, { recursive: true, force: true });
-    cpSync(snapshotPath, workspacePath, { recursive: true });
-}
-export async function runConfiguredWorkspaceCompile(options) {
-    const preserveStageShells = options.preserveStageShells ?? "on-failure";
-    const maxAttempts = resolveWorkspaceCompileMaxAttempts(options.workspaceConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const loopEnabled = maxAttempts != null;
-    const checks = options.workspaceConfig?.checks ?? [];
-    if (loopEnabled && checks.length === 0) {
-        console.log(chalk.yellow("  Self-improving mode needs saved truth checks. Building once without the retry loop."));
-    }
-    else if (loopEnabled) {
-        console.log(chalk.dim(`  Self-improving mode: up to ${maxAttempts} compile attempts.`));
-        console.log(chalk.dim("  Interf Compiler will run the workflow, test the workspace, and retry until it passes or reaches the limit."));
-    }
-    if (!loopEnabled || checks.length === 0) {
-        const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
-            preserveStageShells,
-        });
-        if (!result.ok) {
-            process.exitCode = 1;
-            printCompileFailure(options.workspacePath, result.failedStage);
-            printStageShellReviewHint(options.workspacePath, preserveStageShells);
-            return false;
-        }
-        printStageShellReviewHint(options.workspacePath, preserveStageShells);
-        return true;
-    }
-    let bestOutcome = null;
-    let bestSnapshotPath = null;
-    let bestAttempt = 0;
-    try {
-        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-            if (attempt > 1) {
-                console.log();
-                console.log(chalk.dim(`  Resetting generated workspace state before attempt ${attempt}/${maxAttempts}...`));
-                resetWorkspaceGeneratedState(options.workspacePath, "compile");
-            }
-            const result = await compileWorkspaceWithReporter(options.executor, options.workspacePath, {
-                heading: maxAttempts > 1
-                    ? `Building compiled workspace (attempt ${attempt}/${maxAttempts})...`
-                    : "Building compiled workspace...",
-                successMessage: maxAttempts > 1
-                    ? `Compiled workspace ready for attempt ${attempt}.`
-                    : "Compiled workspace ready.",
-                preserveStageShells,
-            });
-            if (!result.ok) {
-                printCompileFailure(options.workspacePath, result.failedStage);
-                printStageShellReviewHint(options.workspacePath, preserveStageShells);
-                if (attempt < maxAttempts) {
-                    console.log(chalk.yellow(`  Attempt ${attempt}/${maxAttempts} failed. Retrying with a fresh compile.`));
-                    continue;
-                }
-                process.exitCode = 1;
-                return false;
-            }
-            const outcome = await runSavedWorkspaceTest({
-                sourcePath: options.sourcePath,
-                workspaceConfig: options.workspaceConfig ?? {
-                    name: readInterfConfig(options.workspacePath)?.name ?? "workspace",
-                    checks: [],
-                },
-                executionProfile: options.executionProfile,
-                workspacePath: options.workspacePath,
-                preserveSandboxes: preserveStageShells === "always" ? "always" : "on-failure",
-            });
-            if (!outcome) {
-                process.exitCode = 1;
-                console.log(chalk.red("  Could not run the saved workspace test after compile."));
-                return false;
-            }
-            console.log();
-            printSavedTestOutcome(`Compiled workspace · attempt ${attempt}/${maxAttempts}`, outcome);
-            if (!bestOutcome || testScore(outcome) > testScore(bestOutcome)) {
-                if (bestSnapshotPath) {
-                    rmSync(bestSnapshotPath, { recursive: true, force: true });
-                }
-                bestOutcome = outcome;
-                bestSnapshotPath = snapshotWorkspace(options.workspacePath);
-                bestAttempt = attempt;
-            }
-            if (outcome.result.ok) {
-                console.log();
-                console.log(chalk.green(`  Workspace passed on attempt ${attempt}/${maxAttempts}.`));
-                printStageShellReviewHint(options.workspacePath, preserveStageShells);
-                return true;
-            }
-            if (attempt < maxAttempts) {
-                console.log();
-                console.log(chalk.yellow(`  Attempt ${attempt}/${maxAttempts} did not pass. Retrying with a fresh compile.`));
-            }
-        }
-        if (bestSnapshotPath && bestAttempt > 0 && bestAttempt !== maxAttempts) {
-            restoreWorkspaceSnapshot(bestSnapshotPath, options.workspacePath);
-            console.log();
-            console.log(chalk.dim(`  Restored the best-performing compiled workspace from attempt ${bestAttempt}/${maxAttempts}.`));
-        }
-        process.exitCode = 1;
-        console.log();
-        console.log(chalk.red(`  Workspace did not pass within ${maxAttempts} attempts.`));
-        if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt truth-check pass rate: ${questionPassRate(bestOutcome)}%.`));
-        }
-        printStageShellReviewHint(options.workspacePath, preserveStageShells);
-        return false;
-    }
-    finally {
-        if (bestSnapshotPath) {
-            rmSync(bestSnapshotPath, { recursive: true, force: true });
-        }
-    }
-}
-function printStageShellReviewHint(workspacePath, preserveStageShells) {
-    const reviewRoot = join(workspacePath, ".interf", "execution-shells");
-    if (preserveStageShells === "always") {
-        console.log(chalk.dim(`  Preserved stage shells: ${reviewRoot}`));
-        return;
+function readCompileMaxLoopsOverride(argv) {
+    const raw = argv["max-loops"] ??
+        argv.maxLoops;
+    if (raw == null)
+        return null;
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 3) {
+        throw new Error("`--max-loops` must be a whole number from 1 to 3.");
     }
-    console.log(chalk.dim(`  Failed stage shells remain under: ${reviewRoot}`));
+    return parsed;
 }
-//# sourceMappingURL=compile.js.map

package/dist/commands/create-workflow-wizard.d.ts

@@ -35,10 +35,12 @@ export declare function buildWorkspaceWorkflowOptions(sourcePath: string): {
     label: string;
     hint: string;
 }[];
-export declare function chooseWorkspaceWorkflow(sourcePath: string): Promise<string | symbol>;
+export declare function chooseWorkspaceWorkflow(sourcePath: string, options?: {
+    currentWorkflowId?: string;
+    message?: string;
+}): Promise<string | symbol>;
 export declare function createWorkflowWizard(options?: {
     intro?: boolean;
     sourcePath?: string;
 }, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
 export declare function createWorkspaceWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
-//# sourceMappingURL=create-workflow-wizard.d.ts.map

package/dist/commands/create-workflow-wizard.js

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { listWorkspaceWorkflowChoices, } from "../lib/workflow-definitions.js";
-import { isWorkflowId, writeLocalWorkflowDefinition, } from "../lib/local-workflows.js";
-import { renderJsonFrontmatter } from "../lib/parse.js";
+import { createLocalWorkflowPackageFromTemplate } from "../lib/interf-workflow-package.js";
+import { isWorkflowId, } from "../lib/local-workflows.js";
 import { slugify } from "../lib/util.js";
 export const clackWorkflowPrompts = {
     intro: p.intro,
@@ -23,10 +23,30 @@ export function formatWorkflowLabel(workflow) {
 export function buildWorkspaceWorkflowOptions(sourcePath) {
     return listWorkspaceWorkflowChoices(sourcePath).map(formatWorkflowLabel);
 }
-export async function chooseWorkspaceWorkflow(sourcePath) {
+export async function chooseWorkspaceWorkflow(sourcePath, options = {}) {
+    const currentWorkflowId = options.currentWorkflowId;
+    const workflowOptions = buildWorkspaceWorkflowOptions(sourcePath);
+    const orderedOptions = workflowOptions
+        .map((option) => option.value === currentWorkflowId
+        ? {
+            ...option,
+            label: `${option.label} (Current)`,
+            hint: option.hint,
+        }
+        : option)
+        .sort((left, right) => {
+        if (left.value === currentWorkflowId)
+            return -1;
+        if (right.value === currentWorkflowId)
+            return 1;
+        return 0;
+    });
+    if (orderedOptions.length === 1) {
+        return orderedOptions[0]?.value ?? "interf";
+    }
     return p.select({
-        message: "Workspace workflow?",
-        options: buildWorkspaceWorkflowOptions(sourcePath),
+        message: options.message ?? "Workspace workflow?",
+        options: orderedOptions,
     });
 }
 export async function createWorkflowWizard(options = {}, prompts = clackWorkflowPrompts) {
@@ -90,34 +110,16 @@ export async function createWorkspaceWorkflowWizard(sourcePath, prompts = clackW
     });
     if (prompts.isCancel(shapeBias))
         return shapeBias;
-    const workflowPath = writeLocalWorkflowDefinition(sourcePath, workflowId, {
-        id: workflowId,
-        type: "workspace",
+    const workflowPath = createLocalWorkflowPackageFromTemplate({
+        sourcePath,
+        baseWorkflowId: baseWorkflow,
+        workflowId,
         label,
         hint: hint.trim(),
-        extends: baseWorkflow,
-        stage_policy_notes: {
-            summarize: [summarizeBias.trim()],
-            structure: [structureBias.trim()],
-            shape: [shapeBias.trim()],
-        },
-    }, [
-        {
-            relativePath: "README.md",
-            content: [
-                renderJsonFrontmatter({ mode: "extend" }),
-                `# ${label}`,
-                "",
-                `This local workspace workflow extends \`${baseWorkflow}\`.`,
-                "",
-                `- summarize bias: ${summarizeBias.trim()}`,
-                `- structure bias: ${structureBias.trim()}`,
-                `- shape bias: ${shapeBias.trim()}`,
-                "",
-            ].join("\n"),
-        },
-    ]);
+        summarizeBias: summarizeBias.trim(),
+        structureBias: structureBias.trim(),
+        shapeBias: shapeBias.trim(),
+    });
     prompts.log.info(`Saved local workflow: ${workflowPath}`);
     return workflowId;
 }
-//# sourceMappingURL=create-workflow-wizard.js.map

package/dist/commands/create.d.ts

@@ -6,4 +6,3 @@ export declare function createWorkspaceWizard(options?: {
     executionProfile?: WorkflowExecutionProfile;
 }): Promise<void>;
 export { type WorkflowWizardPrompts, formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
-//# sourceMappingURL=create.d.ts.map

package/dist/commands/create.js

@@ -5,7 +5,7 @@ import { detectInterf, defaultWorkspaceNameForSource, listWorkspacesForSourceFol
 import { slugify } from "../lib/util.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
 import { loadSourceFolderConfig, upsertSourceWorkspaceConfig } from "../lib/source-config.js";
-import { chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { buildWorkspaceWorkflowOptions, chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
 import { ensureWorkspaceFromConfig, } from "./workspace-flow.js";
 import { DEFAULT_WORKSPACE_NAME, promptSingleWorkspaceConfig, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
@@ -36,7 +36,7 @@ async function selectCreateTarget() {
             {
                 value: "workflow",
                 label: "Workflow",
-                hint: "Create a reusable local workflow package",
+                hint: "Create a reusable local workflow",
             },
         ],
     });
@@ -89,16 +89,21 @@ export async function createWorkspaceWizard(options = {}) {
     p.log.info("Interf Compiler builds a compiled workspace on top of the dataset. The source files stay where they are and stay the source of truth.");
     const existingConfig = loadSourceFolderConfig(cwd);
     const suggestedName = slugify(defaultWorkspaceNameForSource(cwd) || basename(cwd)) || DEFAULT_WORKSPACE_NAME;
+    const workflowChoice = await chooseWorkspaceWorkflow(cwd, {
+        message: "Which workflow should this workspace start from?",
+    });
+    if (p.isCancel(workflowChoice))
+        return;
+    const workflowId = workflowChoice;
+    const workflowLabel = buildWorkspaceWorkflowOptions(cwd)
+        .find((option) => option.value === workflowId)?.label ?? workflowId;
     const draft = await promptSingleWorkspaceConfig({
         initial: { name: suggestedName },
         introStyle: existingConfig ? "additional" : "first",
+        selectedWorkflowLabel: workflowLabel,
     });
     if (!draft)
         return;
-    const workflowChoice = await chooseWorkspaceWorkflow(cwd);
-    if (p.isCancel(workflowChoice))
-        return;
-    const workflowId = workflowChoice;
     const configToSave = {
         ...draft,
         workflow: workflowId,
@@ -124,7 +129,7 @@ export async function createWorkspaceWizard(options = {}) {
         return;
     }
     const compileNow = await p.confirm({
-        message: "Build it now? (Recommended)",
+        message: "Build it now with this workflow and compile mode? (Recommended)",
         initialValue: true,
     });
     if (p.isCancel(compileNow) || !compileNow) {
@@ -155,11 +160,10 @@ async function compileWorkspaceAfterCreate(executor, sourcePath, workspaceConfig
         workspaceConfig,
         executionProfile,
         maxAttemptsOverride: null,
+        maxLoopsOverride: null,
     });
-    if (!compiled) {
+    if (!compiled)
         process.exitCode = 1;
-        return;
-    }
+    return compiled;
 }
 export { formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
-//# sourceMappingURL=create.js.map

package/dist/commands/default.d.ts

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

package/dist/commands/default.js

@@ -35,4 +35,3 @@ export const defaultCommand = {
         await runInitCommand();
     },
 };
-//# sourceMappingURL=default.js.map

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { inspectInterfSkills, resolveAgent, runAgentPreflight } from "../lib/agents.js";
+import { resolveAgent, runAgentPreflight } from "../lib/agents.js";
 import { loadUserConfig } from "../lib/user-config.js";
 function iconFor(status) {
     if (status === "pass")
@@ -72,20 +72,6 @@ export const doctorCommand = {
             status: "pass",
             message: `${agent.displayName} is configured and available as \`${agent.command}\``,
         });
-        const skillHealth = inspectInterfSkills(agent);
-        const skillProblems = [
-            ...skillHealth.missing.map((name) => `missing ${name}`),
-            ...skillHealth.stale.map((name) => `stale ${name}`),
-            ...skillHealth.wrongAgent.map((name) => `wrong-agent ${name}`),
-        ];
-        checks.push({
-            id: "skills",
-            label: "Optional global Interf Compiler skills",
-            status: skillProblems.length === 0 ? "pass" : "warn",
-            message: skillProblems.length === 0
-                ? "Installed and current"
-                : `Optional only; refresh with \`interf\` or \`interf init\`. Problems: ${skillProblems.join(", ")}`,
-        });
         if (argv.live) {
             const preflight = runAgentPreflight(agent);
             checks.push({
@@ -143,4 +129,3 @@ export const doctorCommand = {
         process.exitCode = ok ? 0 : 1;
     },
 };
-//# sourceMappingURL=doctor.js.map

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

@@ -8,4 +8,3 @@ export declare function resolveOrConfigureLocalExecutor(options?: {
     error?: string;
     cancelled?: boolean;
 }>;
-//# sourceMappingURL=executor-flow.d.ts.map

package/dist/commands/executor-flow.js

@@ -101,4 +101,3 @@ export async function resolveOrConfigureLocalExecutor(options = {}) {
     }
     return resolveLocalExecutor(options);
 }
-//# sourceMappingURL=executor-flow.js.map

package/dist/commands/init.d.ts

@@ -1,4 +1,3 @@
 import type { CommandModule } from "yargs";
 export declare const initCommand: CommandModule;
 export declare function runInitCommand(): Promise<void>;
-//# sourceMappingURL=init.d.ts.map