@interf/compiler 0.4.0 → 0.5.0

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-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,

package/dist/lib/workflow-stage-runner.d.ts

@@ -9,7 +9,7 @@ interface WorkflowStageShape<TContractType extends RuntimeContractType> {
 }
 interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType> {
     executor: WorkflowExecutor;
-    workspacePath: string;
+    compiledPath: string;
     executionPath?: string;
     targetName: string;
     workflow: string;

package/dist/lib/workflow-stage-runner.js

@@ -17,9 +17,9 @@ export async function executeValidatedStage(options) {
         : undefined;
     const code = await runExecutorStage({
         executor: options.executor,
-        workspacePath: options.workspacePath,
+        compiledPath: options.compiledPath,
         executionPath: options.executionPath,
-        workspaceName: options.targetName,
+        compiledName: options.targetName,
         workflow: options.workflow,
         workflowSourcePath: options.workflowSourcePath,
         stage: options.stageDefinition.id,
@@ -42,9 +42,9 @@ export async function executeValidatedSummarizeStage(options) {
         : undefined;
     const code = await runExecutorSummarizeStage({
         executor: options.executor,
-        workspacePath: options.workspacePath,
+        compiledPath: options.compiledPath,
         executionPath: options.executionPath,
-        workspaceName: options.targetName,
+        compiledName: options.targetName,
         workflow: options.workflow,
         workflowSourcePath: options.workflowSourcePath,
         stage: options.stageDefinition.id,
@@ -64,7 +64,7 @@ function finalizeValidatedStage(options, code) {
         options.syncWrites?.();
         options.reconcile?.();
         options.refreshArtifacts?.();
-        return validateStageOutcome(options.workspacePath, options.validate());
+        return validateStageOutcome(options.compiledPath, options.validate());
     };
     if (code !== 0) {
         let completionSatisfied = false;
@@ -79,7 +79,7 @@ function finalizeValidatedStage(options, code) {
         if (completionSatisfied) {
             const validation = refreshAndValidate();
             if (validation.ok) {
-                markRuntimeRunSucceededAfterValidation(options.workspacePath, validation.summary);
+                markRuntimeRunSucceededAfterValidation(options.compiledPath, validation.summary);
                 return {
                     ok: true,
                     code: 0,
@@ -87,7 +87,7 @@ function finalizeValidatedStage(options, code) {
                 };
             }
             reportValidationFailure(options.reporter, validation.summary);
-            markRuntimeRunFailedAfterValidation(options.workspacePath, validation.summary);
+            markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
             return {
                 ok: false,
                 code,
@@ -99,7 +99,7 @@ function finalizeValidatedStage(options, code) {
     const validation = refreshAndValidate();
     if (!validation.ok) {
         reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.workspacePath, validation.summary);
+        markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
     }
     return {
         ok: validation.ok,

package/dist/lib/workflows.d.ts

@@ -1,15 +1,15 @@
 import { type InterfConfig } from "./interf.js";
 export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "./workflow-helpers.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
-export type WorkspaceCheck = "summarize" | "structure" | "compile";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
+export type CompiledCheck = "compiled" | "stage";
 export interface DetectedInterfTarget {
     path: string;
-    kind: "workspace";
-    engineType: "workspace";
+    kind: "compiled";
+    engineType: "compiled";
     config: InterfConfig;
 }
-export declare function detectWorkspace(cwd: string): DetectedInterfTarget | null;
-export declare function createWorkspace(name: string, sourcePath: string, workflowId?: string, about?: string): string;
-export declare function verifyWorkspaceCheck(check: WorkspaceCheck, workspacePath: string): import("./validate-workspace.js").WorkspaceSummarizeValidation | import("./validate-workspace.js").WorkspaceCompileValidation | import("./validate-workspace.js").WorkspaceStructureValidation;
-export { runWorkspaceSummarize, runWorkspaceCompile, compileWorkspace, resolveWorkspaceContext, workspaceExecutionStages, } from "./workspace-compile.js";
-export type { WorkspaceSummarizeResult, WorkspaceCompileResult, WorkspaceStageExecutionDefinition, StageShellRetentionMode, } from "./workspace-compile.js";
+export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledWorkflowValidation;
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";

package/dist/lib/workflows.js

@@ -1,33 +1,31 @@
-import { createWorkspace as createWorkspaceScaffold, } from "./interf.js";
+import { createCompiled as createCompiledScaffold, } from "./interf.js";
 import { detectInterf } from "./interf.js";
-import { validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "./validate.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
-export function detectWorkspace(cwd) {
+import { validateCompiledCompile, } from "./validate.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
+export function detectCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
         return null;
     return {
         path: detected.path,
-        kind: "workspace",
-        engineType: "workspace",
+        kind: "compiled",
+        engineType: "compiled",
         config: detected.config,
     };
 }
-export function createWorkspace(name, sourcePath, workflowId = "interf", about) {
-    return createWorkspaceScaffold(name, sourcePath, workflowId, about);
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
+    return createCompiledScaffold(name, sourcePath, workflowId, about, datasetPath);
 }
-export function verifyWorkspaceCheck(check, workspacePath) {
+export function verifyCompiledCheck(check, compiledPath) {
     switch (check) {
-        case "summarize":
-            return validateWorkspaceSummarize(workspacePath);
-        case "structure":
-            return validateWorkspaceStructure(workspacePath);
-        case "compile":
-            return validateWorkspaceCompile(workspacePath);
+        case "compiled":
+            return validateCompiledCompile(compiledPath);
+        case "stage":
+            return validateCompiledCompile(compiledPath);
         default: {
             const exhaustiveCheck = check;
-            throw new Error(`Unknown workspace check: ${exhaustiveCheck}`);
+            throw new Error(`Unknown compiled check: ${exhaustiveCheck}`);
         }
     }
 }
-export { runWorkspaceSummarize, runWorkspaceCompile, compileWorkspace, resolveWorkspaceContext, workspaceExecutionStages, } from "./workspace-compile.js";
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.4.0",
-  "description": "Interf Compiler is a local runtime for data-processing workflows that turn datasets into compiled workspaces for local agents.",
+  "version": "0.5.0",
+  "description": "Interf Compiler is a local runtime for data-processing workflows that turn datasets into compiled datasets for local agents.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -27,22 +27,23 @@
     "test:e2e:claude": "npm run test:acceptance-live -- --agent claude-code",
     "test:e2e:codex": "npm run test:acceptance-live -- --agent codex",
     "test:e2e:quick": "npm run test:e2e:quick:matrix",
-    "test:e2e:quick:claude": "npm run test:acceptance-cache:refresh:claude && npm run test:acceptance-quick:create-workspace -- --agent claude-code --cache-root .interf-test-cache/claude-code && npm run test:acceptance-quick:query-workspace -- --agent claude-code --cache-root .interf-test-cache/claude-code && npm run test:acceptance-quick:self-improving -- --agent claude-code",
-    "test:e2e:quick:codex": "npm run test:acceptance-cache:refresh:codex && npm run test:acceptance-quick:create-workspace -- --agent codex --cache-root .interf-test-cache/codex && npm run test:acceptance-quick:query-workspace -- --agent codex --cache-root .interf-test-cache/codex && npm run test:acceptance-quick:self-improving -- --agent codex",
+    "test:e2e:quick:agent": "node scripts/run-quick-e2e.mjs",
+    "test:e2e:quick:claude": "npm run test:e2e:quick:agent -- --agent claude-code",
+    "test:e2e:quick:codex": "npm run test:e2e:quick:agent -- --agent codex",
     "test:e2e:quick:matrix": "npm run test:e2e:quick:claude && npm run test:e2e:quick:codex",
     "test:internal:cbre:fast": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json",
-    "test:internal:cbre:fast:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json --keep-workspaces",
+    "test:internal:cbre:fast:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json --keep-project-clones",
     "test:internal:cbre:max": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json",
-    "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-workspaces",
+    "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-project-clones",
     "test:full": "npm test && npm run test:e2e:quick:matrix",
     "test:release:matrix": "npm run test:internal:cbre:max",
-    "test:release": "npm test && npm run test:e2e:claude && npm run test:e2e:codex && npm run test:release:matrix",
+    "test:release": "npm test && npm run test:e2e:claude && npm run test:e2e:codex",
     "test:acceptance-live": "npm run build && node scripts/acceptance-live.mjs",
     "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude",
     "test:acceptance-cache:refresh:claude": "npm run build && node scripts/acceptance-live.mjs --agent claude-code --output-root .interf-test-cache/claude-code",
     "test:acceptance-cache:refresh:codex": "npm run build && node scripts/acceptance-live.mjs --agent codex --output-root .interf-test-cache/codex",
-    "test:acceptance-quick:create-workspace": "npm run build && node scripts/acceptance-targeted.mjs create-workspace",
-    "test:acceptance-quick:query-workspace": "npm run build && node scripts/acceptance-targeted.mjs workspace-query",
+    "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance-targeted.mjs create-compiled",
+    "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance-targeted.mjs compiled-query",
     "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance-targeted.mjs self-improving-compile",
     "prepublishOnly": "node scripts/prepublish-gate.mjs"
   },

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

@@ -1,23 +0,0 @@
-import type { SourceWorkspaceConfig } from "../lib/schema.js";
-import { type StageShellRetentionMode } from "../lib/workflows.js";
-import type { WorkflowExecutor } from "../lib/executors.js";
-import type { WorkspaceCompileResult } from "../lib/workflows.js";
-export interface SavedWorkspaceEntry {
-    config: SourceWorkspaceConfig;
-    path: string | null;
-    localDraft: boolean;
-}
-export declare function listSavedWorkspaceEntries(sourcePath: string): SavedWorkspaceEntry[];
-export declare function findBuiltWorkspacePath(sourcePath: string, workspaceName: string): string | null;
-export declare function findSavedWorkspaceConfig(sourcePath: string, workspaceName: string): SourceWorkspaceConfig | null;
-export declare function chooseWorkspaceConfigToBuild(options: {
-    sourcePath: string;
-    selectMessage: string;
-}): Promise<SourceWorkspaceConfig | null | undefined>;
-export declare function createWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
-export declare function ensureWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
-export declare function compileWorkspaceWithReporter(executor: WorkflowExecutor, workspacePath: string, options?: {
-    heading?: string;
-    successMessage?: string;
-    preserveStageShells?: StageShellRetentionMode;
-}): Promise<WorkspaceCompileResult>;

package/dist/commands/workspace-flow.js

@@ -1,109 +0,0 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { listWorkspacesForSourceFolder } from "../lib/interf.js";
-import { addWorkspace } from "../lib/registry.js";
-import { listSourceWorkspaceConfigs, loadWorkspaceControlConfig, loadSourceFolderConfig, sourceWorkspaceConfigFromInterfConfig, syncWorkspaceInterfConfigFromSourceWorkspaceConfig, } from "../lib/source-config.js";
-import { compileWorkspace, createWorkspace, } from "../lib/workflows.js";
-import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
-function formatSavedWorkspaceHint(entry) {
-    const config = entry.config;
-    const checkCount = config.checks.length;
-    const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
-    if (config.about)
-        return `${config.about} · ${workflowHint}`;
-    if (checkCount === 0)
-        return "No saved truth checks yet";
-    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
-}
-export function listSavedWorkspaceEntries(sourcePath) {
-    const entries = new Map();
-    for (const builtWorkspace of listWorkspacesForSourceFolder(sourcePath)) {
-        const workspaceConfig = loadWorkspaceControlConfig(builtWorkspace.path)
-            ?? sourceWorkspaceConfigFromInterfConfig(builtWorkspace.config);
-        entries.set(builtWorkspace.config.name, {
-            config: workspaceConfig,
-            path: builtWorkspace.path,
-            localDraft: builtWorkspace.config.workflow_origin?.local_draft === true,
-        });
-    }
-    for (const config of listSourceWorkspaceConfigs(loadSourceFolderConfig(sourcePath))) {
-        if (entries.has(config.name))
-            continue;
-        entries.set(config.name, {
-            config,
-            path: null,
-            localDraft: false,
-        });
-    }
-    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
-}
-export function findBuiltWorkspacePath(sourcePath, workspaceName) {
-    return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.path ?? null;
-}
-export function findSavedWorkspaceConfig(sourcePath, workspaceName) {
-    return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.config ?? null;
-}
-export async function chooseWorkspaceConfigToBuild(options) {
-    const savedEntries = listSavedWorkspaceEntries(options.sourcePath);
-    if (savedEntries.length === 0) {
-        return null;
-    }
-    if (savedEntries.length === 1) {
-        return savedEntries[0]?.config ?? null;
-    }
-    const selected = await p.select({
-        message: options.selectMessage,
-        options: savedEntries.map((entry) => ({
-            value: entry.config.name,
-            label: entry.config.name,
-            hint: [
-                formatSavedWorkspaceHint(entry),
-                entry.path ? "built" : "not built yet",
-            ].join(" · "),
-        })),
-    });
-    if (p.isCancel(selected))
-        return undefined;
-    return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
-}
-export function createWorkspaceFromConfig(sourcePath, workspaceConfig) {
-    const workflowId = workspaceConfig.workflow ?? "interf";
-    const workspacePath = createWorkspace(workspaceConfig.name, sourcePath, workflowId, workspaceConfig.about);
-    syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath, workspaceConfig);
-    addWorkspace(workspaceConfig.name, workspacePath, workflowId);
-    return workspacePath;
-}
-export function ensureWorkspaceFromConfig(sourcePath, workspaceConfig) {
-    const existingPath = findBuiltWorkspacePath(sourcePath, workspaceConfig.name);
-    if (existingPath) {
-        syncWorkspaceInterfConfigFromSourceWorkspaceConfig(existingPath, workspaceConfig);
-        addWorkspace(workspaceConfig.name, existingPath, workspaceConfig.workflow ?? "interf");
-        return existingPath;
-    }
-    return createWorkspaceFromConfig(sourcePath, workspaceConfig);
-}
-export async function compileWorkspaceWithReporter(executor, workspacePath, options = {}) {
-    console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building compiled workspace..."}`));
-    const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
-    if (profileLabel) {
-        console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
-    }
-    console.log();
-    const reporter = {
-        line: (message) => console.log(chalk.dim(`  ${message}`)),
-        blankLine: () => console.log(),
-    };
-    const result = await compileWorkspace({
-        executor,
-        workspacePath,
-        reporter,
-        preserveStageShells: options.preserveStageShells,
-    });
-    if (!result.ok) {
-        return result;
-    }
-    console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled workspace ready."}`));
-    return result;
-}