@interf/compiler 0.9.1 → 0.9.3

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

@@ -1,15 +1,15 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { renderCompiledQuerySkill } from "../agents/lib/shells.js";
-import { copyWorkflowPackageDirectory, isPortableWorkflowPackage, patchWorkflowPackageMetadata, resolveWorkflowPackageSourcePath, workflowDefinitionPath, } from "./local-workflows.js";
-import { getCompiledWorkflow, } from "./workflow-definitions.js";
-import { CONTEXT_INTERFACE_FILE, deriveWorkflowInputsFromContextInterface, summarizeContextInterface, writeContextInterface, writeContextInterfaceFile, } from "./context-interface.js";
-import { workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { mergeStagePolicyNotesForStages } from "./workflow-stage-policy.js";
-function workflowPackagePath(dirPath) {
-    return workflowPackagePathForCompiled(dirPath);
+import { copyMethodPackageDirectory, isPortableMethodPackage, patchMethodPackageMetadata, resolveMethodPackageSourcePath, methodDefinitionPath, } from "./local-methods.js";
+import { getCompiledMethod, } from "./method-definitions.js";
+import { CONTEXT_INTERFACE_FILE, deriveMethodInputsFromContextInterface, summarizeContextInterface, writeContextInterface, writeContextInterfaceFile, } from "./context-interface.js";
+import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { mergeStagePolicyNotesForStages } from "./method-stage-policy.js";
+function methodPackagePath(dirPath) {
+    return methodPackagePathForCompiled(dirPath);
 }
-function writeWorkflowStarterDocs(dirPath, docs, options) {
+function writeMethodStarterDocs(dirPath, docs, options) {
     for (const doc of docs ?? []) {
         const targetPath = join(dirPath, doc.relativePath);
         if (!options.overwrite && existsSync(targetPath))
@@ -18,32 +18,32 @@ function writeWorkflowStarterDocs(dirPath, docs, options) {
         writeFileSync(targetPath, doc.content);
     }
 }
-function writeWorkflowPackageJson(rootPath, workflow, options) {
-    const targetPath = join(rootPath, "workflow.json");
+function writeMethodPackageJson(rootPath, method, options) {
+    const targetPath = join(rootPath, "method.json");
     if (!options.overwrite && existsSync(targetPath))
         return;
-    const inputs = workflow.inputs?.length
-        ? workflow.inputs
-        : deriveWorkflowInputsFromContextInterface(workflow.contextInterface ?? workflow.schema);
+    const inputs = method.inputs?.length
+        ? method.inputs
+        : deriveMethodInputsFromContextInterface(method.contextInterface ?? method.schema);
     writeFileSync(targetPath, `${JSON.stringify({
-        id: workflow.id,
+        id: method.id,
         type: "compiled",
-        compiler_api: workflow.compilerApi ?? {
+        compiler_api: method.compilerApi ?? {
             kind: "compiled",
             version: 1,
         },
-        ...(workflow.purpose
+        ...(method.purpose
             ? {
                 purpose: {
-                    label: workflow.purpose.label,
-                    task_hint: workflow.purpose.taskHint,
+                    label: method.purpose.label,
+                    task_hint: method.purpose.taskHint,
                 },
             }
             : {}),
         ...(inputs.length > 0 ? { inputs } : {}),
-        label: workflow.label,
-        hint: workflow.hint,
-        stages: workflow.stages.map((stage) => ({
+        label: method.label,
+        hint: method.hint,
+        stages: method.stages.map((stage) => ({
             id: stage.id,
             label: stage.label,
             description: stage.description,
@@ -53,12 +53,12 @@ function writeWorkflowPackageJson(rootPath, workflow, options) {
             writes: stage.writes,
             ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
         })),
-        ...(workflow.stagePolicyNotes ? { stage_policy_notes: workflow.stagePolicyNotes } : {}),
+        ...(method.stagePolicyNotes ? { stage_policy_notes: method.stagePolicyNotes } : {}),
     }, null, 2)}\n`);
 }
-function renderWorkflowReadme(workflow) {
-    const contextInterface = workflow.contextInterface ?? workflow.schema ?? null;
-    const stageLines = workflow.stages
+function renderMethodReadme(method) {
+    const contextInterface = method.contextInterface ?? method.schema ?? null;
+    const stageLines = method.stages
         .map((stage) => `- \`${stage.id}\` — ${stage.description} (${stage.contractType}; reads: ${stage.reads.join(", ")}; writes: ${stage.writes.join(", ")})`)
         .join("\n");
     const interfaceSummary = contextInterface
@@ -69,9 +69,9 @@ function renderWorkflowReadme(workflow) {
             .map((zone) => `- \`${zone.id}\` — ${zone.role} ${zone.kind} at \`${zone.path}\`: ${zone.description}`)
             .join("\n")
         : null;
-    const inputs = workflow.inputs?.length
-        ? workflow.inputs
-        : deriveWorkflowInputsFromContextInterface(contextInterface);
+    const inputs = method.inputs?.length
+        ? method.inputs
+        : deriveMethodInputsFromContextInterface(contextInterface);
     const inputLines = inputs.length > 0
         ? inputs
             .map((input) => `- \`${input.id}\` — ${input.label}: ${input.description}${input.required ? " (required)" : ""}${input.examples?.length ? ` Example inputs: ${input.examples.join("; ")}` : ""}`)
@@ -86,16 +86,16 @@ function renderWorkflowReadme(workflow) {
         ].join("\n")
         : null;
     return [
-        `# ${workflow.label}`,
+        `# ${method.label}`,
         "",
-        workflow.hint,
-        ...(workflow.purpose
+        method.hint,
+        ...(method.purpose
             ? [
                 "",
                 "## Purpose",
                 "",
-                `- ${workflow.purpose.label}`,
-                `- ${workflow.purpose.taskHint}`,
+                `- ${method.purpose.label}`,
+                `- ${method.purpose.taskHint}`,
             ]
             : []),
         ...(inputLines
@@ -125,11 +125,11 @@ function renderWorkflowReadme(workflow) {
         "",
         "## Package",
         "",
-        "- `workflow.json` = stage graph, compiler API target, and compile contract mapping",
-        "- `workflow.schema.json` = deterministic context interface for the workflow package",
+        "- `method.json` = stage graph, compiler API target, and compile contract mapping",
+        "- `method.schema.json` = deterministic context interface for the Method package",
         "- `improve/`, `compile/stages/`, and `use/query/` = human-readable authoring docs",
-        "- Portable workflow packages are standalone: explicit stages, schema, and docs live together in this folder",
-        "- Interf projects native agent shells from these docs for query use, stage execution, and workflow-improvement loops",
+        "- Portable Method packages are standalone: explicit stages, schema, and docs live together in this folder",
+        "- Interf projects native agent shells from these docs for query use, stage execution, and Method-improvement loops",
         "",
         "## Stages",
         "",
@@ -139,14 +139,14 @@ function renderWorkflowReadme(workflow) {
         "",
     ].join("\n");
 }
-function renderDerivedWorkflowReadme(options) {
+function renderDerivedMethodReadme(options) {
     return [
         `# ${options.label}`,
         "",
         options.hint,
         "",
-        `This workflow package was forked from \`${options.baseWorkflowId}\` and materialized as a standalone package for this kind of work.`,
-        "It starts with that workflow's topology; edit the package when the work needs different stages, zones, or proof.",
+        `This Method package was forked from \`${options.baseMethodId}\` and materialized as a standalone package for this kind of agent work.`,
+        "It starts with that Method's topology; edit the package when the agent work needs different stages, zones, or proof.",
         "",
         "Interf runs the local copy of this package directly. Keep purpose, inputs, context interface, and stage docs self-contained in this folder instead of relying on runtime inheritance.",
         "",
@@ -158,58 +158,58 @@ function renderDerivedWorkflowReadme(options) {
         "",
     ].join("\n");
 }
-function renderSeedWorkflowReadme(options) {
+function renderSeedMethodReadme(options) {
     return [
         `# ${options.label}`,
         "",
         options.hint,
         "",
-        `This workflow package was forked from \`${options.baseWorkflowId}\` as a standalone local package.`,
-        "It starts with that workflow's topology; edit the package when the work needs different stages, zones, or proof.",
+        `This Method package was forked from \`${options.baseMethodId}\` as a standalone local package.`,
+        "It starts with that Method's topology; edit the package when the agent work needs different stages, zones, or proof.",
         "",
         "Interf runs the local copy of this package directly. Refine purpose, inputs, context interface, and stage instructions in this folder instead of relying on inheritance.",
         "",
     ].join("\n");
 }
-function renderScratchWorkflowReadme(options) {
+function renderScratchMethodReadme(options) {
     return [
         `# ${options.label}`,
         "",
         options.hint,
         "",
-        "This workflow package is a neutral from-scratch authoring scaffold.",
+        "This Method package is a neutral from-scratch authoring scaffold.",
         "",
         "It is not copied from `interf-default`, and its placeholder stage is not a recommended topology.",
-        "Replace purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the workflow this source data and task actually need.",
+        "Replace purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this source data and task actually need.",
         "",
     ].join("\n");
 }
-function renderImproveSkill(workflow) {
+function renderImproveSkill(method) {
     return [
-        "# Workflow Improvement",
+        "# Method Improvement",
         "",
-        `Workflow: ${workflow.id}`,
+        `Method: ${method.id}`,
         "",
-        "This file is the editable authoring source for Interf's generated native workflow-improver shell.",
+        "This file is the editable authoring source for Interf's generated native Method-improver shell.",
         "The improver edits this local package directly.",
         "",
         "Default loop:",
         "1. Read the loop context first.",
         "2. Review preserved stage shells, runtime logs, and saved test runs from failed attempts.",
-        "3. Edit only the local Method package for this portable context to create a better Method variation for this kind of work.",
-        `4. Keep purpose, inputs, \`workflow.json\`, \`${CONTEXT_INTERFACE_FILE}\`, and any changed stage docs aligned.`,
+        "3. Edit only the local Method package for this portable context to create a better Method variation for this kind of agent work.",
+        `4. Keep purpose, inputs, \`method.json\`, \`${CONTEXT_INTERFACE_FILE}\`, and any changed stage docs aligned.`,
         "",
         "Guardrails:",
         "- do not edit checks, test specs, or raw files",
-        "- do not hardcode expected answers into workflow docs",
-        "- keep this package standalone; do not add or rely on runtime `extends`",
-        "- keep the workflow stack coherent: purpose, inputs, context interface, and stages should describe the same job",
-        "- prefer small, defensible workflow changes over random churn",
+        "- do not hardcode expected answers into Method docs",
+        "- keep this package standalone; do not rely on runtime inheritance",
+        "- keep the Method stack coherent: purpose, inputs, context interface, and stages should describe the same job",
+        "- prefer small, defensible Method changes over random churn",
         "",
     ].join("\n");
 }
-function renderStageSkill(workflow, stage) {
-    const notes = workflow.stagePolicyNotes?.[stage.id] ?? [];
+function renderStageSkill(method, stage) {
+    const notes = method.stagePolicyNotes?.[stage.id] ?? [];
     const acceptanceKeys = stage.acceptance ? Object.keys(stage.acceptance) : [];
     const abstractRules = stage.contractType === "compiled-file-evidence"
         ? [
@@ -232,11 +232,11 @@ function renderStageSkill(workflow, stage) {
         "",
         "## Requirements",
         "",
-        "- Treat `workflow.json` and `workflow.schema.json` as the authoritative package contract for this stage.",
+        "- Treat `method.json` and `method.schema.json` as the authoritative package contract for this stage.",
         "- Read only from the declared input zones unless this package explicitly documents a broader method.",
         "- Write only inside the declared output zones for this stage. Do not invent undeclared zones or implicit outputs.",
-        "- Keep stage instructions, zone ownership, and workflow-level acceptance aligned when you change this stage.",
-        "- Treat runtime files as proof and execution state, not as the source of truth for workflow behavior.",
+        "- Keep stage instructions, zone ownership, and Method-level acceptance aligned when you change this stage.",
+        "- Treat runtime files as proof and execution state, not as the source of truth for Method behavior.",
         "- Prefer direct file-reading and search tools over shell commands for routine file inspection.",
         ...abstractRules,
         "",
@@ -258,95 +258,95 @@ function renderStageSkill(workflow, stage) {
             : []),
     ].join("\n");
 }
-export function writeCompiledWorkflowPackage(compiledPath, workflow) {
-    writeWorkflowPackageToDir(workflowPackagePath(compiledPath), workflow);
+export function writeCompiledMethodPackage(compiledPath, method) {
+    writeMethodPackageToDir(methodPackagePath(compiledPath), method);
 }
-export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
+export function writeMethodPackageToDir(methodDir, method, options = {}) {
     const overwrite = options.overwrite ?? true;
-    mkdirSync(join(workflowDir, "improve"), { recursive: true });
-    mkdirSync(join(workflowDir, "use", "query"), { recursive: true });
-    mkdirSync(join(workflowDir, "compile", "stages"), { recursive: true });
-    for (const stage of workflow.stages) {
-        mkdirSync(join(workflowDir, "compile", "stages", stage.skillDir), { recursive: true });
+    mkdirSync(join(methodDir, "improve"), { recursive: true });
+    mkdirSync(join(methodDir, "use", "query"), { recursive: true });
+    mkdirSync(join(methodDir, "compile", "stages"), { recursive: true });
+    for (const stage of method.stages) {
+        mkdirSync(join(methodDir, "compile", "stages", stage.skillDir), { recursive: true });
     }
-    writeWorkflowPackageJson(workflowDir, workflow, { overwrite });
-    if (overwrite || !existsSync(join(workflowDir, CONTEXT_INTERFACE_FILE))) {
-        const contextInterface = workflow.contextInterface ?? workflow.schema;
+    writeMethodPackageJson(methodDir, method, { overwrite });
+    if (overwrite || !existsSync(join(methodDir, CONTEXT_INTERFACE_FILE))) {
+        const contextInterface = method.contextInterface ?? method.schema;
         if (contextInterface) {
-            writeContextInterface(workflowDir, {
+            writeContextInterface(methodDir, {
                 ...contextInterface,
-                label: contextInterface.label || `${workflow.label} workflow schema`,
+                label: contextInterface.label || `${method.label} Method schema`,
             });
         }
         else {
-            writeContextInterfaceFile(workflowDir, workflow.stages, `${workflow.label} workflow schema`);
+            writeContextInterfaceFile(methodDir, method.stages, `${method.label} Method schema`);
         }
     }
-    if (overwrite || !existsSync(join(workflowDir, "README.md"))) {
-        writeFileSync(join(workflowDir, "README.md"), renderWorkflowReadme(workflow));
+    if (overwrite || !existsSync(join(methodDir, "README.md"))) {
+        writeFileSync(join(methodDir, "README.md"), renderMethodReadme(method));
     }
-    if (overwrite || !existsSync(join(workflowDir, "improve", "SKILL.md"))) {
-        writeFileSync(join(workflowDir, "improve", "SKILL.md"), renderImproveSkill(workflow));
+    if (overwrite || !existsSync(join(methodDir, "improve", "SKILL.md"))) {
+        writeFileSync(join(methodDir, "improve", "SKILL.md"), renderImproveSkill(method));
     }
-    if (overwrite || !existsSync(join(workflowDir, "use", "query", "SKILL.md"))) {
-        writeFileSync(join(workflowDir, "use", "query", "SKILL.md"), renderCompiledQuerySkill());
+    if (overwrite || !existsSync(join(methodDir, "use", "query", "SKILL.md"))) {
+        writeFileSync(join(methodDir, "use", "query", "SKILL.md"), renderCompiledQuerySkill());
     }
-    for (const stage of workflow.stages) {
-        const targetPath = join(workflowDir, "compile", "stages", stage.skillDir, "SKILL.md");
+    for (const stage of method.stages) {
+        const targetPath = join(methodDir, "compile", "stages", stage.skillDir, "SKILL.md");
         if (overwrite || !existsSync(targetPath)) {
-            writeFileSync(targetPath, renderStageSkill(workflow, stage));
+            writeFileSync(targetPath, renderStageSkill(method, stage));
         }
     }
-    writeWorkflowStarterDocs(workflowDir, workflow.starterDocs, { overwrite });
+    writeMethodStarterDocs(methodDir, method.starterDocs, { overwrite });
 }
-export function seedCompiledWorkflowPackage(options) {
-    const resolvedWorkflow = getCompiledWorkflow(options.workflowId, {
+export function seedCompiledMethodPackage(options) {
+    const resolvedMethod = getCompiledMethod(options.methodId, {
         sourcePath: options.sourcePath,
     });
-    const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, resolvedWorkflow.id);
-    if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
+    const sourceMethodPath = resolveMethodPackageSourcePath(options.sourcePath, resolvedMethod.id);
+    if (sourceMethodPath && isPortableMethodPackage(sourceMethodPath)) {
         // Portable seed packages can be copied directly because compile runs the
-        // local package folder without reading source-root workflow packages.
-        copyWorkflowPackageDirectory(sourceWorkflowPath, workflowPackagePath(options.compiledPath));
-        patchWorkflowPackageMetadata(workflowPackagePath(options.compiledPath), {
-            id: resolvedWorkflow.id,
-            inputs: resolvedWorkflow.inputs,
-            label: resolvedWorkflow.label,
-            hint: resolvedWorkflow.hint,
-            stagePolicyNotes: resolvedWorkflow.stagePolicyNotes,
+        // local package folder without reading source-root Method packages.
+        copyMethodPackageDirectory(sourceMethodPath, methodPackagePath(options.compiledPath));
+        patchMethodPackageMetadata(methodPackagePath(options.compiledPath), {
+            id: resolvedMethod.id,
+            inputs: resolvedMethod.inputs,
+            label: resolvedMethod.label,
+            hint: resolvedMethod.hint,
+            stagePolicyNotes: resolvedMethod.stagePolicyNotes,
         });
-        if (resolvedWorkflow.scope === "builtin") {
-            writeFileSync(join(workflowPackagePath(options.compiledPath), "README.md"), renderWorkflowReadme(resolvedWorkflow));
+        if (resolvedMethod.scope === "builtin") {
+            writeFileSync(join(methodPackagePath(options.compiledPath), "README.md"), renderMethodReadme(resolvedMethod));
         }
         return;
     }
     // Legacy or partially-defined seed packages are resolved once and
     // materialized into a standalone local package.
-    writeCompiledWorkflowPackage(options.compiledPath, resolvedWorkflow);
+    writeCompiledMethodPackage(options.compiledPath, resolvedMethod);
 }
-export function createLocalWorkflowPackageFromTemplate(options) {
-    const targetPath = seedLocalWorkflowPackageFromBase({
+export function createLocalMethodPackageFromTemplate(options) {
+    const targetPath = seedLocalMethodPackageFromBase({
         sourcePath: options.sourcePath,
-        baseWorkflowId: options.baseWorkflowId,
-        workflowId: options.workflowId,
+        baseMethodId: options.baseMethodId,
+        methodId: options.methodId,
         label: options.label,
         hint: options.hint,
     });
-    const baseWorkflow = getCompiledWorkflow(options.baseWorkflowId, {
+    const baseMethod = getCompiledMethod(options.baseMethodId, {
         sourcePath: options.sourcePath,
     });
-    const stagePolicyNotes = mergeStagePolicyNotesForStages(baseWorkflow.stages, baseWorkflow.stagePolicyNotes, options.stagePolicyNotes);
-    patchWorkflowPackageMetadata(targetPath, {
-        id: options.workflowId,
+    const stagePolicyNotes = mergeStagePolicyNotesForStages(baseMethod.stages, baseMethod.stagePolicyNotes, options.stagePolicyNotes);
+    patchMethodPackageMetadata(targetPath, {
+        id: options.methodId,
         label: options.label,
         hint: options.hint,
         stagePolicyNotes,
     });
-    writeFileSync(join(targetPath, "README.md"), renderDerivedWorkflowReadme({
+    writeFileSync(join(targetPath, "README.md"), renderDerivedMethodReadme({
         label: options.label,
         hint: options.hint,
-        baseWorkflowId: options.baseWorkflowId,
-        emphasis: baseWorkflow.stages
+        baseMethodId: options.baseMethodId,
+        emphasis: baseMethod.stages
             .map((stage) => ({
             stageId: stage.id,
             label: stage.label,
@@ -356,33 +356,33 @@ export function createLocalWorkflowPackageFromTemplate(options) {
     }));
     return targetPath;
 }
-export function seedLocalWorkflowPackageFromBase(options) {
-    const baseWorkflow = getCompiledWorkflow(options.baseWorkflowId, {
+export function seedLocalMethodPackageFromBase(options) {
+    const baseMethod = getCompiledMethod(options.baseMethodId, {
         sourcePath: options.sourcePath,
     });
-    const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, options.baseWorkflowId);
-    const targetPath = workflowDefinitionPath(options.sourcePath, options.workflowId);
-    if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
+    const sourceMethodPath = resolveMethodPackageSourcePath(options.sourcePath, options.baseMethodId);
+    const targetPath = methodDefinitionPath(options.sourcePath, options.methodId);
+    if (sourceMethodPath && isPortableMethodPackage(sourceMethodPath)) {
         // Copy directly when the base package is already portable and standalone.
-        copyWorkflowPackageDirectory(sourceWorkflowPath, targetPath);
-        patchWorkflowPackageMetadata(targetPath, {
-            id: options.workflowId,
-            inputs: baseWorkflow.inputs,
+        copyMethodPackageDirectory(sourceMethodPath, targetPath);
+        patchMethodPackageMetadata(targetPath, {
+            id: options.methodId,
+            inputs: baseMethod.inputs,
             label: options.label,
             hint: options.hint,
         });
-        writeFileSync(join(targetPath, "README.md"), renderSeedWorkflowReadme({
+        writeFileSync(join(targetPath, "README.md"), renderSeedMethodReadme({
             label: options.label,
             hint: options.hint,
-            baseWorkflowId: options.baseWorkflowId,
+            baseMethodId: options.baseMethodId,
         }));
         return targetPath;
     }
-    // Legacy or inherited base packages are materialized immediately so the new
-    // local workflow package is standalone from its first write.
-    const localWorkflow = {
-        ...baseWorkflow,
-        id: options.workflowId,
+    // Base packages are materialized immediately so the new local Method package
+    // is standalone from its first write.
+    const localMethod = {
+        ...baseMethod,
+        id: options.methodId,
         label: options.label,
         hint: options.hint,
         recommended: false,
@@ -390,29 +390,29 @@ export function seedLocalWorkflowPackageFromBase(options) {
         starterDocs: [
             {
                 relativePath: "README.md",
-                content: renderSeedWorkflowReadme({
+                content: renderSeedMethodReadme({
                     label: options.label,
                     hint: options.hint,
-                    baseWorkflowId: options.baseWorkflowId,
+                    baseMethodId: options.baseMethodId,
                 }),
             },
-            ...(baseWorkflow.starterDocs ?? []).filter((doc) => doc.relativePath !== "README.md"),
+            ...(baseMethod.starterDocs ?? []).filter((doc) => doc.relativePath !== "README.md"),
         ],
     };
-    writeWorkflowPackageToDir(targetPath, localWorkflow);
+    writeMethodPackageToDir(targetPath, localMethod);
     return targetPath;
 }
-export function createScratchLocalWorkflowPackage(options) {
-    const targetPath = workflowDefinitionPath(options.sourcePath, options.workflowId);
-    const workflow = {
-        id: options.workflowId,
+export function createScratchLocalMethodPackage(options) {
+    const targetPath = methodDefinitionPath(options.sourcePath, options.methodId);
+    const method = {
+        id: options.methodId,
         compilerApi: {
             kind: "compiled",
             version: 1,
         },
         purpose: {
-            label: "From-scratch workflow draft",
-            taskHint: "Replace this neutral scaffold with the workflow stages, outputs, and proof rules this work requires.",
+            label: "From-scratch Method draft",
+            taskHint: "Replace this neutral scaffold with the Method stages, outputs, and proof rules this agent work requires.",
         },
         inputs: [
             {
@@ -427,10 +427,10 @@ export function createScratchLocalWorkflowPackage(options) {
         recommended: false,
         scope: "local",
         contextInterface: {
-            kind: "workflow-schema",
+            kind: "method-schema",
             version: 1,
             target_type: "compiled",
-            label: `${options.label} workflow schema`,
+            label: `${options.label} Method schema`,
             zones: [
                 {
                     id: "raw",
@@ -465,8 +465,8 @@ export function createScratchLocalWorkflowPackage(options) {
             {
                 id: "prepare",
                 label: "Prepare",
-                description: "Neutral placeholder stage for workflow authoring. Replace this stage with the topology this work needs.",
-                contractType: "workflow-draft-stage",
+                description: "Neutral placeholder stage for Method authoring. Replace this stage with the topology this agent work needs.",
+                contractType: "method-draft-stage",
                 skillDir: "prepare",
                 reads: ["raw", "runtime"],
                 writes: ["draft-context"],
@@ -477,20 +477,20 @@ export function createScratchLocalWorkflowPackage(options) {
         ],
         stagePolicyNotes: {
             prepare: [
-                "This is a neutral authoring scaffold, not a recommended workflow topology.",
-                "Replace this stage, output zone, and proof rule when drafting the final workflow.",
+                "This is a neutral authoring scaffold, not a recommended method topology.",
+                "Replace this stage, output zone, and proof rule when drafting the final method.",
             ],
         },
         starterDocs: [
             {
                 relativePath: "README.md",
-                content: renderScratchWorkflowReadme({
+                content: renderScratchMethodReadme({
                     label: options.label,
                     hint: options.hint,
                 }),
             },
         ],
     };
-    writeWorkflowPackageToDir(targetPath, workflow);
+    writeMethodPackageToDir(targetPath, method);
     return targetPath;
 }

package/dist/packages/{workflow-package → method-package}/lib/package-root.js

@@ -2,5 +2,5 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Package root (dist/packages/workflow-package/lib/ -> package root)
+// Package root (dist/packages/method-package/lib/ -> package root)
 export const PACKAGE_ROOT = join(__dirname, "..", "..", "..", "..");

package/dist/packages/method-package/local-methods.d.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema } from "../compiler/lib/schema.js";
+import { RuntimeContractTypeSchema } from "../contracts/lib/schema.js";
+import { MethodInputSpecSchema, type ContextInterface, type MethodInputSpec } from "./context-interface.js";
+export interface LocalMethodStarterDoc {
+    relativePath: string;
+    content: string;
+}
+export interface LocalMethodStageDefinition {
+    id: string;
+    label: string;
+    contract_type: z.infer<typeof RuntimeContractTypeSchema>;
+    skill_dir?: string;
+    description?: string;
+    reads: z.infer<typeof MethodStageZoneAccessSchema>;
+    writes: z.infer<typeof MethodStageZoneAccessSchema>;
+    acceptance?: z.infer<typeof RuntimeStageAcceptanceSchema>;
+}
+export interface LocalMethodDefinition {
+    id: string;
+    type: "compiled";
+    compiler_api?: z.infer<typeof MethodCompilerApiSchema>;
+    purpose?: z.infer<typeof MethodPurposeSchema>;
+    inputs?: Array<z.infer<typeof MethodInputSpecSchema>>;
+    label: string;
+    hint: string;
+    stages?: LocalMethodStageDefinition[];
+    stage_policy_notes?: Record<string, string[]>;
+    method_schema: ContextInterface;
+    starter_docs: LocalMethodStarterDoc[];
+    directoryPath: string;
+    methodPath: string;
+    methodSchemaPath: string;
+}
+export declare function methodDefinitionPath(sourcePath: string, id: string): string;
+export declare function loadMethodDefinitionFromDir(dirPath: string): LocalMethodDefinition | null;
+export declare function listLocalMethodDefinitions(sourcePath: string): LocalMethodDefinition[];
+export declare function loadLocalMethodDefinition(sourcePath: string, id: string): LocalMethodDefinition | null;
+export declare function resolveMethodPackageSourcePath(sourcePath: string, methodId: string): string | null;
+export declare function seedLocalDefaultMethod(options: {
+    sourcePath: string;
+}): {
+    methodId: string;
+    targetPath: string;
+    alreadyExisted: boolean;
+};
+export declare function isMethodId(value: string): boolean;
+export declare function patchMethodPackageMetadata(dirPath: string, options?: {
+    id?: string;
+    inputs?: MethodInputSpec[];
+    label?: string;
+    hint?: string;
+    stagePolicyNotes?: Record<string, string[]>;
+}): void;
+export declare function describeMethodPackagePortability(dirPath: string): string[];
+export declare function isPortableMethodPackage(dirPath: string): boolean;
+export declare function copyMethodPackageDirectory(sourceMethodPath: string, targetMethodPath: string): void;
+export interface MethodValidationResult {
+    ok: boolean;
+    summary: string;
+    errors: string[];
+    counts: Record<string, number>;
+}
+export declare function validateMethodPackage(dirPath: string): MethodValidationResult;