@interf/compiler 0.6.1 → 0.6.3

package/dist/lib/agent-status.d.ts

@@ -1,3 +1 @@
-export declare function extractAgentFailureStatus(event: Record<string, unknown>): string | null;
-export declare function classifyTerminalVisibleStatus(text: string | null | undefined): "done" | "failure" | null;
-export declare function hasAgentStalled(lastActivityAt: number, now: number, stallTimeoutMs: number | null | undefined): boolean;
+export * from "../packages/agents/lib/status.js";

package/dist/lib/agent-status.js

@@ -1,58 +1 @@
-export function extractAgentFailureStatus(event) {
-    const candidates = [];
-    const directMessage = pickString(event.message) ??
-        pickString(event.text) ??
-        pickString(event.content) ??
-        pickString(event.output) ??
-        pickString(event.summary);
-    if (directMessage)
-        candidates.push(directMessage);
-    const item = event.item;
-    if (item && typeof item === "object") {
-        const itemRecord = item;
-        const itemText = pickString(itemRecord.text);
-        if (itemText)
-            candidates.push(itemText);
-        if (typeof itemRecord.aggregated_output === "string") {
-            candidates.push(itemRecord.aggregated_output);
-        }
-    }
-    for (const candidate of candidates) {
-        const lines = candidate
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0);
-        for (const text of lines) {
-            if (text.startsWith("BLOCKED:") || text.startsWith("ERROR:")) {
-                return text;
-            }
-        }
-    }
-    return null;
-}
-export function classifyTerminalVisibleStatus(text) {
-    if (!text)
-        return null;
-    if (text.startsWith("DONE:"))
-        return "done";
-    if (text.startsWith("BLOCKED:") || text.startsWith("ERROR:"))
-        return "failure";
-    return null;
-}
-export function hasAgentStalled(lastActivityAt, now, stallTimeoutMs) {
-    return typeof stallTimeoutMs === "number" && stallTimeoutMs > 0 && now - lastActivityAt >= stallTimeoutMs;
-}
-function pickString(value) {
-    if (typeof value === "string")
-        return value;
-    if (!Array.isArray(value))
-        return null;
-    for (const entry of value) {
-        if (typeof entry === "string")
-            return entry;
-        if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
-            return entry.text;
-        }
-    }
-    return null;
-}
+export * from "../packages/agents/lib/status.js";

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

@@ -1,30 +1 @@
-import type { WorkflowExecutionProfile } from "./executors.js";
-export interface Agent {
-    name: string;
-    displayName: string;
-    skillsDir: string;
-    command: string;
-}
-export interface AgentPreflightResult {
-    ok: boolean;
-    code: number | null;
-    timedOut: boolean;
-    stdout: string;
-    stderr: string;
-    error: string | null;
-}
-export type AgentSpawnSync = typeof import("node:child_process").spawnSync;
-export interface AgentPreflightOptions {
-    timeoutMs?: number;
-    spawnSyncImpl?: AgentSpawnSync;
-}
-export interface AgentAutomationReadiness {
-    ok: boolean;
-    error?: string;
-}
-export interface SpawnAgentOptions {
-    eventLogPath?: string | null;
-    statusLogPath?: string | null;
-    executionProfile?: WorkflowExecutionProfile;
-    completionCheck?: (() => boolean) | null;
-}
+export * from "../packages/agents/lib/types.js";

package/dist/lib/agent-types.js

@@ -1 +1 @@
-export {};
+export * from "../packages/agents/lib/types.js";

package/dist/lib/agents.d.ts

@@ -1,6 +1 @@
-export type { Agent, AgentAutomationReadiness, AgentPreflightOptions, AgentPreflightResult, SpawnAgentOptions, } from "./agent-types.js";
-export { detectAgents, supportsAutomatedRuns, resolveAgent, } from "./agent-detection.js";
-export { buildAgentPreflightPrompt, runAgentPreflight, ensureAgentAutomatedRunReady, } from "./agent-preflight.js";
-export { spawnAgent, } from "./agent-execution.js";
-export { buildAgentArgs, buildAgentEnv } from "./agent-args.js";
-export { extractAgentFailureStatus, classifyTerminalVisibleStatus, hasAgentStalled, } from "./agent-status.js";
+export * from "../packages/agents/lib/agents.js";

package/dist/lib/agents.js

@@ -1,5 +1 @@
-export { detectAgents, supportsAutomatedRuns, resolveAgent, } from "./agent-detection.js";
-export { buildAgentPreflightPrompt, runAgentPreflight, ensureAgentAutomatedRunReady, } from "./agent-preflight.js";
-export { spawnAgent, } from "./agent-execution.js";
-export { buildAgentArgs, buildAgentEnv } from "./agent-args.js";
-export { extractAgentFailureStatus, classifyTerminalVisibleStatus, hasAgentStalled, } from "./agent-status.js";
+export * from "../packages/agents/lib/agents.js";

package/dist/lib/builtin-compiled-workflow.d.ts

@@ -1,38 +1 @@
-import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "./workflow-primitives.js";
-export declare const BUILTIN_COMPILED_STAGE_IDS: {
-    readonly SUMMARIZE: "summarize";
-    readonly STRUCTURE: "structure";
-    readonly SHAPE: "shape";
-};
-export type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
-export declare const BUILTIN_COMPILED_ZONE_IDS: {
-    readonly RAW: "raw";
-    readonly SUMMARIES: "summaries";
-    readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
-    readonly KNOWLEDGE_CLAIMS: "knowledge-claims";
-    readonly KNOWLEDGE_INDEXES: "knowledge-indexes";
-    readonly HOME: "home";
-    readonly RUNTIME: "runtime";
-};
-export type BuiltinCompiledZoneId = typeof BUILTIN_COMPILED_ZONE_IDS[keyof typeof BUILTIN_COMPILED_ZONE_IDS];
-export interface BuiltinCompiledZoneSpec {
-    id: BuiltinCompiledZoneId;
-    role: "input" | "working" | "output" | "runtime";
-    path: string;
-    kind: CompiledZoneKind;
-    required: boolean;
-    description: string;
-}
-export interface BuiltinCompiledStageAccessPattern {
-    id: BuiltinCompiledStageId;
-    contract_type: string;
-    reads: BuiltinCompiledZoneId[];
-    writes: BuiltinCompiledZoneId[];
-}
-export declare function listBuiltinCompiledZoneSpecs(): BuiltinCompiledZoneSpec[];
-export declare function listBuiltinCompiledFallbackStages(): BuiltinCompiledStageAccessPattern[];
-export declare function requiredCompiledZoneOwners<TStage extends {
-    id: string;
-    writes: readonly string[];
-}>(stages: readonly TStage[], zoneId: BuiltinCompiledZoneId): string[];
-export { COMPILED_ZONE_KINDS };
+export * from "../packages/workflow-package/builtin-compiled-workflow.js";

package/dist/lib/builtin-compiled-workflow.js

@@ -1,94 +1 @@
-import { join } from "node:path";
-import { z } from "zod";
-import { PACKAGE_ROOT } from "./config.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { WorkflowCompiledSchemaSchema } from "./schema.js";
-import { COMPILED_ZONE_KINDS } from "./workflow-primitives.js";
-export const BUILTIN_COMPILED_STAGE_IDS = {
-    SUMMARIZE: "summarize",
-    STRUCTURE: "structure",
-    SHAPE: "shape",
-};
-export const BUILTIN_COMPILED_ZONE_IDS = {
-    RAW: "raw",
-    SUMMARIES: "summaries",
-    KNOWLEDGE_ENTITIES: "knowledge-entities",
-    KNOWLEDGE_CLAIMS: "knowledge-claims",
-    KNOWLEDGE_INDEXES: "knowledge-indexes",
-    HOME: "home",
-    RUNTIME: "runtime",
-};
-const BUILTIN_ZONE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ZONE_IDS));
-const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
-const BuiltinWorkflowStageSchema = z.object({
-    id: z.string(),
-    contract_type: z.string(),
-    reads: z.array(z.string()).min(1),
-    writes: z.array(z.string()).min(1),
-});
-const BuiltinWorkflowPackageSchema = z.object({
-    stages: z.array(BuiltinWorkflowStageSchema).min(1),
-});
-let builtinCompiledContractCache = null;
-function builtinWorkflowRootPath() {
-    return join(PACKAGE_ROOT, "builtin-workflows", "interf");
-}
-function builtinWorkflowPath(relativePath) {
-    return join(builtinWorkflowRootPath(), relativePath);
-}
-function assertBuiltinZoneId(value) {
-    if (!BUILTIN_ZONE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow schema declares unsupported zone id "${value}".`);
-    }
-    return value;
-}
-function assertBuiltinStageId(value) {
-    if (!BUILTIN_STAGE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow package declares unsupported stage id "${value}".`);
-    }
-    return value;
-}
-function loadBuiltinCompiledContract() {
-    if (builtinCompiledContractCache)
-        return builtinCompiledContractCache;
-    const schema = readJsonFileWithSchema(builtinWorkflowPath("workflow.schema.json"), "built-in Interf workflow schema", WorkflowCompiledSchemaSchema);
-    if (!schema) {
-        throw new Error(`Missing or invalid built-in workflow schema at ${builtinWorkflowPath("workflow.schema.json")}.`);
-    }
-    const workflow = readJsonFileWithSchema(builtinWorkflowPath("workflow.json"), "built-in Interf workflow package", BuiltinWorkflowPackageSchema);
-    if (!workflow) {
-        throw new Error(`Missing or invalid built-in workflow package at ${builtinWorkflowPath("workflow.json")}.`);
-    }
-    const zones = schema.zones.map((zone) => ({
-        id: assertBuiltinZoneId(zone.id),
-        role: zone.role,
-        path: zone.path,
-        kind: zone.kind,
-        required: zone.required,
-        description: zone.description,
-    }));
-    const stages = workflow.stages.map((stage) => ({
-        id: assertBuiltinStageId(stage.id),
-        contract_type: stage.contract_type,
-        reads: stage.reads.map(assertBuiltinZoneId),
-        writes: stage.writes.map(assertBuiltinZoneId),
-    }));
-    builtinCompiledContractCache = { zones, stages };
-    return builtinCompiledContractCache;
-}
-export function listBuiltinCompiledZoneSpecs() {
-    return loadBuiltinCompiledContract().zones.map((zone) => ({ ...zone }));
-}
-export function listBuiltinCompiledFallbackStages() {
-    return loadBuiltinCompiledContract().stages.map((stage) => ({
-        ...stage,
-        reads: [...stage.reads],
-        writes: [...stage.writes],
-    }));
-}
-export function requiredCompiledZoneOwners(stages, zoneId) {
-    return Array.from(new Set(stages
-        .filter((stage) => stage.writes.includes(zoneId))
-        .map((stage) => stage.id)));
-}
-export { COMPILED_ZONE_KINDS };
+export * from "../packages/workflow-package/builtin-compiled-workflow.js";

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

@@ -1,48 +1 @@
-import { type WorkflowExecutor } from "./executors.js";
-import { type CompiledWorkflowId, type WorkflowStageDefinition } from "./workflow-definitions.js";
-import { type WorkflowReporter, type WorkflowStageResult } from "./workflow-helpers.js";
-export interface CompiledStageExecutionDefinition extends WorkflowStageDefinition {
-}
-export interface CompiledSummarizeResult extends WorkflowStageResult {
-    skipped: boolean;
-    plan: {
-        sourceCount: number;
-        summaryCount: number;
-        targetCount: number;
-    };
-}
-export interface CompiledCompileResult {
-    ok: boolean;
-    stageResults: Record<string, WorkflowStageResult>;
-    failedStage: string | null;
-}
-export type StageShellRetentionMode = "on-failure" | "always";
-export declare function resolveCompiledContext(compiledPath: string): {
-    compiledName: string;
-    sourcePath: string;
-    controlPath: string;
-    workflowId: CompiledWorkflowId;
-};
-export declare function compiledExecutionStages(workflowId: CompiledWorkflowId, compiledPath: string): CompiledStageExecutionDefinition[];
-export declare function runCompiledSummarize(options: {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    reporter?: WorkflowReporter;
-    reportSummary?: boolean;
-    reportStep?: boolean;
-    stageDefinition?: CompiledStageExecutionDefinition;
-    fullPass?: boolean;
-}): Promise<CompiledSummarizeResult>;
-export declare function runCompiledCompile(options: {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    reporter?: WorkflowReporter;
-    reportStep?: boolean;
-    preserveStageShells?: StageShellRetentionMode;
-}): Promise<WorkflowStageResult>;
-export declare function compileCompiled(options: {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    reporter?: WorkflowReporter;
-    preserveStageShells?: StageShellRetentionMode;
-}): Promise<CompiledCompileResult>;
+export * from "../packages/compiler/compiled-compile.js";

package/dist/lib/compiled-compile.js

@@ -1,255 +1 @@
-import { join } from "node:path";
-import { createStageExecutionShell, freezeStageExecutionShell, pruneStageExecutionShells, syncStageExecutionShellWrites, } from "./agent-shells.js";
-import { readInterfConfig, refreshCompiledBootstrapGuidance, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, } from "./interf.js";
-import { reconcileCompiledStageRun, } from "./runtime-reconcile.js";
-import { refreshCompiledArtifacts, } from "./state.js";
-import { buildRuntimeStageContract, } from "./runtime.js";
-import { validateWorkflowPackage } from "./local-workflows.js";
-import { formatActiveCompiledWorkflowStageStep, getActiveCompiledStagePolicyNotes, getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, resolveActiveCompiledStageAcceptance, } from "./workflow-definitions.js";
-import { validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, reportBlankLine, reportLine, reportValidationFailure, workflowCompileStageDirectory, } from "./workflow-helpers.js";
-import { executeValidatedStage, } from "./workflow-stage-runner.js";
-import { syncCompiledRawSnapshot } from "./compiled-raw.js";
-import { workflowPackagePathForCompiled, } from "./compiled-paths.js";
-import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { listFilesRecursive } from "./filesystem.js";
-export function resolveCompiledContext(compiledPath) {
-    const config = readInterfConfig(compiledPath);
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${compiledPath}`);
-    return {
-        compiledName: config?.name ?? "compiled",
-        sourcePath: resolveSourceFolderPath(compiledPath, config),
-        controlPath: resolveSourceControlPath(compiledPath),
-        workflowId,
-    };
-}
-export function compiledExecutionStages(workflowId, compiledPath) {
-    return getActiveCompiledWorkflow(compiledPath, workflowId)
-        .stages;
-}
-function zoneArtifactCount(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
-    try {
-        if (kind === "file") {
-            return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
-        }
-    }
-    catch {
-        if (kind === "file")
-            return 0;
-    }
-    return listFilesRecursive(absolutePath).length;
-}
-function resolveStageContractArtifacts(compiledPath, stageDefinition) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    if (!schema) {
-        throw new Error(`Missing workflow schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
-    }
-    return {
-        reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
-        writes: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.writes),
-    };
-}
-function buildStageCounts(compiledPath, stageDefinition) {
-    const context = resolveCompiledContext(compiledPath);
-    const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    const zoneCounts = {};
-    if (schema) {
-        for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
-            const zone = findCompiledSchemaZone(schema, zoneId);
-            if (!zone)
-                continue;
-            zoneCounts[zoneId] = zoneArtifactCount(compiledPath, zone.path, zone.kind);
-        }
-    }
-    return {
-        source_total: sourceTotal,
-        read_zone_total: stageDefinition.reads.length,
-        write_zone_total: stageDefinition.writes.length,
-        ...zoneCounts,
-    };
-}
-function buildStageContract(compiledPath, workflowId, stageDefinition) {
-    const config = readInterfConfig(compiledPath);
-    const localSkills = buildLocalSkillContractExtension(compiledPath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this workflow stage while still honoring the declared reads, writes, and proof rules.");
-    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
-    const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
-    return buildRuntimeStageContract({
-        compiledName: config?.name ?? "compiled",
-        stageId: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        counts: buildStageCounts(compiledPath, stageDefinition),
-        stageReadArtifacts: stageArtifacts.reads,
-        stageWriteArtifacts: stageArtifacts.writes,
-        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, workflowId, stageDefinition.id),
-        localSkillDocs: localSkills.reads,
-        instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, workflowId, stageDefinition.id),
-    });
-}
-async function runCompiledStage(options) {
-    const context = resolveCompiledContext(options.compiledPath);
-    const stageDefinition = options.stageDefinition;
-    const contract = buildStageContract(options.compiledPath, context.workflowId, stageDefinition);
-    const localSkills = buildLocalSkillContractExtension(options.compiledPath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this workflow stage while still honoring the declared reads, writes, and proof rules.");
-    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, context.workflowId, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
-    }
-    const shell = createStageExecutionShell(options.compiledPath, context.compiledName, context.workflowId, stageDefinition, contract.artifacts.writes);
-    try {
-        return await executeValidatedStage({
-            executor: options.executor,
-            compiledPath: options.compiledPath,
-            executionPath: shell.rootPath,
-            targetName: context.compiledName,
-            workflow: context.workflowId,
-            workflowSourcePath: options.compiledPath,
-            stageDefinition,
-            instructions,
-            summary: `Executing ${stageDefinition.label.toLowerCase()}.`,
-            contract,
-            statusLines: [
-                `Emit exactly one startup line: STATUS: loaded ${stageDefinition.label.toLowerCase()} stage.`,
-                "Emit STATUS: reading declared inputs after you confirm the shell contract and local docs.",
-                "Emit STATUS: writing declared outputs after the stage starts updating the compiled zones.",
-                `Emit DONE: ${stageDefinition.id} complete when the declared outputs and proof are on disk.`,
-            ],
-            reporter: options.reporter,
-            completionCheck: () => validateCompiledStage(options.compiledPath, stageDefinition.id).ok,
-            syncWrites: () => syncStageExecutionShellWrites(options.compiledPath, shell.rootPath, stageDefinition, contract.artifacts.writes),
-            reconcile: () => reconcileCompiledStageRun(options.compiledPath, stageDefinition),
-            refreshArtifacts: () => refreshCompiledArtifacts(options.compiledPath, { ensureViewSpec: true }),
-            validate: () => validateCompiledStage(options.compiledPath, stageDefinition.id),
-        });
-    }
-    finally {
-        freezeStageExecutionShell(shell.rootPath);
-    }
-}
-export async function runCompiledSummarize(options) {
-    const context = resolveCompiledContext(options.compiledPath);
-    const stageDefinition = options.stageDefinition
-        ?? compiledExecutionStages(context.workflowId, options.compiledPath).find((stage) => stage.id === "summarize");
-    if (!stageDefinition) {
-        return {
-            ok: false,
-            code: 1,
-            skipped: true,
-            plan: { sourceCount: 0, summaryCount: 0, targetCount: 0 },
-            summary: "Workflow does not declare a summarize stage.",
-        };
-    }
-    const sourceCount = discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount;
-    const result = await runCompiledStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        reporter: options.reporter,
-        reportStep: options.reportStep,
-        stageDefinition,
-    });
-    return {
-        ...result,
-        skipped: false,
-        plan: {
-            sourceCount,
-            summaryCount: 0,
-            targetCount: sourceCount,
-        },
-    };
-}
-export async function runCompiledCompile(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
-    }
-    let lastResult = { ok: true, code: 0 };
-    try {
-        const context = resolveCompiledContext(options.compiledPath);
-        for (const stageDefinition of compiledExecutionStages(context.workflowId, options.compiledPath)) {
-            const result = await runCompiledStage({
-                executor: options.executor,
-                compiledPath: options.compiledPath,
-                reporter: options.reporter,
-                reportStep: options.reportStep,
-                stageDefinition,
-            });
-            lastResult = result;
-            if (!result.ok)
-                return result;
-        }
-        return lastResult;
-    }
-    finally {
-        if (preserveMode !== "always" && lastResult.ok) {
-            pruneStageExecutionShells(options.compiledPath);
-        }
-    }
-}
-export async function compileCompiled(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
-    }
-    let result = {
-        ok: true,
-        stageResults: {},
-        failedStage: null,
-    };
-    try {
-        const sourceInputPath = resolveSourceInputPath(options.compiledPath);
-        syncCompiledRawSnapshot(options.compiledPath, sourceInputPath);
-        refreshCompiledBootstrapGuidance(options.compiledPath);
-        const workflowValidation = validateWorkflowPackage(join(options.compiledPath, ".interf", "workflow"));
-        if (!workflowValidation.ok) {
-            reportValidationFailure(options.reporter, workflowValidation.summary, workflowValidation.errors);
-            return {
-                ...result,
-                ok: false,
-                failedStage: "workflow",
-                stageResults: {
-                    ...result.stageResults,
-                    workflow: {
-                        ok: false,
-                        code: 1,
-                        summary: workflowValidation.summary,
-                    },
-                },
-            };
-        }
-        const context = resolveCompiledContext(options.compiledPath);
-        const stages = compiledExecutionStages(context.workflowId, options.compiledPath);
-        for (const stageDefinition of stages) {
-            const stageResult = await runCompiledStage({
-                executor: options.executor,
-                compiledPath: options.compiledPath,
-                reporter: options.reporter,
-                reportStep: true,
-                stageDefinition,
-            });
-            result.stageResults[stageDefinition.id] = stageResult;
-            if (!stageResult.ok) {
-                result.ok = false;
-                result.failedStage = stageDefinition.id;
-                return result;
-            }
-        }
-        const workflowValidationResult = validateCompiledWorkflow(options.compiledPath);
-        result.ok = workflowValidationResult.ok;
-        result.failedStage = workflowValidationResult.ok ? null : workflowValidationResult.stage;
-        result.stageResults.compiled = {
-            ok: workflowValidationResult.ok,
-            code: workflowValidationResult.ok ? 0 : 1,
-            summary: workflowValidationResult.summary,
-        };
-        return result;
-    }
-    finally {
-        if (preserveMode !== "always" && result.ok) {
-            pruneStageExecutionShells(options.compiledPath);
-        }
-    }
-}
+export * from "../packages/compiler/compiled-compile.js";

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

@@ -1,40 +1 @@
-export declare const COMPILED_INTERF_DIR = ".interf";
-export declare const COMPILED_CONFIG_FILE = "interf.json";
-export declare const COMPILED_WORKFLOW_DIR = "workflow";
-export declare const COMPILED_TEST_DIR = "tests";
-export declare const COMPILED_TEST_TARGETS_DIR = "targets";
-export declare const COMPILED_RUNTIME_DIR = "runtime";
-export declare const COMPILED_RUNTIME_STATE_FILE = "state.json";
-export declare const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
-export declare const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export declare const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
-export declare const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
-export declare const COMPILED_RUNTIME_RUN_FILE = "run.json";
-export declare const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export declare const COMPILED_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export declare function compiledRuntimeRoot(compiledPath: string): string;
-export declare function compiledRuntimeFilePath(compiledPath: string, fileName: string): string;
-export declare function compiledInterfRoot(compiledPath: string): string;
-export declare function compiledInterfConfigPath(compiledPath: string): string;
-export declare function workflowPackagePathForCompiled(compiledPath: string): string;
-export declare function testRootForCompiled(compiledPath: string): string;
-export declare function testTargetsRootForCompiled(compiledPath: string): string;
-export declare function stageExecutionShellsRoot(compiledPath: string): string;
-export declare function workflowImprovementLoopsRoot(compiledPath: string): string;
-export declare function workflowImprovementRunRoot(compiledPath: string, runId: string): string;
-export declare function workflowImprovementLoopRoot(compiledPath: string, runId: string, loopIndex: number): string;
-export declare function targetTestRunsRootForCompiled(compiledPath: string): string;
-export declare function targetTestSandboxesRootForCompiled(compiledPath: string): string;
-export declare function compiledRuntimeLogsRoot(compiledPath: string): string;
-export declare function compiledRuntimeArchivedStageContractPath(compiledPath: string, runId: string): string;
-export declare function compiledQueryAcceptanceRoot(compiledPath: string): string;
-export declare function compiledRuntimeStatePath(compiledPath: string): string;
-export declare function compiledRuntimeHealthPath(compiledPath: string): string;
-export declare function compiledRuntimeViewSpecPath(compiledPath: string): string;
-export declare function compiledRawSnapshotMetadataPath(compiledPath: string): string;
-export declare function compiledRuntimeInventoryPath(compiledPath: string): string;
-export declare function compiledRuntimeRunPath(compiledPath: string): string;
-export declare function compiledRuntimeRunHistoryPath(compiledPath: string): string;
-export declare function compiledRuntimeStageContractPath(compiledPath: string): string;
-export declare function resolveSourceControlPathForCompiled(compiledPath: string): string;
-export declare function defaultControlPathForCompiled(compiledPath: string): string;
+export * from "../packages/project-model/compiled-paths.js";