@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/agents/lib/types.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowExecutionProfile } from "./executors.js";
+import type { MethodExecutionProfile } from "./executors.js";
 export interface Agent {
     name: string;
     displayName: string;
@@ -25,6 +25,7 @@ export interface AgentAutomationReadiness {
 export interface SpawnAgentOptions {
     eventLogPath?: string | null;
     statusLogPath?: string | null;
-    executionProfile?: WorkflowExecutionProfile;
+    executionProfile?: MethodExecutionProfile;
     completionCheck?: (() => boolean) | null;
+    onStatus?: (line: string) => void;
 }

package/dist/packages/compiler/artifact-counts.d.ts

@@ -0,0 +1 @@
+export declare function countCompiledZoneArtifacts(compiledPath: string, zonePath: string, kind: "directory" | "file" | "runtime"): number;

package/dist/packages/compiler/artifact-counts.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync } from "node:fs";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { compiledZoneAbsolutePath } from "./compiled-schema.js";
+const SCAFFOLD_PLACEHOLDER_SNIPPETS = [
+    "Not yet compiled. Run `interf compile` to build the portable context.",
+    "Not yet compiled. Run `interf compile` to build this portable context.",
+    "Not yet compiled. Run `interf compile` to build the portable context.",
+    "Not yet compiled. Run `interf compile` to build this portable context.",
+];
+function isScaffoldPlaceholderFile(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        return SCAFFOLD_PLACEHOLDER_SNIPPETS.some((snippet) => content.includes(snippet));
+    }
+    catch {
+        return false;
+    }
+}
+export function countCompiledZoneArtifacts(compiledPath, zonePath, kind) {
+    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
+    if (!existsSync(absolutePath))
+        return 0;
+    if (kind === "file")
+        return isScaffoldPlaceholderFile(absolutePath) ? 0 : 1;
+    if (kind === "runtime")
+        return listFilesRecursive(absolutePath).length;
+    return listFilesRecursive(absolutePath)
+        .filter((filePath) => !isScaffoldPlaceholderFile(filePath))
+        .length;
+}

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

@@ -1,6 +1,6 @@
 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_METHOD_DIR = "method";
 export declare const COMPILED_TEST_DIR = "tests";
 export declare const COMPILED_TEST_TARGETS_DIR = "targets";
 export declare const COMPILED_RUNTIME_DIR = "runtime";
@@ -16,13 +16,13 @@ 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 methodPackagePathForCompiled(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 methodImprovementLoopsRoot(compiledPath: string): string;
+export declare function methodImprovementRunRoot(compiledPath: string, runId: string): string;
+export declare function methodImprovementLoopRoot(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;

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

@@ -1,7 +1,7 @@
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 export const COMPILED_INTERF_DIR = ".interf";
 export const COMPILED_CONFIG_FILE = "interf.json";
-export const COMPILED_WORKFLOW_DIR = "workflow";
+export const COMPILED_METHOD_DIR = "method";
 export const COMPILED_TEST_DIR = "tests";
 export const COMPILED_TEST_TARGETS_DIR = "targets";
 export const COMPILED_RUNTIME_DIR = "runtime";
@@ -25,8 +25,8 @@ export function compiledInterfRoot(compiledPath) {
 export function compiledInterfConfigPath(compiledPath) {
     return join(compiledInterfRoot(compiledPath), COMPILED_CONFIG_FILE);
 }
-export function workflowPackagePathForCompiled(compiledPath) {
-    return join(compiledInterfRoot(compiledPath), COMPILED_WORKFLOW_DIR);
+export function methodPackagePathForCompiled(compiledPath) {
+    return join(compiledInterfRoot(compiledPath), COMPILED_METHOD_DIR);
 }
 export function testRootForCompiled(compiledPath) {
     return join(compiledInterfRoot(compiledPath), COMPILED_TEST_DIR);
@@ -37,14 +37,14 @@ export function testTargetsRootForCompiled(compiledPath) {
 export function stageExecutionShellsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "execution-shells");
 }
-export function workflowImprovementLoopsRoot(compiledPath) {
+export function methodImprovementLoopsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "improvement-loops");
 }
-export function workflowImprovementRunRoot(compiledPath, runId) {
-    return join(workflowImprovementLoopsRoot(compiledPath), runId);
+export function methodImprovementRunRoot(compiledPath, runId) {
+    return join(methodImprovementLoopsRoot(compiledPath), runId);
 }
-export function workflowImprovementLoopRoot(compiledPath, runId, loopIndex) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), `loop-${String(loopIndex).padStart(2, "0")}`);
+export function methodImprovementLoopRoot(compiledPath, runId, loopIndex) {
+    return join(methodImprovementRunRoot(compiledPath, runId), `loop-${String(loopIndex).padStart(2, "0")}`);
 }
 export function targetTestRunsRootForCompiled(compiledPath) {
     return join(testTargetsRootForCompiled(compiledPath), "runs");
@@ -91,14 +91,14 @@ export function resolveSourceControlPathForCompiled(compiledPath) {
         const parent = dirname(cursor);
         if (basename(parent) === "interf" &&
             basename(cursor) !== "tests" &&
-            basename(cursor) !== "workflows") {
+            basename(cursor) !== "methods") {
             return dirname(parent);
         }
         if (parent === cursor)
             break;
         cursor = parent;
     }
-    throw new Error(`Compiled context is not under the canonical project layout: ${compiledPath}`);
+    throw new Error(`Portable context is not under the canonical Interf Workspace layout: ${compiledPath}`);
 }
 export function defaultControlPathForCompiled(compiledPath) {
     const relativePath = relative(compiledPath, resolveSourceControlPathForCompiled(compiledPath));

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

@@ -1,8 +1,8 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
-import { type WorkflowReporter, type WorkflowStageResult } from "../workflow-package/workflow-helpers.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
+import { type MethodReporter, type MethodStageResult } from "../method-package/method-helpers.js";
 import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
-export interface CompiledSummarizeResult extends WorkflowStageResult {
-    skipped: boolean;
+import type { RunEventSink } from "../execution/events.js";
+export interface CompiledSummarizeResult extends MethodStageResult {
     plan: {
         sourceCount: number;
         summaryCount: number;
@@ -11,29 +11,35 @@ export interface CompiledSummarizeResult extends WorkflowStageResult {
 }
 export interface CompiledCompileResult {
     ok: boolean;
-    stageResults: Record<string, WorkflowStageResult>;
+    stageResults: Record<string, MethodStageResult>;
     failedStage: string | null;
 }
 export type StageShellRetentionMode = "on-failure" | "always";
 export declare function runCompiledSummarize(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     reportSummary?: boolean;
     reportStep?: boolean;
     stageDefinition?: CompiledStageExecutionDefinition;
     fullPass?: boolean;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<CompiledSummarizeResult>;
 export declare function runCompiledCompile(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     reportStep?: boolean;
     preserveStageShells?: StageShellRetentionMode;
-}): Promise<WorkflowStageResult>;
+    runId?: string;
+    events?: RunEventSink;
+}): Promise<MethodStageResult>;
 export declare function compileCompiled(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<CompiledCompileResult>;

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

@@ -1,25 +1,25 @@
-import { join } from "node:path";
 import { refreshCompiledBootstrapGuidance, } from "../agents/lib/compiled-bootstrap.js";
-import { validateWorkflowPackage } from "../workflow-package/local-workflows.js";
-import { reportValidationFailure, } from "../workflow-package/workflow-helpers.js";
-import { validateCompiledWorkflow, } from "./validate.js";
+import { validateMethodPackage } from "../method-package/local-methods.js";
+import { reportValidationFailure, } from "../method-package/method-helpers.js";
+import { validateCompiledMethod, } from "./validate.js";
 import { pruneStageExecutionShells, } from "../agents/lib/shells.js";
+import { resetCompiledGeneratedState } from "./reset.js";
 import { syncCompiledRawSnapshot } from "./raw-snapshot.js";
 import { compiledExecutionStages, resolveCompiledContext, } from "./compiled-target.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { runCompiledStage } from "./compiled-stage-runner.js";
 import { resolveSourceInputPath } from "../project-model/interf-detect.js";
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
 export async function runCompiledSummarize(options) {
     const context = resolveCompiledContext(options.compiledPath);
     const stageDefinition = options.stageDefinition
-        ?? compiledExecutionStages(context.workflowId, options.compiledPath).find((stage) => stage.id === "summarize");
+        ?? compiledExecutionStages(context.methodId, 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.",
+            summary: "Method does not declare a summarize stage.",
         };
     }
     const sourceCount = discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount;
@@ -29,10 +29,11 @@ export async function runCompiledSummarize(options) {
         reporter: options.reporter,
         reportStep: options.reportStep,
         stageDefinition,
+        runId: options.runId,
+        events: options.events,
     });
     return {
         ...result,
-        skipped: false,
         plan: {
             sourceCount,
             summaryCount: 0,
@@ -48,13 +49,18 @@ export async function runCompiledCompile(options) {
     let lastResult = { ok: true, code: 0 };
     try {
         const context = resolveCompiledContext(options.compiledPath);
-        for (const stageDefinition of compiledExecutionStages(context.workflowId, options.compiledPath)) {
+        const stages = compiledExecutionStages(context.methodId, options.compiledPath);
+        for (const [index, stageDefinition] of stages.entries()) {
             const result = await runCompiledStage({
                 executor: options.executor,
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: options.reportStep,
                 stageDefinition,
+                runId: options.runId,
+                events: options.events,
+                stageIndex: index,
+                stageTotal: stages.length,
             });
             lastResult = result;
             if (!result.ok)
@@ -70,6 +76,7 @@ export async function runCompiledCompile(options) {
 }
 export async function compileCompiled(options) {
     const preserveMode = options.preserveStageShells ?? "on-failure";
+    resetCompiledGeneratedState(options.compiledPath, "compile");
     if (preserveMode !== "always") {
         pruneStageExecutionShells(options.compiledPath);
     }
@@ -82,32 +89,36 @@ export async function compileCompiled(options) {
         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);
+        const methodValidation = validateMethodPackage(methodPackagePathForCompiled(options.compiledPath));
+        if (!methodValidation.ok) {
+            reportValidationFailure(options.reporter, methodValidation.summary, methodValidation.errors);
             return {
                 ...result,
                 ok: false,
-                failedStage: "workflow",
+                failedStage: "method",
                 stageResults: {
                     ...result.stageResults,
-                    workflow: {
+                    method: {
                         ok: false,
                         code: 1,
-                        summary: workflowValidation.summary,
+                        summary: methodValidation.summary,
                     },
                 },
             };
         }
         const context = resolveCompiledContext(options.compiledPath);
-        const stages = compiledExecutionStages(context.workflowId, options.compiledPath);
-        for (const stageDefinition of stages) {
+        const stages = compiledExecutionStages(context.methodId, options.compiledPath);
+        for (const [index, stageDefinition] of stages.entries()) {
             const stageResult = await runCompiledStage({
                 executor: options.executor,
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: true,
                 stageDefinition,
+                runId: options.runId,
+                events: options.events,
+                stageIndex: index,
+                stageTotal: stages.length,
             });
             result.stageResults[stageDefinition.id] = stageResult;
             if (!stageResult.ok) {
@@ -116,13 +127,13 @@ export async function compileCompiled(options) {
                 return result;
             }
         }
-        const workflowValidationResult = validateCompiledWorkflow(options.compiledPath);
-        result.ok = workflowValidationResult.ok;
-        result.failedStage = workflowValidationResult.ok ? null : workflowValidationResult.stage;
+        const methodValidationResult = validateCompiledMethod(options.compiledPath);
+        result.ok = methodValidationResult.ok;
+        result.failedStage = methodValidationResult.ok ? null : methodValidationResult.stage;
         result.stageResults.compiled = {
-            ok: workflowValidationResult.ok,
-            code: workflowValidationResult.ok ? 0 : 1,
-            summary: workflowValidationResult.summary,
+            ok: methodValidationResult.ok,
+            code: methodValidationResult.ok ? 0 : 1,
+            summary: methodValidationResult.summary,
         };
         return result;
     }

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

@@ -1,20 +1,20 @@
-import { type BuiltinCompiledZoneId } from "../workflow-package/builtin-compiled-workflow.js";
-import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "./lib/schema.js";
-export interface WorkflowSchemaStageLike {
+import { type BuiltinCompiledZoneId } from "../method-package/builtin-compiled-method.js";
+import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "./lib/schema.js";
+export interface MethodSchemaStageLike {
     id: string;
     writes: readonly string[];
 }
-export { BUILTIN_COMPILED_ZONE_IDS } from "../workflow-package/builtin-compiled-workflow.js";
-export declare const WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
-export declare function workflowSchemaFilePath(rootPath: string): string;
-export declare function resolveWorkflowSchemaPath(rootPath: string): string | null;
-export declare function workflowSchemaExists(rootPath: string): boolean;
-export declare function workflowSchemaRelativePath(): string;
-export declare function listCompiledSchemaZones(schema: WorkflowCompiledSchema): WorkflowCompiledZone[];
-export declare function findCompiledSchemaZone(schema: WorkflowCompiledSchema, zoneId: WorkflowZoneId): WorkflowCompiledZone | null;
-export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<WorkflowCompiledZone, "path">): string;
-export declare function compiledContractArtifactPath(zone: Pick<WorkflowCompiledZone, "path" | "kind">): string;
-export declare function compiledContractArtifactPathsForZoneIds(schema: WorkflowCompiledSchema, zoneIds: readonly WorkflowZoneId[]): string[];
+export { BUILTIN_COMPILED_ZONE_IDS } from "../method-package/builtin-compiled-method.js";
+export declare const METHOD_SCHEMA_FILE = "method.schema.json";
+export declare function methodSchemaFilePath(rootPath: string): string;
+export declare function resolveMethodSchemaPath(rootPath: string): string | null;
+export declare function methodSchemaExists(rootPath: string): boolean;
+export declare function methodSchemaRelativePath(): string;
+export declare function listCompiledSchemaZones(schema: MethodCompiledSchema): MethodCompiledZone[];
+export declare function findCompiledSchemaZone(schema: MethodCompiledSchema, zoneId: MethodZoneId): MethodCompiledZone | null;
+export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<MethodCompiledZone, "path">): string;
+export declare function compiledContractArtifactPath(zone: Pick<MethodCompiledZone, "path" | "kind">): string;
+export declare function compiledContractArtifactPathsForZoneIds(schema: MethodCompiledSchema, zoneIds: readonly MethodZoneId[]): string[];
 export declare function builtinCompiledZoneRelativePath(zoneId: BuiltinCompiledZoneId): string;
 export declare function builtinCompiledZoneAbsolutePath(compiledPath: string, zoneId: BuiltinCompiledZoneId): string;
 export declare function compiledSummariesPath(compiledPath: string): string;
@@ -23,9 +23,9 @@ export declare function compiledKnowledgeClaimsPath(compiledPath: string): strin
 export declare function compiledKnowledgeIndexesPath(compiledPath: string): string;
 export declare function compiledKnowledgeRootPath(compiledPath: string): string;
 export declare function compiledHomePath(compiledPath: string): string;
-export declare function ensureCompiledZoneTargets(compiledPath: string, schema: WorkflowCompiledSchema): void;
-export declare function buildWorkflowSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeWorkflowSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeWorkflowSchemaDocument(rootPath: string, schema: WorkflowCompiledSchema): WorkflowCompiledSchema;
-export declare function readWorkflowSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
-export declare function readCompiledSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
+export declare function ensureCompiledZoneTargets(compiledPath: string, schema: MethodCompiledSchema): void;
+export declare function buildMethodSchema(stages: MethodSchemaStageLike[], label?: string): MethodCompiledSchema;
+export declare function writeMethodSchemaFile(rootPath: string, stages: MethodSchemaStageLike[], label?: string): MethodCompiledSchema;
+export declare function writeMethodSchemaDocument(rootPath: string, schema: MethodCompiledSchema): MethodCompiledSchema;
+export declare function readMethodSchemaFile(rootPath: string): MethodCompiledSchema | null;
+export declare function readCompiledSchemaFile(rootPath: string): MethodCompiledSchema | null;

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

@@ -2,23 +2,23 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { warnInterf } from "../shared/logger.js";
 import { readJsonFileUnchecked } from "../shared/parse.js";
-import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "../workflow-package/builtin-compiled-workflow.js";
-import { WorkflowCompiledSchemaSchema, } from "./lib/schema.js";
-export { BUILTIN_COMPILED_ZONE_IDS } from "../workflow-package/builtin-compiled-workflow.js";
-export const WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
+import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "../method-package/builtin-compiled-method.js";
+import { MethodCompiledSchemaSchema, } from "./lib/schema.js";
+export { BUILTIN_COMPILED_ZONE_IDS } from "../method-package/builtin-compiled-method.js";
+export const METHOD_SCHEMA_FILE = "method.schema.json";
 const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
-export function workflowSchemaFilePath(rootPath) {
-    return join(rootPath, WORKFLOW_SCHEMA_FILE);
+export function methodSchemaFilePath(rootPath) {
+    return join(rootPath, METHOD_SCHEMA_FILE);
 }
-export function resolveWorkflowSchemaPath(rootPath) {
-    const path = workflowSchemaFilePath(rootPath);
+export function resolveMethodSchemaPath(rootPath) {
+    const path = methodSchemaFilePath(rootPath);
     return existsSync(path) ? path : null;
 }
-export function workflowSchemaExists(rootPath) {
-    return existsSync(workflowSchemaFilePath(rootPath));
+export function methodSchemaExists(rootPath) {
+    return existsSync(methodSchemaFilePath(rootPath));
 }
-export function workflowSchemaRelativePath() {
-    return `workflow/${WORKFLOW_SCHEMA_FILE}`;
+export function methodSchemaRelativePath() {
+    return `method/${METHOD_SCHEMA_FILE}`;
 }
 export function listCompiledSchemaZones(schema) {
     return [...schema.zones];
@@ -85,13 +85,13 @@ function pushZone(zones, zone) {
         return;
     zones.push(zone);
 }
-function normalizeWorkflowSchema(schema) {
+function normalizeMethodSchema(schema) {
     return {
         ...schema,
-        kind: "workflow-schema",
+        kind: "method-schema",
     };
 }
-export function buildWorkflowSchema(stages, label = "Workflow schema") {
+export function buildMethodSchema(stages, label = "Method schema") {
     const zones = [];
     for (const zone of listBuiltinCompiledZoneSpecs()) {
         pushZone(zones, {
@@ -105,37 +105,37 @@ export function buildWorkflowSchema(stages, label = "Workflow schema") {
         });
     }
     return {
-        kind: "workflow-schema",
+        kind: "method-schema",
         version: 1,
         target_type: "compiled",
         label,
         zones,
     };
 }
-export function writeWorkflowSchemaFile(rootPath, stages, label) {
-    const schema = buildWorkflowSchema(stages, label);
-    writeWorkflowSchemaDocument(rootPath, schema);
+export function writeMethodSchemaFile(rootPath, stages, label) {
+    const schema = buildMethodSchema(stages, label);
+    writeMethodSchemaDocument(rootPath, schema);
     return schema;
 }
-export function writeWorkflowSchemaDocument(rootPath, schema) {
-    const normalized = normalizeWorkflowSchema(schema);
-    writeFileSync(workflowSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
+export function writeMethodSchemaDocument(rootPath, schema) {
+    const normalized = normalizeMethodSchema(schema);
+    writeFileSync(methodSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
     return normalized;
 }
-export function readWorkflowSchemaFile(rootPath) {
-    const path = workflowSchemaFilePath(rootPath);
+export function readMethodSchemaFile(rootPath) {
+    const path = methodSchemaFilePath(rootPath);
     if (!existsSync(path))
         return null;
-    const raw = readJsonFileUnchecked(path, "workflow schema");
+    const raw = readJsonFileUnchecked(path, "Method schema");
     if (raw === null)
         return null;
-    const parsed = WorkflowCompiledSchemaSchema.safeParse(raw);
+    const parsed = MethodCompiledSchemaSchema.safeParse(raw);
     if (!parsed.success) {
-        warnInterf(`Warning: failed to validate workflow schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        warnInterf(`Warning: failed to validate Method schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
         return null;
     }
-    return normalizeWorkflowSchema(parsed.data);
+    return normalizeMethodSchema(parsed.data);
 }
 export function readCompiledSchemaFile(rootPath) {
-    return readWorkflowSchemaFile(rootPath);
+    return readMethodSchemaFile(rootPath);
 }

package/dist/packages/compiler/compiled-stage-plan.d.ts

@@ -1,13 +1,13 @@
 import { type RuntimeStageContractDraft } from "./runtime.js";
-import { type CompiledWorkflowId, type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
+import { type MethodStageDefinition } from "../method-package/method-definitions.js";
 import { resolveCompiledContext, type CompiledStageExecutionDefinition } from "./compiled-target.js";
 import type { RuntimeStageInstructions } from "./lib/schema.js";
-export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<WorkflowStageDefinition, "id" | "reads" | "writes">): {
+export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<MethodStageDefinition, "id" | "reads" | "writes">): {
     reads: string[];
     writes: string[];
 };
-export declare function buildStageCounts(compiledPath: string, stageDefinition: WorkflowStageDefinition): Record<string, number>;
-export declare function buildStageContract(compiledPath: string, workflowId: CompiledWorkflowId, stageDefinition: WorkflowStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;
+export declare function buildStageCounts(compiledPath: string, stageDefinition: MethodStageDefinition): Record<string, number>;
+export declare function buildStageContract(compiledPath: string, stageDefinition: MethodStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;
 export declare function buildCompiledStageExecutionPlan(compiledPath: string, stageDefinition: CompiledStageExecutionDefinition): {
     context: ReturnType<typeof resolveCompiledContext>;
     contract: RuntimeStageContractDraft;

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

@@ -3,9 +3,9 @@ import { buildRuntimeStageContract, } from "./runtime.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { listFilesRecursive } from "../shared/filesystem.js";
 import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, workflowCompileStageDirectory, } from "../workflow-package/workflow-helpers.js";
-import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } from "../workflow-package/workflow-definitions.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../method-package/method-helpers.js";
+import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } from "../method-package/method-definitions.js";
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readInterfConfig } from "../project-model/interf-detect.js";
 import { resolveCompiledContext, } from "./compiled-target.js";
 function zoneArtifactCount(compiledPath, zonePath, kind) {
@@ -22,9 +22,9 @@ function zoneArtifactCount(compiledPath, zonePath, kind) {
     return listFilesRecursive(absolutePath).length;
 }
 export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     if (!schema) {
-        throw new Error(`Missing workflow schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
+        throw new Error(`Missing Method schema for stage "${stageDefinition.id}" at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
     return {
         reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
@@ -34,7 +34,7 @@ export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
 export function buildStageCounts(compiledPath, stageDefinition) {
     const context = resolveCompiledContext(compiledPath);
     const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zoneCounts = {};
     if (schema) {
         for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
@@ -51,7 +51,7 @@ export function buildStageCounts(compiledPath, stageDefinition) {
         ...zoneCounts,
     };
 }
-export function buildStageContract(compiledPath, workflowId, stageDefinition, instructions) {
+export function buildStageContract(compiledPath, stageDefinition, instructions) {
     const config = readInterfConfig(compiledPath);
     const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
     return buildRuntimeStageContract({
@@ -61,19 +61,19 @@ export function buildStageContract(compiledPath, workflowId, stageDefinition, in
         counts: buildStageCounts(compiledPath, stageDefinition),
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
-        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, workflowId, stageDefinition.id),
+        methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
         localSkillDocs: instructions.local_docs,
         instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, workflowId, stageDefinition.id),
+        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, stageDefinition.id),
     });
 }
 export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {
     const context = resolveCompiledContext(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 localSkills = buildLocalSkillContractExtension(compiledPath, [methodCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this Method stage while still honoring the declared reads, writes, and proof rules.");
     const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
     return {
         context,
         instructions,
-        contract: buildStageContract(compiledPath, context.workflowId, stageDefinition, instructions),
+        contract: buildStageContract(compiledPath, stageDefinition, instructions),
     };
 }

package/dist/packages/compiler/compiled-stage-runner.d.ts

@@ -1,10 +1,15 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
-import { type WorkflowReporter, type WorkflowStageResult } from "../workflow-package/workflow-helpers.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
+import { type MethodReporter, type MethodStageResult } from "../method-package/method-helpers.js";
 import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
+import { type RunEventSink } from "../execution/events.js";
 export declare function runCompiledStage(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     reportStep?: boolean;
     stageDefinition: CompiledStageExecutionDefinition;
-}): Promise<WorkflowStageResult>;
+    runId?: string;
+    events?: RunEventSink;
+    stageIndex?: number;
+    stageTotal?: number;
+}): Promise<MethodStageResult>;