@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/runtime-reconcile.d.ts

@@ -1,3 +1,2 @@
-export declare function reconcileWorkspaceSummarizeRun(dirPath: string, expectedSummaryTotal: number): boolean;
-export declare function reconcileWorkspaceStructureRun(dirPath: string): boolean;
-export declare function reconcileWorkspaceShapeRun(dirPath: string): boolean;
+import { type WorkflowStageDefinition } from "./workflow-definitions.js";
+export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<WorkflowStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;

package/dist/lib/runtime-reconcile.js

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
-import { countFilesRecursive, listFilesRecursive } from "./filesystem.js";
-import { parseJsonFrontmatter, readJsonFileUnchecked } from "./parse.js";
+import { listFilesRecursive } from "./filesystem.js";
+import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { parseJsonFrontmatter } from "./parse.js";
 import { loadRuntimeRun } from "./runtime.js";
-import { initWorkspaceState, loadState, refreshWorkspaceArtifacts, saveState, } from "./state.js";
-import { validateWorkspace, validateWorkspaceCompile, validateWorkspaceStructure, validateWorkspaceSummarize, } from "./validate.js";
-import { workspaceHomeIsShaped } from "./workspace-home.js";
-import { workspaceRuntimeRoot } from "./workspace-paths.js";
+import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
+import { compiledInventoryFromEntries } from "./runtime-inventory.js";
+import { compiledRuntimeRoot } from "./compiled-paths.js";
+import { isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
     if (!run)
@@ -14,22 +15,18 @@ function readActiveRunStartedAtMs(dirPath) {
     const startedAtMs = Date.parse(run.started_at);
     return Number.isFinite(startedAtMs) ? startedAtMs : null;
 }
-function pathUpdatedSince(dirPath, relativePath, sinceMs) {
-    const absolutePath = join(dirPath, relativePath);
+function anyPathUpdatedSince(absolutePath, sinceMs) {
     if (!existsSync(absolutePath))
         return false;
     try {
-        return statSync(absolutePath).mtimeMs >= sinceMs;
+        const stat = statSync(absolutePath);
+        if (stat.isFile())
+            return stat.mtimeMs >= sinceMs;
     }
     catch {
         return false;
     }
-}
-function anyFileUpdatedSince(dirPath, relativeDir, sinceMs) {
-    const absoluteDir = join(dirPath, relativeDir);
-    if (!existsSync(absoluteDir))
-        return false;
-    for (const filePath of listFilesRecursive(absoluteDir)) {
+    for (const filePath of listFilesRecursive(absolutePath)) {
         try {
             if (statSync(filePath).mtimeMs >= sinceMs)
                 return true;
@@ -40,7 +37,15 @@ function anyFileUpdatedSince(dirPath, relativeDir, sinceMs) {
     }
     return false;
 }
-function readSummaryAbstract(content) {
+function zoneArtifactCount(dirPath, zonePath, kind) {
+    const absolutePath = compiledZoneAbsolutePath(dirPath, { path: zonePath });
+    if (!existsSync(absolutePath))
+        return 0;
+    if (kind === "file")
+        return 1;
+    return listFilesRecursive(absolutePath).length;
+}
+function summaryAbstract(content) {
     const parsed = parseJsonFrontmatter(content);
     if (!parsed)
         return null;
@@ -53,194 +58,110 @@ function readSummaryAbstract(content) {
     const bodyAbstract = match?.[1]?.trim() ?? "";
     return bodyAbstract.length > 0 ? bodyAbstract : null;
 }
-function isWorkspaceInventoryEntry(entry) {
-    return entry !== null;
-}
-function buildWorkspaceInventoryEntries(dirPath) {
-    const summariesDir = join(dirPath, "summaries");
-    if (!existsSync(summariesDir))
+function buildStageInventoryEntries(dirPath, stage) {
+    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
+    if (!schema)
         return [];
-    return listFilesRecursive(summariesDir, (filePath) => filePath.endsWith(".md"))
+    const inputZone = stage.reads
+        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
+        .find((zone) => zone && zone.kind !== "runtime");
+    const outputZone = stage.writes
+        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
+        .find((zone) => zone && zone.kind !== "runtime");
+    if (!inputZone || !outputZone)
+        return [];
+    const outputRoot = compiledZoneAbsolutePath(dirPath, outputZone);
+    if (!existsSync(outputRoot))
+        return [];
+    return listFilesRecursive(outputRoot, isOutputMarkdownFile)
         .map((filePath) => {
-        const relativeSummaryPath = relative(dirPath, filePath);
         const content = readFileSync(filePath, "utf8");
         const parsed = parseJsonFrontmatter(content);
         if (!parsed)
             return null;
-        const source = typeof parsed.frontmatter.source === "string"
+        const inputPath = typeof parsed.frontmatter.source === "string"
             ? parsed.frontmatter.source.trim()
             : typeof parsed.frontmatter.source_file === "string"
                 ? parsed.frontmatter.source_file.trim()
                 : typeof parsed.frontmatter.raw === "string"
                     ? parsed.frontmatter.raw.trim()
                     : "";
-        if (source.length === 0)
+        if (inputPath.length === 0)
             return null;
-        const abstract = readSummaryAbstract(content);
+        const abstract = summaryAbstract(content);
         return {
-            source,
-            summary: relativeSummaryPath,
-            source_kind: typeof parsed.frontmatter.source_kind === "string"
-                ? parsed.frontmatter.source_kind
-                : "unknown",
-            evidence_tier: typeof parsed.frontmatter.evidence_tier === "string"
-                ? parsed.frontmatter.evidence_tier
-                : "primary",
-            truth_mode: typeof parsed.frontmatter.truth_mode === "string"
-                ? parsed.frontmatter.truth_mode
-                : "reported-data",
+            input_zone: inputZone.id,
+            input_path: inputPath,
+            output_zone: outputZone.id,
+            output_path: relative(dirPath, filePath).replaceAll("\\", "/"),
             state: typeof parsed.frontmatter.state === "string"
                 ? parsed.frontmatter.state
-                : "summarized",
-            status: "summarized",
-            ...(abstract ? { abstract } : {}),
-            frontmatter_scanned: true,
-            abstract_read: Boolean(abstract),
+                : "complete",
+            metadata: {
+                source_kind: typeof parsed.frontmatter.source_kind === "string"
+                    ? parsed.frontmatter.source_kind
+                    : "unknown",
+                evidence_tier: typeof parsed.frontmatter.evidence_tier === "string"
+                    ? parsed.frontmatter.evidence_tier
+                    : "primary",
+                truth_mode: typeof parsed.frontmatter.truth_mode === "string"
+                    ? parsed.frontmatter.truth_mode
+                    : "reported-data",
+                abstract,
+                frontmatter_scanned: true,
+                abstract_read: Boolean(abstract),
+            },
         };
     })
-        .filter(isWorkspaceInventoryEntry)
-        .sort((left, right) => left.source.localeCompare(right.source));
-}
-function writeWorkspaceInventory(dirPath, entries) {
-    writeFileSync(join(workspaceRuntimeRoot(dirPath), "inventory.json"), JSON.stringify({
-        entries,
-        total: entries.length,
-    }, null, 2) + "\n");
+        .filter((entry) => entry !== null)
+        .sort((left, right) => left.input_path.localeCompare(right.input_path));
 }
-export function reconcileWorkspaceSummarizeRun(dirPath, expectedSummaryTotal) {
-    const startedAtMs = readActiveRunStartedAtMs(dirPath);
-    if (startedAtMs === null)
-        return false;
-    const plan = readJsonFileUnchecked(join(workspaceRuntimeRoot(dirPath), "summarize-targets.json"), "summarize plan");
-    if (!plan || plan.targetCount === 0)
-        return false;
-    if (!plan.targets.every((target) => pathUpdatedSince(dirPath, target.output, startedAtMs))) {
-        return false;
-    }
-    const summaryValidation = validateWorkspace(dirPath);
-    const summaryCount = countFilesRecursive(join(dirPath, "summaries"));
-    if (summaryCount < expectedSummaryTotal ||
-        !summaryValidation.summary_frontmatter_valid ||
-        !summaryValidation.abstracts_valid) {
-        return false;
-    }
-    const inventoryEntries = buildWorkspaceInventoryEntries(dirPath);
-    if (inventoryEntries.length < expectedSummaryTotal)
-        return false;
-    writeWorkspaceInventory(dirPath, inventoryEntries);
-    const currentState = {
-        ...initWorkspaceState(),
-        ...(loadState(dirPath) ?? {}),
-    };
-    const nextState = {
-        ...currentState,
-        pending: [],
-        summarized: inventoryEntries.length,
-        structured: 0,
-        shaped: 0,
-        compiled: 0,
-        last_summarize: new Date().toISOString(),
-        last_structure: null,
-        last_shape: null,
-        last_compile: null,
-        inventory_complete: true,
-        abstracts_read: Math.max(currentState.abstracts_read ?? 0, inventoryEntries.length),
-        full_reads: 0,
-        entity_count: 0,
-        claim_count: 0,
-    };
-    saveState(dirPath, nextState);
-    refreshWorkspaceArtifacts(dirPath, { ensureViewSpec: true });
-    return validateWorkspaceSummarize(dirPath).ok;
+function writeStageInventory(dirPath, stageId, entries) {
+    writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
 }
-export function reconcileWorkspaceStructureRun(dirPath) {
-    const startedAtMs = readActiveRunStartedAtMs(dirPath);
-    if (startedAtMs === null)
-        return false;
-    if (!(anyFileUpdatedSince(dirPath, "knowledge/entities", startedAtMs) ||
-        anyFileUpdatedSince(dirPath, "knowledge/claims", startedAtMs) ||
-        anyFileUpdatedSince(dirPath, "knowledge/indexes", startedAtMs))) {
-        return false;
-    }
-    const summaryCount = countFilesRecursive(join(dirPath, "summaries"));
-    const inventoryEntries = buildWorkspaceInventoryEntries(dirPath);
-    if (summaryCount > 0 && inventoryEntries.length < summaryCount) {
-        return false;
-    }
-    if (inventoryEntries.length > 0) {
-        writeWorkspaceInventory(dirPath, inventoryEntries);
-    }
-    const validation = validateWorkspaceStructure(dirPath);
-    if (!validation.required || !validation.checks.outputs_present)
-        return false;
-    const currentState = {
-        ...initWorkspaceState(),
-        ...(loadState(dirPath) ?? {}),
-    };
-    const entityCount = countFilesRecursive(join(dirPath, "knowledge", "entities"));
-    const claimCount = countFilesRecursive(join(dirPath, "knowledge", "claims"));
-    const nextState = {
-        ...currentState,
-        summarized: summaryCount,
-        structured: summaryCount,
-        shaped: 0,
-        compiled: 0,
-        inventory_complete: true,
-        abstracts_read: Math.max(currentState.abstracts_read ?? 0, validation.counts.abstracts_read),
-        full_reads: Math.max(currentState.full_reads ?? 0, summaryCount),
-        entity_count: entityCount,
-        claim_count: claimCount,
-        last_structure: new Date().toISOString(),
-        last_shape: null,
-        last_compile: null,
-    };
-    saveState(dirPath, nextState);
-    refreshWorkspaceArtifacts(dirPath, { ensureViewSpec: true });
-    return validateWorkspaceStructure(dirPath).ok;
+function activeRunCounts(dirPath) {
+    return { ...(loadRuntimeRun(dirPath)?.counts ?? {}) };
 }
-export function reconcileWorkspaceShapeRun(dirPath) {
+export function reconcileCompiledStageRun(dirPath, stage) {
     const startedAtMs = readActiveRunStartedAtMs(dirPath);
     if (startedAtMs === null)
         return false;
-    if (!pathUpdatedSince(dirPath, "home.md", startedAtMs)) {
+    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
+    if (!schema)
         return false;
-    }
-    if (!workspaceHomeIsShaped(dirPath)) {
+    const writeZones = stage.writes
+        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
+        .filter((zone) => zone !== null);
+    if (writeZones.length === 0)
         return false;
-    }
-    const summaryCount = countFilesRecursive(join(dirPath, "summaries"));
-    const inventoryEntries = buildWorkspaceInventoryEntries(dirPath);
-    if (summaryCount > 0 && inventoryEntries.length < summaryCount) {
+    if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
         return false;
     }
+    const inventoryEntries = buildStageInventoryEntries(dirPath, stage);
     if (inventoryEntries.length > 0) {
-        writeWorkspaceInventory(dirPath, inventoryEntries);
+        writeStageInventory(dirPath, stage.id, inventoryEntries);
     }
-    const structureValidation = validateWorkspaceStructure(dirPath);
-    if (!structureValidation.ok)
-        return false;
     const currentState = {
-        ...initWorkspaceState(),
+        ...initCompiledState(),
         ...(loadState(dirPath) ?? {}),
+        stages: {
+            ...(loadState(dirPath)?.stages ?? {}),
+        },
     };
-    const entityCount = countFilesRecursive(join(dirPath, "knowledge", "entities"));
-    const claimCount = countFilesRecursive(join(dirPath, "knowledge", "claims"));
     const now = new Date().toISOString();
-    const nextState = {
-        ...currentState,
-        summarized: summaryCount,
-        structured: summaryCount,
-        shaped: summaryCount,
-        compiled: summaryCount,
-        inventory_complete: true,
-        abstracts_read: Math.max(currentState.abstracts_read ?? 0, summaryCount),
-        full_reads: Math.max(currentState.full_reads ?? 0, summaryCount),
-        entity_count: entityCount,
-        claim_count: claimCount,
-        last_shape: now,
-        last_compile: now,
+    currentState.stages[stage.id] = {
+        contract_type: stage.contractType,
+        status: "succeeded",
+        started_at: loadRuntimeRun(dirPath)?.started_at ?? now,
+        finished_at: now,
+        counts: activeRunCounts(dirPath),
+        zone_counts: Object.fromEntries(writeZones.map((zone) => [zone.id, zoneArtifactCount(dirPath, zone.path, zone.kind)])),
+        artifacts: writeZones.map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`),
+        summary: loadRuntimeRun(dirPath)?.summary ?? null,
+        run_id: loadRuntimeRun(dirPath)?.run_id ?? null,
     };
-    saveState(dirPath, nextState);
-    refreshWorkspaceArtifacts(dirPath, { ensureViewSpec: true });
-    return validateWorkspaceCompile(dirPath).ok;
+    currentState.last_compile = now;
+    saveState(dirPath, currentState);
+    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
+    return true;
 }

package/dist/lib/runtime-runs.js

@@ -36,34 +36,34 @@ export function writeStageContract(dirPath, contract) {
 export async function runExecutorStage(options) {
     const run = startRuntimeRun(options);
     const prompt = options.buildPrompt(run.contract_path);
-    writeRuntimeRunPrompt(options.workspacePath, run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.workspacePath;
+    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    const executionPath = options.executionPath ?? options.compiledPath;
     const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.workspacePath, run.run_id),
-        statusLogPath: statusLogPath(options.workspacePath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
         completionCheck: options.completionCheck,
     });
-    finalizeRuntimeRun(options.workspacePath, code);
+    finalizeRuntimeRun(options.compiledPath, code);
     return code;
 }
 export async function runExecutorSummarizeStage(options) {
     const run = startRuntimeRun(options);
     const prompt = options.buildPrompt(run.contract_path);
     let lastReported = 0;
-    writeRuntimeRunPrompt(options.workspacePath, run.run_id, prompt);
-    const executionPath = options.executionPath ?? options.workspacePath;
+    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    const executionPath = options.executionPath ?? options.compiledPath;
     const progressPromise = options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.workspacePath, run.run_id),
-        statusLogPath: statusLogPath(options.workspacePath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
         completionCheck: options.completionCheck,
     });
     const timer = setInterval(() => {
-        const currentSummaryCount = countFilesRecursive(join(options.workspacePath, "summaries"));
+        const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
         const completed = Math.max(0, Math.min(options.targetCount, currentSummaryCount - options.startingSummaryCount));
         if (completed <= lastReported)
             return;
         lastReported = completed;
-        updateRuntimeRun(options.workspacePath, {
+        updateRuntimeRun(options.compiledPath, {
             counts: {
                 ...run.counts,
                 completed_summaries: completed,
@@ -75,7 +75,7 @@ export async function runExecutorSummarizeStage(options) {
     }, 10000);
     try {
         const code = await progressPromise;
-        finalizeRuntimeRun(options.workspacePath, code);
+        finalizeRuntimeRun(options.compiledPath, code);
         return code;
     }
     finally {
@@ -145,8 +145,8 @@ function startRuntimeRun(options) {
         version: 1,
         generated_at: generatedAt,
         run_id: runId,
-        target_type: "workspace",
-        target_name: options.workspaceName,
+        target_type: "compiled",
+        target_name: options.compiledName,
         workflow: {
             id: options.workflow,
             stage_index: stagePosition?.stageIndex ?? null,
@@ -163,13 +163,13 @@ function startRuntimeRun(options) {
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };
-    const contractPath = writeStageContract(options.workspacePath, contract);
+    const contractPath = writeStageContract(options.compiledPath, contract);
     const run = {
         kind: "interf-run",
         version: 1,
         run_id: runId,
-        target_type: "workspace",
-        target_name: options.workspaceName,
+        target_type: "compiled",
+        target_name: options.compiledName,
         workflow: options.workflow,
         stage: options.stage,
         stage_label: stageDefinition?.label ?? options.stageLabel,
@@ -179,20 +179,20 @@ function startRuntimeRun(options) {
         started_at: generatedAt,
         updated_at: generatedAt,
         finished_at: null,
-        contract_path: relative(options.workspacePath, contractPath),
-        ...(options.executionPath ? { execution_path: relative(options.workspacePath, options.executionPath) } : {}),
+        contract_path: relative(options.compiledPath, contractPath),
+        ...(options.executionPath ? { execution_path: relative(options.compiledPath, options.executionPath) } : {}),
         counts: { ...contract.counts },
         output_artifacts: [...contract.artifacts.writes],
         logs: {
-            prompt_path: relative(options.workspacePath, promptLogPath(options.workspacePath, runId)),
-            event_stream_path: relative(options.workspacePath, eventLogPath(options.workspacePath, runId)),
-            status_path: relative(options.workspacePath, statusLogPath(options.workspacePath, runId)),
+            prompt_path: relative(options.compiledPath, promptLogPath(options.compiledPath, runId)),
+            event_stream_path: relative(options.compiledPath, eventLogPath(options.compiledPath, runId)),
+            status_path: relative(options.compiledPath, statusLogPath(options.compiledPath, runId)),
         },
         summary: options.summary,
         exit_code: null,
         error: null,
     };
-    return beginRuntimeRun(options.workspacePath, run);
+    return beginRuntimeRun(options.compiledPath, run);
 }
 function finalizeRuntimeRun(dirPath, code) {
     const current = loadRuntimeRun(dirPath);
@@ -293,28 +293,19 @@ function normalizeRuntimeRunStatus(record) {
     return "running";
 }
 function inferRuntimeTargetType(targetType) {
-    if (targetType === "workspace") {
-        return "workspace";
+    if (targetType === "compiled") {
+        return "compiled";
     }
     return null;
 }
 function inferRuntimeContractType(contractType, stage) {
-    if (contractType === "workspace-file-evidence") {
-        return "workspace-file-evidence";
+    if (typeof contractType === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(contractType)) {
+        return contractType;
     }
-    if (contractType === "workspace-knowledge-structure") {
-        return "workspace-knowledge-structure";
+    if (typeof stage === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(stage)) {
+        return stage;
     }
-    if (contractType === "workspace-query-shape") {
-        return "workspace-query-shape";
-    }
-    if (stage === "structure" || stage === "compile") {
-        return "workspace-knowledge-structure";
-    }
-    if (stage === "shape") {
-        return "workspace-query-shape";
-    }
-    return "workspace-file-evidence";
+    return "compiled";
 }
 function replaceOrAppendRunHistoryEntry(dirPath, run) {
     const historyPath = runHistoryPath(dirPath);

package/dist/lib/runtime-types.d.ts

@@ -4,9 +4,9 @@ export type RuntimeRunStatus = "running" | "succeeded" | "failed";
 export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "workflow" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
     executor: WorkflowExecutor;
-    workspacePath: string;
+    compiledPath: string;
     executionPath?: string;
-    workspaceName: string;
+    compiledName: string;
     workflow: WorkflowId;
     workflowSourcePath?: string;
     stage: RuntimeStage;
@@ -26,27 +26,18 @@ export interface RuntimeStageAcceptanceValidation {
     summary: string;
     failures: string[];
 }
-export interface WorkspaceSummarizeContractOptions {
-    workspaceName: string;
-    targetCount: number;
-    expectedSummaryTotal: number;
-    sourcePath: string;
-    planPath: string;
-    workflowNotes?: string[];
-    localSkillDocs?: string[];
-    instructions: RuntimeStageInstructions;
-    acceptance?: RuntimeStageAcceptance;
-}
-export interface WorkspaceKnowledgeContractOptions {
-    workspaceName: string;
-    summaryCount: number;
+export interface RuntimeStageContractOptions {
+    compiledName: string;
+    stageId: string;
+    stageLabel: string;
+    counts?: Record<string, number>;
+    extraReadArtifacts?: string[];
+    stageReadArtifacts: string[];
+    stageWriteArtifacts: string[];
     workflowNotes?: string[];
     localSkillDocs?: string[];
     instructions: RuntimeStageInstructions;
     acceptance?: RuntimeStageAcceptance;
 }
-export interface WorkspaceShapeContractOptions extends WorkspaceKnowledgeContractOptions {
-    shapeInputPath: string;
-}
 export interface RuntimeRunPatch extends Partial<Pick<RuntimeRun, "counts" | "summary" | "status" | "error" | "exit_code" | "finished_at">> {
 }

package/dist/lib/runtime.d.ts

@@ -1,6 +1,6 @@
-export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeSummarizeExecutionOptions, WorkspaceSummarizeContractOptions, } from "./runtime-types.js";
+export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeSummarizeExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
 export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildWorkspaceSummarizeContract, buildWorkspaceStructureContract, buildWorkspaceShapeContract, } from "./runtime-contracts.js";
+export { buildRuntimeStageContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/lib/runtime.js

@@ -1,5 +1,5 @@
 export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
-export { buildWorkspaceSummarizeContract, buildWorkspaceStructureContract, buildWorkspaceShapeContract, } from "./runtime-contracts.js";
+export { buildRuntimeStageContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";