@interf/compiler 0.9.1 → 0.9.4

package/dist/packages/agents/lib/shells.js

@@ -3,12 +3,12 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
 import { CHART_APPROXIMATION_NOTES } from "./chart-guidance.js";
 import { projectRawSnapshot } from "../../compiler/raw-snapshot.js";
-import { WORKFLOW_PACKAGE_DIR } from "../../project-model/interf-detect.js";
-import { CONTEXT_INTERFACE_FILE as WORKFLOW_SCHEMA_FILE, contextInterfaceZoneAbsolutePath as compiledZoneAbsolutePath, readContextInterface as readCompiledSchemaFile, resolveContextInterfacePath as resolveWorkflowSchemaPath, } from "../../workflow-package/context-interface.js";
-import { stageExecutionShellsRoot, workflowImprovementLoopRoot, workflowPackagePathForCompiled, compiledInterfConfigPath, compiledRuntimeRoot, } from "../../compiler/compiled-paths.js";
+import { METHOD_PACKAGE_DIR } from "../../project-model/interf-detect.js";
+import { CONTEXT_INTERFACE_FILE as METHOD_SCHEMA_FILE, contextInterfaceZoneAbsolutePath as compiledZoneAbsolutePath, readContextInterface as readCompiledSchemaFile, resolveContextInterfacePath as resolveMethodSchemaPath, } from "../../method-package/context-interface.js";
+import { stageExecutionShellsRoot, methodImprovementLoopRoot, methodPackagePathForCompiled, compiledInterfConfigPath, compiledRuntimeRoot, } from "../../compiler/compiled-paths.js";
 import { ensureCompiledZoneTargets } from "../../compiler/compiled-schema.js";
 import { listFilesRecursive } from "../../shared/filesystem.js";
-import { resolveWorkflowImprovementReviewSourcePaths } from "../../workflow-package/workflow-review-paths.js";
+import { resolveMethodImprovementReviewSourcePaths } from "../../method-package/method-review-paths.js";
 const LOCAL_SKILL_ROOTS = [
     ".claude/skills",
     ".codex/skills",
@@ -24,19 +24,19 @@ export function writeNativeAgentSurface(rootPath, agentsContent, skillName, skil
     return changed;
 }
 function compiledQuerySkillSourcePath(compiledPath) {
-    return join(workflowPackagePathForCompiled(compiledPath), "use", "query", "SKILL.md");
+    return join(methodPackagePathForCompiled(compiledPath), "use", "query", "SKILL.md");
 }
 function compiledZoneSummaryLines(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     if (!schema)
-        return ["- No workflow schema is available yet."];
+        return ["- No Method schema is available yet."];
     return schema.zones
         .filter((zone) => zone.kind !== "runtime")
         .map((zone) => `- \`${zone.id}\` -> \`${zone.path}\` (${zone.role} ${zone.kind})`);
 }
-export function renderCompiledAgents(compiledPath, name, workflowId, about, options = {}) {
-    const workflowOriginSelected = options.workflowOriginSelected ?? workflowId;
-    const workflowLocalDraft = options.workflowLocalDraft === true;
+export function renderCompiledAgents(compiledPath, name, methodId, about, options = {}) {
+    const methodOriginSelected = options.methodOriginSelected ?? methodId;
+    const methodLocalDraft = options.methodLocalDraft === true;
     const zoneLines = compiledZoneSummaryLines(compiledPath);
     return [
         `# ${name}`,
@@ -53,29 +53,29 @@ export function renderCompiledAgents(compiledPath, name, workflowId, about, opti
         "## How to use this portable context",
         "",
         "1. Use the local native `interf-query` skill that Interf generated for this portable context.",
-        "2. Let the workflow docs and declared output zones guide retrieval instead of assuming a fixed note layout.",
+        "2. Let the Method docs and declared output zones guide retrieval instead of assuming a fixed note layout.",
         "3. Use `raw/` when you need direct quotes, exact chart values, table lookups, or verification.",
         "",
         "## How this portable context works",
         "",
         "- The Method package defines the context interface this portable context implements on disk.",
         "- `.interf/interf.json` points to the local `raw/` snapshot via `source.path` and back to the Interf Workspace via `source.control_path`.",
-        `- Method seed: \`${workflowOriginSelected}\`.`,
-        ...(workflowLocalDraft
+        `- Method seed: \`${methodOriginSelected}\`.`,
+        ...(methodLocalDraft
             ? ["- This portable context now carries a local Method draft improved from that seed. Recompiling this portable context reuses the local `.interf/method/` package."]
             : []),
-        `- Active local Method id: \`${workflowId}\`.`,
+        `- Active local Method id: \`${methodId}\`.`,
         "- `.interf/method/` is the local editable Method package for this portable context.",
-        `- \`.interf/method/${WORKFLOW_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
+        `- \`.interf/method/${METHOD_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
         "- `.interf/method/improve/` is the editable source for Method-improvement loops.",
         "- `.interf/method/use/query/` is the editable source for the generated native query shell.",
         "- `.interf/method/compile/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
         "- Native local query skills are generated under local agent skill directories such as `.claude/skills/` and `.codex/skills/`.",
         "- `raw/` contains the local raw snapshot used for evidence and verification.",
-        `- Method zones are declared in \`.interf/method/${WORKFLOW_SCHEMA_FILE}\`.`,
+        `- Method zones are declared in \`.interf/method/${METHOD_SCHEMA_FILE}\`.`,
         ...zoneLines,
         "- `.interf/runtime/` holds runtime artifacts written by Interf.",
-        "- `.interf/tests/` mirrors the latest saved comparison and keeps detailed target runs plus preserved sandboxes.",
+        "- `.interf/tests/` mirrors the latest saved readiness-check run and keeps detailed target runs plus preserved sandboxes.",
         "- `.interf/tests/targets/` holds detailed raw and compiled target runs plus preserved test sandboxes.",
         "",
         "## Manual query rules",
@@ -91,8 +91,8 @@ export function renderCompiledAgents(compiledPath, name, workflowId, about, opti
         "```",
         "interf compile            build this portable context",
         "interf test               run checks against this portable context",
-        "interf verify stage <id>  verify one workflow stage",
-        "interf verify compiled    verify the full portable context output",
+        "interf verify stage <id>  verify one Method stage",
+        "interf verify portable-context    verify the full portable context output",
         "interf status             show deterministic health",
         "```",
         "",
@@ -112,7 +112,7 @@ export function renderCompiledQuerySkill() {
         "",
         "Default loop:",
         "1. Read `.interf/method/README.md` and this file first.",
-        `2. Use the Method zones declared in \`.interf/method/${WORKFLOW_SCHEMA_FILE}\` before consulting \`raw/\`.`,
+        `2. Use the Method zones declared in \`.interf/method/${METHOD_SCHEMA_FILE}\` before consulting \`raw/\`.`,
         "3. Use `raw/` for direct quotes, verification, exact lookups, and cases where the portable context is missing the needed evidence or is ambiguous.",
         "",
         "Answering rule:",
@@ -133,7 +133,7 @@ function renderRawTestAgents() {
         "# Raw Test Shell",
         "",
         "This is an isolated raw-files test shell generated by Interf.",
-        "There is no compiled context in this shell.",
+        "There is no portable context in this shell.",
         "",
         "## How to use this shell",
         "",
@@ -144,7 +144,7 @@ function renderRawTestAgents() {
         "## Rules",
         "",
         "- Answer only from the files under `raw/`.",
-        "- There is no compiled context here, so do not assume any compiled-context output zones exist.",
+        "- There is no portable context here, so do not assume any portable-context output zones exist.",
         "- Do not treat hidden runtime files or test artifacts as evidence.",
         ...chartNotes,
         "- Write the requested answer and trace files, then stop.",
@@ -169,7 +169,7 @@ function renderRawTestQuerySkill() {
         "1. Read `raw/` directly.",
         "2. Verify exact claims against the raw files before answering strongly.",
         ...chartNotes,
-        "8. Do not rely on compiled context artifacts because they do not exist in this shell.",
+        "8. Do not rely on portable-context artifacts because they do not exist in this shell.",
         "",
     ].join("\n");
 }
@@ -180,8 +180,8 @@ function readCompiledQuerySkillSource(compiledPath) {
     }
     return readFileSync(filePath, "utf8").trim();
 }
-function stageShellWorkflowRoot(shellRoot) {
-    return join(shellRoot, WORKFLOW_PACKAGE_DIR);
+function stageShellMethodRoot(shellRoot) {
+    return join(shellRoot, METHOD_PACKAGE_DIR);
 }
 function shellInputZonePath(shellRoot, zoneId) {
     return join(shellRoot, "inputs", zoneId);
@@ -230,10 +230,10 @@ function linkRelativePath(targetPath, linkPathname) {
     symlinkSync(relative(dirname(linkPathname), targetPath), linkPathname);
 }
 function loadCompiledSchema(compiledPath) {
-    const workflowRoot = workflowPackagePathForCompiled(compiledPath);
-    const schema = readCompiledSchemaFile(workflowRoot);
+    const methodRoot = methodPackagePathForCompiled(compiledPath);
+    const schema = readCompiledSchemaFile(methodRoot);
     if (!schema) {
-        throw new Error(`Missing workflow schema at ${join(workflowRoot, WORKFLOW_SCHEMA_FILE)}`);
+        throw new Error(`Missing Method schema at ${join(methodRoot, METHOD_SCHEMA_FILE)}`);
     }
     return schema;
 }
@@ -243,7 +243,7 @@ function zoneMap(schema) {
 function zoneOrThrow(zones, zoneId) {
     const zone = zones.get(zoneId);
     if (!zone) {
-        throw new Error(`Missing workflow schema zone "${zoneId}" for stage shell projection.`);
+        throw new Error(`Missing Method schema zone "${zoneId}" for stage shell projection.`);
     }
     return zone;
 }
@@ -298,21 +298,21 @@ function ensureShellLocalProjection(sourcePath, targetPath, zone) {
 }
 function ensureCompiledExecutionSurface(compiledPath) {
     mkdirSync(compiledRuntimeRoot(compiledPath), { recursive: true });
-    mkdirSync(workflowPackagePathForCompiled(compiledPath), { recursive: true });
+    mkdirSync(methodPackagePathForCompiled(compiledPath), { recursive: true });
     const schema = loadCompiledSchema(compiledPath);
     ensureCompiledZoneTargets(compiledPath, schema);
     return schema;
 }
 function readStageMethodDoc(compiledPath, stage) {
-    const path = join(workflowPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir, "SKILL.md");
+    const path = join(methodPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir, "SKILL.md");
     if (!existsSync(path))
         return null;
     return readFileSync(path, "utf8").trim();
 }
-function stageWorkflowDocsPath(compiledPath, stage) {
-    return join(workflowPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir);
+function stageMethodDocsPath(compiledPath, stage) {
+    return join(methodPackagePathForCompiled(compiledPath), "compile", "stages", stage.skillDir);
 }
-function renderStageExecutionAgents(compiledName, workflowId, stage) {
+function renderStageExecutionAgents(compiledName, methodId, stage) {
     return [
         `# ${compiledName} — ${stage.label} Execution Shell`,
         "",
@@ -333,14 +333,14 @@ function renderStageExecutionAgents(compiledName, workflowId, stage) {
         "- For file zones, `runtime/paths.json` points to the exact file path inside those mount roots.",
         "- declared compiled zone paths are also projected at the shell root so Method-relative contract paths stay valid.",
         "- `runtime/` = stage contract and machine-readable path map for this shell.",
-        "- `method/` = Method metadata, workflow schema, and docs for the current stage only.",
+        "- `method/` = Method metadata, `method.schema.json`, and docs for the current stage only.",
         "",
         "## Boundaries",
         "",
-        `- Workflow: \`${workflowId}\`.`,
+        `- Method: \`${methodId}\`.`,
         `- Contract type: \`${stage.contractType}\`.`,
-        "- This shell has its own AGENTS/CLAUDE/native skills. It does not inherit the compiled-context query shell.",
-        "- The compiled context root itself is not linked into this shell.",
+        "- This shell has its own AGENTS/CLAUDE/native skills. It does not inherit the portable-context query shell.",
+        "- The portable context root itself is not linked into this shell.",
         "- Do not switch into query mode or act like a user-facing assistant.",
         "- Do not modify files under `inputs/` unless the same zone is also mounted under `outputs/`.",
         "",
@@ -412,25 +412,25 @@ function renderCompiledQueryNativeSkill(querySkillContent) {
         "",
     ].join("\n");
 }
-function projectWorkflowMetadata(compiledPath, shellRoot, stage) {
-    const shellWorkflowRoot = stageShellWorkflowRoot(shellRoot);
-    mkdirSync(join(shellWorkflowRoot, "compile", "stages"), { recursive: true });
-    const compiledWorkflowRoot = workflowPackagePathForCompiled(compiledPath);
-    const workflowJsonPath = join(compiledWorkflowRoot, "workflow.json");
-    if (existsSync(workflowJsonPath)) {
-        linkPath(workflowJsonPath, join(shellWorkflowRoot, "workflow.json"));
+function projectMethodMetadata(compiledPath, shellRoot, stage) {
+    const shellMethodRoot = stageShellMethodRoot(shellRoot);
+    mkdirSync(join(shellMethodRoot, "compile", "stages"), { recursive: true });
+    const compiledMethodRoot = methodPackagePathForCompiled(compiledPath);
+    const methodJsonPath = join(compiledMethodRoot, "method.json");
+    if (existsSync(methodJsonPath)) {
+        linkPath(methodJsonPath, join(shellMethodRoot, "method.json"));
     }
-    const compiledSchemaPath = resolveWorkflowSchemaPath(compiledWorkflowRoot);
+    const compiledSchemaPath = resolveMethodSchemaPath(compiledMethodRoot);
     if (compiledSchemaPath) {
-        linkPath(compiledSchemaPath, join(shellWorkflowRoot, WORKFLOW_SCHEMA_FILE));
+        linkPath(compiledSchemaPath, join(shellMethodRoot, METHOD_SCHEMA_FILE));
     }
-    const readmePath = join(compiledWorkflowRoot, "README.md");
+    const readmePath = join(compiledMethodRoot, "README.md");
     if (existsSync(readmePath)) {
-        linkPath(readmePath, join(shellWorkflowRoot, "README.md"));
+        linkPath(readmePath, join(shellMethodRoot, "README.md"));
     }
-    const stageDocsPath = stageWorkflowDocsPath(compiledPath, stage);
+    const stageDocsPath = stageMethodDocsPath(compiledPath, stage);
     if (existsSync(stageDocsPath)) {
-        linkPath(stageDocsPath, join(shellWorkflowRoot, "compile", "stages", stage.skillDir));
+        linkPath(stageDocsPath, join(shellMethodRoot, "compile", "stages", stage.skillDir));
     }
 }
 function projectCompiledSchemaZones(compiledPath, shellRoot, schema, zoneIds, materializedZoneIds) {
@@ -481,11 +481,11 @@ function projectStageZoneMountAliases(shellRoot, stage, schema) {
         }
     }
 }
-function writeExecutionShellPathsFile(shellRoot, workflowId, stage, mounts) {
+function writeExecutionShellPathsFile(shellRoot, methodId, stage, mounts) {
     const paths = {
         kind: "interf-execution-shell",
         version: 1,
-        workflow: workflowId,
+        method: methodId,
         stage: stage.id,
         reads: mounts.reads,
         writes: mounts.writes,
@@ -661,93 +661,97 @@ export function renderClaudeBootstrap(content) {
         "",
     ].join("\n");
 }
-function renderWorkflowAuthoringAgents(options) {
+function renderMethodAuthoringAgents(options) {
     return [
-        `# ${options.label} — Workflow Authoring Shell`,
+        `# ${options.label} — Method Authoring Shell`,
         "",
-        "This is an automated workflow-authoring shell generated by Interf.",
-        "It exists to create one standalone workflow from the source data, desired portable-context outputs, and proof requirements in this task.",
+        "This is an automated Method-authoring shell generated by Interf.",
+        "It exists to create one standalone Method package from the source data, desired portable-context outputs, and proof requirements in this task.",
         "",
         "## Start Here",
         "",
         "1. Read `runtime/authoring-context.json` now.",
-        `2. Read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${WORKFLOW_SCHEMA_FILE}\` now.`,
-        "3. Review `artifacts/source-dataset/raw/`.",
-        "4. Use the local native `interf-workflow-author` skill now.",
+        `2. Read \`method/README.md\`, \`method/method.json\`, and \`method/${METHOD_SCHEMA_FILE}\` now.`,
+        "3. Review `artifacts/source-folder/raw/`.",
+        "4. Use the local native `interf-method-author` skill now.",
         "",
         "## Boundaries",
         "",
-        `- New workflow id: \`${options.workflowId}\`.`,
+        `- New Method package id: \`${options.methodId}\`.`,
         "- Authoring mode: from scratch.",
-        ...(options.referenceWorkflowId
-            ? [`- Reference workflow id: \`${options.referenceWorkflowId}\` (context only, not a seed).`]
+        ...(options.referenceMethodId
+            ? [`- Reference Method package id: \`${options.referenceMethodId}\` (context only, not a seed).`]
             : []),
-        "- Edit only files under `workflow/`.",
+        "- Edit only files under `method/`.",
         "- Do not edit source artifacts.",
-        "- Keep the workflow valid for the current compiler API and workflow schema.",
+        "- Keep the Method package valid for the current compiler API and `method.schema.json`.",
+        "- Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
         "- For acceptance criteria, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
+        "- For file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`.",
         "- Prefer direct file-reading and search tools over shell commands for routine file inspection.",
         "- Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
         "",
         "## Goal",
         "",
-        "- produce one standalone workflow tuned to the source data, desired outputs, and checks in this task",
-        "- replace the neutral scaffold topology with the stage graph this work needs",
+        "- produce one standalone Method package tuned to the source data, desired outputs, and checks in this task",
+        "- replace the neutral scaffold topology with the stage graph this agent work needs",
         "- define output zones and stage proof so Interf can show whether the data is ready",
         "- preserve deterministic stage and context-interface contracts",
-        "- stop once the workflow edits are complete",
+        "- stop once the Method edits are complete",
         "",
     ].join("\n");
 }
-function renderWorkflowAuthoringSkill() {
+function renderMethodAuthoringSkill() {
     return [
         "---",
-        "name: interf-workflow-author",
+        "name: interf-method-author",
         "description: >",
-        "  Native local workflow-authoring skill for an automated Interf workflow draft run.",
+        "  Native local Method-authoring skill for an automated Interf Method draft run.",
         "---",
         "",
-        "# Interf Workflow Authoring",
+        "# Interf Method Authoring",
         "",
         "Read `runtime/authoring-context.json` first.",
-        "Then review the neutral workflow scaffold under `workflow/` and the raw snapshot under `artifacts/source-dataset/raw/`.",
+        "Then review the neutral Method package scaffold under `method/` and the raw snapshot under `artifacts/source-folder/raw/`.",
         "",
         "Rules:",
-        "- edit only `workflow/`",
-        `- keep \`workflow.json\`, \`${WORKFLOW_SCHEMA_FILE}\`, and any changed stage docs aligned`,
+        "- edit only `method/`",
+        `- keep \`method.json\`, \`${METHOD_SCHEMA_FILE}\`, and any changed stage docs aligned`,
         "- use `zone_counts_at_least` for numeric fixed minimums; use `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`",
+        "- for file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`",
         "- design the stage graph from the source data and preparation-and-evidence brief",
+        "- use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids; never use underscores",
         "- replace the placeholder `prepare` stage unless that exact stage is truly the final method",
         "- keep the package standalone; do not introduce runtime inheritance or hidden source-package assumptions",
-        "- do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path",
+        "- do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path",
         "- respect stage boundaries: do not make structure outputs link to notes or entrypoints first created by later stages",
         "- prefer conservative routing changes over speculative note sprawl",
         "- prefer direct file-reading and search tools over shell commands for routine file inspection",
         "- do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files",
-        "- do not hardcode readiness-check answers into workflow docs",
+        "- do not hardcode readiness-check answers into Method docs",
         "- do not edit source artifacts",
         "",
     ].join("\n");
 }
-function improvementWorkflowDocsPath(compiledPath) {
-    return join(workflowPackagePathForCompiled(compiledPath), "improve");
+function improvementMethodDocsPath(compiledPath) {
+    return join(methodPackagePathForCompiled(compiledPath), "improve");
 }
-export function createWorkflowAuthoringShell(options) {
-    const shellRoot = mkdtempSync(join(tmpdir(), `interf-workflow-author-${options.workflowId}-`));
+export function createMethodAuthoringShell(options) {
+    const shellRoot = mkdtempSync(join(tmpdir(), `interf-method-author-${options.methodId}-`));
     mkdirSync(join(shellRoot, "runtime"), { recursive: true });
     mkdirSync(join(shellRoot, "artifacts"), { recursive: true });
     mkdirSync(join(shellRoot, "logs"), { recursive: true });
     const context = {
-        kind: "interf-workflow-authoring",
+        kind: "interf-method-authoring",
         version: 1,
         generated_at: new Date().toISOString(),
         authoring_mode: "from-scratch",
-        workflow_id: options.workflowId,
-        workflow_label: options.label,
-        ...(options.referenceWorkflowId ? { reference_workflow_id: options.referenceWorkflowId } : {}),
+        method_id: options.methodId,
+        method_label: options.label,
+        ...(options.referenceMethodId ? { reference_method_id: options.referenceMethodId } : {}),
         task_prompt: options.taskPrompt,
-        dataset: {
-            source_path: options.datasetPath,
+        preparation: {
+            source_folder_path: options.sourceFolderPath,
             checks: {
                 count: options.checks.length,
                 questions: options.checks.map((check, index) => ({
@@ -759,86 +763,90 @@ export function createWorkflowAuthoringShell(options) {
     };
     writeFileSync(join(shellRoot, "runtime", "authoring-context.json"), `${JSON.stringify(context, null, 2)}\n`);
     projectRawSnapshot({
-        sourcePath: options.datasetPath,
-        destinationPath: join(shellRoot, "artifacts", "source-dataset", "raw"),
+        sourcePath: options.sourceFolderPath,
+        destinationPath: join(shellRoot, "artifacts", "source-folder", "raw"),
         compiledPath: shellRoot,
         mode: "copy",
         prune: true,
         preserveTimestamps: true,
     });
-    linkPath(options.workflowPath, join(shellRoot, "workflow"));
-    writeNativeAgentSurface(shellRoot, renderWorkflowAuthoringAgents({
-        workflowId: options.workflowId,
+    copyResolvedTree({
+        sourcePath: options.methodPath,
+        targetPath: join(shellRoot, "method"),
+        shellType: "method-authoring",
+    });
+    writeNativeAgentSurface(shellRoot, renderMethodAuthoringAgents({
+        methodId: options.methodId,
         label: options.label,
-        referenceWorkflowId: options.referenceWorkflowId ?? null,
-    }), "interf-workflow-author", renderWorkflowAuthoringSkill());
+        referenceMethodId: options.referenceMethodId ?? null,
+    }), "interf-method-author", renderMethodAuthoringSkill());
     return {
         rootPath: shellRoot,
-        workflowBeforePath: join(shellRoot, "artifacts", "workflow-before"),
-        workflowAfterPath: join(shellRoot, "artifacts", "workflow-after"),
-        promptLogPath: join(shellRoot, "logs", "workflow-author.prompt.txt"),
-        eventLogPath: join(shellRoot, "logs", "workflow-author.events.ndjson"),
-        statusLogPath: join(shellRoot, "logs", "workflow-author.status.log"),
+        methodBeforePath: join(shellRoot, "artifacts", "method-before"),
+        methodAfterPath: join(shellRoot, "artifacts", "method-after"),
+        promptLogPath: join(shellRoot, "logs", "method-author.prompt.txt"),
+        eventLogPath: join(shellRoot, "logs", "method-author.events.ndjson"),
+        statusLogPath: join(shellRoot, "logs", "method-author.status.log"),
     };
 }
-function renderWorkflowImprovementAgents(compiledName, workflowId, loopIndex) {
+function renderMethodImprovementAgents(compiledName, methodId, loopIndex) {
     return [
-        `# ${compiledName} — Workflow Improvement Shell`,
+        `# ${compiledName} — Method Improvement Shell`,
         "",
-        "This is an automated workflow-improvement shell generated by Interf.",
-        "It exists to review failed compile/test runs and edit the workflow package for the next variation.",
+        "This is an automated Method-improvement shell generated by Interf.",
+        "It exists to review failed compile/test runs and edit the Method package for the next variation.",
         "",
         "## Start Here",
         "",
         "1. Read `runtime/loop-context.json` now.",
-        `2. Read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${WORKFLOW_SCHEMA_FILE}\` now.`,
-        "3. Read `workflow/improve/SKILL.md` now.",
-        "4. Use the local native `interf-workflow-improver` skill now.",
+        `2. Read \`method/README.md\`, \`method/method.json\`, and \`method/${METHOD_SCHEMA_FILE}\` now.`,
+        "3. Read `method/improve/SKILL.md` now.",
+        "4. Use the local native `interf-method-improver` skill now.",
         "",
         "## Boundaries",
         "",
-        `- Workflow: \`${workflowId}\`.`,
+        `- Method: \`${methodId}\`.`,
         `- Improvement loop: ${loopIndex}.`,
-        "- Edit only files under `workflow/`.",
+        "- Edit only files under `method/`.",
         "- Do not edit checks, test specs, raw files, or generated context outputs.",
         "- Review context outputs under `artifacts/compiled-view/` and test/runtime evidence under `artifacts/`.",
-        "- Keep the workflow valid for the current compiler API and workflow schema.",
+        "- Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "- For acceptance criteria, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
         "",
         "## Goal",
         "",
-        "- create a better workflow variation for this kind of work",
-        "- preserve deterministic compiled-context structure",
-        "- stop after the workflow edits are complete",
+        "- create a better Method variation for this kind of agent work",
+        "- preserve deterministic portable-context structure",
+        "- stop after the Method edits are complete",
         "",
     ].join("\n");
 }
-function readWorkflowImprovementDoc(compiledPath) {
-    const path = join(improvementWorkflowDocsPath(compiledPath), "SKILL.md");
+function readMethodImprovementDoc(compiledPath) {
+    const path = join(improvementMethodDocsPath(compiledPath), "SKILL.md");
     if (!existsSync(path))
         return null;
     return readFileSync(path, "utf8").trim();
 }
-function renderWorkflowImprovementSkill(workflowId, loopIndex, improvementDoc) {
+function renderMethodImprovementSkill(methodId, loopIndex, improvementDoc) {
     return [
         "---",
-        "name: interf-workflow-improver",
+        "name: interf-method-improver",
         "description: >",
-        "  Native local workflow-improvement skill for this Interf run.",
-        "  Use it only inside an automated workflow-improvement shell.",
+        "  Native local Method-improvement skill for this Interf run.",
+        "  Use it only inside an automated Method-improvement shell.",
         "---",
         "",
-        `# Interf Workflow Improvement — ${workflowId}`,
+        `# Interf Method Improvement — ${methodId}`,
         "",
-        "This local native skill exists for automated workflow-improvement loops.",
+        "This local native skill exists for automated Method-improvement loops.",
         "Read `runtime/loop-context.json` first.",
-        "Then review the linked workflow package, `artifacts/compiled-view/`, preserved stage shells, runtime logs, and saved test outputs before editing `workflow/`.",
+        "Then review the linked Method package, `artifacts/compiled-view/`, preserved stage shells, runtime logs, and saved test outputs before editing `method/`.",
         "",
         "## Current Loop",
         "",
-        `- workflow: \`${workflowId}\``,
+        `- method: \`${methodId}\``,
         `- loop index: ${loopIndex}`,
-        "- editable source: `workflow/improve/SKILL.md`",
+        "- editable source: `method/improve/SKILL.md`",
         "",
         ...(improvementDoc
             ? [
@@ -862,15 +870,10 @@ function projectCompiledReviewArtifactsSnapshot(compiledPath, shellRoot, schema)
         copyResolvedTree({
             sourcePath,
             targetPath: join(compiledViewRoot, zone.path),
-            shellType: "workflow-improvement",
+            shellType: "method-improvement",
         });
     }
 }
-function linkIfExists(targetPath, linkPathname) {
-    if (!existsSync(targetPath))
-        return;
-    linkPath(targetPath, linkPathname);
-}
 function copyIfExists(sourcePath, targetPath, shellType) {
     if (!existsSync(sourcePath))
         return;
@@ -894,21 +897,21 @@ function projectCompiledRuntimeArtifacts(compiledPath, shellRoot) {
         "logs",
     ];
     for (const artifactName of artifactNames) {
-        copyIfExists(join(runtimeRoot, artifactName), join(runtimeTarget, artifactName), "workflow-improvement");
+        copyIfExists(join(runtimeRoot, artifactName), join(runtimeTarget, artifactName), "method-improvement");
     }
 }
 export function pruneStageExecutionShells(compiledPath) {
     rmSync(stageExecutionShellsRoot(compiledPath), { recursive: true, force: true });
 }
-export function projectCompiledQueryShell(compiledPath, compiledName, workflowId, about, options) {
-    const agentsContent = renderCompiledAgents(compiledPath, compiledName, workflowId, about, options);
+export function projectCompiledQueryShell(compiledPath, compiledName, methodId, about, options) {
+    const agentsContent = renderCompiledAgents(compiledPath, compiledName, methodId, about, options);
     const querySkillContent = readCompiledQuerySkillSource(compiledPath);
     return writeNativeAgentSurface(compiledPath, agentsContent, "interf-query", renderCompiledQueryNativeSkill(querySkillContent));
 }
 export function projectRawTestQueryShell(rootPath) {
     return writeNativeAgentSurface(rootPath, renderRawTestAgents(), "interf-query", renderRawTestQuerySkill());
 }
-export function createStageExecutionShell(compiledPath, compiledName, workflowId, stage, writeArtifacts = []) {
+export function createStageExecutionShell(compiledPath, compiledName, methodId, stage, writeArtifacts = []) {
     const schema = ensureCompiledExecutionSurface(compiledPath);
     const materializedZones = stageMaterializedZoneSet(schema, stage, writeArtifacts);
     const shellsRoot = stageExecutionShellsRoot(compiledPath);
@@ -920,10 +923,10 @@ export function createStageExecutionShell(compiledPath, compiledName, workflowId
     linkPath(compiledInterfConfigPath(compiledPath), join(shellRoot, "interf.json"));
     linkPath(join(compiledRuntimeRoot(compiledPath), "stage-contract.json"), shellRuntimePath(shellRoot, "stage-contract.json"));
     projectCompiledSchemaZones(compiledPath, shellRoot, schema, new Set([...stage.reads, ...stage.writes]), materializedZones);
-    projectWorkflowMetadata(compiledPath, shellRoot, stage);
+    projectMethodMetadata(compiledPath, shellRoot, stage);
     projectStageZoneMountAliases(shellRoot, stage, schema);
-    writeExecutionShellPathsFile(shellRoot, workflowId, stage, buildStageZoneMounts(compiledPath, shellRoot, stage, schema));
-    const agentsContent = renderStageExecutionAgents(compiledName, workflowId, stage);
+    writeExecutionShellPathsFile(shellRoot, methodId, stage, buildStageZoneMounts(compiledPath, shellRoot, stage, schema));
+    const agentsContent = renderStageExecutionAgents(compiledName, methodId, stage);
     writeNativeAgentSurface(shellRoot, agentsContent, "interf-stage", renderStageExecutionSkill(stage, readStageMethodDoc(compiledPath, stage)));
     return {
         rootPath: shellRoot,
@@ -932,9 +935,9 @@ export function createStageExecutionShell(compiledPath, compiledName, workflowId
 export function freezeStageExecutionShell(rootPath) {
     return freezePreservedShell(rootPath, "stage-execution");
 }
-export function createWorkflowImprovementShell(options) {
+export function createMethodImprovementShell(options) {
     const schema = ensureCompiledExecutionSurface(options.compiledPath);
-    const loopRootPath = workflowImprovementLoopRoot(options.compiledPath, options.runId, options.loopIndex);
+    const loopRootPath = methodImprovementLoopRoot(options.compiledPath, options.runId, options.loopIndex);
     const shellRoot = join(loopRootPath, "shell");
     mkdirSync(shellRoot, { recursive: true });
     mkdirSync(join(shellRoot, "runtime"), { recursive: true });
@@ -942,34 +945,38 @@ export function createWorkflowImprovementShell(options) {
     mkdirSync(join(loopRootPath, "logs"), { recursive: true });
     writeFileSync(join(shellRoot, "runtime", "loop-context.json"), `${JSON.stringify(options.context, null, 2)}\n`);
     projectCompiledReviewArtifactsSnapshot(options.compiledPath, shellRoot, schema);
-    linkPath(workflowPackagePathForCompiled(options.compiledPath), join(shellRoot, "workflow"));
-    copyIfExists(compiledInterfConfigPath(options.compiledPath), join(shellRoot, "interf.json"), "workflow-improvement");
+    copyResolvedTree({
+        sourcePath: methodPackagePathForCompiled(options.compiledPath),
+        targetPath: join(shellRoot, "method"),
+        shellType: "method-improvement",
+    });
+    copyIfExists(compiledInterfConfigPath(options.compiledPath), join(shellRoot, "interf.json"), "method-improvement");
     projectCompiledRuntimeArtifacts(options.compiledPath, shellRoot);
-    const reviewSources = resolveWorkflowImprovementReviewSourcePaths(options.compiledPath);
+    const reviewSources = resolveMethodImprovementReviewSourcePaths(options.compiledPath);
     if (reviewSources.executionShells) {
-        copyIfExists(reviewSources.executionShells, join(shellRoot, "artifacts", "execution-shells"), "workflow-improvement");
+        copyIfExists(reviewSources.executionShells, join(shellRoot, "artifacts", "execution-shells"), "method-improvement");
     }
     if (reviewSources.testComparisons) {
-        copyIfExists(reviewSources.testComparisons, join(shellRoot, "artifacts", "test-comparisons"), "workflow-improvement");
+        copyIfExists(reviewSources.testComparisons, join(shellRoot, "artifacts", "test-comparisons"), "method-improvement");
     }
     if (reviewSources.targetTestRuns) {
-        copyIfExists(reviewSources.targetTestRuns, join(shellRoot, "artifacts", "test-runs"), "workflow-improvement");
+        copyIfExists(reviewSources.targetTestRuns, join(shellRoot, "artifacts", "test-runs"), "method-improvement");
     }
     if (reviewSources.targetTestSandboxes) {
-        copyIfExists(reviewSources.targetTestSandboxes, join(shellRoot, "artifacts", "test-sandboxes"), "workflow-improvement");
+        copyIfExists(reviewSources.targetTestSandboxes, join(shellRoot, "artifacts", "test-sandboxes"), "method-improvement");
     }
-    const agentsContent = renderWorkflowImprovementAgents(options.compiledName, options.workflowId, options.loopIndex);
-    writeNativeAgentSurface(shellRoot, agentsContent, "interf-workflow-improver", renderWorkflowImprovementSkill(options.workflowId, options.loopIndex, readWorkflowImprovementDoc(options.compiledPath)));
+    const agentsContent = renderMethodImprovementAgents(options.compiledName, options.methodId, options.loopIndex);
+    writeNativeAgentSurface(shellRoot, agentsContent, "interf-method-improver", renderMethodImprovementSkill(options.methodId, options.loopIndex, readMethodImprovementDoc(options.compiledPath)));
     return {
         rootPath: shellRoot,
         loopRootPath,
-        workflowBeforePath: join(loopRootPath, "workflow-before"),
-        workflowAfterPath: join(loopRootPath, "workflow-after"),
-        promptLogPath: join(loopRootPath, "logs", "workflow-improver.prompt.txt"),
-        eventLogPath: join(loopRootPath, "logs", "workflow-improver.events.ndjson"),
-        statusLogPath: join(loopRootPath, "logs", "workflow-improver.status.log"),
+        methodBeforePath: join(loopRootPath, "method-before"),
+        methodAfterPath: join(loopRootPath, "method-after"),
+        promptLogPath: join(loopRootPath, "logs", "method-improver.prompt.txt"),
+        eventLogPath: join(loopRootPath, "logs", "method-improver.events.ndjson"),
+        statusLogPath: join(loopRootPath, "logs", "method-improver.status.log"),
     };
 }
-export function freezeWorkflowImprovementShell(rootPath) {
-    return freezePreservedShell(rootPath, "workflow-improvement");
+export function freezeMethodImprovementShell(rootPath) {
+    return freezePreservedShell(rootPath, "method-improvement");
 }