@interf/compiler 0.9.1 → 0.9.3

package/dist/packages/{workflow-authoring/workflow-improvement.js → method-authoring/method-improvement.js}

@@ -1,15 +1,15 @@
 import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
-import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from "../agents/lib/shells.js";
-import { validateWorkflowPackage } from "../workflow-package/local-workflows.js";
-import { CONTEXT_INTERFACE_FILE } from "../workflow-package/context-interface.js";
+import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../agents/lib/shells.js";
+import { validateMethodPackage } from "../method-package/local-methods.js";
+import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { resolveWorkflowImprovementReviewPaths } from "../workflow-package/workflow-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, workflowImprovementRunRoot, workflowPackagePathForCompiled, } from "../compiler/compiled-paths.js";
+import { resolveMethodImprovementReviewPaths } from "../method-package/method-review-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../compiler/compiled-paths.js";
 import { readInterfConfig } from "../project-model/interf.js";
 import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { WorkflowImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
-import { runWorkflowEditSession } from "./workflow-edit-session.js";
+import { MethodImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
+import { runMethodEditSession } from "./method-edit-session.js";
 function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     if (!absolutePath)
         return null;
@@ -33,15 +33,15 @@ function buildLoopContext(options) {
     const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.compiledPath));
     const latestFailure = previousVariations.at(-1) ?? null;
     return {
-        kind: "interf-workflow-improvement-loop",
+        kind: "interf-method-improvement-loop",
         version: 1,
         generated_at: new Date().toISOString(),
         target_name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         loop_index: options.loopIndex,
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
-        review_paths: resolveWorkflowImprovementReviewPaths(options.compiledPath),
+        review_paths: resolveMethodImprovementReviewPaths(options.compiledPath),
         readiness_checks: {
             count: options.compiledConfig.checks.length,
             questions: options.compiledConfig.checks.map((check, index) => ({
@@ -53,86 +53,86 @@ function buildLoopContext(options) {
         latest_failure: latestFailure,
     };
 }
-function buildWorkflowImprovementPrompt() {
+function buildMethodImprovementPrompt() {
     return [
-        "This is an automated Interf workflow-improvement run, not an open-ended chat session.",
+        "This is an automated Interf Method-improvement run, not an open-ended chat session.",
         "The user already invoked this through `interf compile` with self-improving loops enabled. Execute it now.",
         "Read `runtime/loop-context.json` first.",
-        `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, \`workflow/${CONTEXT_INTERFACE_FILE}\`, and \`workflow/improve/SKILL.md\` if it exists.`,
-        "Review preserved evidence from earlier failures under `artifacts/` before you edit the workflow.",
-        "Treat `workflow/improve/SKILL.md` as guidance for how to improve the workflow, not as the default file to edit.",
-        "Treat the workflow package as four aligned layers: purpose, inputs, context interface, and stages.",
-        "Prefer editing the stage docs, workflow contract, input contract, or schema ownership that actually change compiled outputs.",
-        "Edit only files under `workflow/`.",
-        "Do not edit checks, test specs, raw dataset files, or generated compiled outputs.",
-        "Keep the workflow valid for the current compiler API and workflow schema.",
+        `Then read \`method/README.md\`, \`method/method.json\`, \`method/${CONTEXT_INTERFACE_FILE}\`, and \`method/improve/SKILL.md\` if it exists.`,
+        "Review preserved evidence from earlier failures under `artifacts/` before you edit the Method.",
+        "Treat `method/improve/SKILL.md` as guidance for how to improve the Method, not as the default file to edit.",
+        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
+        "Prefer editing the stage docs, Method contract, input contract, or schema ownership that actually change portable-context outputs.",
+        "Edit only files under `method/`.",
+        "Do not edit checks, test specs, raw source files, or generated portable-context outputs.",
+        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
         "Do not make one stage point at files or notes that are only created later by another stage.",
-        "Prefer small, defensible changes to workflow docs, stage docs, stage policies, or schema ownership over random churn.",
+        "Prefer small, defensible changes to Method docs, stage docs, stage policies, or schema ownership over random churn.",
         "Do not narrate plans or ask follow-up questions.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "As soon as the workflow edits are complete, stop.",
+        "As soon as the Method edits are complete, stop.",
     ].join("\n");
 }
-function updateCompiledWorkflowOrigin(options) {
+function updateCompiledMethodOrigin(options) {
     const current = readInterfConfig(options.compiledPath);
     if (!current)
         return;
     const nextConfig = {
         ...current,
-        workflow: current.workflow ?? options.selectedWorkflowId,
-        workflow_origin: {
-            selected: options.selectedWorkflowId,
+        method: current.method ?? options.selectedMethodId,
+        method_origin: {
+            selected: options.selectedMethodId,
             ...(options.localDraft ? { local_draft: true } : {}),
         },
     };
     saveCompiledInterfConfig(options.compiledPath, nextConfig);
 }
-function workflowImprovementRunLedgerPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "run.json");
+function methodImprovementRunLedgerPath(compiledPath, runId) {
+    return join(methodImprovementRunRoot(compiledPath, runId), "run.json");
 }
-function workflowImprovementLoopHistoryPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
+function methodImprovementLoopHistoryPath(compiledPath, runId) {
+    return join(methodImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
 }
-function workflowImprovementLoopRecordPath(loopRootPath) {
+function methodImprovementLoopRecordPath(loopRootPath) {
     return join(loopRootPath, "loop.json");
 }
-function readWorkflowImprovementRunLedger(compiledPath, runId) {
-    const ledgerPath = workflowImprovementRunLedgerPath(compiledPath, runId);
+function readMethodImprovementRunLedger(compiledPath, runId) {
+    const ledgerPath = methodImprovementRunLedgerPath(compiledPath, runId);
     if (!existsSync(ledgerPath))
         return null;
-    return readJsonFileWithSchema(ledgerPath, "workflow improvement run ledger", WorkflowImprovementRunLedgerSchema);
+    return readJsonFileWithSchema(ledgerPath, "Method improvement run ledger", MethodImprovementRunLedgerSchema);
 }
-function writeWorkflowImprovementRunLedger(compiledPath, runId, record, options) {
-    const runRoot = workflowImprovementRunRoot(compiledPath, runId);
+function writeMethodImprovementRunLedger(compiledPath, runId, record, options) {
+    const runRoot = methodImprovementRunRoot(compiledPath, runId);
     mkdirSync(runRoot, { recursive: true });
-    const existing = readWorkflowImprovementRunLedger(compiledPath, runId);
+    const existing = readMethodImprovementRunLedger(compiledPath, runId);
     const generatedAt = existing?.generated_at ?? new Date().toISOString();
     const ledger = {
-        kind: "interf-workflow-improvement-run",
+        kind: "interf-method-improvement-run",
         version: 1,
         generated_at: generatedAt,
         updated_at: new Date().toISOString(),
         run_id: runId,
         target_name: options.targetName,
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
         loops: [...(existing?.loops ?? []), record],
     };
-    writeFileSync(workflowImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
-    writeFileSync(workflowImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
-    appendFileSync(workflowImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
+    writeFileSync(methodImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
+    writeFileSync(methodImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
+    appendFileSync(methodImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
 }
-function buildWorkflowImprovementLoopRecord(options) {
+function buildMethodImprovementLoopRecord(options) {
     return {
-        kind: "interf-workflow-improvement-loop-record",
+        kind: "interf-method-improvement-loop-record",
         version: 1,
         recorded_at: new Date().toISOString(),
         run_id: options.runId,
         loop_index: options.loopIndex,
         target_name: options.targetName,
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         result: options.result,
         changed: options.changed,
         applied: options.result === "updated",
@@ -140,8 +140,8 @@ function buildWorkflowImprovementLoopRecord(options) {
         shell_path: options.shellPath,
         loop_root_path: options.loopRootPath,
         context_path: join(options.shellPath, "runtime", "loop-context.json"),
-        workflow_before_path: options.workflowBeforePath,
-        workflow_after_path: options.workflowAfterPath,
+        method_before_path: options.methodBeforePath,
+        method_after_path: options.methodAfterPath,
         prompt_log_path: options.promptLogPath,
         event_log_path: options.eventLogPath,
         status_log_path: options.statusLogPath,
@@ -149,36 +149,36 @@ function buildWorkflowImprovementLoopRecord(options) {
         validation: options.validation,
     };
 }
-export async function runWorkflowImprovementLoop(options) {
+export async function runMethodImprovementLoop(options) {
     const compiledName = readInterfConfig(options.compiledPath)?.name ?? "compiled";
     const context = buildLoopContext(options);
-    const shell = createWorkflowImprovementShell({
+    const shell = createMethodImprovementShell({
         compiledPath: options.compiledPath,
         compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         runId: options.runId,
         loopIndex: options.loopIndex,
         context,
     });
-    const workflowRoot = workflowPackagePathForCompiled(options.compiledPath);
-    const session = await runWorkflowEditSession({
+    const methodRoot = methodPackagePathForCompiled(options.compiledPath);
+    const session = await runMethodEditSession({
         executor: options.executor,
-        workflowPath: workflowRoot,
+        methodPath: methodRoot,
         shell,
-        prompt: buildWorkflowImprovementPrompt(),
-        validate: validateWorkflowPackage,
+        prompt: buildMethodImprovementPrompt(),
+        validate: validateMethodPackage,
         maxValidationRepairAttempts: 1,
     });
-    const preservedShellManifestPath = freezeWorkflowImprovementShell(shell.rootPath);
-    writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+    const preservedShellManifestPath = freezeMethodImprovementShell(shell.rootPath);
+    writeMethodImprovementRunLedger(options.compiledPath, options.runId, buildMethodImprovementLoopRecord({
         targetName: compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         runId: options.runId,
         loopIndex: options.loopIndex,
         shellPath: shell.rootPath,
         loopRootPath: shell.loopRootPath,
-        workflowBeforePath: shell.workflowBeforePath,
-        workflowAfterPath: shell.workflowAfterPath,
+        methodBeforePath: shell.methodBeforePath,
+        methodAfterPath: shell.methodAfterPath,
         promptLogPath: shell.promptLogPath,
         eventLogPath: shell.eventLogPath,
         statusLogPath: shell.statusLogPath,
@@ -189,14 +189,14 @@ export async function runWorkflowImprovementLoop(options) {
         summary: session.summary,
     }), {
         targetName: compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         maxLoops: options.maxLoops,
         maxAttempts: options.maxAttempts,
     });
     if (session.status === "updated") {
-        updateCompiledWorkflowOrigin({
+        updateCompiledMethodOrigin({
             compiledPath: options.compiledPath,
-            selectedWorkflowId: options.workflowId,
+            selectedMethodId: options.methodId,
             localDraft: true,
         });
     }

package/dist/packages/{workflow-package/builtin-compiled-workflow.d.ts → method-package/builtin-compiled-method.d.ts}

@@ -1,4 +1,4 @@
-import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "../compiler/workflow-primitives.js";
+import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "../compiler/method-primitives.js";
 export declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";

package/dist/packages/{workflow-package/builtin-compiled-workflow.js → method-package/builtin-compiled-method.js}

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { z } from "zod";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { COMPILED_ZONE_KINDS } from "../compiler/workflow-primitives.js";
-import { WorkflowCompiledSchemaSchema } from "../compiler/lib/schema.js";
+import { COMPILED_ZONE_KINDS } from "../compiler/method-primitives.js";
+import { MethodCompiledSchemaSchema } from "../compiler/lib/schema.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
 export const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",
@@ -20,44 +20,44 @@ export const BUILTIN_COMPILED_ZONE_IDS = {
 };
 const BUILTIN_ZONE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ZONE_IDS));
 const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
-const BuiltinWorkflowStageSchema = z.object({
+const BuiltinMethodStageSchema = z.object({
     id: z.string(),
     contract_type: z.string(),
     reads: z.array(z.string()).min(1),
     writes: z.array(z.string()).min(1),
 });
-const BuiltinWorkflowPackageSchema = z.object({
-    stages: z.array(BuiltinWorkflowStageSchema).min(1),
+const BuiltinMethodPackageSchema = z.object({
+    stages: z.array(BuiltinMethodStageSchema).min(1),
 });
 let builtinCompiledContractCache = null;
-function builtinWorkflowRootPath() {
-    return join(PACKAGE_ROOT, "builtin-workflows", "interf");
+function builtinMethodRootPath() {
+    return join(PACKAGE_ROOT, "builtin-methods", "interf-default");
 }
-function builtinWorkflowPath(relativePath) {
-    return join(builtinWorkflowRootPath(), relativePath);
+function builtinMethodPath(relativePath) {
+    return join(builtinMethodRootPath(), relativePath);
 }
 function assertBuiltinZoneId(value) {
     if (!BUILTIN_ZONE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow schema declares unsupported zone id "${value}".`);
+        throw new Error(`Built-in Interf Method schema declares unsupported zone id "${value}".`);
     }
     return value;
 }
 function assertBuiltinStageId(value) {
     if (!BUILTIN_STAGE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow package declares unsupported stage id "${value}".`);
+        throw new Error(`Built-in Interf Method package declares unsupported stage id "${value}".`);
     }
     return value;
 }
 function loadBuiltinCompiledContract() {
     if (builtinCompiledContractCache)
         return builtinCompiledContractCache;
-    const schema = readJsonFileWithSchema(builtinWorkflowPath("workflow.schema.json"), "built-in Interf workflow schema", WorkflowCompiledSchemaSchema);
+    const schema = readJsonFileWithSchema(builtinMethodPath("method.schema.json"), "built-in Interf Method schema", MethodCompiledSchemaSchema);
     if (!schema) {
-        throw new Error(`Missing or invalid built-in workflow schema at ${builtinWorkflowPath("workflow.schema.json")}.`);
+        throw new Error(`Missing or invalid built-in Method schema at ${builtinMethodPath("method.schema.json")}.`);
     }
-    const workflow = readJsonFileWithSchema(builtinWorkflowPath("workflow.json"), "built-in Interf workflow package", BuiltinWorkflowPackageSchema);
-    if (!workflow) {
-        throw new Error(`Missing or invalid built-in workflow package at ${builtinWorkflowPath("workflow.json")}.`);
+    const method = readJsonFileWithSchema(builtinMethodPath("method.json"), "built-in Interf Method package", BuiltinMethodPackageSchema);
+    if (!method) {
+        throw new Error(`Missing or invalid built-in Method package at ${builtinMethodPath("method.json")}.`);
     }
     const zones = schema.zones.map((zone) => ({
         id: assertBuiltinZoneId(zone.id),
@@ -67,7 +67,7 @@ function loadBuiltinCompiledContract() {
         required: zone.required,
         description: zone.description,
     }));
-    const stages = workflow.stages.map((stage) => ({
+    const stages = method.stages.map((stage) => ({
         id: assertBuiltinStageId(stage.id),
         contract_type: stage.contract_type,
         reads: stage.reads.map(assertBuiltinZoneId),

package/dist/packages/{workflow-package → method-package}/context-interface.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "../compiler/lib/schema.js";
-export declare const CONTEXT_INTERFACE_FILE = "workflow.schema.json";
+import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../compiler/lib/schema.js";
+export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"workflow-schema">;
+    kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
@@ -17,8 +17,8 @@ export declare const ContextInterfaceSchema: 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>;
@@ -36,8 +36,8 @@ export declare const ContextInterfaceZoneSchema: 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>;
@@ -50,25 +50,25 @@ export declare const ContextInterfaceZoneRoleSchema: z.ZodEnum<{
     input: "input";
     working: "working";
 }>;
-export declare const WorkflowInputSpecSchema: z.ZodObject<{
+export declare const MethodInputSpecSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export declare const WorkflowInputContractSchema: z.ZodArray<z.ZodObject<{
+export declare const MethodInputContractSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
-export type ContextInterface = WorkflowCompiledSchema;
-export type ContextInterfaceZone = WorkflowCompiledZone;
-export type ContextInterfaceZoneId = WorkflowZoneId;
+export type ContextInterface = MethodCompiledSchema;
+export type ContextInterfaceZone = MethodCompiledZone;
+export type ContextInterfaceZoneId = MethodZoneId;
 export type ContextInterfaceZoneRole = z.infer<typeof ContextInterfaceZoneRoleSchema>;
-export type WorkflowInputSpec = z.infer<typeof WorkflowInputSpecSchema>;
+export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
 export interface ContextInterfaceStageLike {
     id: string;
     writes: readonly string[];
@@ -89,7 +89,7 @@ export declare function contextInterfaceZoneAbsolutePath(compiledPath: string, z
 export declare function contextInterfaceArtifactPath(zone: Pick<ContextInterfaceZone, "path" | "kind">): string;
 export declare function contextInterfaceArtifactPathsForZoneIds(contextInterface: ContextInterface, zoneIds: readonly ContextInterfaceZoneId[]): string[];
 export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
-export declare function deriveWorkflowInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): WorkflowInputSpec[];
+export declare function deriveMethodInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): MethodInputSpec[];
 export declare function buildContextInterface(stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterfaceFile(rootPath: string, stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterface(rootPath: string, contextInterface: ContextInterface): ContextInterface;

package/dist/packages/{workflow-package → method-package}/context-interface.js

@@ -3,32 +3,32 @@ import { join } from "node:path";
 import { z } from "zod";
 import { warnInterf } from "../shared/logger.js";
 import { readJsonFileUnchecked } from "../shared/parse.js";
-import { WorkflowCompiledSchemaSchema, WorkflowCompiledZoneSchema, WorkflowZoneIdSchema, WorkflowZoneRoleSchema, } from "../compiler/lib/schema.js";
-import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-workflow.js";
-// Workflow packages define the context interface. The compiler persists the
+import { MethodCompiledSchemaSchema, MethodCompiledZoneSchema, MethodZoneIdSchema, MethodZoneRoleSchema, } from "../compiler/lib/schema.js";
+import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-method.js";
+// Method packages define the context interface. The compiler persists the
 // same schema on disk, but higher layers should prefer this boundary when they
-// mean "the workflow-declared shape a compiled context must implement."
-export const CONTEXT_INTERFACE_FILE = "workflow.schema.json";
-export const ContextInterfaceSchema = WorkflowCompiledSchemaSchema;
-export const ContextInterfaceZoneSchema = WorkflowCompiledZoneSchema;
-export const ContextInterfaceZoneIdSchema = WorkflowZoneIdSchema;
-export const ContextInterfaceZoneRoleSchema = WorkflowZoneRoleSchema;
+// mean "the Method-declared shape a portable context must implement."
+export const CONTEXT_INTERFACE_FILE = "method.schema.json";
+export const ContextInterfaceSchema = MethodCompiledSchemaSchema;
+export const ContextInterfaceZoneSchema = MethodCompiledZoneSchema;
+export const ContextInterfaceZoneIdSchema = MethodZoneIdSchema;
+export const ContextInterfaceZoneRoleSchema = MethodZoneRoleSchema;
 // Package-owned input contract for authoring, review, and future authoring flows.
 // This does not change compiler execution semantics; it describes what data a
-// workflow expects to organize before the compiler materializes the context
+// Method expects to organize before the compiler materializes the context
 // interface on disk.
-export const WorkflowInputSpecSchema = z.object({
-    id: WorkflowZoneIdSchema,
+export const MethodInputSpecSchema = z.object({
+    id: MethodZoneIdSchema,
     label: z.string().min(1),
     description: z.string().min(1),
     required: z.boolean().default(false),
     examples: z.array(z.string().min(1)).optional(),
 }).strict();
-export const WorkflowInputContractSchema = z.array(WorkflowInputSpecSchema);
+export const MethodInputContractSchema = z.array(MethodInputSpecSchema);
 function normalizeContextInterface(contextInterface) {
     return {
         ...contextInterface,
-        kind: "workflow-schema",
+        kind: "method-schema",
     };
 }
 function pushContextInterfaceZone(zones, zone) {
@@ -87,7 +87,7 @@ export function summarizeContextInterface(contextInterface) {
         runtimeZones: contextInterface.zones.filter((zone) => zone.role === "runtime"),
     };
 }
-export function deriveWorkflowInputsFromContextInterface(contextInterface) {
+export function deriveMethodInputsFromContextInterface(contextInterface) {
     if (!contextInterface)
         return [];
     return contextInterface.zones
@@ -99,7 +99,7 @@ export function deriveWorkflowInputsFromContextInterface(contextInterface) {
         required: zone.required,
     }));
 }
-export function buildContextInterface(stages, label = "Workflow context interface") {
+export function buildContextInterface(stages, label = "Method context interface") {
     const zones = [];
     for (const zone of listBuiltinCompiledZoneSpecs()) {
         pushContextInterfaceZone(zones, {
@@ -113,7 +113,7 @@ export function buildContextInterface(stages, label = "Workflow context interfac
         });
     }
     return {
-        kind: "workflow-schema",
+        kind: "method-schema",
         version: 1,
         target_type: "compiled",
         label,
@@ -134,12 +134,12 @@ export function readContextInterface(rootPath) {
     const path = contextInterfaceFilePath(rootPath);
     if (!existsSync(path))
         return null;
-    const raw = readJsonFileUnchecked(path, "workflow context interface");
+    const raw = readJsonFileUnchecked(path, "Method context interface");
     if (raw === null)
         return null;
     const parsed = ContextInterfaceSchema.safeParse(raw);
     if (!parsed.success) {
-        warnInterf(`Warning: failed to validate workflow context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        warnInterf(`Warning: failed to validate Method context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
         return null;
     }
     return normalizeContextInterface(parsed.data);

package/dist/packages/method-package/index.d.ts

@@ -0,0 +1,11 @@
+export * as builtinMethod from "./builtin-compiled-method.js";
+export * as contextInterface from "./context-interface.js";
+export * as localMethods from "./local-methods.js";
+export * as packageWriters from "./interf-method-package.js";
+export * as methodDefinitions from "./method-definitions.js";
+export * as methodHelpers from "./method-helpers.js";
+export * as methodStagePolicy from "./method-stage-policy.js";
+export * as methodStageRunner from "./method-stage-runner.js";
+export * as methodReviewPaths from "./method-review-paths.js";
+export * as packageRoot from "./lib/package-root.js";
+export { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, ContextInterfaceZoneSchema, ContextInterfaceZoneIdSchema, ContextInterfaceZoneRoleSchema, MethodInputSpecSchema, MethodInputContractSchema, contextInterfaceFilePath, resolveContextInterfacePath, contextInterfaceExists, contextInterfaceRelativePath, listContextInterfaceZones, findContextInterfaceZone, contextInterfaceZoneAbsolutePath, contextInterfaceArtifactPath, contextInterfaceArtifactPathsForZoneIds, buildContextInterface, writeContextInterfaceFile, writeContextInterface, readContextInterface, type ContextInterface, type ContextInterfaceZone, type ContextInterfaceZoneId, type ContextInterfaceZoneRole, type ContextInterfaceStageLike, type MethodInputSpec, type ContextInterfaceSummary, summarizeContextInterface, deriveMethodInputsFromContextInterface, } from "./context-interface.js";

package/dist/packages/method-package/index.js

@@ -0,0 +1,11 @@
+export * as builtinMethod from "./builtin-compiled-method.js";
+export * as contextInterface from "./context-interface.js";
+export * as localMethods from "./local-methods.js";
+export * as packageWriters from "./interf-method-package.js";
+export * as methodDefinitions from "./method-definitions.js";
+export * as methodHelpers from "./method-helpers.js";
+export * as methodStagePolicy from "./method-stage-policy.js";
+export * as methodStageRunner from "./method-stage-runner.js";
+export * as methodReviewPaths from "./method-review-paths.js";
+export * as packageRoot from "./lib/package-root.js";
+export { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, ContextInterfaceZoneSchema, ContextInterfaceZoneIdSchema, ContextInterfaceZoneRoleSchema, MethodInputSpecSchema, MethodInputContractSchema, contextInterfaceFilePath, resolveContextInterfacePath, contextInterfaceExists, contextInterfaceRelativePath, listContextInterfaceZones, findContextInterfaceZone, contextInterfaceZoneAbsolutePath, contextInterfaceArtifactPath, contextInterfaceArtifactPathsForZoneIds, buildContextInterface, writeContextInterfaceFile, writeContextInterface, readContextInterface, summarizeContextInterface, deriveMethodInputsFromContextInterface, } from "./context-interface.js";

package/dist/packages/method-package/interf-method-package.d.ts

@@ -0,0 +1,31 @@
+import { type MethodDefinition } from "./method-definitions.js";
+export declare function writeCompiledMethodPackage(compiledPath: string, method: MethodDefinition<string>): void;
+export declare function writeMethodPackageToDir(methodDir: string, method: MethodDefinition<string>, options?: {
+    overwrite?: boolean;
+}): void;
+export declare function seedCompiledMethodPackage(options: {
+    compiledPath: string;
+    sourcePath: string;
+    methodId: string;
+}): void;
+export declare function createLocalMethodPackageFromTemplate(options: {
+    sourcePath: string;
+    baseMethodId: string;
+    methodId: string;
+    label: string;
+    hint: string;
+    stagePolicyNotes: Record<string, string[]>;
+}): string;
+export declare function seedLocalMethodPackageFromBase(options: {
+    sourcePath: string;
+    baseMethodId: string;
+    methodId: string;
+    label: string;
+    hint: string;
+}): string;
+export declare function createScratchLocalMethodPackage(options: {
+    sourcePath: string;
+    methodId: string;
+    label: string;
+    hint: string;
+}): string;