@interf/compiler 0.3.4 → 0.4.0

package/dist/lib/workflow-improvement.js

@@ -0,0 +1,396 @@
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from "./agent-shells.js";
+import { readInterfConfig } from "./interf.js";
+import { validateWorkflowPackage } from "./local-workflows.js";
+import { readJsonFileWithSchema } from "./parse.js";
+import { saveWorkspaceInterfConfig } 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";
+function copyDirectory(sourcePath, targetPath) {
+    rmSync(targetPath, { recursive: true, force: true });
+    mkdirSync(targetPath, { recursive: true });
+    cpSync(sourcePath, targetPath, { recursive: true });
+}
+function listFileSnapshot(dirPath) {
+    const snapshot = new Map();
+    if (!existsSync(dirPath))
+        return snapshot;
+    const collect = (currentPath) => {
+        for (const entry of readdirSync(currentPath)) {
+            const fullPath = join(currentPath, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                collect(fullPath);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            snapshot.set(relative(dirPath, fullPath), readFileSync(fullPath, "utf8"));
+        }
+    };
+    collect(dirPath);
+    return snapshot;
+}
+function directoriesMatch(leftPath, rightPath) {
+    const left = listFileSnapshot(leftPath);
+    const right = listFileSnapshot(rightPath);
+    if (left.size !== right.size)
+        return false;
+    for (const [relativePath, content] of left.entries()) {
+        if (right.get(relativePath) !== content) {
+            return false;
+        }
+    }
+    return true;
+}
+function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
+    if (!absolutePath)
+        return null;
+    const normalizedSourceRoot = `${sourceRoot}/`;
+    if (absolutePath !== sourceRoot && !absolutePath.startsWith(normalizedSourceRoot)) {
+        return null;
+    }
+    const relativePath = relative(sourceRoot, absolutePath);
+    return join(shellRoot, relativePath);
+}
+function mapLoopSummaryForShell(summary, workspacePath) {
+    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,
+    };
+}
+function buildLoopContext(options) {
+    const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.workspacePath));
+    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",
+        workflow_id: options.workflowId,
+        loop_index: options.loopIndex,
+        max_loops: options.maxLoops,
+        max_attempts: options.maxAttempts,
+        review_paths: resolveWorkflowImprovementReviewPaths(options.workspacePath),
+        truth_checks: {
+            count: options.workspaceConfig.checks.length,
+            questions: options.workspaceConfig.checks.map((check, index) => ({
+                id: check.id ?? `check-${index + 1}`,
+                question: check.question,
+            })),
+        },
+        previous_variations: previousVariations,
+        latest_failure: latestFailure,
+    };
+}
+function buildWorkflowImprovementPrompt() {
+    return [
+        "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.",
+        "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.",
+        "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);
+    if (!current)
+        return;
+    const nextConfig = {
+        ...current,
+        workflow: current.workflow ?? options.selectedWorkflowId,
+        workflow_origin: {
+            selected: options.selectedWorkflowId,
+            ...(options.localDraft ? { local_draft: true } : {}),
+        },
+    };
+    saveWorkspaceInterfConfig(options.workspacePath, nextConfig);
+}
+function workflowImprovementRunLedgerPath(workspacePath, runId) {
+    return join(workflowImprovementRunRoot(workspacePath, runId), "run.json");
+}
+function workflowImprovementLoopHistoryPath(workspacePath, runId) {
+    return join(workflowImprovementRunRoot(workspacePath, runId), "loop-history.jsonl");
+}
+function workflowImprovementLoopRecordPath(loopRootPath) {
+    return join(loopRootPath, "loop.json");
+}
+function readWorkflowImprovementRunLedger(workspacePath, runId) {
+    const ledgerPath = workflowImprovementRunLedgerPath(workspacePath, 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);
+    mkdirSync(runRoot, { recursive: true });
+    const existing = readWorkflowImprovementRunLedger(workspacePath, runId);
+    const generatedAt = existing?.generated_at ?? new Date().toISOString();
+    const ledger = {
+        kind: "interf-workflow-improvement-run",
+        version: 1,
+        generated_at: generatedAt,
+        updated_at: new Date().toISOString(),
+        run_id: runId,
+        target_name: options.targetName,
+        workflow_id: options.workflowId,
+        max_loops: options.maxLoops,
+        max_attempts: options.maxAttempts,
+        loops: [...(existing?.loops ?? []), record],
+    };
+    writeFileSync(workflowImprovementRunLedgerPath(workspacePath, 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`);
+}
+function buildWorkflowImprovementLoopRecord(options) {
+    return {
+        kind: "interf-workflow-improvement-loop-record",
+        version: 1,
+        recorded_at: new Date().toISOString(),
+        run_id: options.runId,
+        loop_index: options.loopIndex,
+        target_name: options.targetName,
+        workflow_id: options.workflowId,
+        result: options.result,
+        changed: options.changed,
+        applied: options.result === "updated",
+        summary: options.summary,
+        shell_path: options.shellPath,
+        loop_root_path: options.loopRootPath,
+        context_path: join(options.shellPath, "runtime", "loop-context.json"),
+        workflow_before_path: options.workflowBeforePath,
+        workflow_after_path: options.workflowAfterPath,
+        prompt_log_path: options.promptLogPath,
+        event_log_path: options.eventLogPath,
+        status_log_path: options.statusLogPath,
+        preserved_shell_manifest_path: options.preservedShellManifestPath,
+        validation: options.validation,
+    };
+}
+export async function runWorkflowImprovementLoop(options) {
+    const workspaceName = readInterfConfig(options.workspacePath)?.name ?? "workspace";
+    const context = buildLoopContext(options);
+    const shell = createWorkflowImprovementShell({
+        workspacePath: options.workspacePath,
+        workspaceName,
+        workflowId: options.workflowId,
+        runId: options.runId,
+        loopIndex: options.loopIndex,
+        context,
+    });
+    const workflowRoot = workflowPackagePathForWorkspace(options.workspacePath);
+    copyDirectory(workflowRoot, shell.workflowBeforePath);
+    const prompt = buildWorkflowImprovementPrompt();
+    writeFileSync(shell.promptLogPath, `${prompt}\n`);
+    let code = 1;
+    let executeError = null;
+    try {
+        code = await options.executor.execute(shell.rootPath, prompt, {
+            eventLogPath: shell.eventLogPath,
+            statusLogPath: shell.statusLogPath,
+        });
+    }
+    catch (error) {
+        executeError = error instanceof Error ? error.message : String(error);
+    }
+    copyDirectory(workflowRoot, shell.workflowAfterPath);
+    const preservedShellManifestPath = freezeWorkflowImprovementShell(shell.rootPath);
+    const changed = !directoriesMatch(shell.workflowBeforePath, shell.workflowAfterPath);
+    if (executeError) {
+        copyDirectory(shell.workflowBeforePath, workflowRoot);
+        const summary = `Workflow improver failed before completing: ${executeError}`;
+        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            runId: options.runId,
+            loopIndex: options.loopIndex,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+            workflowBeforePath: shell.workflowBeforePath,
+            workflowAfterPath: shell.workflowAfterPath,
+            promptLogPath: shell.promptLogPath,
+            eventLogPath: shell.eventLogPath,
+            statusLogPath: shell.statusLogPath,
+            preservedShellManifestPath,
+            changed,
+            validation: null,
+            result: "executor-failed",
+            summary,
+        }), {
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            maxLoops: options.maxLoops,
+            maxAttempts: options.maxAttempts,
+        });
+        return {
+            status: "executor-failed",
+            changed,
+            validation: null,
+            summary,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+        };
+    }
+    if (code !== 0) {
+        copyDirectory(shell.workflowBeforePath, workflowRoot);
+        const summary = `Workflow improver exited with code ${code}.`;
+        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            runId: options.runId,
+            loopIndex: options.loopIndex,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+            workflowBeforePath: shell.workflowBeforePath,
+            workflowAfterPath: shell.workflowAfterPath,
+            promptLogPath: shell.promptLogPath,
+            eventLogPath: shell.eventLogPath,
+            statusLogPath: shell.statusLogPath,
+            preservedShellManifestPath,
+            changed,
+            validation: null,
+            result: "executor-failed",
+            summary,
+        }), {
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            maxLoops: options.maxLoops,
+            maxAttempts: options.maxAttempts,
+        });
+        return {
+            status: "executor-failed",
+            changed,
+            validation: null,
+            summary,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+        };
+    }
+    if (!changed) {
+        const validation = validateWorkflowPackage(workflowRoot);
+        const result = validation.ok ? "no-change" : "invalid";
+        if (!validation.ok) {
+            copyDirectory(shell.workflowBeforePath, workflowRoot);
+        }
+        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,
+            workflowId: options.workflowId,
+            runId: options.runId,
+            loopIndex: options.loopIndex,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+            workflowBeforePath: shell.workflowBeforePath,
+            workflowAfterPath: shell.workflowAfterPath,
+            promptLogPath: shell.promptLogPath,
+            eventLogPath: shell.eventLogPath,
+            statusLogPath: shell.statusLogPath,
+            preservedShellManifestPath,
+            changed: false,
+            validation,
+            result,
+            summary,
+        }), {
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            maxLoops: options.maxLoops,
+            maxAttempts: options.maxAttempts,
+        });
+        return {
+            status: result,
+            changed: false,
+            validation,
+            summary,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+        };
+    }
+    const validation = validateWorkflowPackage(workflowRoot);
+    if (!validation.ok) {
+        copyDirectory(shell.workflowBeforePath, workflowRoot);
+        const summary = `Workflow variation failed validation: ${validation.summary}`;
+        writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            runId: options.runId,
+            loopIndex: options.loopIndex,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+            workflowBeforePath: shell.workflowBeforePath,
+            workflowAfterPath: shell.workflowAfterPath,
+            promptLogPath: shell.promptLogPath,
+            eventLogPath: shell.eventLogPath,
+            statusLogPath: shell.statusLogPath,
+            preservedShellManifestPath,
+            changed: true,
+            validation,
+            result: "invalid",
+            summary,
+        }), {
+            targetName: workspaceName,
+            workflowId: options.workflowId,
+            maxLoops: options.maxLoops,
+            maxAttempts: options.maxAttempts,
+        });
+        return {
+            status: "invalid",
+            changed: true,
+            validation,
+            summary,
+            shellPath: shell.rootPath,
+            loopRootPath: shell.loopRootPath,
+        };
+    }
+    writeWorkflowImprovementRunLedger(options.workspacePath, options.runId, buildWorkflowImprovementLoopRecord({
+        targetName: workspaceName,
+        workflowId: options.workflowId,
+        runId: options.runId,
+        loopIndex: options.loopIndex,
+        shellPath: shell.rootPath,
+        loopRootPath: shell.loopRootPath,
+        workflowBeforePath: shell.workflowBeforePath,
+        workflowAfterPath: shell.workflowAfterPath,
+        promptLogPath: shell.promptLogPath,
+        eventLogPath: shell.eventLogPath,
+        statusLogPath: shell.statusLogPath,
+        preservedShellManifestPath,
+        changed: true,
+        validation,
+        result: "updated",
+        summary: "Workflow variation updated and validated.",
+    }), {
+        targetName: workspaceName,
+        workflowId: options.workflowId,
+        maxLoops: options.maxLoops,
+        maxAttempts: options.maxAttempts,
+    });
+    updateWorkspaceWorkflowOrigin({
+        workspacePath: options.workspacePath,
+        selectedWorkflowId: options.workflowId,
+        localDraft: true,
+    });
+    return {
+        status: "updated",
+        changed: true,
+        validation,
+        summary: "Workflow variation updated and validated.",
+        shellPath: shell.rootPath,
+        loopRootPath: shell.loopRootPath,
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { WorkflowImprovementContext } from "./schema.js";
+export interface WorkflowImprovementReviewSourcePaths {
+    workspaceRuntime: 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"];

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

@@ -0,0 +1,27 @@
+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);
+    return {
+        workspaceRuntime: existsSync(workspaceRuntime) ? workspaceRuntime : 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);
+    return {
+        workflow_root: "workflow",
+        workspace_runtime: sources.workspaceRuntime ? "artifacts/workspace-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,
+        test_sandboxes: sources.targetTestSandboxes ? "artifacts/test-sandboxes" : null,
+    };
+}

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

@@ -21,6 +21,7 @@ interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType
     statusLines: string[];
     reporter?: WorkflowReporter;
     completionCheck?: (() => boolean) | null;
+    syncWrites?: (() => void) | null;
     reconcile?: (() => boolean) | null;
     refreshArtifacts?: (() => void) | null;
     validate: () => {
@@ -38,4 +39,3 @@ export declare function findStageByContractType<TStage extends {
 export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<WorkflowStageResult>;
 export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<WorkflowStageResult>;
 export {};
-//# sourceMappingURL=workflow-stage-runner.d.ts.map

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

@@ -10,6 +10,7 @@ export function findStageByContractType(stages, contractType) {
 export async function executeValidatedStage(options) {
     const completionCheck = options.completionCheck
         ? () => {
+            options.syncWrites?.();
             options.reconcile?.();
             return options.completionCheck?.() === true;
         }
@@ -34,6 +35,7 @@ export async function executeValidatedStage(options) {
 export async function executeValidatedSummarizeStage(options) {
     const completionCheck = options.completionCheck
         ? () => {
+            options.syncWrites?.();
             options.reconcile?.();
             return options.completionCheck?.() === true;
         }
@@ -59,6 +61,7 @@ export async function executeValidatedSummarizeStage(options) {
 }
 function finalizeValidatedStage(options, code) {
     const refreshAndValidate = () => {
+        options.syncWrites?.();
         options.reconcile?.();
         options.refreshArtifacts?.();
         return validateStageOutcome(options.workspacePath, options.validate());
@@ -66,6 +69,7 @@ function finalizeValidatedStage(options, code) {
     if (code !== 0) {
         let completionSatisfied = false;
         try {
+            options.syncWrites?.();
             options.reconcile?.();
             completionSatisfied = options.completionCheck?.() === true;
         }
@@ -103,4 +107,3 @@ function finalizeValidatedStage(options, code) {
         summary: validation.summary,
     };
 }
-//# sourceMappingURL=workflow-stage-runner.js.map

package/dist/lib/workflows.d.ts

@@ -1,6 +1,6 @@
 import { type InterfConfig } from "./interf.js";
 export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "./workflow-helpers.js";
-export { workflowCreateDirectory, workflowQueryDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } 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 interface DetectedInterfTarget {
     path: string;
@@ -13,4 +13,3 @@ export declare function createWorkspace(name: string, sourcePath: string, workfl
 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";
-//# sourceMappingURL=workflows.d.ts.map

package/dist/lib/workflows.js

@@ -1,7 +1,7 @@
 import { createWorkspace as createWorkspaceScaffold, } from "./interf.js";
 import { detectInterf } from "./interf.js";
 import { validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "./validate.js";
-export { workflowCreateDirectory, workflowQueryDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
 export function detectWorkspace(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
@@ -31,4 +31,3 @@ export function verifyWorkspaceCheck(check, workspacePath) {
     }
 }
 export { runWorkspaceSummarize, runWorkspaceCompile, compileWorkspace, resolveWorkspaceContext, workspaceExecutionStages, } from "./workspace-compile.js";
-//# sourceMappingURL=workflows.js.map

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

@@ -52,4 +52,3 @@ export declare function compileWorkspace(options: {
     reporter?: WorkflowReporter;
     preserveStageShells?: StageShellRetentionMode;
 }): Promise<WorkspaceCompileResult>;
-//# sourceMappingURL=workspace-compile.d.ts.map