@interf/compiler 0.4.1 → 0.5.1

package/dist/lib/workflow-definitions.js

@@ -3,16 +3,9 @@ import { join } from "node:path";
 import { isWorkflowId, listLocalWorkflowDefinitions, loadLocalWorkflowDefinition, loadWorkflowDefinitionFromDir, } from "./local-workflows.js";
 import { PACKAGE_ROOT } from "./config.js";
 import { resolveSourceControlPath } from "./interf.js";
-import { validateWorkspaceContractSequence, } from "./workflow-abi.js";
 import { warnInterf } from "./logger.js";
-import { workflowPackagePathForWorkspace } from "./workspace-paths.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 let builtinInterfWorkflowCache = null;
-function validateWorkspaceStages(stages) {
-    if (stages.length < 3)
-        return false;
-    const sequence = validateWorkspaceContractSequence(stages.map((stage) => stage.contractType));
-    return sequence.ok;
-}
 function toWorkflowStages(stages, fallbackStages) {
     if (!stages || stages.length === 0)
         return [...fallbackStages];
@@ -42,13 +35,13 @@ function mergeStagePolicyNotes(stages, baseNotes, overrideNotes) {
 }
 export function standaloneWorkflowDefinitionFromLocalPackage(local) {
     if (!local.stages || local.stages.length === 0) {
-        throw new Error(`Workflow package "${local.id}" is missing explicit stages. Workspace-local and portable workflow packages must be standalone.`);
+        throw new Error(`Workflow package "${local.id}" is missing explicit stages. Compiled-local and portable workflow packages must be standalone.`);
     }
     const stages = toWorkflowStages(local.stages, []);
     return {
         id: local.id,
         compilerApi: local.compiler_api ?? {
-            kind: "workspace",
+            kind: "compiled",
             version: 1,
         },
         label: local.label,
@@ -71,9 +64,6 @@ function getBuiltinInterfWorkflow() {
         throw new Error("Missing built-in Interf workflow package at builtin-workflows/interf.");
     }
     const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    if (!validateWorkspaceStages(resolved.stages)) {
-        throw new Error("Built-in Interf workflow package has an invalid stage ordering.");
-    }
     builtinInterfWorkflowCache = {
         ...resolved,
         id: "interf",
@@ -82,31 +72,28 @@ function getBuiltinInterfWorkflow() {
     };
     return builtinInterfWorkflowCache;
 }
-function listBuiltinWorkspaceWorkflows() {
+function listBuiltinCompiledWorkflows() {
     return [getBuiltinInterfWorkflow()];
 }
-function resolveWorkspaceWorkflowFromLocal(workflowId, sourcePath) {
+function resolveCompiledWorkflowFromLocal(workflowId, sourcePath) {
     const local = loadLocalWorkflowDefinition(sourcePath, workflowId);
     if (!local)
         return null;
     if (local.extends) {
-        throw new Error(`Workflow "${workflowId}" uses legacy extends. Rewrite it as a standalone package before creating or compiling a workspace.`);
+        throw new Error(`Workflow "${workflowId}" uses legacy extends. Rewrite it as a standalone package before creating or compiling a compiled dataset.`);
     }
     const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-    if (!validateWorkspaceStages(resolved.stages)) {
-        throw new Error(`Workflow "${workflowId}" has an invalid stage ordering. Workspace workflows must have one or more workspace-file-evidence stages followed by one or more workspace-knowledge-structure stages and one or more workspace-query-shape stages.`);
-    }
     return resolved;
 }
-export function listWorkspaceWorkflowChoices(sourcePath) {
-    const builtins = listBuiltinWorkspaceWorkflows();
+export function listCompiledWorkflowChoices(sourcePath) {
+    const builtins = listBuiltinCompiledWorkflows();
     if (!sourcePath)
         return builtins;
     const locals = listLocalWorkflowDefinitions(sourcePath)
         .filter((definition) => definition.id !== "interf")
         .map((definition) => {
         try {
-            return resolveWorkspaceWorkflowFromLocal(definition.id, sourcePath);
+            return resolveCompiledWorkflowFromLocal(definition.id, sourcePath);
         }
         catch (error) {
             warnInterf(`Warning: skipping local workflow "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
@@ -116,66 +103,69 @@ export function listWorkspaceWorkflowChoices(sourcePath) {
         .filter((definition) => definition !== null);
     return [...builtins, ...locals];
 }
-export function getWorkspaceWorkflow(workflowId, options = {}) {
-    const builtin = listBuiltinWorkspaceWorkflows().find((candidate) => candidate.id === workflowId);
+export function getCompiledWorkflow(workflowId, options = {}) {
+    const builtin = listBuiltinCompiledWorkflows().find((candidate) => candidate.id === workflowId);
     if (builtin)
         return builtin;
     if (options.sourcePath) {
-        const local = resolveWorkspaceWorkflowFromLocal(workflowId, options.sourcePath);
+        const local = resolveCompiledWorkflowFromLocal(workflowId, options.sourcePath);
         if (local)
             return local;
         throw new Error(`No local workflow package found for "${workflowId}" under ${join(options.sourcePath, "interf", "workflows", workflowId)}.`);
     }
     throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf Compiler can resolve a local workflow package.`);
 }
-export function getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId) {
-    const workflowPath = workflowPackagePathForWorkspace(workspacePath);
+export function getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId) {
+    const workflowPath = workflowPackagePathForCompiled(compiledPath);
     if (existsSync(join(workflowPath, "workflow.json"))) {
         const local = loadWorkflowDefinitionFromDir(workflowPath);
         if (!local) {
-            throw new Error(`Workspace-local workflow package at ${workflowPath} is missing or invalid. Interf compile runs the workspace-local package directly; recreate or reseed this workspace instead of relying on source-root fallback.`);
+            throw new Error(`Dataset-local workflow package at ${workflowPath} is missing or invalid. Interf compile runs the local package directly; recreate or reseed this compiled dataset instead of relying on source-root fallback.`);
         }
         if (local.extends) {
-            throw new Error(`Workspace-local workflow package at ${workflowPath} still uses legacy extends. Materialize it as a standalone package before compiling this workspace.`);
-        }
-        const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
-        if (!validateWorkspaceStages(resolved.stages)) {
-            throw new Error(`Workspace-local workflow package at ${workflowPath} has an invalid stage ordering. Interf compile will not silently switch methods for this workspace.`);
+            throw new Error(`Dataset-local workflow package at ${workflowPath} still uses legacy extends. Materialize it as a standalone package before compiling this compiled dataset.`);
         }
-        return resolved;
+        return standaloneWorkflowDefinitionFromLocalPackage(local);
     }
-    throw new Error(`Missing workspace-local workflow package at ${workflowPath}. Interf compile runs the workspace-local package directly, so recreate or reseed this workspace instead of relying on source-root workflow "${fallbackWorkflowId}" under ${resolveSourceControlPath(workspacePath)}.`);
+    throw new Error(`Missing local workflow package at ${workflowPath}. Interf compile runs the local package directly, so recreate or reseed this compiled dataset instead of relying on source-root workflow "${fallbackWorkflowId}" under ${resolveSourceControlPath(compiledPath)}.`);
 }
-export function resolveWorkspaceWorkflowId(value) {
+export function resolveCompiledWorkflowId(value) {
     if (typeof value === "string" && isWorkflowId(value)) {
         return value;
     }
-    return "interf";
+    return null;
 }
-export function resolveWorkspaceWorkflowFromConfig(config) {
+export function resolveCompiledWorkflowFromConfig(config) {
     if (!config || typeof config !== "object")
-        return "interf";
+        return null;
     const raw = config;
-    return resolveWorkspaceWorkflowId(raw.workflow);
+    return resolveCompiledWorkflowId(raw.workflow);
+}
+export function resolveRequiredCompiledWorkflowFromConfig(config, label = "compiled config") {
+    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    if (!workflowId) {
+        throw new Error(`Missing or invalid workflow in ${label}.`);
+    }
+    return workflowId;
 }
-export function formatWorkspaceWorkflowStageStep(workflowId, stage, options = {}) {
-    return formatWorkflowStageStep(getWorkspaceWorkflow(workflowId, options), stage);
+export function formatCompiledWorkflowStageStep(workflowId, stage, options = {}) {
+    return formatWorkflowStageStep(getCompiledWorkflow(workflowId, options), stage);
 }
 function resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath) {
     if (sourcePath &&
-        existsSync(join(workflowPackagePathForWorkspace(sourcePath), "workflow.json"))) {
-        return getActiveWorkspaceWorkflow(sourcePath, workflowId);
+        existsSync(join(workflowPackagePathForCompiled(sourcePath), "workflow.json"))) {
+        return getActiveCompiledWorkflow(sourcePath, workflowId);
     }
-    return getWorkspaceWorkflow(workflowId, { sourcePath });
+    return getCompiledWorkflow(workflowId, { sourcePath });
 }
 function formatWorkflowStageStep(workflow, stage) {
     const stageIndex = workflow.stages.findIndex((candidate) => candidate.id === stage);
     if (stageIndex === -1) {
-        throw new Error(`Stage "${stage}" is not part of the workspace runtime.`);
+        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
     }
     const stageDefinition = workflow.stages[stageIndex];
     if (!stageDefinition) {
-        throw new Error(`Stage "${stage}" is not part of the workspace runtime.`);
+        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
     }
     return `Step ${stageIndex + 1}/${workflow.stages.length} - ${stageDefinition.label}`;
 }
@@ -197,20 +187,20 @@ export function getWorkflowStagePosition(workflowId, stage, sourcePath) {
 export function getWorkflowStages(workflowId, sourcePath) {
     return resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath).stages.map((definition) => definition.id);
 }
-export function getActiveWorkspaceStages(workspacePath, fallbackWorkflowId) {
-    return getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId).stages.map((definition) => definition.id);
+export function getActiveCompiledStages(compiledPath, fallbackWorkflowId) {
+    return getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId).stages.map((definition) => definition.id);
 }
 export function getWorkflowStagePolicyNotes(workflowId, stage, sourcePath) {
     const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
     return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
 }
-export function getActiveWorkspaceStagePolicyNotes(workspacePath, fallbackWorkflowId, stage) {
-    const workflow = getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId);
+export function getActiveCompiledStagePolicyNotes(compiledPath, fallbackWorkflowId, stage) {
+    const workflow = getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId);
     return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
 }
-export function resolveActiveWorkspaceStageAcceptance(workspacePath, fallbackWorkflowId, stage) {
-    return getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId).stages.find((candidate) => candidate.id === stage)?.acceptance;
+export function resolveActiveCompiledStageAcceptance(compiledPath, fallbackWorkflowId, stage) {
+    return getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId).stages.find((candidate) => candidate.id === stage)?.acceptance;
 }
-export function formatActiveWorkspaceWorkflowStageStep(workspacePath, fallbackWorkflowId, stage) {
-    return formatWorkflowStageStep(getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId), stage);
+export function formatActiveCompiledWorkflowStageStep(compiledPath, fallbackWorkflowId, stage) {
+    return formatWorkflowStageStep(getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId), stage);
 }

package/dist/lib/workflow-helpers.d.ts

@@ -1,4 +1,4 @@
-import { type LocalInstructionMode, type RuntimeContractType, type RuntimeInstructionMode, type RuntimeStageInstructions } from "./schema.js";
+import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "./schema.js";
 import { type WorkflowStageDefinition } from "./workflow-definitions.js";
 export interface WorkflowReporter {
     line?: (message: string) => void;
@@ -24,11 +24,10 @@ export declare function emptyLocalSkillContractExtension(): LocalSkillContractEx
 export declare function buildLocalSkillContractExtension(rootPath: string, directories: string[], purpose: string): LocalSkillContractExtension;
 export declare function buildLocalSkillContractExtensionRelativeTo(rootPath: string, relativeToPath: string, directories: string[], purpose: string): LocalSkillContractExtension;
 export declare function mergeLocalSkillContractExtensions(extensions: LocalSkillContractExtension[]): LocalSkillContractExtension;
-export declare function buildStageInstructions(bundledSkill: string, localSkills: LocalSkillContractExtension): RuntimeStageInstructions;
+export declare function buildStageInstructions(stageSkillDir: string, localSkills: LocalSkillContractExtension): RuntimeStageInstructions;
 export declare function reportLine(reporter: WorkflowReporter | undefined, message: string): void;
 export declare function reportBlankLine(reporter: WorkflowReporter | undefined): void;
 export declare function reportValidationFailure(reporter: WorkflowReporter | undefined, summary: string, errors?: string[]): void;
-export declare function bundledSkillForContractType(contractType: RuntimeContractType): string;
 export declare function resolveStageAcceptance(workflowId: string, stageId: string, sourcePath?: string): WorkflowStageDefinition["acceptance"] | undefined;
 export declare function validateStageOutcome(_dirPath: string, validation: {
     ok: boolean;

package/dist/lib/workflow-helpers.js

@@ -2,10 +2,9 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
 import { isMarkdownFile } from "./util.js";
-import { workspaceBundledSkillForContractType } from "./workflow-abi.js";
-import { getWorkspaceWorkflow, } from "./workflow-definitions.js";
+import { getCompiledWorkflow, } from "./workflow-definitions.js";
 import { parseJsonFrontmatter } from "./parse.js";
-import { workflowPackagePathForWorkspace } from "./workspace-paths.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
 export function workflowQueryDirectory() {
     return "workflow/use/query";
@@ -41,7 +40,7 @@ function collectLocalSkillDocs(rootPath, directories) {
 }
 function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
     const docs = new Map();
-    const workflowRoot = workflowPackagePathForWorkspace(rootPath);
+    const workflowRoot = workflowPackagePathForCompiled(rootPath);
     const rootReadme = join(workflowRoot, "README.md");
     if (existsSync(rootReadme)) {
         const read = projectWorkflowReadPath(rootPath, relativeToPath, rootReadme);
@@ -68,16 +67,16 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
 }
 function resolveAuthoringDirectory(rootPath, directory) {
     if (directory === "workflow") {
-        return workflowPackagePathForWorkspace(rootPath);
+        return workflowPackagePathForCompiled(rootPath);
     }
     if (directory.startsWith(`workflow${sep}`) || directory.startsWith("workflow/")) {
         const relativeWorkflowPath = directory.replace(/^workflow[\\/]/, "");
-        return join(workflowPackagePathForWorkspace(rootPath), relativeWorkflowPath);
+        return join(workflowPackagePathForCompiled(rootPath), relativeWorkflowPath);
     }
     return join(rootPath, directory);
 }
 function projectWorkflowReadPath(rootPath, relativeToPath, absolutePath) {
-    const workflowRoot = workflowPackagePathForWorkspace(rootPath);
+    const workflowRoot = workflowPackagePathForCompiled(rootPath);
     const normalizedWorkflowRoot = `${workflowRoot}${sep}`;
     if (absolutePath === workflowRoot || absolutePath.startsWith(normalizedWorkflowRoot)) {
         const relativeWorkflowPath = relative(workflowRoot, absolutePath);
@@ -139,9 +138,9 @@ export function mergeLocalSkillContractExtensions(extensions) {
         modeSources,
     };
 }
-export function buildStageInstructions(bundledSkill, localSkills) {
+export function buildStageInstructions(stageSkillDir, localSkills) {
     return {
-        bundled_skill: bundledSkill,
+        stage_skill_dir: stageSkillDir,
         effective_mode: localSkills.effectiveMode,
         local_mode: localSkills.localMode,
         local_docs: localSkills.reads,
@@ -160,11 +159,8 @@ export function reportValidationFailure(reporter, summary, errors = []) {
         reportLine(reporter, `- ${error}`);
     }
 }
-export function bundledSkillForContractType(contractType) {
-    return workspaceBundledSkillForContractType(contractType);
-}
 export function resolveStageAcceptance(workflowId, stageId, sourcePath) {
-    return getWorkspaceWorkflow(workflowId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
+    return getCompiledWorkflow(workflowId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
 }
 export function validateStageOutcome(_dirPath, validation) {
     return validation;

package/dist/lib/workflow-improvement.d.ts

@@ -1,6 +1,6 @@
 import type { WorkflowExecutor } from "./executors.js";
 import { type WorkflowValidationResult } from "./local-workflows.js";
-import type { SourceWorkspaceConfig, WorkflowImprovementLoopSummary } from "./schema.js";
+import type { SourceDatasetConfig, WorkflowImprovementLoopSummary } from "./schema.js";
 export interface WorkflowImprovementRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;
@@ -11,9 +11,9 @@ export interface WorkflowImprovementRunResult {
 }
 export declare function runWorkflowImprovementLoop(options: {
     executor: WorkflowExecutor;
-    workspacePath: string;
+    compiledPath: string;
     workflowId: string;
-    workspaceConfig: Pick<SourceWorkspaceConfig, "checks">;
+    compiledConfig: Pick<SourceDatasetConfig, "checks">;
     runId: string;
     loopIndex: number;
     maxLoops: number;

package/dist/lib/workflow-improvement.js

@@ -4,10 +4,10 @@ import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from
 import { readInterfConfig } from "./interf.js";
 import { validateWorkflowPackage } from "./local-workflows.js";
 import { readJsonFileWithSchema } from "./parse.js";
-import { saveWorkspaceInterfConfig } from "./source-config.js";
+import { saveCompiledInterfConfig } from "./source-config.js";
 import { WorkflowImprovementRunLedgerSchema, } from "./schema.js";
 import { resolveWorkflowImprovementReviewPaths } from "./workflow-review-paths.js";
-import { targetTestRunsRootForWorkspace, targetTestSandboxesRootForWorkspace, workflowImprovementRunRoot, workflowPackagePathForWorkspace, } from "./workspace-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, workflowImprovementRunRoot, workflowPackagePathForCompiled, } from "./compiled-paths.js";
 function copyDirectory(sourcePath, targetPath) {
     rmSync(targetPath, { recursive: true, force: true });
     mkdirSync(targetPath, { recursive: true });
@@ -55,31 +55,31 @@ function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     const relativePath = relative(sourceRoot, absolutePath);
     return join(shellRoot, relativePath);
 }
-function mapLoopSummaryForShell(summary, workspacePath) {
+function mapLoopSummaryForShell(summary, compiledPath) {
     const shellTestRunsRoot = "artifacts/test-runs";
     const shellTestSandboxesRoot = "artifacts/test-sandboxes";
     return {
         ...summary,
-        test_run_path: toShellArtifactPath(summary.test_run_path, targetTestRunsRootForWorkspace(workspacePath), shellTestRunsRoot) ?? summary.test_run_path ?? null,
-        test_sandbox_path: toShellArtifactPath(summary.test_sandbox_path, targetTestSandboxesRootForWorkspace(workspacePath), shellTestSandboxesRoot) ?? summary.test_sandbox_path ?? null,
+        test_run_path: toShellArtifactPath(summary.test_run_path, targetTestRunsRootForCompiled(compiledPath), shellTestRunsRoot) ?? summary.test_run_path ?? null,
+        test_sandbox_path: toShellArtifactPath(summary.test_sandbox_path, targetTestSandboxesRootForCompiled(compiledPath), shellTestSandboxesRoot) ?? summary.test_sandbox_path ?? null,
     };
 }
 function buildLoopContext(options) {
-    const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.workspacePath));
+    const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.compiledPath));
     const latestFailure = previousVariations.at(-1) ?? null;
     return {
         kind: "interf-workflow-improvement-loop",
         version: 1,
         generated_at: new Date().toISOString(),
-        target_name: readInterfConfig(options.workspacePath)?.name ?? "workspace",
+        target_name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
         workflow_id: options.workflowId,
         loop_index: options.loopIndex,
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
-        review_paths: resolveWorkflowImprovementReviewPaths(options.workspacePath),
+        review_paths: resolveWorkflowImprovementReviewPaths(options.compiledPath),
         truth_checks: {
-            count: options.workspaceConfig.checks.length,
-            questions: options.workspaceConfig.checks.map((check, index) => ({
+            count: options.compiledConfig.checks.length,
+            questions: options.compiledConfig.checks.map((check, index) => ({
                 id: check.id ?? `check-${index + 1}`,
                 question: check.question,
             })),
@@ -93,21 +93,21 @@ function buildWorkflowImprovementPrompt() {
         "This is an automated Interf Compiler workflow-improvement run, not an open-ended chat session.",
         "The user already invoked this through `interf compile` with self-improving loops enabled. Execute it now.",
         "Read `runtime/loop-context.json` first.",
-        "Then read `workflow/README.md`, `workflow/workflow.json`, `workflow/workspace.schema.json`, and `workflow/improve/SKILL.md` if it exists.",
+        "Then read `workflow/README.md`, `workflow/workflow.json`, `workflow/compiled.schema.json`, and `workflow/improve/SKILL.md` if it exists.",
         "Review preserved evidence from earlier failures under `artifacts/` before you edit the workflow.",
         "Treat `workflow/improve/SKILL.md` as guidance for how to improve the workflow, not as the default file to edit.",
         "Prefer editing the stage docs, workflow contract, or schema ownership that actually change compiled outputs.",
         "Edit only files under `workflow/`.",
-        "Do not edit truth checks, test specs, raw dataset files, or generated workspace outputs.",
-        "Keep the workflow valid for the current compiler API and workspace schema.",
+        "Do not edit truth checks, test specs, raw dataset files, or generated compiled outputs.",
+        "Keep the workflow valid for the current compiler API and compiled schema.",
         "Prefer small, defensible changes to workflow docs, stage docs, stage policies, or schema ownership over random churn.",
         "Do not narrate plans or ask follow-up questions.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
         "As soon as the workflow edits are complete, stop.",
     ].join("\n");
 }
-function updateWorkspaceWorkflowOrigin(options) {
-    const current = readInterfConfig(options.workspacePath);
+function updateCompiledWorkflowOrigin(options) {
+    const current = readInterfConfig(options.compiledPath);
     if (!current)
         return;
     const nextConfig = {
@@ -118,27 +118,27 @@ function updateWorkspaceWorkflowOrigin(options) {
             ...(options.localDraft ? { local_draft: true } : {}),
         },
     };
-    saveWorkspaceInterfConfig(options.workspacePath, nextConfig);
+    saveCompiledInterfConfig(options.compiledPath, nextConfig);
 }
-function workflowImprovementRunLedgerPath(workspacePath, runId) {
-    return join(workflowImprovementRunRoot(workspacePath, runId), "run.json");
+function workflowImprovementRunLedgerPath(compiledPath, runId) {
+    return join(workflowImprovementRunRoot(compiledPath, runId), "run.json");
 }
-function workflowImprovementLoopHistoryPath(workspacePath, runId) {
-    return join(workflowImprovementRunRoot(workspacePath, runId), "loop-history.jsonl");
+function workflowImprovementLoopHistoryPath(compiledPath, runId) {
+    return join(workflowImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
 }
 function workflowImprovementLoopRecordPath(loopRootPath) {
     return join(loopRootPath, "loop.json");
 }
-function readWorkflowImprovementRunLedger(workspacePath, runId) {
-    const ledgerPath = workflowImprovementRunLedgerPath(workspacePath, runId);
+function readWorkflowImprovementRunLedger(compiledPath, runId) {
+    const ledgerPath = workflowImprovementRunLedgerPath(compiledPath, runId);
     if (!existsSync(ledgerPath))
         return null;
     return readJsonFileWithSchema(ledgerPath, "workflow improvement run ledger", WorkflowImprovementRunLedgerSchema);
 }
-function writeWorkflowImprovementRunLedger(workspacePath, runId, record, options) {
-    const runRoot = workflowImprovementRunRoot(workspacePath, runId);
+function writeWorkflowImprovementRunLedger(compiledPath, runId, record, options) {
+    const runRoot = workflowImprovementRunRoot(compiledPath, runId);
     mkdirSync(runRoot, { recursive: true });
-    const existing = readWorkflowImprovementRunLedger(workspacePath, runId);
+    const existing = readWorkflowImprovementRunLedger(compiledPath, runId);
     const generatedAt = existing?.generated_at ?? new Date().toISOString();
     const ledger = {
         kind: "interf-workflow-improvement-run",
@@ -152,9 +152,9 @@ function writeWorkflowImprovementRunLedger(workspacePath, runId, record, options
         max_attempts: options.maxAttempts,
         loops: [...(existing?.loops ?? []), record],
     };
-    writeFileSync(workflowImprovementRunLedgerPath(workspacePath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
+    writeFileSync(workflowImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
     writeFileSync(workflowImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
-    appendFileSync(workflowImprovementLoopHistoryPath(workspacePath, runId), `${JSON.stringify(record)}\n`);
+    appendFileSync(workflowImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
 }
 function buildWorkflowImprovementLoopRecord(options) {
     return {
@@ -182,17 +182,17 @@ function buildWorkflowImprovementLoopRecord(options) {
     };
 }
 export async function runWorkflowImprovementLoop(options) {
-    const workspaceName = readInterfConfig(options.workspacePath)?.name ?? "workspace";
+    const compiledName = readInterfConfig(options.compiledPath)?.name ?? "compiled";
     const context = buildLoopContext(options);
     const shell = createWorkflowImprovementShell({
-        workspacePath: options.workspacePath,
-        workspaceName,
+        compiledPath: options.compiledPath,
+        compiledName,
         workflowId: options.workflowId,
         runId: options.runId,
         loopIndex: options.loopIndex,
         context,
     });
-    const workflowRoot = workflowPackagePathForWorkspace(options.workspacePath);
+    const workflowRoot = workflowPackagePathForCompiled(options.compiledPath);
     copyDirectory(workflowRoot, shell.workflowBeforePath);
     const prompt = buildWorkflowImprovementPrompt();
     writeFileSync(shell.promptLogPath, `${prompt}\n`);
@@ -213,8 +213,8 @@ export async function runWorkflowImprovementLoop(options) {
     if (executeError) {
         copyDirectory(shell.workflowBeforePath, workflowRoot);
         const summary = `Workflow improver failed before completing: ${executeError}`;
-        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: workspaceName,
+        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: compiledName,
             workflowId: options.workflowId,
             runId: options.runId,
             loopIndex: options.loopIndex,
@@ -231,7 +231,7 @@ export async function runWorkflowImprovementLoop(options) {
             result: "executor-failed",
             summary,
         }), {
-            targetName: workspaceName,
+            targetName: compiledName,
             workflowId: options.workflowId,
             maxLoops: options.maxLoops,
             maxAttempts: options.maxAttempts,
@@ -248,8 +248,8 @@ export async function runWorkflowImprovementLoop(options) {
     if (code !== 0) {
         copyDirectory(shell.workflowBeforePath, workflowRoot);
         const summary = `Workflow improver exited with code ${code}.`;
-        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: workspaceName,
+        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: compiledName,
             workflowId: options.workflowId,
             runId: options.runId,
             loopIndex: options.loopIndex,
@@ -266,7 +266,7 @@ export async function runWorkflowImprovementLoop(options) {
             result: "executor-failed",
             summary,
         }), {
-            targetName: workspaceName,
+            targetName: compiledName,
             workflowId: options.workflowId,
             maxLoops: options.maxLoops,
             maxAttempts: options.maxAttempts,
@@ -289,8 +289,8 @@ export async function runWorkflowImprovementLoop(options) {
         const summary = validation.ok
             ? "Workflow improver made no workflow edits."
             : `Workflow variation is invalid without any workflow edits: ${validation.summary}`;
-        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: workspaceName,
+        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: compiledName,
             workflowId: options.workflowId,
             runId: options.runId,
             loopIndex: options.loopIndex,
@@ -307,7 +307,7 @@ export async function runWorkflowImprovementLoop(options) {
             result,
             summary,
         }), {
-            targetName: workspaceName,
+            targetName: compiledName,
             workflowId: options.workflowId,
             maxLoops: options.maxLoops,
             maxAttempts: options.maxAttempts,
@@ -325,8 +325,8 @@ export async function runWorkflowImprovementLoop(options) {
     if (!validation.ok) {
         copyDirectory(shell.workflowBeforePath, workflowRoot);
         const summary = `Workflow variation failed validation: ${validation.summary}`;
-        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: workspaceName,
+        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: compiledName,
             workflowId: options.workflowId,
             runId: options.runId,
             loopIndex: options.loopIndex,
@@ -343,7 +343,7 @@ export async function runWorkflowImprovementLoop(options) {
             result: "invalid",
             summary,
         }), {
-            targetName: workspaceName,
+            targetName: compiledName,
             workflowId: options.workflowId,
             maxLoops: options.maxLoops,
             maxAttempts: options.maxAttempts,
@@ -357,8 +357,8 @@ export async function runWorkflowImprovementLoop(options) {
             loopRootPath: shell.loopRootPath,
         };
     }
-    writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
-        targetName: workspaceName,
+    writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+        targetName: compiledName,
         workflowId: options.workflowId,
         runId: options.runId,
         loopIndex: options.loopIndex,
@@ -375,13 +375,13 @@ export async function runWorkflowImprovementLoop(options) {
         result: "updated",
         summary: "Workflow variation updated and validated.",
     }), {
-        targetName: workspaceName,
+        targetName: compiledName,
         workflowId: options.workflowId,
         maxLoops: options.maxLoops,
         maxAttempts: options.maxAttempts,
     });
-    updateWorkspaceWorkflowOrigin({
-        workspacePath: options.workspacePath,
+    updateCompiledWorkflowOrigin({
+        compiledPath: options.compiledPath,
         selectedWorkflowId: options.workflowId,
         localDraft: true,
     });

package/dist/lib/workflow-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];

package/dist/lib/workflow-primitives.js

@@ -0,0 +1,5 @@
+export const COMPILED_ZONE_KINDS = [
+    "directory",
+    "file",
+    "runtime",
+];

package/dist/lib/workflow-review-paths.d.ts

@@ -1,10 +1,10 @@
 import type { WorkflowImprovementContext } from "./schema.js";
 export interface WorkflowImprovementReviewSourcePaths {
-    workspaceRuntime: string | null;
+    compiledRuntime: string | null;
     testComparisons: string | null;
     executionShells: string | null;
     targetTestRuns: string | null;
     targetTestSandboxes: string | null;
 }
-export declare function resolveWorkflowImprovementReviewSourcePaths(workspacePath: string): WorkflowImprovementReviewSourcePaths;
-export declare function resolveWorkflowImprovementReviewPaths(workspacePath: string): WorkflowImprovementContext["review_paths"];
+export declare function resolveWorkflowImprovementReviewSourcePaths(compiledPath: string): WorkflowImprovementReviewSourcePaths;
+export declare function resolveWorkflowImprovementReviewPaths(compiledPath: string): WorkflowImprovementContext["review_paths"];

package/dist/lib/workflow-review-paths.js

@@ -1,24 +1,24 @@
 import { existsSync } from "node:fs";
-import { testRootForWorkspace, targetTestRunsRootForWorkspace, targetTestSandboxesRootForWorkspace, stageExecutionShellsRoot, workspaceRuntimeRoot, } from "./workspace-paths.js";
-export function resolveWorkflowImprovementReviewSourcePaths(workspacePath) {
-    const workspaceRuntime = workspaceRuntimeRoot(workspacePath);
-    const testComparisons = testRootForWorkspace(workspacePath);
-    const executionShells = stageExecutionShellsRoot(workspacePath);
-    const targetTestRuns = targetTestRunsRootForWorkspace(workspacePath);
-    const targetTestSandboxes = targetTestSandboxesRootForWorkspace(workspacePath);
+import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "./compiled-paths.js";
+export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
+    const compiledRuntime = compiledRuntimeRoot(compiledPath);
+    const testComparisons = testRootForCompiled(compiledPath);
+    const executionShells = stageExecutionShellsRoot(compiledPath);
+    const targetTestRuns = targetTestRunsRootForCompiled(compiledPath);
+    const targetTestSandboxes = targetTestSandboxesRootForCompiled(compiledPath);
     return {
-        workspaceRuntime: existsSync(workspaceRuntime) ? workspaceRuntime : null,
+        compiledRuntime: existsSync(compiledRuntime) ? compiledRuntime : null,
         testComparisons: existsSync(testComparisons) ? testComparisons : null,
         executionShells: existsSync(executionShells) ? executionShells : null,
         targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
         targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,
     };
 }
-export function resolveWorkflowImprovementReviewPaths(workspacePath) {
-    const sources = resolveWorkflowImprovementReviewSourcePaths(workspacePath);
+export function resolveWorkflowImprovementReviewPaths(compiledPath) {
+    const sources = resolveWorkflowImprovementReviewSourcePaths(compiledPath);
     return {
         workflow_root: "workflow",
-        workspace_runtime: sources.workspaceRuntime ? "artifacts/workspace-runtime" : null,
+        compiled_runtime: sources.compiledRuntime ? "artifacts/compiled-runtime" : null,
         test_comparisons: sources.testComparisons ? "artifacts/test-comparisons" : null,
         execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,
         test_runs: sources.targetTestRuns ? "artifacts/test-runs" : null,