@interf/compiler 0.7.3 → 0.9.3

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,36 +53,36 @@ 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 workflow 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 project root via `source.control_path`.",
-        `- Workflow seed: \`${workflowOriginSelected}\`.`,
-        ...(workflowLocalDraft
-            ? ["- This portable context now carries a local workflow draft improved from that seed. Recompiling this portable context reuses the local `.interf/workflow/` package."]
+        "- 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: \`${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 workflow id: \`${workflowId}\`.`,
-        "- `.interf/workflow/` is the local editable method package for this portable context.",
-        `- \`.interf/workflow/${WORKFLOW_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
-        "- `.interf/workflow/improve/` is the editable source for workflow-improvement loops.",
-        "- `.interf/workflow/use/query/` is the editable source for the generated native query shell.",
-        "- `.interf/workflow/compile/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
+        `- Active local Method id: \`${methodId}\`.`,
+        "- `.interf/method/` is the local editable Method package 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.",
-        `- Workflow zones are declared in \`.interf/workflow/${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",
         "",
-        "- Prefer the workflow-declared context outputs before `raw/`.",
-        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/workflow/use/query/SKILL.md`.",
-        "- Treat `.interf/` as method/runtime metadata, not answer evidence, unless explicitly asked to inspect workflow or test history.",
+        "- Prefer the Method-declared context outputs before `raw/`.",
+        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/method/use/query/SKILL.md`.",
+        "- Treat `.interf/` as method/runtime metadata, not answer evidence, unless explicitly asked to inspect Method or test history.",
         "- Use `raw/` for quotes, verification, ambiguity, or evidence the portable context does not expose well.",
         "- If exact chart, table, or image-derived evidence matters, inspect the raw source and say whether the answer was text-derived, table-derived, or chart-derived.",
         "",
@@ -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",
         "```",
         "",
@@ -111,16 +111,16 @@ export function renderCompiledQuerySkill() {
         "This file is the editable authoring source for the generated native local `interf-query` skill.",
         "",
         "Default loop:",
-        "1. Read `workflow/README.md` and this file first.",
-        `2. Use the workflow zones declared in \`workflow/${WORKFLOW_SCHEMA_FILE}\` before falling back to \`raw/\`.`,
+        "1. Read `.interf/method/README.md` and this file first.",
+        `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:",
         "- do not modify files under `raw/`",
-        "- treat the workflow as the method layer and the portable-context zones as the working retrieval surface",
+        "- treat the Method as the portable-context contract and use its zones as the working retrieval surface",
         "- say explicitly when an answer depends on approximation, bounded inference, or a raw-source re-check",
         "- use `raw/` to confirm source page, metric family, provenance, or exact wording when the portable context is missing the needed evidence or is ambiguous",
-        "- do not invent navigation or note structure beyond what this workflow declares",
+        "- do not invent navigation or note structure beyond what this Method declares",
         "- when the portable context is insufficient, verify in `raw/` and then answer",
         "",
         "You can edit this file to bias manual question-answering behavior for this portable context.",
@@ -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.",
@@ -158,7 +158,7 @@ function renderRawTestQuerySkill() {
         "name: interf-query",
         "description: >",
         "  Native local query skill for an Interf raw test shell. Use it only",
-        "  to answer baseline questions directly from `raw/`.",
+        "  to answer source-files readiness checks directly from `raw/`.",
         "---",
         "",
         "# Interf Raw Test Query",
@@ -169,19 +169,19 @@ 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");
 }
 function readCompiledQuerySkillSource(compiledPath) {
     const filePath = compiledQuerySkillSourcePath(compiledPath);
     if (!existsSync(filePath)) {
-        throw new Error(`Missing compiled query skill source at ${filePath}. Interf compile runs the local workflow package directly, so reseed or repair this compiled context instead of auto-healing query docs.`);
+        throw new Error(`Missing compiled query skill source at ${filePath}. Interf compile runs the local Method package directly, so reseed or repair this portable context instead of auto-healing query docs.`);
     }
     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`,
         "",
@@ -331,16 +331,16 @@ function renderStageExecutionAgents(compiledName, workflowId, stage) {
         "- `inputs/<zone-id>/` = read mounts for the current stage.",
         "- `outputs/<zone-id>/` = write mounts for the current 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 workflow-relative contract paths stay valid.",
+        "- 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.",
-        "- `workflow/` = workflow 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/`.",
         "",
@@ -381,7 +381,7 @@ function renderStageExecutionSkill(stage, stageMethodDoc) {
         `- contract type: \`${stage.contractType}\``,
         `- reads: ${stage.reads.join(", ")}`,
         `- writes: ${stage.writes.join(", ")}`,
-        `- editable source: \`workflow/compile/stages/${stage.skillDir}/SKILL.md\``,
+        `- editable source: \`method/compile/stages/${stage.skillDir}/SKILL.md\``,
         "",
         ...(stageMethodDoc
             ? [
@@ -399,38 +399,38 @@ function renderCompiledQueryNativeSkill(querySkillContent) {
         "name: interf-query",
         "description: >",
         "  Native local query skill for this portable context built by Interf.",
-        "  Use it for manual questions against the portable context and raw fallback.",
+        "  Use it for manual questions against the portable context and source files under raw/.",
         "---",
         "",
         "# Interf Query",
         "",
         "This is the native local query skill for portable context built by Interf.",
         "Use it when reading this portable context manually.",
-        "Editable source: `.interf/workflow/use/query/SKILL.md`.",
+        "Editable source: `.interf/method/use/query/SKILL.md`.",
         "",
         querySkillContent.trim(),
         "",
     ].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,
@@ -655,135 +655,103 @@ function freezePreservedShell(rootPath, shellType) {
 }
 export function renderClaudeBootstrap(content) {
     return [
-        "<!-- Generated compatibility mirror of AGENTS.md. Interf may rewrite this file. -->",
+        "<!-- Generated mirror of AGENTS.md. Interf may rewrite this file. -->",
         "",
         content.trimEnd(),
         "",
     ].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 or refine 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/` and `artifacts/preview-compiled/` if present.",
-        "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}\`.`,
-        `- Seed workflow: \`${options.baseWorkflowId}\`.`,
-        "- Edit only files under `workflow/`.",
-        "- Do not edit raw files or preview artifacts.",
-        "- Keep the workflow valid for the current compiler API and workflow schema.",
-        "- For acceptance rules, 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`.",
+        `- New Method package id: \`${options.methodId}\`.`,
+        "- Authoring mode: from scratch.",
+        ...(options.referenceMethodId
+            ? [`- Reference Method package id: \`${options.referenceMethodId}\` (context only, not a seed).`]
+            : []),
+        "- Edit only files under `method/`.",
+        "- Do not edit source artifacts.",
+        "- 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",
+        "- 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 seeded package under `workflow/`, the raw snapshot under `artifacts/source-dataset/raw/`, and any preview context outputs under `artifacts/preview-compiled/`.",
+        "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`",
-        "- prefer small, defensible package edits over random churn",
-        "- keep the package standalone; do not introduce runtime inheritance or fallback assumptions",
-        "- do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path",
+        "- 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 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 benchmark answers into workflow docs",
-        "- do not edit raw files or preview artifacts",
+        "- do not hardcode readiness-check answers into Method docs",
+        "- do not edit source artifacts",
         "",
     ].join("\n");
 }
-function authoringCopyIfExists(sourcePath, targetPath) {
-    if (!existsSync(sourcePath))
-        return;
-    mkdirSync(dirname(targetPath), { recursive: true });
-    cpSync(sourcePath, targetPath, {
-        recursive: true,
-        force: true,
-        errorOnExist: false,
-        preserveTimestamps: true,
-    });
-}
-function projectCompiledPreviewSnapshot(previewCompiledPath, shellRoot) {
-    const previewRoot = join(shellRoot, "artifacts", "preview-compiled");
-    mkdirSync(previewRoot, { recursive: true });
-    authoringCopyIfExists(join(previewCompiledPath, "AGENTS.md"), join(previewRoot, "AGENTS.md"));
-    authoringCopyIfExists(join(previewCompiledPath, "CLAUDE.md"), join(previewRoot, "CLAUDE.md"));
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(previewCompiledPath));
-    for (const zone of schema?.zones ?? []) {
-        if (zone.kind === "runtime" || zone.role === "input")
-            continue;
-        const absolutePath = compiledZoneAbsolutePath(previewCompiledPath, zone);
-        if (!existsSync(absolutePath))
-            continue;
-        authoringCopyIfExists(absolutePath, join(previewRoot, zone.path));
-    }
+function improvementMethodDocsPath(compiledPath) {
+    return join(methodPackagePathForCompiled(compiledPath), "improve");
 }
-function projectCompiledPreviewRuntime(previewCompiledPath, shellRoot) {
-    const targetRoot = join(shellRoot, "artifacts", "preview-runtime");
-    mkdirSync(targetRoot, { recursive: true });
-    const runtimeRoot = compiledRuntimeRoot(previewCompiledPath);
-    for (const artifactName of [
-        "run.json",
-        "state.json",
-        "health.json",
-        "view-spec.json",
-        "raw-snapshot.json",
-        "execution-shells",
-        "logs",
-    ]) {
-        authoringCopyIfExists(join(runtimeRoot, artifactName), join(targetRoot, artifactName));
-    }
-}
-function improvementWorkflowDocsPath(compiledPath) {
-    return join(workflowPackagePathForCompiled(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(),
-        workflow_id: options.workflowId,
-        workflow_label: options.label,
-        seed_workflow_id: options.baseWorkflowId,
+        authoring_mode: "from-scratch",
+        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) => ({
@@ -792,104 +760,93 @@ export function createWorkflowAuthoringShell(options) {
                 })),
             },
         },
-        preview: options.preview
-            ? {
-                prepared: true,
-                compile_ok: options.preview.compileResult.ok,
-                failed_stage: options.preview.compileResult.failedStage,
-            }
-            : {
-                prepared: false,
-                compile_ok: null,
-                failed_stage: null,
-            },
     };
     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,
     });
-    if (options.preview) {
-        projectCompiledPreviewSnapshot(options.preview.compiledPath, shellRoot);
-        projectCompiledPreviewRuntime(options.preview.compiledPath, shellRoot);
-    }
-    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,
-        baseWorkflowId: options.baseWorkflowId,
-    }), "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.",
-        "- For acceptance rules, 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`.",
+        "- 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
             ? [
@@ -913,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;
@@ -945,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);
@@ -971,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,
@@ -983,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 });
@@ -993,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");
 }