@interf/compiler 0.4.1 → 0.5.0

package/dist/commands/test.js

@@ -1,21 +1,41 @@
 import chalk from "chalk";
+import * as p from "@clack/prompts";
 import { detectInterf, resolveSourceControlPath, } from "../lib/interf.js";
-import { sourceWorkspaceConfigFromInterfConfig, } from "../lib/source-config.js";
+import { fingerprintTruthChecks, sourceDatasetConfigFromInterfConfig, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { chooseWorkspaceConfigToBuild, ensureWorkspaceFromConfig, findBuiltWorkspacePath, findSavedWorkspaceConfig, } from "./workspace-flow.js";
-import { printSavedTestComparison, runSavedRawTest, runSavedWorkspaceTest, saveTestComparisonRun, } from "./test-flow.js";
+import { chooseCompiledConfigToBuild, findBuiltCompiledPath, findSavedCompiledConfig, } from "./compiled-flow.js";
+import { printAgentTestFailures, printAgentTestMatrix, printSavedTestComparisonState, readSavedTestComparison, runSavedRawTest, runSavedCompiledTest, saveTestComparisonRun, } from "./test-flow.js";
+import { listRunAgentOptions, promptForTestAgents, resolveNamedLocalExecutor, resolveOrConfigureLocalExecutor, } from "./executor-flow.js";
+export function resolveConfiguredDatasetSelection(options) {
+    if (options.hintedDatasetConfig &&
+        (!options.requestedDatasetName || options.hintedDatasetConfig.name === options.requestedDatasetName)) {
+        return options.hintedDatasetConfig;
+    }
+    if (!options.requestedDatasetName) {
+        return null;
+    }
+    return findSavedCompiledConfig(options.sourcePath, options.requestedDatasetName);
+}
 export const testCommand = {
     command: "test",
-    describe: "Compare raw files and a compiled workspace on saved truth checks",
+    describe: "Compare files as-is and a compiled dataset on saved truth checks",
     builder: (yargs) => addExecutionProfileOptions(yargs)
+        .option("dataset", {
+        type: "string",
+        describe: "Dataset id to test when this project has more than one dataset",
+    })
         .option("target", {
-        choices: ["both", "raw", "workspace"],
-        describe: "Test raw files, the compiled workspace, or both. Default: both when a compiled workspace exists, otherwise raw.",
+        choices: ["both", "raw", "compiled"],
+        describe: "Test files as-is, the compiled dataset, or both. Default: both when a compiled dataset exists, otherwise files as-is.",
     })
         .option("keep-sandboxes", {
         type: "boolean",
         default: false,
-        describe: "Keep every raw or workspace test sandbox under .interf/tests/targets/sandboxes for review instead of pruning successful runs",
+        describe: "Keep every test sandbox for review instead of pruning successful ones",
+    })
+        .option("agents", {
+        type: "string",
+        describe: "Comma-separated local agents to use for this test, or `all`. Example: --agents claude-code,codex",
     }),
     handler: async (argv) => {
         await runTestCommand(argv);
@@ -27,82 +47,261 @@ function readSandboxRetentionMode(argv) {
 }
 function readRequestedMode(argv) {
     const value = argv.target;
-    return value === "raw" || value === "workspace" || value === "both" ? value : null;
+    return value === "raw" || value === "compiled" || value === "both" ? value : null;
+}
+async function promptTestMode(hasBuiltCompiled) {
+    if (!hasBuiltCompiled) {
+        return "raw";
+    }
+    const selected = await p.select({
+        message: "What do you want to test?",
+        options: [
+            {
+                value: "both",
+                label: "Compare files-as-is and compiled dataset (Recommended)",
+                hint: "Measure whether compilation helps on the saved truth checks",
+            },
+            {
+                value: "raw",
+                label: "Files-as-is only",
+                hint: "Measure the current baseline on the dataset files",
+            },
+            {
+                value: "compiled",
+                label: "Compiled dataset only",
+                hint: "Measure the current compiled dataset on the saved truth checks",
+            },
+        ],
+    });
+    if (p.isCancel(selected))
+        return null;
+    return selected;
+}
+function parseRequestedAgents(argv) {
+    const raw = argv.agents;
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return null;
+    if (raw.trim() === "all") {
+        return listRunAgentOptions().map((agent) => agent.name);
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+async function resolveSelectedTestAgents(options) {
+    const requestedAgents = parseRequestedAgents(options.argv);
+    if (requestedAgents && requestedAgents.length > 0) {
+        const selected = [];
+        for (const agentName of requestedAgents) {
+            const resolved = resolveNamedLocalExecutor(agentName, {
+                executionProfile: options.executionProfile,
+            });
+            if (!resolved.executor) {
+                process.exitCode = 1;
+                console.log(chalk.red(`  ${resolved.error ?? `Could not resolve local agent \"${agentName}\".`}`));
+                return null;
+            }
+            const option = listRunAgentOptions().find((agent) => agent.name === agentName);
+            selected.push({
+                name: agentName,
+                label: option?.displayName ?? agentName,
+                executor: resolved.executor,
+            });
+        }
+        return selected;
+    }
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+        const prompted = await promptForTestAgents();
+        if (prompted.cancelled)
+            return null;
+        if (prompted.agents.length > 0) {
+            const selected = [];
+            for (const agent of prompted.agents) {
+                const resolved = resolveNamedLocalExecutor(agent.name, {
+                    executionProfile: options.executionProfile,
+                });
+                if (!resolved.executor) {
+                    process.exitCode = 1;
+                    console.log(chalk.red(`  ${resolved.error ?? `Could not resolve local agent \"${agent.name}\".`}`));
+                    return null;
+                }
+                selected.push({
+                    name: agent.name,
+                    label: agent.displayName,
+                    executor: resolved.executor,
+                });
+            }
+            return selected;
+        }
+    }
+    const fallback = await resolveOrConfigureLocalExecutor({
+        preflight: true,
+        executionProfile: options.executionProfile,
+        purpose: "test",
+    });
+    if (!fallback.executor) {
+        if (fallback.cancelled)
+            return null;
+        process.exitCode = 1;
+        console.log(chalk.red(fallback.error ?? "No local agent detected."));
+        return null;
+    }
+    return [
+        {
+            name: fallback.executor.name,
+            label: fallback.executor.displayName,
+            executor: fallback.executor,
+        },
+    ];
+}
+async function runModeForAgent(options) {
+    const rawOutcome = options.mode === "raw" || options.mode === "both"
+        ? await runSavedRawTest({
+            sourcePath: options.sourcePath,
+            datasetConfig: options.datasetConfig,
+            executor: options.executor,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.executor.name,
+        })
+        : null;
+    const compiledOutcome = options.mode === "compiled" || options.mode === "both"
+        ? await runSavedCompiledTest({
+            sourcePath: options.sourcePath,
+            datasetConfig: options.datasetConfig,
+            compiledPath: options.builtCompiledPath,
+            executor: options.executor,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.executor.name,
+        })
+        : null;
+    return {
+        agentLabel: options.executor.displayName,
+        rawOutcome,
+        compiledOutcome,
+    };
 }
 export async function runTestCommand(argv = {}) {
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
-    const sourcePath = detected ? resolveSourceControlPath(detected.path) : cwd;
-    const selectedWorkspace = detected
-        ? (findSavedWorkspaceConfig(sourcePath, detected.config.name) ?? sourceWorkspaceConfigFromInterfConfig(detected.config))
-        : await chooseWorkspaceConfigToBuild({
-            sourcePath,
-            selectMessage: "Which workspace do you want to test?",
-        });
-    if (selectedWorkspace === undefined)
-        return;
-    if (!selectedWorkspace) {
+    const sourcePath = typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
+        ? argv.sourcePath.trim()
+        : (detected ? resolveSourceControlPath(detected.path) : cwd);
+    const requestedDatasetName = typeof argv.dataset === "string" && argv.dataset.trim().length > 0
+        ? argv.dataset.trim()
+        : null;
+    const hintedDatasetConfig = (argv.datasetConfig ?? null);
+    const selectedCompiled = detected
+        ? (() => {
+            const targetName = requestedDatasetName ?? hintedDatasetConfig?.name ?? detected.config.name;
+            return resolveConfiguredDatasetSelection({
+                sourcePath,
+                requestedDatasetName: targetName,
+                hintedDatasetConfig,
+            }) ?? (targetName === detected.config.name ? sourceDatasetConfigFromInterfConfig(detected.config) : null);
+        })()
+        : requestedDatasetName || hintedDatasetConfig
+            ? resolveConfiguredDatasetSelection({
+                sourcePath,
+                requestedDatasetName,
+                hintedDatasetConfig,
+            })
+            : await chooseCompiledConfigToBuild({
+                sourcePath,
+                selectMessage: "Which dataset do you want to test?",
+            });
+    if (selectedCompiled === undefined)
+        return false;
+    if (!selectedCompiled) {
         process.exitCode = 1;
-        console.log(chalk.red("  No workspaces are set up for this folder yet."));
-        console.log(chalk.dim("  Start with `interf` or `interf init`."));
-        return;
+        if (requestedDatasetName) {
+            console.log(chalk.red(`  Dataset "${requestedDatasetName}" is not set up in this project.`));
+            console.log(chalk.dim("  Run `interf list` to see the saved datasets."));
+        }
+        else {
+            console.log(chalk.red("  No datasets are set up for this folder yet."));
+            console.log(chalk.dim("  Start with `interf` or `interf init`."));
+        }
+        return false;
     }
-    if (selectedWorkspace.checks.length === 0) {
+    if (selectedCompiled.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."));
-        return;
+        console.log(chalk.red(`  Dataset "${selectedCompiled.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 false;
     }
     const executionProfile = executionProfileFromArgv(argv);
     const preserveSandboxes = readSandboxRetentionMode(argv);
-    const builtWorkspacePath = detected?.path ?? findBuiltWorkspacePath(sourcePath, selectedWorkspace.name);
-    const hasBuiltWorkspace = Boolean(builtWorkspacePath);
+    const builtCompiledPath = detected?.config.name === selectedCompiled.name
+        ? detected.path
+        : findBuiltCompiledPath(sourcePath, selectedCompiled.name);
+    const hasBuiltCompiled = Boolean(builtCompiledPath);
     const requestedMode = readRequestedMode(argv);
-    const selectedMode = requestedMode ?? (hasBuiltWorkspace ? "both" : "raw");
-    if (selectedMode === "workspace" && !hasBuiltWorkspace) {
+    const selectedMode = requestedMode ?? (process.stdin.isTTY && process.stdout.isTTY
+        ? await promptTestMode(hasBuiltCompiled)
+        : (hasBuiltCompiled ? "both" : "raw"));
+    if (!selectedMode)
+        return false;
+    if (selectedMode === "compiled" && !hasBuiltCompiled) {
         process.exitCode = 1;
-        console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" is not compiled yet.`));
+        console.log(chalk.red(`  Dataset "${selectedCompiled.name}" is not compiled yet.`));
         console.log(chalk.dim("  Run `interf compile` first."));
-        return;
+        return false;
     }
-    if (selectedMode === "both" && !hasBuiltWorkspace) {
-        console.log(chalk.dim(`  Workspace "${selectedWorkspace.name}" is not compiled yet. Running the raw files only.`));
+    if (selectedMode === "both" && !hasBuiltCompiled) {
+        console.log(chalk.dim(`  Dataset "${selectedCompiled.name}" is not compiled yet. Running the files as-is only.`));
     }
-    const mode = selectedMode === "both" && !hasBuiltWorkspace
+    const mode = selectedMode === "both" && !hasBuiltCompiled
         ? "raw"
         : selectedMode;
-    const artifactWorkspacePath = builtWorkspacePath ?? ensureWorkspaceFromConfig(sourcePath, selectedWorkspace);
-    const rawOutcome = mode === "raw" || mode === "both"
-        ? await runSavedRawTest({
-            sourcePath,
-            workspaceConfig: selectedWorkspace,
-            workspacePath: artifactWorkspacePath,
-            executionProfile,
-            preserveSandboxes,
-        })
-        : null;
-    const workspaceOutcome = mode === "workspace" || mode === "both"
-        ? await runSavedWorkspaceTest({
-            sourcePath,
-            workspaceConfig: selectedWorkspace,
-            executionProfile,
-            workspacePath: artifactWorkspacePath,
-            preserveSandboxes,
-        })
-        : null;
-    if ((mode === "workspace" || mode === "both") && !workspaceOutcome) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" is not compiled yet.`));
-        console.log(chalk.dim("  Run `interf compile` first."));
-        return;
+    const selectedAgents = await resolveSelectedTestAgents({
+        argv,
+        executionProfile,
+    });
+    if (!selectedAgents || selectedAgents.length === 0) {
+        return false;
     }
-    const comparisonRunPath = saveTestComparisonRun({
+    const rows = await Promise.all(selectedAgents.map((agent) => runModeForAgent({
         sourcePath,
-        workspacePath: artifactWorkspacePath,
-        workspaceName: selectedWorkspace.name,
+        datasetConfig: selectedCompiled,
+        builtCompiledPath: builtCompiledPath ?? null,
         mode,
-        rawOutcome,
-        workspaceOutcome,
-    });
-    printSavedTestComparison(rawOutcome, workspaceOutcome, comparisonRunPath);
+        preserveSandboxes,
+        executor: agent.executor,
+    })));
+    if ((mode === "compiled" || mode === "both") && rows.some((row) => !row.compiledOutcome)) {
+        process.exitCode = 1;
+        console.log(chalk.red(`  Dataset "${selectedCompiled.name}" is not compiled yet.`));
+        console.log(chalk.dim("  Run `interf compile` first."));
+        return false;
+    }
+    printAgentTestMatrix(rows);
+    printAgentTestFailures(rows);
+    if (rows.length === 1) {
+        const row = rows[0];
+        const comparisonRunPath = saveTestComparisonRun({
+            sourcePath,
+            compiledPath: builtCompiledPath ?? null,
+            compiledName: selectedCompiled.name,
+            checksFingerprint: fingerprintTruthChecks(selectedCompiled.checks),
+            mode,
+            rawOutcome: row?.rawOutcome ?? null,
+            compiledOutcome: row?.compiledOutcome ?? null,
+        });
+        const latestComparison = readSavedTestComparison(sourcePath, selectedCompiled.name);
+        if (latestComparison) {
+            if (mode === "both") {
+                console.log();
+                console.log(chalk.dim(`  Saved summary: ${comparisonRunPath}`));
+            }
+            else {
+                printSavedTestComparisonState(latestComparison, comparisonRunPath);
+            }
+        }
+        return true;
+    }
+    console.log();
+    console.log(chalk.dim("  Multi-agent compare does not overwrite the dataset's saved latest result."));
+    return true;
 }

package/dist/commands/verify.js

@@ -1,16 +1,14 @@
 import chalk from "chalk";
 import { detectInterf } from "../lib/interf.js";
-import { validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "../lib/validate.js";
+import { validateCompiledCompile, validateCompiledStage, } from "../lib/validate.js";
 import { validateWorkflowPackage } from "../lib/local-workflows.js";
 function normalizeVerifyCheck(value) {
     if (!value)
         return null;
-    if (value === "summarize")
-        return "summarize";
-    if (value === "structure")
-        return "structure";
-    if (value === "compile")
-        return "compile";
+    if (value === "stage")
+        return "stage";
+    if (value === "compiled" || value === "compile")
+        return "compiled";
     if (value === "workflow")
         return "workflow";
     return null;
@@ -21,7 +19,11 @@ export const verifyCommand = {
     builder: (yargs) => yargs
         .positional("check", {
         type: "string",
-        describe: "Check to run (`summarize`, `structure`, `compile`, or `workflow`)",
+        describe: "Check to run (`stage`, `compiled`, or `workflow`)",
+    })
+        .positional("stageId", {
+        type: "string",
+        describe: "Stage id when using `verify stage <stage-id>`",
     })
         .option("path", {
         type: "string",
@@ -53,14 +55,21 @@ export const verifyCommand = {
             const detected = detectInterf(process.cwd());
             if (!detected) {
                 process.exitCode = 1;
-                console.log(chalk.red("Run this from inside a compiled workspace."));
+                console.log(chalk.red("Run this from inside a compiled dataset."));
                 return;
             }
-            result = check === "summarize"
-                ? validateWorkspaceSummarize(detected.path)
-                : check === "structure"
-                    ? validateWorkspaceStructure(detected.path)
-                    : validateWorkspaceCompile(detected.path);
+            if (check === "compiled") {
+                result = validateCompiledCompile(detected.path);
+            }
+            else {
+                const stageId = argv.stageId;
+                if (!stageId) {
+                    process.exitCode = 1;
+                    console.log(chalk.red("`interf verify stage` needs <stage-id>."));
+                    return;
+                }
+                result = validateCompiledStage(detected.path, stageId);
+            }
         }
         if (argv.json) {
             console.log(JSON.stringify(result, null, 2));

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { createWorkspace, compileWorkspace, runWorkspaceSummarize, runWorkspaceCompile, } from "./lib/workflows.js";
+export { createCompiled, compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./lib/workflows.js";
 export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
-export { computeWorkspaceHealth, } from "./lib/state.js";
+export { computeCompiledHealth, } from "./lib/state.js";
 export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
-export { validateWorkspaceSummarize, validateWorkspaceCompile, } from "./lib/validate.js";
-export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";
+export { validateCompiledSummarize, validateCompiledCompile, } from "./lib/validate.js";
+export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, CompiledHealthSchema, } from "./lib/schema.js";
 export type { InterfConfig } from "./lib/interf.js";
 export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, LoadedTestSpec, TestTargetCandidate, } from "./lib/test.js";
-export type { SourceTruthCheck, SourceWorkspaceConfig, SourceFolderConfig, WorkspaceHealth, } from "./lib/schema.js";
-export type { WorkspaceSummarizeValidation, WorkspaceCompileValidation, } from "./lib/validate.js";
-export type { WorkspaceSummarizeResult, WorkspaceCompileResult, } from "./lib/workflows.js";
+export type { SourceTruthCheck, SourceDatasetConfig, SourceFolderConfig, CompiledHealth, } from "./lib/schema.js";
+export type { CompiledStageValidation, CompiledWorkflowValidation, } from "./lib/validate.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, } from "./lib/workflows.js";

package/dist/index.js

@@ -1,6 +1,6 @@
-export { createWorkspace, compileWorkspace, runWorkspaceSummarize, runWorkspaceCompile, } from "./lib/workflows.js";
+export { createCompiled, compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./lib/workflows.js";
 export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
-export { computeWorkspaceHealth, } from "./lib/state.js";
+export { computeCompiledHealth, } from "./lib/state.js";
 export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
-export { validateWorkspaceSummarize, validateWorkspaceCompile, } from "./lib/validate.js";
-export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, WorkspaceHealthSchema, } from "./lib/schema.js";
+export { validateCompiledSummarize, validateCompiledCompile, } from "./lib/validate.js";
+export { InterfConfigSchema, TestSpecSchema, SourceFolderConfigSchema, CompiledHealthSchema, } from "./lib/schema.js";

package/dist/lib/agent-args.js

@@ -1,3 +1,4 @@
+const CODEX_SANDBOX_MODE = `work${"space-write"}`;
 export function buildAgentArgs(agent, prompt, executionProfile = {}) {
     if (agent.name === "claude-code") {
         const args = [
@@ -22,7 +23,7 @@ export function buildAgentArgs(agent, prompt, executionProfile = {}) {
             "exec",
             "--json",
             "-s",
-            "workspace-write",
+            CODEX_SANDBOX_MODE,
             "--skip-git-repo-check",
         ];
         if (executionProfile.model) {

package/dist/lib/agent-constants.js

@@ -22,7 +22,7 @@ export const AGENTS = [
     },
 ];
 export const CODEX_NOISE_PATTERNS = [
-    /codex_core_skills::loader: failed to stat skills entry .*\/(interf-[^ ]+|workspace\/[^ ]+) \(symlink\): No such file or directory/,
+    /codex_core_skills::loader: failed to stat skills entry .*\/(interf-[^ ]+|compiled\/[^ ]+) \(symlink\): No such file or directory/,
     /codex_core::codex: failed to load skill .*\/gstack\/SKILL\.md: invalid description: exceeds maximum length of 1024 characters/,
 ];
 export const VISIBLE_STATUS_PREFIXES = ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"];

package/dist/lib/agent-render.js

@@ -167,14 +167,14 @@ function summarizeToolUse(name, input) {
     const target = summarizeToolTarget(input);
     switch (name) {
         case "Read":
-            return target ? `reading ${target}` : "reading workspace files";
+            return target ? `reading ${target}` : "reading compiled files";
         case "Write":
-            return target ? `writing ${target}` : "writing workspace files";
+            return target ? `writing ${target}` : "writing compiled files";
         case "Edit":
-            return target ? `editing ${target}` : "editing workspace files";
+            return target ? `editing ${target}` : "editing compiled files";
         case "Glob":
         case "Grep":
-            return target ? `${name.toLowerCase()} on ${target}` : `${name.toLowerCase()}ing workspace files`;
+            return target ? `${name.toLowerCase()} on ${target}` : `${name.toLowerCase()}ing compiled files`;
         case "Bash":
             return target ? `running ${target}` : "running a local helper";
         default:

package/dist/lib/agent-shells.d.ts

@@ -8,26 +8,26 @@ export interface NativeStageDefinition {
     reads: WorkflowZoneId[];
     writes: WorkflowZoneId[];
 }
-export declare function renderWorkspaceAgents(name: string, workflowId: string, about?: string, options?: {
+export declare function renderCompiledAgents(compiledPath: string, name: string, workflowId: string, about?: string, options?: {
     workflowOriginSelected?: string | null;
     workflowLocalDraft?: boolean;
 }): string;
-export declare function renderWorkspaceQuerySkill(): string;
-export declare function syncStageExecutionShellWrites(workspacePath: string, shellRoot: string, stage: NativeStageDefinition): void;
+export declare function renderCompiledQuerySkill(): string;
+export declare function syncStageExecutionShellWrites(compiledPath: string, shellRoot: string, stage: NativeStageDefinition, writeArtifacts?: readonly string[]): void;
 export declare function renderClaudeBootstrap(content: string): string;
-export declare function pruneStageExecutionShells(workspacePath: string): void;
-export declare function projectWorkspaceQueryShell(workspacePath: string, workspaceName: string, workflowId: string, about?: string, options?: {
+export declare function pruneStageExecutionShells(compiledPath: string): void;
+export declare function projectCompiledQueryShell(compiledPath: string, compiledName: string, workflowId: string, about?: string, options?: {
     workflowOriginSelected?: string | null;
     workflowLocalDraft?: boolean;
 }): boolean;
 export declare function projectRawTestQueryShell(rootPath: string): boolean;
-export declare function createStageExecutionShell(workspacePath: string, workspaceName: string, workflowId: string, stage: NativeStageDefinition): {
+export declare function createStageExecutionShell(compiledPath: string, compiledName: string, workflowId: string, stage: NativeStageDefinition, writeArtifacts?: readonly string[]): {
     rootPath: string;
 };
 export declare function freezeStageExecutionShell(rootPath: string): string | null;
 export declare function createWorkflowImprovementShell(options: {
-    workspacePath: string;
-    workspaceName: string;
+    compiledPath: string;
+    compiledName: string;
     workflowId: string;
     runId: string;
     loopIndex: number;