@interf/compiler 0.7.3 → 0.9.1

package/dist/packages/compiler/lib/schema.d.ts

@@ -32,6 +32,161 @@ export declare const CompiledStageStatusSchema: z.ZodEnum<{
 }>;
 export declare const SourceCompiledMaxAttemptsSchema: z.ZodNumber;
 export declare const SourceCompiledMaxLoopsSchema: z.ZodNumber;
+export declare const ReadinessStatusSchema: z.ZodEnum<{
+    stale: "stale";
+    failed: "failed";
+    "not-configured": "not-configured";
+    "not-built": "not-built";
+    building: "building";
+    built: "built";
+    checking: "checking";
+    ready: "ready";
+    "not-ready": "not-ready";
+}>;
+export declare const ReadinessGateSchema: z.ZodEnum<{
+    "preparation-config": "preparation-config";
+    "portable-context": "portable-context";
+    "compile-run": "compile-run";
+    "readiness-checks": "readiness-checks";
+    "source-baseline": "source-baseline";
+    "portable-context-check": "portable-context-check";
+    "checks-current": "checks-current";
+}>;
+export declare const ReadinessCheckSchema: z.ZodObject<{
+    gate: z.ZodEnum<{
+        "preparation-config": "preparation-config";
+        "portable-context": "portable-context";
+        "compile-run": "compile-run";
+        "readiness-checks": "readiness-checks";
+        "source-baseline": "source-baseline";
+        "portable-context-check": "portable-context-check";
+        "checks-current": "checks-current";
+    }>;
+    ok: z.ZodBoolean;
+    status: z.ZodOptional<z.ZodEnum<{
+        stale: "stale";
+        failed: "failed";
+        "not-configured": "not-configured";
+        "not-built": "not-built";
+        building: "building";
+        built: "built";
+        checking: "checking";
+        ready: "ready";
+        "not-ready": "not-ready";
+    }>>;
+    summary: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ReadinessTargetResultSchema: z.ZodObject<{
+    passed: z.ZodNumber;
+    total: z.ZodNumber;
+    pass_rate: z.ZodNullable<z.ZodNumber>;
+    checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stale: z.ZodDefault<z.ZodBoolean>;
+    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const ReadinessStateSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    kind: z.ZodLiteral<"interf-readiness-state">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    preparation: z.ZodString;
+    status: z.ZodEnum<{
+        stale: "stale";
+        failed: "failed";
+        "not-configured": "not-configured";
+        "not-built": "not-built";
+        building: "building";
+        built: "built";
+        checking: "checking";
+        ready: "ready";
+        "not-ready": "not-ready";
+    }>;
+    ready: z.ZodBoolean;
+    summary: z.ZodString;
+    portable_context_path: z.ZodNullable<z.ZodString>;
+    latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    compile: z.ZodNullable<z.ZodObject<{
+        gate: z.ZodEnum<{
+            "preparation-config": "preparation-config";
+            "portable-context": "portable-context";
+            "compile-run": "compile-run";
+            "readiness-checks": "readiness-checks";
+            "source-baseline": "source-baseline";
+            "portable-context-check": "portable-context-check";
+            "checks-current": "checks-current";
+        }>;
+        ok: z.ZodBoolean;
+        status: z.ZodOptional<z.ZodEnum<{
+            stale: "stale";
+            failed: "failed";
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+        }>>;
+        summary: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    check_results: z.ZodObject<{
+        configured: z.ZodNumber;
+        fingerprint: z.ZodNullable<z.ZodString>;
+        source_files: z.ZodNullable<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+            pass_rate: z.ZodNullable<z.ZodNumber>;
+            checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stale: z.ZodDefault<z.ZodBoolean>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        portable_context: z.ZodNullable<z.ZodObject<{
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+            pass_rate: z.ZodNullable<z.ZodNumber>;
+            checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stale: z.ZodDefault<z.ZodBoolean>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        delta: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        gate: z.ZodEnum<{
+            "preparation-config": "preparation-config";
+            "portable-context": "portable-context";
+            "compile-run": "compile-run";
+            "readiness-checks": "readiness-checks";
+            "source-baseline": "source-baseline";
+            "portable-context-check": "portable-context-check";
+            "checks-current": "checks-current";
+        }>;
+        ok: z.ZodBoolean;
+        status: z.ZodOptional<z.ZodEnum<{
+            stale: "stale";
+            failed: "failed";
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+        }>>;
+        summary: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
 export declare const CompiledStageStateSchema: z.ZodObject<{
     contract_type: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<{
@@ -512,7 +667,7 @@ export declare const WorkflowImprovementContextSchema: z.ZodObject<{
         test_runs: z.ZodNullable<z.ZodString>;
         test_sandboxes: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
-    truth_checks: z.ZodObject<{
+    readiness_checks: z.ZodObject<{
         count: z.ZodNumber;
         questions: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -655,6 +810,11 @@ export type PreservedShellSnapshot = z.infer<typeof PreservedShellSnapshotSchema
 export type WorkflowPackageValidation = z.infer<typeof WorkflowPackageValidationSchema>;
 export type WorkflowImprovementLoopRecord = z.infer<typeof WorkflowImprovementLoopRecordSchema>;
 export type WorkflowImprovementRunLedger = z.infer<typeof WorkflowImprovementRunLedgerSchema>;
+export type ReadinessStatus = z.infer<typeof ReadinessStatusSchema>;
+export type ReadinessGate = z.infer<typeof ReadinessGateSchema>;
+export type ReadinessCheck = z.infer<typeof ReadinessCheckSchema>;
+export type ReadinessTargetResult = z.infer<typeof ReadinessTargetResultSchema>;
+export type ReadinessState = z.infer<typeof ReadinessStateSchema>;
 export type CompiledState = z.infer<typeof CompiledStateSchema>;
 export type ViewSection = z.infer<typeof ViewSectionSchema>;
 export type ViewCard = z.infer<typeof ViewCardSchema>;

package/dist/packages/compiler/lib/schema.js

@@ -23,6 +23,92 @@ export const WorkflowZoneRoleSchema = z.enum(["input", "working", "output", "run
 export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
 export const SourceCompiledMaxAttemptsSchema = z.number().int().min(1).max(5);
 export const SourceCompiledMaxLoopsSchema = z.number().int().min(1).max(3);
+export const ReadinessStatusSchema = z.enum([
+    "not-configured",
+    "not-built",
+    "building",
+    "built",
+    "checking",
+    "ready",
+    "not-ready",
+    "stale",
+    "failed",
+]);
+export const ReadinessGateSchema = z.enum([
+    "preparation-config",
+    "portable-context",
+    "compile-run",
+    "readiness-checks",
+    "source-baseline",
+    "portable-context-check",
+    "checks-current",
+]);
+export const ReadinessCheckSchema = z.object({
+    gate: ReadinessGateSchema,
+    ok: z.boolean(),
+    status: ReadinessStatusSchema.optional(),
+    summary: z.string().min(1),
+    detail: z.string().min(1).optional(),
+    run_id: z.string().min(1).nullable().optional(),
+    artifact_path: z.string().min(1).nullable().optional(),
+}).strict();
+export const ReadinessTargetResultSchema = z.object({
+    passed: z.number().int().min(0),
+    total: z.number().int().min(0),
+    pass_rate: z.number().min(0).max(100).nullable(),
+    checks_fingerprint: z.string().min(1).nullable().optional(),
+    stale: z.boolean().default(false),
+    run_id: z.string().min(1).nullable().optional(),
+    run_path: z.string().min(1).nullable().optional(),
+}).strict();
+function normalizeReadinessState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const input = value;
+    const output = { ...input };
+    if (typeof output.preparation !== "string" && typeof input.dataset === "string") {
+        output.preparation = input.dataset;
+    }
+    delete output.dataset;
+    if (Array.isArray(output.checks)) {
+        output.checks = output.checks.map((check) => {
+            if (!check || typeof check !== "object" || Array.isArray(check))
+                return check;
+            const normalizedCheck = { ...check };
+            if (normalizedCheck.gate === "dataset-config")
+                normalizedCheck.gate = "preparation-config";
+            return normalizedCheck;
+        });
+    }
+    if (output.compile && typeof output.compile === "object" && !Array.isArray(output.compile)) {
+        const compile = { ...output.compile };
+        if (compile.gate === "dataset-config")
+            compile.gate = "preparation-config";
+        output.compile = compile;
+    }
+    return output;
+}
+export const ReadinessStateSchema = z.preprocess(normalizeReadinessState, z.object({
+    kind: z.literal("interf-readiness-state"),
+    version: z.literal(1),
+    generated_at: z.string().min(1),
+    preparation: z.string().min(1),
+    status: ReadinessStatusSchema,
+    ready: z.boolean(),
+    summary: z.string().min(1),
+    portable_context_path: z.string().min(1).nullable(),
+    latest_compile_run_id: z.string().min(1).nullable().optional(),
+    latest_test_run_id: z.string().min(1).nullable().optional(),
+    compile: ReadinessCheckSchema.nullable(),
+    check_results: z.object({
+        configured: z.number().int().min(0),
+        fingerprint: z.string().min(1).nullable(),
+        source_files: ReadinessTargetResultSchema.nullable(),
+        portable_context: ReadinessTargetResultSchema.nullable(),
+        delta: z.number().nullable(),
+    }).strict(),
+    checks: z.array(ReadinessCheckSchema).default([]),
+}).strict());
 export const CompiledStageStateSchema = z.object({
     contract_type: RuntimeContractTypeSchema.optional(),
     status: CompiledStageStatusSchema.optional(),
@@ -298,7 +384,7 @@ export const WorkflowImprovementContextSchema = z.object({
         test_runs: z.string().nullable(),
         test_sandboxes: z.string().nullable(),
     }),
-    truth_checks: z.object({
+    readiness_checks: z.object({
         count: z.number().int().min(0),
         questions: z.array(z.object({
             id: z.string(),

package/dist/packages/compiler/raw-snapshot.d.ts

@@ -9,7 +9,7 @@ export declare function resolveCompiledRawPath(compiledPath: string, config?: {
     [x: string]: unknown;
     type: "compiled";
     name: string;
-    workflow: string;
+    method: string;
     checks: {
         question: string;
         id?: string | undefined;
@@ -25,12 +25,19 @@ export declare function resolveCompiledRawPath(compiledPath: string, config?: {
     }[];
     source: {
         path: string;
-        dataset_path: string;
         control_path?: string | undefined;
+        preparation_path?: string | undefined;
+        source_folder_path?: string | undefined;
+        dataset_path?: string | undefined;
     };
     about?: string | undefined;
+    workflow?: string | undefined;
     max_attempts?: number | undefined;
     max_loops?: number | undefined;
+    method_origin?: {
+        selected: string;
+        local_draft?: boolean | undefined;
+    } | undefined;
     workflow_origin?: {
         selected: string;
         local_draft?: boolean | undefined;

package/dist/packages/compiler/runtime-acceptance.js

@@ -108,7 +108,7 @@ export function validateResolvedStageAcceptance(dirPath, options) {
         return {
             ok: false,
             summary: `Stage acceptance failed for ${options.stageId}: missing workflow schema.`,
-            failures: [`Missing workflow/${WORKFLOW_SCHEMA_FILE}.`],
+            failures: [`Missing method/${WORKFLOW_SCHEMA_FILE}.`],
         };
     }
     const failures = [];

package/dist/packages/compiler/runtime-contracts.js

@@ -12,7 +12,7 @@ export function buildRuntimeStageContract(options) {
         artifacts: {
             reads: [
                 "interf.json",
-                `workflow/${WORKFLOW_SCHEMA_FILE}`,
+                `method/${WORKFLOW_SCHEMA_FILE}`,
                 ...(options.extraReadArtifacts ?? []),
                 ...options.stageReadArtifacts,
                 ...localSkillDocs,
@@ -28,7 +28,7 @@ export function buildRuntimeStageContract(options) {
             notes: [
                 `This is the "${options.stageLabel}" stage for the compiled context "${options.compiledName}".`,
                 "The workflow package is the authoritative method layer for this run.",
-                `Use \`workflow/${WORKFLOW_SCHEMA_FILE}\` as the deterministic context-interface reference for this compiled context.`,
+                `Use \`method/${WORKFLOW_SCHEMA_FILE}\` as the deterministic context-interface reference for this portable context.`,
                 "Honor the declared read and write artifacts instead of inventing a parallel workflow.",
                 "Only create or update files that fall under the declared write targets for this stage.",
                 "Interf writes `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",

package/dist/packages/compiler/runtime-prompt.js

@@ -3,7 +3,7 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
     const modeNotes = instructions.effective_mode === "override"
         ? [
             "Local stage instruction docs are authoritative for this run.",
-            "Do not fall back to bundled workflow heuristics unless the stage contract explicitly leaves room for them.",
+            "Use bundled workflow heuristics only when the stage contract explicitly permits them.",
             "Interf still enforces the same required reads, writes, verifier outputs, and runtime reconciliation at stage close.",
         ]
         : instructions.effective_mode === "extend"
@@ -15,15 +15,15 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
                 "Use the current compiled workflow docs as the default workflow for this run.",
             ];
     return [
-        `Interf workflow stage docs: workflow/compile/stages/${stageSkillDir}/`,
+        `Interf Method stage docs: method/compile/stages/${stageSkillDir}/`,
         "",
         "This is an automated Interf stage run, not an open-ended chat session.",
         "The user has already invoked this stage through the Interf CLI. Execute it now.",
         "Do not ask what the user wants, offer help, list tools, or wait for another instruction.",
         `Read \`${contractPath}\` first. It is the authoritative contract for this stage.`,
-        "If `runtime/paths.json` exists in this shell, read it next. It maps workflow zone ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
+        "If `runtime/paths.json` exists in this shell, read it next. It maps Method zone ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
         "For file-zone mounts, `runtime/paths.json` also gives the exact file path inside the `inputs/` or `outputs/` mount root.",
-        "Honor the contract's counts, artifact paths, and policies instead of inventing another workflow.",
+        "Honor the contract's counts, artifact paths, and policies instead of inventing another Method.",
         "Read only the files named by the contract's `artifacts.reads` list plus any paths they explicitly direct you to open.",
         "Prefer direct file-reading and search tools over shell commands when you inspect inputs, docs, or generated outputs.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` for routine file inspection if a native read/search tool can do the same job.",
@@ -33,8 +33,8 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
         "If a contract-listed output file does not exist yet, create it in one whole-file write. Do not attempt patch-style edits against a missing runtime path.",
         "Stay inside the current compiled context. Do not try to open repo docs, repo source files, or other paths outside the compiled context unless the stage contract explicitly requires them.",
         instructions.effective_mode === "override"
-            ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary workflow layer for this run."
-            : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current compiled workflow docs and the contract as the default behavior.",
+            ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary Method layer for this run."
+            : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current compiled Method docs and the contract as the default behavior.",
         ...modeNotes,
         "Do not narrate intentions, plans, or reasoning to the user.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",

package/dist/packages/compiler/runtime-reconcile.js

@@ -6,7 +6,7 @@ import { parseJsonFrontmatter } from "../shared/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
-import { compiledRuntimeRoot } from "./compiled-paths.js";
+import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
@@ -93,7 +93,7 @@ function buildInventoryMetadata(options) {
     return metadata;
 }
 function buildStageInventoryEntries(dirPath, stage) {
-    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
     if (!schema)
         return [];
     const readableInputZones = stage.reads
@@ -155,7 +155,7 @@ export function reconcileCompiledStageRun(dirPath, stage) {
     const startedAtMs = readActiveRunStartedAtMs(dirPath);
     if (startedAtMs === null)
         return false;
-    const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
     if (!schema)
         return false;
     const writeZones = stage.writes

package/dist/packages/compiler/runtime-runs.js

@@ -49,6 +49,7 @@ export async function runExecutorStage(options) {
         eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
         statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
+        onStatus: options.onStatus,
     });
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
@@ -63,6 +64,7 @@ export async function runExecutorSummarizeStage(options) {
         eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
         statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
+        onStatus: options.onStatus,
     });
     const timer = setInterval(() => {
         const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
@@ -79,6 +81,7 @@ export async function runExecutorSummarizeStage(options) {
             summary: `${options.stageLabel} ${completed}/${options.targetCount} source files into summaries.`,
         });
         console.log(chalk.dim(`  STATUS: wrote ${completed}/${options.targetCount} summaries`));
+        options.onStatus?.(`STATUS: wrote ${completed}/${options.targetCount} summaries`);
     }, 10000);
     try {
         const code = await progressPromise;

package/dist/packages/compiler/runtime-types.d.ts

@@ -16,6 +16,7 @@ export interface RuntimeStageExecutionOptions {
     contract: RuntimeStageContractDraft;
     buildPrompt: (contractPath: string) => string;
     completionCheck?: (() => boolean) | null;
+    onStatus?: (line: string) => void;
 }
 export interface RuntimeSummarizeExecutionOptions extends RuntimeStageExecutionOptions {
     startingSummaryCount: number;

package/dist/packages/compiler/state-health.js

@@ -32,7 +32,7 @@ export function computeCompiledHealth(dirPath) {
     let workflow = null;
     if (workflowId) {
         try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+            workflow = getActiveCompiledWorkflow(dirPath);
         }
         catch {
             workflow = null;

package/dist/packages/compiler/state-view.js

@@ -71,7 +71,7 @@ export function normalizeCompiledViewSpec(existing, defaults) {
 function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     const config = readInterfConfig(dirPath);
     const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`);
-    const workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+    const workflow = getActiveCompiledWorkflow(dirPath);
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
     const outputDocumentPaths = (schema?.zones ?? [])
         .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
@@ -97,7 +97,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
             ...(outputDocumentPaths.length > 0
                 ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
                 : []),
-            { id: "workflow", type: "documents", title: "Workflow Docs", paths: ["workflow/README.md", ...workflow.stages.map((stage) => `workflow/compile/stages/${stage.skillDir}`)] },
+            { id: "method", type: "documents", title: "Method Docs", paths: ["method/README.md", ...workflow.stages.map((stage) => `method/compile/stages/${stage.skillDir}`)] },
         ],
     };
 }

package/dist/packages/compiler/validate-compiled.js

@@ -1,5 +1,4 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { discoverSourceFiles } from "./discovery.js";
 import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
 import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
@@ -10,7 +9,10 @@ import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime
 import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
 import { listFilesRecursive } from "../shared/filesystem.js";
 function workflowSchemaPresent(dirPath) {
-    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
+    return workflowSchemaExists(workflowPackagePathForCompiled(dirPath));
+}
+function workflowJsonPresent(dirPath) {
+    return existsSync(workflowPackagePathForCompiled(dirPath) + "/workflow.json");
 }
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
@@ -28,7 +30,7 @@ function readWorkflowContext(dirPath) {
     let workflow = null;
     if (workflowId) {
         try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+            workflow = getActiveCompiledWorkflow(dirPath);
         }
         catch {
             workflow = null;
@@ -85,7 +87,7 @@ export function validateCompiled(dirPath) {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_present: workflowJsonPresent(dirPath),
         workflow_valid: context.workflow !== null,
         schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
@@ -97,7 +99,7 @@ export function validateCompiledStage(dirPath, stageId) {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_present: workflowJsonPresent(dirPath),
         workflow_valid: context.workflow !== null,
         schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
@@ -110,13 +112,13 @@ export function validateCompiledStage(dirPath, stageId) {
     else if (!checks.config_type_match)
         errors.push("Config is not a compiled context.");
     if (!checks.workflow_present)
-        errors.push("Missing .interf/workflow/workflow.json.");
+        errors.push("Missing .interf/method/workflow.json.");
     else if (!checks.workflow_valid)
         errors.push("Could not load the active workflow package.");
     if (!checks.schema_present)
-        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
+        errors.push(`Missing .interf/method/${WORKFLOW_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
-        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
+        errors.push(`Could not parse .interf/method/${WORKFLOW_SCHEMA_FILE}.`);
     const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
     checks.stage_present = workflowStage !== null;
     if (!checks.stage_present) {
@@ -179,7 +181,7 @@ export function validateCompiledWorkflow(dirPath) {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_present: workflowJsonPresent(dirPath),
         workflow_valid: context.workflow !== null,
         schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,

package/dist/packages/execution/adapters.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionBackendKind, InterfRunEvent } from "./lib/schema.js";
+import type { RunEventSink } from "./events.js";
+export interface ExecutionAdapterContext {
+    runId: string;
+    backend: ExecutionBackendKind;
+    events?: RunEventSink;
+}
+export interface ExecutionAdapter<TInput, TResult> {
+    kind: ExecutionBackendKind;
+    run(input: TInput, context: ExecutionAdapterContext): Promise<TResult>;
+}
+export interface ExecutionEventRecorder {
+    record(event: InterfRunEvent): void | Promise<void>;
+}
+export declare const nativeExecutionBackendKind = "native";

package/dist/packages/execution/adapters.js

@@ -0,0 +1 @@
+export const nativeExecutionBackendKind = "native";

package/dist/packages/execution/events.d.ts

@@ -0,0 +1,8 @@
+import { type InterfRunEvent } from "./lib/schema.js";
+export interface RunEventSink {
+    emit(event: InterfRunEvent): void | Promise<void>;
+}
+export declare const nullRunEventSink: RunEventSink;
+export declare function parseInterfRunEvent(value: unknown): InterfRunEvent;
+export declare function createRunEventId(prefix?: string): string;
+export declare function createRunEventTimestamp(date?: Date): string;

package/dist/packages/execution/events.js

@@ -0,0 +1,16 @@
+import { InterfRunEventSchema, } from "./lib/schema.js";
+export const nullRunEventSink = {
+    emit() {
+        // Intentionally empty. Callers can depend on an event sink without
+        // requiring a service process.
+    },
+};
+export function parseInterfRunEvent(value) {
+    return InterfRunEventSchema.parse(value);
+}
+export function createRunEventId(prefix = "event") {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+export function createRunEventTimestamp(date = new Date()) {
+    return date.toISOString();
+}

package/dist/packages/execution/index.d.ts

@@ -0,0 +1,9 @@
+export * as schema from "./lib/schema.js";
+export * as events from "./events.js";
+export * as adapters from "./adapters.js";
+export type { ArtifactRef, ArtifactRole, CompileRun, CompileRunStatus, ExecutionBackendKind, InterfRunEvent, ObservableRunMetric, ObservableRunStatus, ObservableRunType, ProofCheck, ProofRecord, RunObservability, StageRun, StageRunContract, StageRunLogs, StageRunStatus, WorkflowTrace, WorkflowTraceEvent, WorkflowTraceEventType, WorkflowTraceRun, WorkflowTraceRunStatus, WorkflowTraceStreamChunk, WorkflowTraceStructuredError, } from "./lib/schema.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, CompileRunSchema, CompileRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, WorkflowTraceEventSchema, WorkflowTraceEventTypeSchema, WorkflowTraceRunSchema, WorkflowTraceRunStatusSchema, WorkflowTraceSchema, WorkflowTraceStreamChunkSchema, WorkflowTraceStructuredErrorSchema, } from "./lib/schema.js";
+export type { ExecutionAdapter, ExecutionAdapterContext, ExecutionEventRecorder, } from "./adapters.js";
+export { nativeExecutionBackendKind, } from "./adapters.js";
+export type { RunEventSink, } from "./events.js";
+export { createRunEventId, createRunEventTimestamp, nullRunEventSink, parseInterfRunEvent, } from "./events.js";

package/dist/packages/execution/index.js

@@ -0,0 +1,6 @@
+export * as schema from "./lib/schema.js";
+export * as events from "./events.js";
+export * as adapters from "./adapters.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, CompileRunSchema, CompileRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, WorkflowTraceEventSchema, WorkflowTraceEventTypeSchema, WorkflowTraceRunSchema, WorkflowTraceRunStatusSchema, WorkflowTraceSchema, WorkflowTraceStreamChunkSchema, WorkflowTraceStructuredErrorSchema, } from "./lib/schema.js";
+export { nativeExecutionBackendKind, } from "./adapters.js";
+export { createRunEventId, createRunEventTimestamp, nullRunEventSink, parseInterfRunEvent, } from "./events.js";