@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/compiler/compiled-stage-runner.js

@@ -2,26 +2,41 @@ import { createStageExecutionShell, freezeStageExecutionShell, syncStageExecutio
 import { reconcileCompiledStageRun } from "./runtime-reconcile.js";
 import { refreshCompiledArtifacts } from "./state.js";
 import { validateCompiledStage } from "./validate.js";
-import { executeValidatedStage, } from "../workflow-package/workflow-stage-runner.js";
-import { formatActiveCompiledWorkflowStageStep, } from "../workflow-package/workflow-definitions.js";
-import { reportBlankLine, reportLine, } from "../workflow-package/workflow-helpers.js";
+import { executeValidatedStage, } from "../method-package/method-stage-runner.js";
+import { formatActiveCompiledMethodStageStep, } from "../method-package/method-definitions.js";
+import { reportBlankLine, reportLine, } from "../method-package/method-helpers.js";
 import { buildCompiledStageExecutionPlan, } from "./compiled-stage-plan.js";
+import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
+async function emitRunEvent(sink, event) {
+    await sink?.emit(event);
+}
 export async function runCompiledStage(options) {
     const stageDefinition = options.stageDefinition;
     const plan = buildCompiledStageExecutionPlan(options.compiledPath, stageDefinition);
     if (options.reportStep !== false) {
         reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, plan.context.workflowId, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
+        reportLine(options.reporter, `${formatActiveCompiledMethodStageStep(options.compiledPath, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
     }
-    const shell = createStageExecutionShell(options.compiledPath, plan.context.compiledName, plan.context.workflowId, stageDefinition, plan.contract.artifacts.writes);
+    const shell = createStageExecutionShell(options.compiledPath, plan.context.compiledName, plan.context.methodId, stageDefinition, plan.contract.artifacts.writes);
     try {
-        return await executeValidatedStage({
+        if (options.runId && options.events) {
+            await emitRunEvent(options.events, {
+                type: "stage.started",
+                event_id: createRunEventId("event"),
+                run_id: options.runId,
+                timestamp: createRunEventTimestamp(),
+                stage_id: stageDefinition.id,
+                ...(typeof options.stageIndex === "number" ? { stage_index: options.stageIndex } : {}),
+                ...(typeof options.stageTotal === "number" ? { stage_total: options.stageTotal } : {}),
+            });
+        }
+        const result = await executeValidatedStage({
             executor: options.executor,
             compiledPath: options.compiledPath,
             executionPath: shell.rootPath,
             targetName: plan.context.compiledName,
-            workflow: plan.context.workflowId,
-            workflowSourcePath: options.compiledPath,
+            method: plan.context.methodId,
+            methodSourcePath: options.compiledPath,
             stageDefinition,
             instructions: plan.instructions,
             summary: `Executing ${stageDefinition.label.toLowerCase()}.`,
@@ -34,11 +49,44 @@ export async function runCompiledStage(options) {
             ],
             reporter: options.reporter,
             completionCheck: () => validateCompiledStage(options.compiledPath, stageDefinition.id).ok,
+            onStatus: options.runId && options.events
+                ? (line) => {
+                    void options.events?.emit({
+                        type: "log.appended",
+                        event_id: createRunEventId("event"),
+                        run_id: options.runId,
+                        timestamp: createRunEventTimestamp(),
+                        stage_id: stageDefinition.id,
+                        stream: "status",
+                        message: line,
+                    });
+                }
+                : undefined,
             syncWrites: () => syncStageExecutionShellWrites(options.compiledPath, shell.rootPath, stageDefinition, plan.contract.artifacts.writes),
             reconcile: () => reconcileCompiledStageRun(options.compiledPath, stageDefinition),
             refreshArtifacts: () => refreshCompiledArtifacts(options.compiledPath, { ensureViewSpec: true }),
             validate: () => validateCompiledStage(options.compiledPath, stageDefinition.id),
         });
+        if (options.runId && options.events) {
+            await emitRunEvent(options.events, result.ok
+                ? {
+                    type: "stage.passed",
+                    event_id: createRunEventId("event"),
+                    run_id: options.runId,
+                    timestamp: createRunEventTimestamp(),
+                    stage_id: stageDefinition.id,
+                    summary: result.summary ?? `${stageDefinition.label} completed.`,
+                }
+                : {
+                    type: "stage.failed",
+                    event_id: createRunEventId("event"),
+                    run_id: options.runId,
+                    timestamp: createRunEventTimestamp(),
+                    stage_id: stageDefinition.id,
+                    error: result.summary ?? `${stageDefinition.label} failed.`,
+                });
+        }
+        return result;
     }
     finally {
         freezeStageExecutionShell(shell.rootPath);

package/dist/packages/compiler/compiled-target.d.ts

@@ -1,11 +1,11 @@
-import { type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
-import { type CompiledWorkflowId } from "../workflow-package/workflow-definitions.js";
-export interface CompiledStageExecutionDefinition extends WorkflowStageDefinition {
+import { type MethodStageDefinition } from "../method-package/method-definitions.js";
+import { type CompiledMethodId } from "../method-package/method-definitions.js";
+export interface CompiledStageExecutionDefinition extends MethodStageDefinition {
 }
 export declare function resolveCompiledContext(compiledPath: string): {
     compiledName: string;
     sourcePath: string;
     controlPath: string;
-    workflowId: CompiledWorkflowId;
+    methodId: CompiledMethodId;
 };
-export declare function compiledExecutionStages(workflowId: CompiledWorkflowId, compiledPath: string): CompiledStageExecutionDefinition[];
+export declare function compiledExecutionStages(_methodId: CompiledMethodId, compiledPath: string): CompiledStageExecutionDefinition[];

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

@@ -1,16 +1,16 @@
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
 import { readInterfConfig, resolveSourceFolderPath, resolveSourceControlPath, } from "../project-model/interf-detect.js";
 export function resolveCompiledContext(compiledPath) {
     const config = readInterfConfig(compiledPath);
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${compiledPath}`);
+    const methodId = resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${compiledPath}`);
     return {
         compiledName: config?.name ?? "compiled",
         sourcePath: resolveSourceFolderPath(compiledPath, config),
         controlPath: resolveSourceControlPath(compiledPath),
-        workflowId,
+        methodId,
     };
 }
-export function compiledExecutionStages(workflowId, compiledPath) {
-    return getActiveCompiledWorkflow(compiledPath, workflowId)
+export function compiledExecutionStages(_methodId, compiledPath) {
+    return getActiveCompiledMethod(compiledPath)
         .stages;
 }

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

@@ -1,4 +1,4 @@
-export * as primitives from "./workflow-primitives.js";
+export * as primitives from "./method-primitives.js";
 export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
@@ -20,5 +20,5 @@ export * as stateView from "./state-view.js";
 export * as validate from "./validate.js";
 export * as validateCompiled from "./validate-compiled.js";
 export * as validateHelpers from "./validate-helpers.js";
-export * as workflows from "./workflows.js";
-export type { CompiledCompileResult, CompiledSummarizeResult, StageShellRetentionMode, } from "./workflows.js";
+export * as methods from "./method-runs.js";
+export type { CompiledCompileResult, CompiledSummarizeResult, StageShellRetentionMode, } from "./method-runs.js";

package/dist/packages/compiler/index.js

@@ -1,4 +1,4 @@
-export * as primitives from "./workflow-primitives.js";
+export * as primitives from "./method-primitives.js";
 export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
@@ -20,4 +20,4 @@ export * as stateView from "./state-view.js";
 export * as validate from "./validate.js";
 export * as validateCompiled from "./validate-compiled.js";
 export * as validateHelpers from "./validate-helpers.js";
-export * as workflows from "./workflows.js";
+export * as methods from "./method-runs.js";

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

@@ -1,43 +1,32 @@
 import { z } from "zod";
+import { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, TestCaseExpectSchema, TestTargetTypeSchema, MethodIdSchema } from "../../contracts/lib/schema.js";
+export { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
 export type RuntimeStatus = "idle" | "running" | "compiled" | "stale" | "failed";
 export type CompiledStage = "idle" | "compiled" | "failed" | string;
-export declare const RuntimeTargetTypeSchema: z.ZodEnum<{
-    compiled: "compiled";
-}>;
-export declare const TestTargetTypeSchema: z.ZodEnum<{
-    compiled: "compiled";
-    raw: "raw";
-}>;
-export declare const WorkflowIdPattern: RegExp;
-export declare const RuntimeStageSchema: z.ZodString;
-export declare const RuntimeContractTypeSchema: z.ZodString;
-export declare const WorkflowIdSchema: z.ZodString;
-export declare const WorkflowZoneIdSchema: z.ZodString;
-export declare const WorkflowCompiledZoneKindSchema: z.ZodEnum<{
+export declare const MethodZoneIdSchema: z.ZodString;
+export declare const MethodCompiledZoneKindSchema: z.ZodEnum<{
     runtime: "runtime";
-    directory: "directory";
     file: "file";
+    directory: "directory";
 }>;
-export declare const WorkflowZoneRoleSchema: z.ZodEnum<{
+export declare const MethodZoneRoleSchema: z.ZodEnum<{
     output: "output";
     runtime: "runtime";
     input: "input";
     working: "working";
 }>;
 export declare const CompiledStageStatusSchema: z.ZodEnum<{
+    failed: "failed";
     idle: "idle";
     running: "running";
-    failed: "failed";
     succeeded: "succeeded";
 }>;
-export declare const SourceCompiledMaxAttemptsSchema: z.ZodNumber;
-export declare const SourceCompiledMaxLoopsSchema: z.ZodNumber;
 export declare const CompiledStageStateSchema: z.ZodObject<{
     contract_type: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
         idle: "idle";
         running: "running";
-        failed: "failed";
         succeeded: "succeeded";
     }>>;
     started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -54,9 +43,9 @@ export declare const CompiledStateSchema: z.ZodObject<{
     stages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         contract_type: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
             idle: "idle";
             running: "running";
-            failed: "failed";
             succeeded: "succeeded";
         }>>;
         started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -103,15 +92,15 @@ export declare const CompiledHealthSchema: z.ZodObject<{
     target_name: z.ZodString;
     status: z.ZodEnum<{
         compiled: "compiled";
-        idle: "idle";
-        running: "running";
         stale: "stale";
         failed: "failed";
+        idle: "idle";
+        running: "running";
     }>;
     stage: z.ZodUnion<readonly [z.ZodEnum<{
         compiled: "compiled";
-        idle: "idle";
         failed: "failed";
+        idle: "idle";
     }>, z.ZodString]>;
     summary: z.ZodString;
     metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
@@ -161,11 +150,11 @@ export declare const CompiledRawSnapshotSchema: z.ZodObject<{
     source_total: z.ZodNumber;
     sample_files: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
-export declare const WorkflowPurposeSchema: z.ZodObject<{
+export declare const MethodPurposeSchema: z.ZodObject<{
     label: z.ZodString;
     task_hint: z.ZodString;
 }, z.core.$strict>;
-export declare const WorkflowZoneSchema: z.ZodObject<{
+export declare const MethodZoneSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
         output: "output";
@@ -176,14 +165,14 @@ export declare const WorkflowZoneSchema: z.ZodObject<{
     path: z.ZodString;
     kind: z.ZodEnum<{
         runtime: "runtime";
-        directory: "directory";
         file: "file";
+        directory: "directory";
     }>;
     required: z.ZodBoolean;
     owned_by: z.ZodArray<z.ZodString>;
     description: z.ZodString;
 }, z.core.$strip>;
-export declare const WorkflowCompiledZoneSchema: z.ZodObject<{
+export declare const MethodCompiledZoneSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
         output: "output";
@@ -194,15 +183,15 @@ export declare const WorkflowCompiledZoneSchema: z.ZodObject<{
     path: z.ZodString;
     kind: z.ZodEnum<{
         runtime: "runtime";
-        directory: "directory";
         file: "file";
+        directory: "directory";
     }>;
     required: z.ZodBoolean;
     owned_by: z.ZodArray<z.ZodString>;
     description: z.ZodString;
 }, z.core.$strip>;
-export declare const WorkflowSchemaSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"workflow-schema">;
+export declare const MethodSchemaSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
@@ -217,16 +206,16 @@ export declare const WorkflowSchemaSchema: z.ZodObject<{
         path: z.ZodString;
         kind: z.ZodEnum<{
             runtime: "runtime";
-            directory: "directory";
             file: "file";
+            directory: "directory";
         }>;
         required: z.ZodBoolean;
         owned_by: z.ZodArray<z.ZodString>;
         description: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const WorkflowCompiledSchemaSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"workflow-schema">;
+export declare const MethodCompiledSchemaSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
@@ -241,20 +230,20 @@ export declare const WorkflowCompiledSchemaSchema: z.ZodObject<{
         path: z.ZodString;
         kind: z.ZodEnum<{
             runtime: "runtime";
-            directory: "directory";
             file: "file";
+            directory: "directory";
         }>;
         required: z.ZodBoolean;
         owned_by: z.ZodArray<z.ZodString>;
         description: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const WorkflowCompilerApiSchema: z.ZodObject<{
+export declare const MethodCompilerApiSchema: z.ZodObject<{
     kind: z.ZodLiteral<"compiled">;
     version: z.ZodLiteral<1>;
 }, z.core.$strip>;
-export type WorkflowCompilerApi = z.infer<typeof WorkflowCompilerApiSchema>;
-export declare const WorkflowStageZoneAccessSchema: z.ZodArray<z.ZodString>;
+export type MethodCompilerApi = z.infer<typeof MethodCompilerApiSchema>;
+export declare const MethodStageZoneAccessSchema: z.ZodArray<z.ZodString>;
 export declare const ExecutionShellZoneMountSchema: z.ZodObject<{
     zone_id: z.ZodString;
     compiled_path: z.ZodString;
@@ -265,7 +254,7 @@ export declare const ExecutionShellZoneMountSchema: z.ZodObject<{
 export declare const ExecutionShellPathsSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-execution-shell">;
     version: z.ZodLiteral<1>;
-    workflow: z.ZodString;
+    method: z.ZodString;
     stage: z.ZodString;
     reads: z.ZodArray<z.ZodObject<{
         zone_id: z.ZodString;
@@ -282,20 +271,6 @@ export declare const ExecutionShellPathsSchema: z.ZodObject<{
         output_mount_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const RuntimeExecutorInfoSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        "local-agent": "local-agent";
-        "connected-provider": "connected-provider";
-        managed: "managed";
-    }>;
-    name: z.ZodString;
-    display_name: z.ZodString;
-    command: z.ZodNullable<z.ZodString>;
-    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strip>;
 export declare const RuntimeStageInstructionsSchema: z.ZodObject<{
     stage_skill_dir: z.ZodString;
     effective_mode: z.ZodEnum<{
@@ -333,7 +308,7 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         compiled: "compiled";
     }>;
     target_name: z.ZodString;
-    workflow: z.ZodObject<{
+    method: z.ZodObject<{
         id: z.ZodString;
         stage_index: z.ZodNullable<z.ZodNumber>;
         stage_total: z.ZodNumber;
@@ -412,13 +387,13 @@ export declare const RuntimeRunSchema: z.ZodObject<{
         compiled: "compiled";
     }>;
     target_name: z.ZodString;
-    workflow: z.ZodString;
+    method: z.ZodString;
     stage: z.ZodString;
     stage_label: z.ZodString;
     contract_type: z.ZodString;
     status: z.ZodEnum<{
-        running: "running";
         failed: "failed";
+        running: "running";
         succeeded: "succeeded";
     }>;
     executor: z.ZodObject<{
@@ -473,14 +448,7 @@ export declare const CompiledInventorySchema: z.ZodObject<{
     }, z.core.$strict>>;
     total: z.ZodNumber;
 }, z.core.$strip>;
-export declare const TestCaseExpectSchema: z.ZodObject<{
-    must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-    must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    min_words: z.ZodOptional<z.ZodNumber>;
-    max_words: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const WorkflowImprovementLoopSummarySchema: z.ZodObject<{
+export declare const MethodImprovementLoopSummarySchema: z.ZodObject<{
     variation: z.ZodNumber;
     kind: z.ZodEnum<{
         baseline: "baseline";
@@ -495,24 +463,24 @@ export declare const WorkflowImprovementLoopSummarySchema: z.ZodObject<{
     test_sandbox_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     summary: z.ZodString;
 }, z.core.$strip>;
-export declare const WorkflowImprovementContextSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-workflow-improvement-loop">;
+export declare const MethodImprovementContextSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-method-improvement-loop">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     target_name: z.ZodString;
-    workflow_id: z.ZodString;
+    method_id: z.ZodString;
     loop_index: z.ZodNumber;
     max_loops: z.ZodNumber;
     max_attempts: z.ZodNumber;
     review_paths: z.ZodObject<{
-        workflow_root: z.ZodString;
+        method_root: z.ZodString;
         compiled_runtime: z.ZodNullable<z.ZodString>;
         test_comparisons: z.ZodNullable<z.ZodString>;
         execution_shells: z.ZodNullable<z.ZodString>;
         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;
@@ -550,37 +518,39 @@ export declare const WorkflowImprovementContextSchema: z.ZodObject<{
         summary: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export type WorkflowImprovementLoopSummary = z.infer<typeof WorkflowImprovementLoopSummarySchema>;
-export type WorkflowImprovementContext = z.infer<typeof WorkflowImprovementContextSchema>;
+export type MethodImprovementLoopSummary = z.infer<typeof MethodImprovementLoopSummarySchema>;
+export type MethodImprovementContext = z.infer<typeof MethodImprovementContextSchema>;
 export declare const PreservedShellTypeSchema: z.ZodEnum<{
     "stage-execution": "stage-execution";
-    "workflow-improvement": "workflow-improvement";
+    "method-authoring": "method-authoring";
+    "method-improvement": "method-improvement";
 }>;
 export declare const PreservedShellSnapshotSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-preserved-shell">;
     version: z.ZodLiteral<1>;
     shell_type: z.ZodEnum<{
         "stage-execution": "stage-execution";
-        "workflow-improvement": "workflow-improvement";
+        "method-authoring": "method-authoring";
+        "method-improvement": "method-improvement";
     }>;
     generated_at: z.ZodString;
     root_path: z.ZodString;
     materialized_symlinks: z.ZodNumber;
 }, z.core.$strip>;
-export declare const WorkflowPackageValidationSchema: z.ZodObject<{
+export declare const MethodPackageValidationSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     summary: z.ZodString;
     errors: z.ZodArray<z.ZodString>;
     counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
 }, z.core.$strip>;
-export declare const WorkflowImprovementLoopRecordSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-workflow-improvement-loop-record">;
+export declare const MethodImprovementLoopRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-method-improvement-loop-record">;
     version: z.ZodLiteral<1>;
     recorded_at: z.ZodString;
     run_id: z.ZodString;
     loop_index: z.ZodNumber;
     target_name: z.ZodString;
-    workflow_id: z.ZodString;
+    method_id: z.ZodString;
     result: z.ZodEnum<{
         updated: "updated";
         "no-change": "no-change";
@@ -593,8 +563,8 @@ export declare const WorkflowImprovementLoopRecordSchema: z.ZodObject<{
     shell_path: z.ZodString;
     loop_root_path: z.ZodString;
     context_path: z.ZodString;
-    workflow_before_path: z.ZodString;
-    workflow_after_path: z.ZodString;
+    method_before_path: z.ZodString;
+    method_after_path: z.ZodString;
     prompt_log_path: z.ZodString;
     event_log_path: z.ZodString;
     status_log_path: z.ZodString;
@@ -606,24 +576,24 @@ export declare const WorkflowImprovementLoopRecordSchema: z.ZodObject<{
         counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const WorkflowImprovementRunLedgerSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-workflow-improvement-run">;
+export declare const MethodImprovementRunLedgerSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-method-improvement-run">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     updated_at: z.ZodString;
     run_id: z.ZodString;
     target_name: z.ZodString;
-    workflow_id: z.ZodString;
+    method_id: z.ZodString;
     max_loops: z.ZodNumber;
     max_attempts: z.ZodNumber;
     loops: z.ZodArray<z.ZodObject<{
-        kind: z.ZodLiteral<"interf-workflow-improvement-loop-record">;
+        kind: z.ZodLiteral<"interf-method-improvement-loop-record">;
         version: z.ZodLiteral<1>;
         recorded_at: z.ZodString;
         run_id: z.ZodString;
         loop_index: z.ZodNumber;
         target_name: z.ZodString;
-        workflow_id: z.ZodString;
+        method_id: z.ZodString;
         result: z.ZodEnum<{
             updated: "updated";
             "no-change": "no-change";
@@ -636,8 +606,8 @@ export declare const WorkflowImprovementRunLedgerSchema: z.ZodObject<{
         shell_path: z.ZodString;
         loop_root_path: z.ZodString;
         context_path: z.ZodString;
-        workflow_before_path: z.ZodString;
-        workflow_after_path: z.ZodString;
+        method_before_path: z.ZodString;
+        method_after_path: z.ZodString;
         prompt_log_path: z.ZodString;
         event_log_path: z.ZodString;
         status_log_path: z.ZodString;
@@ -652,19 +622,24 @@ export declare const WorkflowImprovementRunLedgerSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type PreservedShellType = z.infer<typeof PreservedShellTypeSchema>;
 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 MethodPackageValidation = z.infer<typeof MethodPackageValidationSchema>;
+export type MethodImprovementLoopRecord = z.infer<typeof MethodImprovementLoopRecordSchema>;
+export type MethodImprovementRunLedger = z.infer<typeof MethodImprovementRunLedgerSchema>;
+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>;
 export type CompiledHealth = z.infer<typeof CompiledHealthSchema>;
 export type CompiledViewSpec = z.infer<typeof CompiledViewSpecSchema>;
 export type CompiledRawSnapshot = z.infer<typeof CompiledRawSnapshotSchema>;
-export type WorkflowCompiledZone = z.infer<typeof WorkflowCompiledZoneSchema>;
-export type WorkflowCompiledSchema = z.infer<typeof WorkflowCompiledSchemaSchema>;
-export type WorkflowCompiledZoneKind = z.infer<typeof WorkflowCompiledZoneKindSchema>;
-export type WorkflowZoneId = z.infer<typeof WorkflowZoneIdSchema>;
+export type MethodCompiledZone = z.infer<typeof MethodCompiledZoneSchema>;
+export type MethodCompiledSchema = z.infer<typeof MethodCompiledSchemaSchema>;
+export type MethodCompiledZoneKind = z.infer<typeof MethodCompiledZoneKindSchema>;
+export type MethodZoneId = z.infer<typeof MethodZoneIdSchema>;
 export type ExecutionShellZoneMount = z.infer<typeof ExecutionShellZoneMountSchema>;
 export type ExecutionShellPaths = z.infer<typeof ExecutionShellPathsSchema>;
 export type RuntimeExecutorInfo = z.infer<typeof RuntimeExecutorInfoSchema>;
@@ -672,7 +647,7 @@ export type RuntimeTargetType = z.infer<typeof RuntimeTargetTypeSchema>;
 export type TestTargetType = z.infer<typeof TestTargetTypeSchema>;
 export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
 export type RuntimeContractType = z.infer<typeof RuntimeContractTypeSchema>;
-export type WorkflowId = z.infer<typeof WorkflowIdSchema>;
+export type MethodId = z.infer<typeof MethodIdSchema>;
 export type LocalInstructionMode = "extend" | "override";
 export type RuntimeInstructionMode = "builtin" | LocalInstructionMode;
 export type RuntimeStageInstructions = z.infer<typeof RuntimeStageInstructionsSchema>;