@interf/compiler 0.9.1 → 0.9.4

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,7 +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,8 +1,6 @@
 export declare const COMPILED_INTERF_DIR = ".interf";
 export declare const COMPILED_CONFIG_FILE = "interf.json";
 export declare const COMPILED_METHOD_DIR = "method";
-export declare const COMPILED_WORKFLOW_DIR = "method";
-export declare const LEGACY_COMPILED_WORKFLOW_DIR = "workflow";
 export declare const COMPILED_TEST_DIR = "tests";
 export declare const COMPILED_TEST_TARGETS_DIR = "targets";
 export declare const COMPILED_RUNTIME_DIR = "runtime";
@@ -18,14 +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 legacyWorkflowPackagePathForCompiled(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

@@ -2,8 +2,6 @@ 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_METHOD_DIR = "method";
-export const COMPILED_WORKFLOW_DIR = COMPILED_METHOD_DIR;
-export const LEGACY_COMPILED_WORKFLOW_DIR = "workflow";
 export const COMPILED_TEST_DIR = "tests";
 export const COMPILED_TEST_TARGETS_DIR = "targets";
 export const COMPILED_RUNTIME_DIR = "runtime";
@@ -27,11 +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 legacyWorkflowPackagePathForCompiled(compiledPath) {
-    return join(compiledInterfRoot(compiledPath), LEGACY_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);
@@ -42,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");
@@ -96,15 +91,14 @@ export function resolveSourceControlPathForCompiled(compiledPath) {
         const parent = dirname(cursor);
         if (basename(parent) === "interf" &&
             basename(cursor) !== "tests" &&
-            basename(cursor) !== "methods" &&
-            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,9 +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";
 import type { RunEventSink } from "../execution/events.js";
-export interface CompiledSummarizeResult extends WorkflowStageResult {
-    skipped: boolean;
+export interface CompiledSummarizeResult extends MethodStageResult {
     plan: {
         sourceCount: number;
         summaryCount: number;
@@ -12,14 +11,14 @@ 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;
@@ -28,18 +27,18 @@ export declare function runCompiledSummarize(options: {
     events?: RunEventSink;
 }): Promise<CompiledSummarizeResult>;
 export declare function runCompiledCompile(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     reportStep?: boolean;
     preserveStageShells?: StageShellRetentionMode;
     runId?: string;
     events?: RunEventSink;
-}): Promise<WorkflowStageResult>;
+}): Promise<MethodStageResult>;
 export declare function compileCompiled(options: {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     preserveStageShells?: StageShellRetentionMode;
     runId?: string;
     events?: RunEventSink;

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

@@ -1,25 +1,25 @@
 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 { workflowPackagePathForCompiled } from "./compiled-paths.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;
@@ -34,7 +34,6 @@ export async function runCompiledSummarize(options) {
     });
     return {
         ...result,
-        skipped: false,
         plan: {
             sourceCount,
             summaryCount: 0,
@@ -50,7 +49,7 @@ export async function runCompiledCompile(options) {
     let lastResult = { ok: true, code: 0 };
     try {
         const context = resolveCompiledContext(options.compiledPath);
-        const stages = 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,
@@ -77,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);
     }
@@ -89,25 +89,25 @@ export async function compileCompiled(options) {
         const sourceInputPath = resolveSourceInputPath(options.compiledPath);
         syncCompiledRawSnapshot(options.compiledPath, sourceInputPath);
         refreshCompiledBootstrapGuidance(options.compiledPath);
-        const workflowValidation = validateWorkflowPackage(workflowPackagePathForCompiled(options.compiledPath));
-        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);
+        const stages = compiledExecutionStages(context.methodId, options.compiledPath);
         for (const [index, stageDefinition] of stages.entries()) {
             const stageResult = await runCompiledStage({
                 executor: options.executor,
@@ -127,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 `method/${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 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, 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])) {
@@ -61,7 +61,7 @@ export function buildStageContract(compiledPath, stageDefinition, instructions)
         counts: buildStageCounts(compiledPath, stageDefinition),
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
-        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
+        methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
         localSkillDocs: instructions.local_docs,
         instructions,
         acceptance: resolveActiveCompiledStageAcceptance(compiledPath, stageDefinition.id),
@@ -69,7 +69,7 @@ export function buildStageContract(compiledPath, stageDefinition, instructions)
 }
 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,

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

@@ -1,15 +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;
     runId?: string;
     events?: RunEventSink;
     stageIndex?: number;
     stageTotal?: number;
-}): Promise<WorkflowStageResult>;
+}): Promise<MethodStageResult>;

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

@@ -2,9 +2,9 @@ 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) {
@@ -15,9 +15,9 @@ export async function runCompiledStage(options) {
     const plan = buildCompiledStageExecutionPlan(options.compiledPath, stageDefinition);
     if (options.reportStep !== false) {
         reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, 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 {
         if (options.runId && options.events) {
             await emitRunEvent(options.events, {
@@ -35,8 +35,8 @@ export async function runCompiledStage(options) {
             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()}.`,

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[];