@interf/compiler 0.3.4 → 0.4.1

package/dist/lib/workspace-compile.js

@@ -1,20 +1,21 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { countFilesRecursive } from "./filesystem.js";
-import { createStageExecutionShell, pruneStageExecutionShells } from "./agent-shells.js";
+import { createStageExecutionShell, freezeStageExecutionShell, pruneStageExecutionShells, syncStageExecutionShellWrites, } from "./agent-shells.js";
 import { readInterfConfig, refreshWorkspaceBootstrapGuidance, resolveSourceFolderPath, resolveSourceControlPath, } from "./interf.js";
-import { findSourceWorkspaceConfig, loadSourceFolderConfig } from "./source-config.js";
 import { buildSummarizePlan, writeSummarizePlan } from "./summarize-plan.js";
 import { reconcileWorkspaceShapeRun, reconcileWorkspaceStructureRun, reconcileWorkspaceSummarizeRun, } from "./runtime-reconcile.js";
 import { loadState, refreshWorkspaceArtifacts, } from "./state.js";
 import { buildWorkspaceShapeContract, buildWorkspaceStructureContract, buildWorkspaceSummarizeContract, validateStageContractAcceptance, } from "./runtime.js";
 import { readJsonFileUnchecked } from "./parse.js";
-import { formatWorkspaceWorkflowStageStep, getWorkflowStagePolicyNotes, getWorkspaceWorkflow, resolveWorkspaceWorkflowFromConfig, } from "./workflow-definitions.js";
+import { validateWorkflowPackage } from "./local-workflows.js";
+import { formatActiveWorkspaceWorkflowStageStep, getActiveWorkspaceStagePolicyNotes, getActiveWorkspaceWorkflow, resolveWorkspaceWorkflowFromConfig, resolveActiveWorkspaceStageAcceptance, } from "./workflow-definitions.js";
 import { validateWorkspaceCompile, validateWorkspaceStructure, validateWorkspaceSummarize, } from "./validate.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, bundledSkillForContractType, reportBlankLine, reportLine, reportValidationFailure, resolveStageAcceptance, workflowCompileStageDirectory, } from "./workflow-helpers.js";
+import { buildLocalSkillContractExtension, buildStageInstructions, bundledSkillForContractType, reportBlankLine, reportLine, reportValidationFailure, workflowCompileStageDirectory, } from "./workflow-helpers.js";
 import { executeValidatedStage, executeValidatedSummarizeStage, findStageByContractType, } from "./workflow-stage-runner.js";
 import { syncWorkspaceRawSnapshot } from "./workspace-raw.js";
-const SHAPE_INPUT_RELATIVE_PATH = ".interf/shape-input.json";
+import { workspaceRuntimeRoot } from "./workspace-paths.js";
+const SHAPE_INPUT_RELATIVE_PATH = ".interf/runtime/shape-input.json";
 export function resolveWorkspaceContext(workspacePath) {
     const config = readInterfConfig(workspacePath);
     const workflowId = resolveWorkspaceWorkflowFromConfig(config);
@@ -26,11 +27,11 @@ export function resolveWorkspaceContext(workspacePath) {
     };
 }
 export function workspaceExecutionStages(workflowId, workspacePath) {
-    return getWorkspaceWorkflow(workflowId, { sourcePath: resolveSourceControlPath(workspacePath) })
+    return getActiveWorkspaceWorkflow(workspacePath, workflowId)
         .stages;
 }
 function readWorkspaceInventoryTotal(workspacePath) {
-    const inventory = readJsonFileUnchecked(join(workspacePath, ".interf", "inventory.json"), "workspace inventory");
+    const inventory = readJsonFileUnchecked(join(workspaceRuntimeRoot(workspacePath), "inventory.json"), "workspace inventory");
     if (!inventory)
         return 0;
     if (typeof inventory.total === "number")
@@ -83,21 +84,19 @@ function isWorkspaceShapeStageComplete(workspacePath, summaryCount) {
         (state.shaped ?? state.compiled ?? 0) >= summaryCount &&
         (state.compiled ?? 0) >= summaryCount);
 }
-function writeWorkspaceShapeInput(workspacePath, workspaceName, controlPath) {
+function writeWorkspaceShapeInput(workspacePath, workspaceName) {
     const workspaceConfig = readInterfConfig(workspacePath);
-    const sourceConfig = loadSourceFolderConfig(controlPath);
-    const sourceWorkspace = findSourceWorkspaceConfig(sourceConfig, workspaceName);
-    const questions = (sourceWorkspace?.checks ?? []).map((check, index) => ({
+    const questions = (workspaceConfig?.checks ?? []).map((check, index) => ({
         id: check.id ?? `check-${index + 1}`,
         question: check.question,
     }));
-    mkdirSync(join(workspacePath, ".interf"), { recursive: true });
+    mkdirSync(workspaceRuntimeRoot(workspacePath), { recursive: true });
     writeFileSync(join(workspacePath, SHAPE_INPUT_RELATIVE_PATH), JSON.stringify({
         kind: "workspace-shape-input",
         version: 1,
         generated_at: new Date().toISOString(),
         target_name: workspaceName,
-        about: sourceWorkspace?.about ?? workspaceConfig?.about ?? null,
+        about: workspaceConfig?.about ?? null,
         question_count: questions.length,
         questions,
     }, null, 2) + "\n");
@@ -105,14 +104,13 @@ function writeWorkspaceShapeInput(workspacePath, workspaceName, controlPath) {
 }
 export function buildWorkspaceCompileContract(workspacePath, workflowId, summaryCount, instructions, stageId = "shape", stageSkillDir = "shape", shapeInputPath = SHAPE_INPUT_RELATIVE_PATH) {
     const config = readInterfConfig(workspacePath);
-    const controlPath = resolveSourceControlPath(workspacePath);
-    const acceptance = resolveStageAcceptance(workflowId, stageId, controlPath);
+    const acceptance = resolveActiveWorkspaceStageAcceptance(workspacePath, workflowId, stageId);
     const localSkills = buildLocalSkillContractExtension(workspacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use them to refine workspace shaping, navigation, and retrieval routes.");
     return buildWorkspaceShapeContract({
         workspaceName: config?.name ?? "workspace",
         summaryCount,
         shapeInputPath,
-        workflowNotes: getWorkflowStagePolicyNotes(workflowId, stageId, controlPath),
+        workflowNotes: getActiveWorkspaceStagePolicyNotes(workspacePath, workflowId, stageId),
         localSkillDocs: localSkills.reads,
         instructions,
         acceptance,
@@ -120,13 +118,12 @@ export function buildWorkspaceCompileContract(workspacePath, workflowId, summary
 }
 function buildWorkspaceStructureStageContract(workspacePath, workflowId, summaryCount, instructions, stageId = "structure", stageSkillDir = "structure") {
     const config = readInterfConfig(workspacePath);
-    const controlPath = resolveSourceControlPath(workspacePath);
-    const acceptance = resolveStageAcceptance(workflowId, stageId, controlPath);
+    const acceptance = resolveActiveWorkspaceStageAcceptance(workspacePath, workflowId, stageId);
     const localSkills = buildLocalSkillContractExtension(workspacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use them to refine workspace structure, taxonomy, ontology, entity extraction, and claim extraction.");
     return buildWorkspaceStructureContract({
         workspaceName: config?.name ?? "workspace",
         summaryCount,
-        workflowNotes: getWorkflowStagePolicyNotes(workflowId, stageId, controlPath),
+        workflowNotes: getActiveWorkspaceStagePolicyNotes(workspacePath, workflowId, stageId),
         localSkillDocs: localSkills.reads,
         instructions,
         acceptance,
@@ -135,7 +132,6 @@ function buildWorkspaceStructureStageContract(workspacePath, workflowId, summary
 export async function runWorkspaceSummarize(options) {
     const context = resolveWorkspaceContext(options.workspacePath);
     const sourcePath = options.sourcePath ?? context.sourcePath;
-    const controlPath = context.controlPath;
     const workflowId = context.workflowId;
     const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-file-evidence");
     const stageStatusLabel = stageDefinition.label.toLowerCase();
@@ -151,7 +147,7 @@ export async function runWorkspaceSummarize(options) {
         refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true });
         const validation = validateWorkspaceSummarize(options.workspacePath);
         if (options.reportStep !== false) {
-            reportLine(options.reporter, `${formatWorkspaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath: controlPath })} skipped (no work required)`);
+            reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} skipped (no work required)`);
         }
         if (!validation.ok) {
             reportValidationFailure(options.reporter, validation.summary);
@@ -164,45 +160,52 @@ export async function runWorkspaceSummarize(options) {
         };
     }
     if (options.reportStep !== false) {
-        reportLine(options.reporter, `${formatWorkspaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath: controlPath })} (${plan.targetCount} files)`);
+        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (${plan.targetCount} files)`);
     }
     const shell = createStageExecutionShell(options.workspacePath, context.workspaceName, workflowId, stageDefinition);
-    const stageResult = await executeValidatedSummarizeStage({
-        executor: options.executor,
-        workspacePath: options.workspacePath,
-        executionPath: shell.rootPath,
-        targetName: context.workspaceName,
-        workflow: workflowId,
-        workflowSourcePath: controlPath,
-        stageDefinition,
-        instructions,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${plan.targetCount} source files.`,
-        contract: buildWorkspaceSummarizeContract({
-            workspaceName: context.workspaceName,
-            targetCount: plan.targetCount,
-            expectedSummaryTotal,
-            sourcePath,
-            planPath,
-            workflowNotes: getWorkflowStagePolicyNotes(workflowId, stageDefinition.id, controlPath),
-            localSkillDocs: localSkills.reads,
+    let stageResult;
+    try {
+        stageResult = await executeValidatedSummarizeStage({
+            executor: options.executor,
+            workspacePath: options.workspacePath,
+            executionPath: shell.rootPath,
+            targetName: context.workspaceName,
+            workflow: workflowId,
+            workflowSourcePath: options.workspacePath,
+            stageDefinition,
             instructions,
-            acceptance: resolveStageAcceptance(workflowId, stageDefinition.id, controlPath),
-        }),
-        statusLines: [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${plan.targetCount} files.`,
-            "The CLI owns live file-count progress. Do not emit per-file progress.",
-            "If `.interf/inventory.json` already exists, overwrite it completely instead of patching prior contents.",
-            "Emit STATUS: batch committed after a completed batch has been merged into summaries/ and inventory.",
-            `Emit DONE: ${stageStatusLabel} complete ${plan.targetCount}/${plan.targetCount} when finished.`,
-        ],
-        reporter: options.reporter,
-        completionCheck: () => isWorkspaceSummarizeStageComplete(options.workspacePath, expectedSummaryTotal),
-        reconcile: () => reconcileWorkspaceSummarizeRun(options.workspacePath, expectedSummaryTotal),
-        refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-        validate: () => validateWorkspaceSummarize(options.workspacePath),
-        startingSummaryCount: plan.summaryCount,
-        targetCount: plan.targetCount,
-    });
+            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${plan.targetCount} source files.`,
+            contract: buildWorkspaceSummarizeContract({
+                workspaceName: context.workspaceName,
+                targetCount: plan.targetCount,
+                expectedSummaryTotal,
+                sourcePath,
+                planPath,
+                workflowNotes: getActiveWorkspaceStagePolicyNotes(options.workspacePath, workflowId, stageDefinition.id),
+                localSkillDocs: localSkills.reads,
+                instructions,
+                acceptance: resolveActiveWorkspaceStageAcceptance(options.workspacePath, workflowId, stageDefinition.id),
+            }),
+            statusLines: [
+                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${plan.targetCount} files.`,
+                "The CLI owns live file-count progress. Do not emit per-file progress.",
+                "If `.interf/runtime/inventory.json` already exists, overwrite it completely instead of patching prior contents.",
+                "Emit STATUS: batch committed after a completed batch has been merged into summaries/ and inventory.",
+                `Emit DONE: ${stageStatusLabel} complete ${plan.targetCount}/${plan.targetCount} when finished.`,
+            ],
+            reporter: options.reporter,
+            completionCheck: () => isWorkspaceSummarizeStageComplete(options.workspacePath, expectedSummaryTotal),
+            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
+            reconcile: () => reconcileWorkspaceSummarizeRun(options.workspacePath, expectedSummaryTotal),
+            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
+            validate: () => validateWorkspaceSummarize(options.workspacePath),
+            startingSummaryCount: plan.summaryCount,
+            targetCount: plan.targetCount,
+        });
+    }
+    finally {
+        freezeStageExecutionShell(shell.rootPath);
+    }
     if (!stageResult.ok) {
         return {
             ok: false,
@@ -223,7 +226,6 @@ async function runWorkspaceStructure(options) {
     const workspaceName = workspaceConfig?.name ?? "workspace";
     const workflowId = resolveWorkspaceWorkflowFromConfig(workspaceConfig);
     const sourcePath = options.sourcePath ?? resolveSourceFolderPath(options.workspacePath, workspaceConfig);
-    const controlPath = resolveSourceControlPath(options.workspacePath);
     const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-knowledge-structure");
     const stageStatusLabel = stageDefinition.label.toLowerCase();
     const summaryCount = countFilesRecursive(join(options.workspacePath, "summaries"));
@@ -231,73 +233,84 @@ async function runWorkspaceStructure(options) {
     const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
     if (options.reportStep !== false) {
         reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatWorkspaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath: controlPath })} (building knowledge structure)`);
+        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (building knowledge structure)`);
     }
     const shell = createStageExecutionShell(options.workspacePath, workspaceName, workflowId, stageDefinition);
-    return executeValidatedStage({
-        executor: options.executor,
-        workspacePath: options.workspacePath,
-        executionPath: shell.rootPath,
-        targetName: workspaceName,
-        workflow: workflowId,
-        workflowSourcePath: controlPath,
-        stageDefinition,
-        instructions,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
-        contract: buildWorkspaceStructureStageContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir),
-        statusLines: [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
-            `Emit STATUS: inventoried summaries ${summaryCount}/${summaryCount} after the inventory pass completes.`,
-            `Emit STATUS: structured knowledge layer after entities, claims, and indexes are updated.`,
-            `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
-        ],
-        reporter: options.reporter,
-        completionCheck: () => isWorkspaceStructureStageComplete(options.workspacePath, summaryCount),
-        reconcile: () => reconcileWorkspaceStructureRun(options.workspacePath),
-        refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-        validate: () => validateWorkspaceStructure(options.workspacePath),
-    });
+    try {
+        return await executeValidatedStage({
+            executor: options.executor,
+            workspacePath: options.workspacePath,
+            executionPath: shell.rootPath,
+            targetName: workspaceName,
+            workflow: workflowId,
+            workflowSourcePath: options.workspacePath,
+            stageDefinition,
+            instructions,
+            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
+            contract: buildWorkspaceStructureStageContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir),
+            statusLines: [
+                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
+                `Emit STATUS: inventoried summaries ${summaryCount}/${summaryCount} after the inventory pass completes.`,
+                `Emit STATUS: structured knowledge layer after entities, claims, and indexes are updated.`,
+                `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
+            ],
+            reporter: options.reporter,
+            completionCheck: () => isWorkspaceStructureStageComplete(options.workspacePath, summaryCount),
+            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
+            reconcile: () => reconcileWorkspaceStructureRun(options.workspacePath),
+            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
+            validate: () => validateWorkspaceStructure(options.workspacePath),
+        });
+    }
+    finally {
+        freezeStageExecutionShell(shell.rootPath);
+    }
 }
 async function runWorkspaceShape(options) {
     const workspaceConfig = readInterfConfig(options.workspacePath);
     const workspaceName = workspaceConfig?.name ?? "workspace";
     const workflowId = resolveWorkspaceWorkflowFromConfig(workspaceConfig);
     const sourcePath = options.sourcePath ?? resolveSourceFolderPath(options.workspacePath, workspaceConfig);
-    const controlPath = resolveSourceControlPath(options.workspacePath);
     const stageDefinition = options.stageDefinition ?? findStageByContractType(workspaceExecutionStages(workflowId, options.workspacePath), "workspace-query-shape");
     const stageStatusLabel = stageDefinition.label.toLowerCase();
     const summaryCount = countFilesRecursive(join(options.workspacePath, "summaries"));
     const localSkills = buildLocalSkillContractExtension(options.workspacePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine final workspace shaping, navigation, and retrieval routes.");
     const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
-    const shapeInputPath = writeWorkspaceShapeInput(options.workspacePath, workspaceName, controlPath);
+    const shapeInputPath = writeWorkspaceShapeInput(options.workspacePath, workspaceName);
     if (options.reportStep !== false) {
         reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatWorkspaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath: controlPath })} (shaping workspace surface)`);
+        reportLine(options.reporter, `${formatActiveWorkspaceWorkflowStageStep(options.workspacePath, workflowId, stageDefinition.id)} (shaping workspace surface)`);
     }
     const shell = createStageExecutionShell(options.workspacePath, workspaceName, workflowId, stageDefinition);
-    return executeValidatedStage({
-        executor: options.executor,
-        workspacePath: options.workspacePath,
-        executionPath: shell.rootPath,
-        targetName: workspaceName,
-        workflow: workflowId,
-        workflowSourcePath: controlPath,
-        stageDefinition,
-        instructions,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
-        contract: buildWorkspaceCompileContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir, shapeInputPath),
-        statusLines: [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
-            `Emit STATUS: read shaping input after ${shapeInputPath} has been loaded.`,
-            "Emit STATUS: shaped workspace surface after home.md and any focused indexes are updated.",
-            `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
-        ],
-        reporter: options.reporter,
-        completionCheck: () => isWorkspaceShapeStageComplete(options.workspacePath, summaryCount),
-        reconcile: () => reconcileWorkspaceShapeRun(options.workspacePath),
-        refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
-        validate: () => validateWorkspaceCompile(options.workspacePath),
-    });
+    try {
+        return await executeValidatedStage({
+            executor: options.executor,
+            workspacePath: options.workspacePath,
+            executionPath: shell.rootPath,
+            targetName: workspaceName,
+            workflow: workflowId,
+            workflowSourcePath: options.workspacePath,
+            stageDefinition,
+            instructions,
+            summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
+            contract: buildWorkspaceCompileContract(options.workspacePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir, shapeInputPath),
+            statusLines: [
+                `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
+                `Emit STATUS: read shaping input after ${shapeInputPath} has been loaded.`,
+                "Emit STATUS: shaped workspace surface after home.md and any focused indexes are updated.",
+                `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when the required outputs are on disk.`,
+            ],
+            reporter: options.reporter,
+            completionCheck: () => isWorkspaceShapeStageComplete(options.workspacePath, summaryCount),
+            syncWrites: () => syncStageExecutionShellWrites(options.workspacePath, shell.rootPath, stageDefinition),
+            reconcile: () => reconcileWorkspaceShapeRun(options.workspacePath),
+            refreshArtifacts: () => refreshWorkspaceArtifacts(options.workspacePath, { ensureViewSpec: true }),
+            validate: () => validateWorkspaceCompile(options.workspacePath),
+        });
+    }
+    finally {
+        freezeStageExecutionShell(shell.rootPath);
+    }
 }
 async function runWorkspaceCompileStages(options) {
     const workspaceConfig = readInterfConfig(options.workspacePath);
@@ -377,6 +390,31 @@ export async function compileWorkspace(options) {
         const controlPath = resolveSourceControlPath(options.workspacePath);
         syncWorkspaceRawSnapshot(options.workspacePath, controlPath);
         refreshWorkspaceBootstrapGuidance(options.workspacePath);
+        const workflowValidation = validateWorkflowPackage(join(options.workspacePath, ".interf", "workflow"));
+        if (!workflowValidation.ok) {
+            const summary = workflowValidation.summary;
+            reportValidationFailure(options.reporter, summary, workflowValidation.errors);
+            const failedResult = {
+                ok: false,
+                summarize: {
+                    ok: false,
+                    code: 1,
+                    skipped: true,
+                    plan: buildSummarizePlan(controlPath, options.workspacePath),
+                    summary,
+                },
+                structure: null,
+                shape: null,
+                compile: {
+                    ok: false,
+                    code: 1,
+                    summary,
+                },
+                failedStage: "workflow",
+            };
+            result = failedResult;
+            return failedResult;
+        }
         const { sourcePath, workflowId } = resolveWorkspaceContext(options.workspacePath);
         const stages = workspaceExecutionStages(workflowId, options.workspacePath);
         let summarize = {
@@ -436,4 +474,3 @@ export async function compileWorkspace(options) {
         }
     }
 }
-//# sourceMappingURL=workspace-compile.js.map

package/dist/lib/workspace-home.d.ts

@@ -0,0 +1,5 @@
+export declare const UNCOMPILED_WORKSPACE_HOME_NOTICE = "Not yet compiled. Run `interf compile` to build this compiled workspace.";
+export declare function renderUncompiledWorkspaceHome(workspaceName: string, about?: string): string;
+export declare function workspaceHomeHasCompilePlaceholder(content: string): boolean;
+export declare function readWorkspaceHomeContent(dirPath: string): string | null;
+export declare function workspaceHomeIsShaped(dirPath: string): boolean;

package/dist/lib/workspace-home.js

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export const UNCOMPILED_WORKSPACE_HOME_NOTICE = "Not yet compiled. Run `interf compile` to build this compiled workspace.";
+export function renderUncompiledWorkspaceHome(workspaceName, about) {
+    return [
+        `# ${workspaceName} — Home`,
+        "",
+        UNCOMPILED_WORKSPACE_HOME_NOTICE,
+        ...(about ? ["", `About: ${about}`] : []),
+        "",
+    ].join("\n");
+}
+export function workspaceHomeHasCompilePlaceholder(content) {
+    return content.includes(UNCOMPILED_WORKSPACE_HOME_NOTICE);
+}
+export function readWorkspaceHomeContent(dirPath) {
+    const homePath = join(dirPath, "home.md");
+    if (!existsSync(homePath))
+        return null;
+    try {
+        return readFileSync(homePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function workspaceHomeIsShaped(dirPath) {
+    const content = readWorkspaceHomeContent(dirPath);
+    if (content === null)
+        return false;
+    return !workspaceHomeHasCompilePlaceholder(content);
+}

package/dist/lib/workspace-layout.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeLegacyWorkspaceLayout(workspacePath: string): boolean;
+export declare function workspaceNeedsLegacyLayoutNormalization(workspacePath: string): boolean;

package/dist/lib/workspace-layout.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { WORKSPACE_CONFIG_FILE, WORKSPACE_INTERF_DIR, WORKSPACE_RUNTIME_DIR, WORKSPACE_TEST_DIR, WORKSPACE_WORKFLOW_DIR, workflowPackagePathForWorkspace, workspaceInterfConfigPath, workspaceInterfRoot, workspaceRuntimeRoot, } from "./workspace-paths.js";
+const LEGACY_WORKSPACE_CONFIG_FILE = "interf.json";
+const LEGACY_WORKFLOW_DIR = "workflow";
+function movePathIfMissing(sourcePath, targetPath) {
+    if (!existsSync(sourcePath)) {
+        return false;
+    }
+    if (existsSync(targetPath)) {
+        return false;
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    renameSync(sourcePath, targetPath);
+    return true;
+}
+export function normalizeLegacyWorkspaceLayout(workspacePath) {
+    const interfRoot = workspaceInterfRoot(workspacePath);
+    const runtimeRoot = workspaceRuntimeRoot(workspacePath);
+    let changed = false;
+    changed = movePathIfMissing(join(workspacePath, LEGACY_WORKSPACE_CONFIG_FILE), workspaceInterfConfigPath(workspacePath)) || changed;
+    changed = movePathIfMissing(join(workspacePath, LEGACY_WORKFLOW_DIR), workflowPackagePathForWorkspace(workspacePath)) || changed;
+    if (!existsSync(interfRoot)) {
+        return changed;
+    }
+    for (const entry of readdirSync(interfRoot)) {
+        if (entry === WORKSPACE_RUNTIME_DIR ||
+            entry === WORKSPACE_TEST_DIR ||
+            entry === WORKSPACE_WORKFLOW_DIR ||
+            entry === WORKSPACE_CONFIG_FILE) {
+            continue;
+        }
+        changed = movePathIfMissing(join(interfRoot, entry), join(runtimeRoot, entry)) || changed;
+    }
+    return changed;
+}
+export function workspaceNeedsLegacyLayoutNormalization(workspacePath) {
+    if (existsSync(join(workspacePath, LEGACY_WORKSPACE_CONFIG_FILE)) &&
+        !existsSync(workspaceInterfConfigPath(workspacePath))) {
+        return true;
+    }
+    if (!existsSync(join(workspacePath, WORKSPACE_INTERF_DIR)))
+        return false;
+    if (existsSync(join(workspacePath, LEGACY_WORKFLOW_DIR)) &&
+        !existsSync(workflowPackagePathForWorkspace(workspacePath))) {
+        return true;
+    }
+    for (const entry of readdirSync(join(workspacePath, WORKSPACE_INTERF_DIR))) {
+        if (entry === WORKSPACE_RUNTIME_DIR ||
+            entry === WORKSPACE_TEST_DIR ||
+            entry === WORKSPACE_WORKFLOW_DIR ||
+            entry === WORKSPACE_CONFIG_FILE) {
+            continue;
+        }
+        if (!existsSync(join(workspaceRuntimeRoot(workspacePath), entry))) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/lib/workspace-paths.d.ts

@@ -0,0 +1,41 @@
+export declare const WORKSPACE_INTERF_DIR = ".interf";
+export declare const WORKSPACE_CONFIG_FILE = "interf.json";
+export declare const WORKSPACE_WORKFLOW_DIR = "workflow";
+export declare const WORKSPACE_TEST_DIR = "tests";
+export declare const WORKSPACE_TEST_TARGETS_DIR = "targets";
+export declare const WORKSPACE_RUNTIME_DIR = "runtime";
+export declare const WORKSPACE_RUNTIME_STATE_FILE = "state.json";
+export declare const WORKSPACE_RUNTIME_HEALTH_FILE = "health.json";
+export declare const WORKSPACE_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
+export declare const WORKSPACE_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
+export declare const WORKSPACE_RUNTIME_INVENTORY_FILE = "inventory.json";
+export declare const WORKSPACE_RUNTIME_RUN_FILE = "run.json";
+export declare const WORKSPACE_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
+export declare const WORKSPACE_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
+export declare function workspaceRuntimeRoot(workspacePath: string): string;
+export declare function workspaceRuntimeFilePath(workspacePath: string, fileName: string): string;
+export declare function workspaceInterfRoot(workspacePath: string): string;
+export declare function workspaceInterfConfigPath(workspacePath: string): string;
+export declare function workflowPackagePathForWorkspace(workspacePath: string): string;
+export declare function testRootForWorkspace(workspacePath: string): string;
+export declare function testRunsRootForWorkspace(workspacePath: string): string;
+export declare function testTargetsRootForWorkspace(workspacePath: string): string;
+export declare function latestTestComparisonPathForWorkspace(workspacePath: string): string;
+export declare function stageExecutionShellsRoot(workspacePath: string): string;
+export declare function workflowImprovementLoopsRoot(workspacePath: string): string;
+export declare function workflowImprovementRunRoot(workspacePath: string, runId: string): string;
+export declare function workflowImprovementLoopRoot(workspacePath: string, runId: string, loopIndex: number): string;
+export declare function targetTestRunsRootForWorkspace(workspacePath: string): string;
+export declare function targetTestSandboxesRootForWorkspace(workspacePath: string): string;
+export declare function workspaceRuntimeLogsRoot(workspacePath: string): string;
+export declare function workspaceQueryAcceptanceRoot(workspacePath: string): string;
+export declare function workspaceRuntimeStatePath(workspacePath: string): string;
+export declare function workspaceRuntimeHealthPath(workspacePath: string): string;
+export declare function workspaceRuntimeViewSpecPath(workspacePath: string): string;
+export declare function workspaceRawSnapshotMetadataPath(workspacePath: string): string;
+export declare function workspaceRuntimeInventoryPath(workspacePath: string): string;
+export declare function workspaceRuntimeRunPath(workspacePath: string): string;
+export declare function workspaceRuntimeRunHistoryPath(workspacePath: string): string;
+export declare function workspaceRuntimeStageContractPath(workspacePath: string): string;
+export declare function resolveSourceControlPathForWorkspace(workspacePath: string): string;
+export declare function defaultControlPathForWorkspace(workspacePath: string): string;