@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/workflow-abi.js

@@ -1,33 +1,33 @@
-export const WORKSPACE_CONTRACT_TYPES = [
-    "workspace-file-evidence",
-    "workspace-knowledge-structure",
-    "workspace-query-shape",
+export const COMPILED_CONTRACT_TYPES = [
+    "compiled-file-evidence",
+    "compiled-knowledge-structure",
+    "compiled-query-shape",
 ];
-export const WORKSPACE_ZONE_KINDS = [
+export const COMPILED_ZONE_KINDS = [
     "directory",
     "file",
     "runtime",
 ];
-export const WORKSPACE_CONTRACT_FAMILY_METADATA = {
-    "workspace-file-evidence": {
+export const COMPILED_CONTRACT_FAMILY_METADATA = {
+    "compiled-file-evidence": {
         order: 0,
         bundledSkill: "compile/stages/summarize",
     },
-    "workspace-knowledge-structure": {
+    "compiled-knowledge-structure": {
         order: 1,
         bundledSkill: "compile/stages/structure",
     },
-    "workspace-query-shape": {
+    "compiled-query-shape": {
         order: 2,
         bundledSkill: "compile/stages/shape",
     },
 };
-export const BUILTIN_WORKSPACE_STAGE_IDS = {
+export const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",
     STRUCTURE: "structure",
     SHAPE: "shape",
 };
-export const BUILTIN_WORKSPACE_ZONE_IDS = {
+export const BUILTIN_COMPILED_ZONE_IDS = {
     RAW: "raw",
     SUMMARIES: "summaries",
     KNOWLEDGE_ENTITIES: "knowledge-entities",
@@ -36,146 +36,121 @@ export const BUILTIN_WORKSPACE_ZONE_IDS = {
     HOME: "home",
     RUNTIME: "runtime",
 };
-export const BUILTIN_WORKSPACE_ZONE_SPECS = [
+export const BUILTIN_COMPILED_ZONE_SPECS = [
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.RAW,
+        id: BUILTIN_COMPILED_ZONE_IDS.RAW,
         path: "raw",
         kind: "directory",
         required: true,
-        description: "Workspace-local raw snapshot copied from the dataset for direct evidence and verification.",
+        description: "Compiled-local raw snapshot copied from the dataset for direct evidence and verification.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
+        id: BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
         path: "summaries",
         kind: "directory",
         required: true,
         description: "Per-file evidence notes produced by file-evidence stages.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_ENTITIES,
+        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
         path: "knowledge/entities",
         kind: "directory",
         required: true,
         description: "Canonical entity notes produced by knowledge-structure stages.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_CLAIMS,
+        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
         path: "knowledge/claims",
         kind: "directory",
         required: true,
         description: "Claim notes produced by knowledge-structure stages.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
+        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
         path: "knowledge/indexes",
         kind: "directory",
         required: true,
         description: "Retrieval indexes and navigation notes produced by structure and shape stages.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.HOME,
+        id: BUILTIN_COMPILED_ZONE_IDS.HOME,
         path: "home.md",
         kind: "file",
         required: true,
-        description: "Primary entrypoint note for agents using the compiled workspace.",
+        description: "Primary entrypoint note for agents using the compiled dataset.",
     },
     {
-        id: BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
+        id: BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
         path: ".interf/runtime",
         kind: "runtime",
         required: true,
         description: "CLI-owned runtime state, health, stage contracts, and proof artifacts.",
     },
 ];
-export const BUILTIN_WORKSPACE_STAGE_ACCESS_PATTERNS = [
+export const BUILTIN_COMPILED_STAGE_ACCESS_PATTERNS = [
     {
-        id: BUILTIN_WORKSPACE_STAGE_IDS.SUMMARIZE,
+        id: BUILTIN_COMPILED_STAGE_IDS.SUMMARIZE,
         label: "Summarize",
         description: "Turn source files into per-file summaries.",
-        contractType: "workspace-file-evidence",
+        contractType: "compiled-file-evidence",
         skillDir: "summarize",
         reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.RAW,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
+            BUILTIN_COMPILED_ZONE_IDS.RAW,
+            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
         ],
         writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
+            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
         ],
     },
     {
-        id: BUILTIN_WORKSPACE_STAGE_IDS.STRUCTURE,
+        id: BUILTIN_COMPILED_STAGE_IDS.STRUCTURE,
         label: "Structure",
         description: "Build the cross-file knowledge structure from the summaries.",
-        contractType: "workspace-knowledge-structure",
+        contractType: "compiled-knowledge-structure",
         skillDir: "structure",
         reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
+            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
+            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
         ],
         writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
         ],
     },
     {
-        id: BUILTIN_WORKSPACE_STAGE_IDS.SHAPE,
+        id: BUILTIN_COMPILED_STAGE_IDS.SHAPE,
         label: "Shape",
-        description: "Shape the final workspace around the saved focus and truth checks.",
-        contractType: "workspace-query-shape",
+        description: "Shape the final compiled around the saved focus and truth checks.",
+        contractType: "compiled-query-shape",
         skillDir: "shape",
         reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.RAW,
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
+            BUILTIN_COMPILED_ZONE_IDS.RAW,
+            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
+            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
         ],
         writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_WORKSPACE_ZONE_IDS.HOME,
+            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
+            BUILTIN_COMPILED_ZONE_IDS.HOME,
         ],
     },
 ];
-export function workspaceContractOrder(contractType) {
-    return WORKSPACE_CONTRACT_FAMILY_METADATA[contractType].order;
+export function listBuiltinCompiledZoneSpecs() {
+    return BUILTIN_COMPILED_ZONE_SPECS.map((zone) => ({ ...zone }));
 }
-export function workspaceBundledSkillForContractType(contractType) {
-    return WORKSPACE_CONTRACT_FAMILY_METADATA[contractType].bundledSkill;
-}
-export function hasValidWorkspaceContractSequence(contractTypes) {
-    return contractTypes.every((contractType, index) => index === 0 ||
-        workspaceContractOrder(contractType) >= workspaceContractOrder(contractTypes[index - 1]));
-}
-export function listMissingWorkspaceContractTypes(contractTypes) {
-    return WORKSPACE_CONTRACT_TYPES.filter((contractType) => !contractTypes.includes(contractType));
-}
-export function validateWorkspaceContractSequence(contractTypes) {
-    const missing = listMissingWorkspaceContractTypes(contractTypes);
-    const orderValid = hasValidWorkspaceContractSequence(contractTypes);
-    return {
-        ok: missing.length === 0 && orderValid,
-        orderValid,
-        missing,
-    };
-}
-export function listBuiltinWorkspaceZoneSpecs() {
-    return BUILTIN_WORKSPACE_ZONE_SPECS.map((zone) => ({ ...zone }));
-}
-export function listBuiltinWorkspaceFallbackStages() {
-    return BUILTIN_WORKSPACE_STAGE_ACCESS_PATTERNS.map((stage) => ({
+export function listBuiltinCompiledFallbackStages() {
+    return BUILTIN_COMPILED_STAGE_ACCESS_PATTERNS.map((stage) => ({
         id: stage.id,
         contract_type: stage.contractType,
         reads: [...stage.reads],
         writes: [...stage.writes],
     }));
 }
-export function requiredWorkspaceZoneOwners(stages, zoneId) {
-    const writerContractTypes = new Set(BUILTIN_WORKSPACE_STAGE_ACCESS_PATTERNS
-        .filter((stage) => stage.writes.includes(zoneId))
-        .map((stage) => stage.contractType));
+export function requiredCompiledZoneOwners(stages, zoneId) {
     return Array.from(new Set(stages
-        .filter((stage) => writerContractTypes.has(stage.contractType))
+        .filter((stage) => stage.writes.includes(zoneId))
         .map((stage) => stage.id)));
 }

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

@@ -24,7 +24,7 @@ export interface WorkflowDefinition<TId extends string> {
     starterDocs?: WorkflowStarterDoc[];
     scope?: "builtin" | "local";
 }
-export type WorkspaceWorkflowId = string;
+export type CompiledWorkflowId = string;
 export declare function standaloneWorkflowDefinitionFromLocalPackage(local: {
     id: string;
     compiler_api?: WorkflowCompilerApi;
@@ -43,14 +43,14 @@ export declare function standaloneWorkflowDefinitionFromLocalPackage(local: {
     stage_policy_notes?: Record<string, string[]>;
     starter_docs: WorkflowStarterDoc[];
 }): WorkflowDefinition<string>;
-export declare function listWorkspaceWorkflowChoices(sourcePath?: string): WorkflowDefinition<string>[];
-export declare function getWorkspaceWorkflow(workflowId: WorkspaceWorkflowId, options?: {
+export declare function listCompiledWorkflowChoices(sourcePath?: string): WorkflowDefinition<string>[];
+export declare function getCompiledWorkflow(workflowId: CompiledWorkflowId, options?: {
     sourcePath?: string;
 }): WorkflowDefinition<string>;
-export declare function getActiveWorkspaceWorkflow(workspacePath: string, fallbackWorkflowId: WorkspaceWorkflowId): WorkflowDefinition<string>;
-export declare function resolveWorkspaceWorkflowId(value: unknown): WorkspaceWorkflowId;
-export declare function resolveWorkspaceWorkflowFromConfig(config: unknown): WorkspaceWorkflowId;
-export declare function formatWorkspaceWorkflowStageStep(workflowId: WorkspaceWorkflowId, stage: string, options?: {
+export declare function getActiveCompiledWorkflow(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId): WorkflowDefinition<string>;
+export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId;
+export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId;
+export declare function formatCompiledWorkflowStageStep(workflowId: CompiledWorkflowId, stage: string, options?: {
     sourcePath?: string;
 }): string;
 export declare function getWorkflowStageDefinition(workflowId: WorkflowId, stage: string, sourcePath?: string): WorkflowStageDefinition | null;
@@ -60,8 +60,8 @@ export declare function getWorkflowStagePosition(workflowId: WorkflowId, stage:
     stages: string[];
 } | null;
 export declare function getWorkflowStages(workflowId: WorkflowId, sourcePath?: string): string[];
-export declare function getActiveWorkspaceStages(workspacePath: string, fallbackWorkflowId: WorkflowId): string[];
+export declare function getActiveCompiledStages(compiledPath: string, fallbackWorkflowId: WorkflowId): string[];
 export declare function getWorkflowStagePolicyNotes(workflowId: WorkflowId, stage: string, sourcePath?: string): string[];
-export declare function getActiveWorkspaceStagePolicyNotes(workspacePath: string, fallbackWorkflowId: WorkflowId, stage: string): string[];
-export declare function resolveActiveWorkspaceStageAcceptance(workspacePath: string, fallbackWorkflowId: WorkflowId, stage: string): WorkflowStageDefinition["acceptance"] | undefined;
-export declare function formatActiveWorkspaceWorkflowStageStep(workspacePath: string, fallbackWorkflowId: WorkspaceWorkflowId, stage: string): string;
+export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): string[];
+export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): WorkflowStageDefinition["acceptance"] | undefined;
+export declare function formatActiveCompiledWorkflowStageStep(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId, stage: string): string;

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,62 @@ 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";
 }
-export function resolveWorkspaceWorkflowFromConfig(config) {
+export function resolveCompiledWorkflowFromConfig(config) {
     if (!config || typeof config !== "object")
         return "interf";
     const raw = config;
-    return resolveWorkspaceWorkflowId(raw.workflow);
+    return resolveCompiledWorkflowId(raw.workflow);
 }
-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 +180,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;