@interf/compiler 0.13.0 → 0.18.0

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

@@ -1,10 +1,10 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
-import { MethodCompiledSchemaSchema, MethodZoneIdSchema, } from "../compiler/lib/schema.js";
-import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-method.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
+import { MethodCompiledSchemaSchema, MethodArtifactIdSchema, } from "../../engine/compile/lib/schema.js";
+import { listBuiltinCompiledArtifactSpecs, requiredCompiledArtifactOwners, } from "./builtin-compiled-method.js";
 // Method packages define the context interface. The compiler persists the
 // same schema on disk, but higher layers should prefer this boundary when they
 // mean "the Method-declared shape a portable context must implement."
@@ -15,7 +15,7 @@ export const ContextInterfaceSchema = MethodCompiledSchemaSchema;
 // Method expects to organize before the compiler materializes the context
 // interface on disk.
 export const MethodInputSpecSchema = z.object({
-    id: MethodZoneIdSchema,
+    id: MethodArtifactIdSchema,
     label: z.string().min(1),
     description: z.string().min(1),
     required: z.boolean().default(false),
@@ -27,13 +27,23 @@ function normalizeContextInterface(contextInterface) {
         kind: "method-schema",
     };
 }
-function pushContextInterfaceZone(zones, zone) {
-    if (zones.some((existing) => existing.path === zone.path))
-        return;
-    zones.push(zone);
+function artifactToMethodArtifact(artifact) {
+    const path = artifact.shape.kind === "path" ? artifact.shape.path : artifact.id;
+    return {
+        id: artifact.id,
+        role: "output",
+        path,
+        kind: artifact.shape.kind === "path" ? artifact.shape.artifact_kind : "directory",
+        required: true,
+        owned_by: [...artifact.built_by_stages],
+        description: artifact.description,
+    };
 }
-function titleCaseZoneId(zoneId) {
-    return zoneId
+export function listContextInterfaceArtifacts(contextInterface) {
+    return contextInterface.artifacts.map(artifactToMethodArtifact);
+}
+function titleCaseArtifactId(artifactId) {
+    return artifactId
         .split("-")
         .filter(Boolean)
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
@@ -49,53 +59,52 @@ export function resolveContextInterfacePath(rootPath) {
 export function contextInterfaceExists(rootPath) {
     return existsSync(contextInterfaceFilePath(rootPath));
 }
-export function contextInterfaceZoneAbsolutePath(compiledPath, zone) {
-    return join(compiledPath, zone.path);
+export function contextInterfaceArtifactAbsolutePath(compiledPath, artifact) {
+    return join(compiledPath, artifact.path);
 }
-export function contextInterfaceArtifactPath(zone) {
-    if (zone.kind === "file")
-        return zone.path;
-    return zone.path.endsWith("/") ? zone.path : `${zone.path}/`;
+export function contextInterfaceArtifactPath(artifact) {
+    if (artifact.kind === "file")
+        return artifact.path;
+    return artifact.path.endsWith("/") ? artifact.path : `${artifact.path}/`;
 }
 export function summarizeContextInterface(contextInterface) {
+    const artifacts = listContextInterfaceArtifacts(contextInterface);
     return {
-        inputZones: contextInterface.zones.filter((zone) => zone.role === "input"),
-        workingZones: contextInterface.zones.filter((zone) => zone.role === "working"),
-        outputZones: contextInterface.zones.filter((zone) => zone.role === "output"),
-        runtimeZones: contextInterface.zones.filter((zone) => zone.role === "runtime"),
+        inputArtifacts: artifacts.filter((artifact) => artifact.role === "input"),
+        workingArtifacts: artifacts.filter((artifact) => artifact.role === "working"),
+        outputArtifacts: artifacts.filter((artifact) => artifact.role === "output"),
+        runtimeArtifacts: artifacts.filter((artifact) => artifact.role === "runtime"),
     };
 }
 export function deriveMethodInputsFromContextInterface(contextInterface) {
     if (!contextInterface)
         return [];
-    return contextInterface.zones
-        .filter((zone) => zone.role === "input")
-        .map((zone) => ({
-        id: zone.id,
-        label: titleCaseZoneId(zone.id),
-        description: zone.description,
-        required: zone.required,
+    return listContextInterfaceArtifacts(contextInterface)
+        .filter((artifact) => artifact.role === "input")
+        .map((artifact) => ({
+        id: artifact.id,
+        label: titleCaseArtifactId(artifact.id),
+        description: artifact.description,
+        required: artifact.required,
     }));
 }
 export function buildContextInterface(stages, label = "Method context interface") {
-    const zones = [];
-    for (const zone of listBuiltinCompiledZoneSpecs()) {
-        pushContextInterfaceZone(zones, {
-            id: zone.id,
-            role: zone.role,
-            path: zone.path,
-            kind: zone.kind,
-            required: zone.required,
-            owned_by: requiredCompiledZoneOwners(stages, zone.id),
-            description: zone.description,
-        });
-    }
     return {
         kind: "method-schema",
         version: 1,
         target_type: "compiled",
         label,
-        zones,
+        artifacts: listBuiltinCompiledArtifactSpecs().map((artifact) => ({
+            id: artifact.id,
+            description: artifact.description,
+            shape: {
+                kind: "path",
+                path: artifact.path,
+                artifact_kind: artifact.kind === "file" ? "file" : "directory",
+            },
+            checks: [],
+            built_by_stages: requiredCompiledArtifactOwners(stages, artifact.id),
+        })),
     };
 }
 export function writeContextInterfaceFile(rootPath, stages, label) {

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

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { renderCompiledQuerySkill } from "../agents/lib/shells.js";
+import { renderCompiledQuerySkill } from "../../engine/agents/lib/shells.js";
 import { copyMethodPackageDirectory, isPortableMethodPackage, patchMethodPackageMetadata, resolveMethodPackageSourcePath, methodDefinitionPath, mergeStagePolicyNotesForStages, } 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 { CONTEXT_INTERFACE_FILE, deriveMethodInputsFromContextInterface, listContextInterfaceArtifacts, summarizeContextInterface, writeContextInterface, writeContextInterfaceFile, } from "./context-interface.js";
+import { methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
 function writeMethodStarterDocs(dirPath, docs, options) {
     for (const doc of docs ?? []) {
         const targetPath = join(dirPath, doc.relativePath);
@@ -47,7 +47,6 @@ function writeMethodPackageJson(rootPath, method, options) {
             skill_dir: stage.skillDir,
             reads: stage.reads,
             writes: stage.writes,
-            ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
         })),
         ...(method.stagePolicyNotes ? { stage_policy_notes: method.stagePolicyNotes } : {}),
     }, null, 2)}\n`);
@@ -60,9 +59,12 @@ function renderMethodReadme(method) {
     const interfaceSummary = contextInterface
         ? summarizeContextInterface(contextInterface)
         : null;
-    const contextInterfaceLines = contextInterface?.zones
-        ? contextInterface.zones
-            .map((zone) => `- \`${zone.id}\` — ${zone.role} ${zone.kind} at \`${zone.path}\`: ${zone.description}`)
+    const contextInterfaceArtifacts = contextInterface
+        ? listContextInterfaceArtifacts(contextInterface)
+        : [];
+    const contextInterfaceLines = contextInterfaceArtifacts.length > 0
+        ? contextInterfaceArtifacts
+            .map((artifact) => `- \`${artifact.id}\` — ${artifact.role} ${artifact.kind} Artifact at \`${artifact.path}\`: ${artifact.description}`)
             .join("\n")
         : null;
     const inputs = method.inputs?.length
@@ -75,10 +77,10 @@ function renderMethodReadme(method) {
         : null;
     const contextInterfaceSummaryLines = interfaceSummary
         ? [
-            `- Input zones: ${interfaceSummary.inputZones.length > 0 ? interfaceSummary.inputZones.map((zone) => `\`${zone.id}\``).join(", ") : "none"}`,
-            `- Working zones: ${interfaceSummary.workingZones.length > 0 ? interfaceSummary.workingZones.map((zone) => `\`${zone.id}\``).join(", ") : "none"}`,
-            `- Output zones: ${interfaceSummary.outputZones.length > 0 ? interfaceSummary.outputZones.map((zone) => `\`${zone.id}\``).join(", ") : "none"}`,
-            `- Runtime zones: ${interfaceSummary.runtimeZones.length > 0 ? interfaceSummary.runtimeZones.map((zone) => `\`${zone.id}\``).join(", ") : "none"}`,
+            `- Input Artifacts: ${interfaceSummary.inputArtifacts.length > 0 ? interfaceSummary.inputArtifacts.map((artifact) => `\`${artifact.id}\``).join(", ") : "none"}`,
+            `- Working Artifacts: ${interfaceSummary.workingArtifacts.length > 0 ? interfaceSummary.workingArtifacts.map((artifact) => `\`${artifact.id}\``).join(", ") : "none"}`,
+            `- Output Artifacts: ${interfaceSummary.outputArtifacts.length > 0 ? interfaceSummary.outputArtifacts.map((artifact) => `\`${artifact.id}\``).join(", ") : "none"}`,
+            `- Runtime Artifacts: ${interfaceSummary.runtimeArtifacts.length > 0 ? interfaceSummary.runtimeArtifacts.map((artifact) => `\`${artifact.id}\``).join(", ") : "none"}`,
         ].join("\n")
         : null;
     return [
@@ -113,7 +115,7 @@ function renderMethodReadme(method) {
                         "",
                     ]
                     : []),
-                "Zone map:",
+                "Artifact map:",
                 "",
                 contextInterfaceLines,
             ]
@@ -142,7 +144,7 @@ function renderDerivedMethodReadme(options) {
         options.hint,
         "",
         `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.",
+        "It starts with that Method's topology; edit the package when the agent work needs different stages, Artifacts, or checks.",
         "",
         "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.",
         "",
@@ -161,7 +163,7 @@ function renderSeedMethodReadme(options) {
         options.hint,
         "",
         `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.",
+        "It starts with that Method's topology; edit the package when the agent work needs different stages, Artifacts, or checks.",
         "",
         "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.",
         "",
@@ -206,7 +208,6 @@ function renderImproveSkill(method) {
 }
 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"
         ? [
             "- Valid abstract forms for deterministic validation are:",
@@ -223,27 +224,19 @@ function renderStageSkill(method, stage) {
         "## Stage Contract",
         "",
         `- Contract type: \`${stage.contractType}\``,
-        `- Reads zones: ${stage.reads.map((zoneId) => `\`${zoneId}\``).join(", ")}`,
-        `- Writes zones: ${stage.writes.map((zoneId) => `\`${zoneId}\``).join(", ")}`,
+        `- Reads Artifacts: ${stage.reads.map((artifactId) => `\`${artifactId}\``).join(", ")}`,
+        `- Writes Artifacts: ${stage.writes.map((artifactId) => `\`${artifactId}\``).join(", ")}`,
         "",
         "## Requirements",
         "",
         "- 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 Method-level acceptance aligned when you change this stage.",
+        "- Read only from the declared input Artifacts unless this package explicitly documents a broader method.",
+        "- Write only inside the declared output Artifacts for this stage. Do not invent undeclared Artifacts or implicit outputs.",
+        "- Keep stage instructions, artifact ownership, and Method-level checks 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,
         "",
-        ...(acceptanceKeys.length > 0
-            ? [
-                "## Declarative Acceptance",
-                "",
-                ...acceptanceKeys.map((key) => `- \`${key}\``),
-                "",
-            ]
-            : []),
         ...(notes.length > 0
             ? [
                 "## Notes",
@@ -428,24 +421,15 @@ export function createScratchLocalMethodPackage(options) {
             version: 1,
             target_type: "compiled",
             label: `${options.label} Method schema`,
-            zones: [
+            artifacts: [
                 {
                     id: "draft-context",
-                    role: "output",
-                    path: "draft",
-                    kind: "directory",
-                    required: true,
-                    owned_by: ["prepare"],
-                    description: "Temporary placeholder output zone for the neutral authoring scaffold. Replace it with task-specific output zones.",
-                },
-                {
-                    id: "runtime",
-                    role: "runtime",
-                    path: ".interf/runtime",
-                    kind: "runtime",
-                    required: true,
-                    owned_by: [],
-                    description: "CLI-owned runtime state, health, stage contracts, and proof artifacts.",
+                    description: "Temporary placeholder Artifact for the neutral authoring scaffold. Replace it with task-specific Artifacts.",
+                    shape: { kind: "path", path: "draft", artifact_kind: "directory" },
+                    checks: [
+                        { id: "exists", kind: "min_file_count", required: true, params: { min: 1 } },
+                    ],
+                    built_by_stages: ["prepare"],
                 },
             ],
         },
@@ -456,17 +440,15 @@ export function createScratchLocalMethodPackage(options) {
                 description: "Neutral placeholder stage for Method authoring. Replace this stage with the topology this agent work needs.",
                 contractType: "method-draft-stage",
                 skillDir: "prepare",
-                reads: ["runtime"],
+                role: "general",
+                reads: [],
                 writes: ["draft-context"],
-                acceptance: {
-                    stage_truthy: ["finished_at"],
-                },
             },
         ],
         stagePolicyNotes: {
             prepare: [
                 "This is a neutral authoring scaffold, not a recommended method topology.",
-                "Replace this stage, output zone, and proof rule when drafting the final method.",
+                "Replace this stage, Artifact, and check when drafting the final method.",
             ],
         },
         starterDocs: [

package/dist/packages/{method-package → methods/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/method-package/lib/ -> package root)
-export const PACKAGE_ROOT = join(__dirname, "..", "..", "..", "..");
+// Package root (dist/packages/methods/package/lib/ -> package root)
+export const PACKAGE_ROOT = join(__dirname, "..", "..", "..", "..", "..");

package/dist/packages/{method-package → methods/package}/local-methods.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema } from "../compiler/lib/schema.js";
-import { RuntimeContractTypeSchema } from "../contracts/lib/schema.js";
+import { MethodCompilerApiSchema, MethodPurposeSchema, type MethodStageArtifactReadAccess, type MethodStageArtifactWriteAccess } from "../../engine/compile/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;
@@ -12,9 +12,14 @@ export interface LocalMethodStageDefinition {
     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>;
+    /**
+     * Optional role hint. Open-ended string; defaults to `general` at the
+     * runtime layer when missing. Maps to a connected agent via the user's
+     * role-map (`~/.interf/agents.json`).
+     */
+    role?: string;
+    reads: MethodStageArtifactReadAccess;
+    writes: MethodStageArtifactWriteAccess;
 }
 export interface LocalMethodDefinition {
     id: string;

package/dist/packages/{method-package → methods/package}/local-methods.js

@@ -1,15 +1,14 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
 import { z } from "zod";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
-import { isMarkdownFile } from "../shared/file-types.js";
-import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema, } from "../compiler/lib/schema.js";
-import { RuntimeContractTypeSchema, InterfIdPattern, } from "../contracts/lib/schema.js";
-import { asPreparationDataDir, preparationMethodsRoot, } from "../contracts/lib/preparation-paths.js";
-import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-method.js";
-import { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, contextInterfaceExists, contextInterfaceFilePath, readContextInterface, MethodInputSpecSchema, writeContextInterface, } from "./context-interface.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { isMarkdownFile } from "../../contracts/utils/file-types.js";
+import { MethodCompilerApiSchema, MethodPurposeSchema, MethodStageArtifactReadAccessSchema, MethodStageArtifactWriteAccessSchema, } from "../../engine/compile/lib/schema.js";
+import { RuntimeContractTypeSchema, InterfIdPattern, } from "../../contracts/lib/schema.js";
+import { asPreparationDataDir, preparationMethodsRoot, } from "../../contracts/lib/preparation-paths.js";
+import { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, contextInterfaceExists, contextInterfaceFilePath, listContextInterfaceArtifacts, readContextInterface, MethodInputSpecSchema, writeContextInterface, } from "./context-interface.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
 const LocalMethodStageDefinitionSchema = z.object({
     id: z.string().regex(InterfIdPattern),
@@ -17,9 +16,9 @@ const LocalMethodStageDefinitionSchema = z.object({
     contract_type: RuntimeContractTypeSchema,
     skill_dir: z.string().regex(InterfIdPattern).optional(),
     description: z.string().min(1).optional(),
-    reads: MethodStageZoneAccessSchema,
-    writes: MethodStageZoneAccessSchema,
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
+    role: z.string().min(1).optional(),
+    reads: MethodStageArtifactReadAccessSchema,
+    writes: MethodStageArtifactWriteAccessSchema,
 });
 const LocalMethodDefinitionSchema = z.object({
     id: z.string().regex(InterfIdPattern),
@@ -364,8 +363,9 @@ export function validateMethodPackage(dirPath) {
         const stages = def.stages ?? [];
         const stageIds = new Set(stages.map((stage) => stage.id));
         const seenPaths = new Map();
-        const seenZoneIds = new Set();
-        const zoneById = new Map(methodSchema.zones.map((zone) => [zone.id, zone]));
+        const seenArtifactIds = new Set();
+        const schemaArtifacts = listContextInterfaceArtifacts(methodSchema);
+        const artifactById = new Map(schemaArtifacts.map((artifact) => [artifact.id, artifact]));
         const normalizedParts = (value) => value.replaceAll("\\", "/").split("/").filter(Boolean);
         const hasOverlappingPath = (value, other) => {
             const a = normalizedParts(value);
@@ -374,78 +374,51 @@ export function validateMethodPackage(dirPath) {
             const longer = a.length <= b.length ? b : a;
             return shorter.every((part, index) => longer[index] === part);
         };
-        for (const zone of methodSchema.zones) {
-            if (seenZoneIds.has(zone.id)) {
-                errors.push(`method.schema.json repeats zone id "${zone.id}".`);
+        for (const artifact of schemaArtifacts) {
+            if (seenArtifactIds.has(artifact.id)) {
+                errors.push(`method.schema.json repeats Artifact id "${artifact.id}".`);
             }
-            seenZoneIds.add(zone.id);
-            const existingPathOwner = seenPaths.get(zone.path);
+            seenArtifactIds.add(artifact.id);
+            const existingPathOwner = seenPaths.get(artifact.path);
             if (existingPathOwner) {
-                errors.push(`method.schema.json repeats zone path "${zone.path}".`);
+                errors.push(`method.schema.json repeats Artifact path "${artifact.path}".`);
             }
             for (const [existingPath, existingZoneId] of seenPaths.entries()) {
-                if (existingPath === zone.path)
+                if (existingPath === artifact.path)
                     continue;
-                if (hasOverlappingPath(zone.path, existingPath)) {
-                    errors.push(`method.schema.json zones "${zone.id}" and "${existingZoneId}" overlap on path "${zone.path}" / "${existingPath}".`);
+                if (hasOverlappingPath(artifact.path, existingPath)) {
+                    errors.push(`method.schema.json Artifacts "${artifact.id}" and "${existingZoneId}" overlap on path "${artifact.path}" / "${existingPath}".`);
                 }
             }
-            seenPaths.set(zone.path, zone.id);
-            if ((zone.role === "input" || zone.role === "runtime") && zone.owned_by.length > 0) {
-                errors.push(`method.schema.json zone "${zone.id}" cannot declare owners because its role is "${zone.role}".`);
+            seenPaths.set(artifact.path, artifact.id);
+            if ((artifact.role === "input" || artifact.role === "runtime") && artifact.owned_by.length > 0) {
+                errors.push(`method.schema.json Artifact "${artifact.id}" cannot declare owners because its role is "${artifact.role}".`);
             }
-            for (const owner of zone.owned_by) {
+            for (const owner of artifact.owned_by) {
                 if (!stageIds.has(owner)) {
-                    errors.push(`method.schema.json references unknown stage "${owner}" for zone "${zone.path}".`);
+                    errors.push(`method.schema.json references unknown stage "${owner}" for Artifact path "${artifact.path}".`);
                 }
             }
         }
         for (const stage of stages) {
-            for (const zoneId of stage.reads) {
-                if (!zoneById.has(zoneId)) {
-                    errors.push(`Stage "${stage.id}" reads unknown zone "${zoneId}".`);
+            for (const artifactId of stage.reads) {
+                if (!artifactById.has(artifactId)) {
+                    errors.push(`Stage "${stage.id}" reads unknown Artifact "${artifactId}".`);
                 }
             }
-            for (const zoneId of stage.writes) {
-                const zone = zoneById.get(zoneId);
-                if (!zone) {
-                    errors.push(`Stage "${stage.id}" writes unknown zone "${zoneId}".`);
+            for (const artifactId of stage.writes) {
+                const artifact = artifactById.get(artifactId);
+                if (!artifact) {
+                    errors.push(`Stage "${stage.id}" writes unknown Artifact "${artifactId}".`);
                     continue;
                 }
-                if (zone.role === "input" || zone.role === "runtime") {
-                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but zones with role "${zone.role}" are engine-owned inputs, not writable stage outputs.`);
+                if (artifact.role === "input" || artifact.role === "runtime") {
+                    errors.push(`Stage "${stage.id}" writes Artifact "${artifactId}" but Artifacts with role "${artifact.role}" are engine-owned inputs, not writable stage outputs.`);
                 }
-                if (!zone.owned_by.includes(stage.id)) {
-                    errors.push(`Stage "${stage.id}" writes zone "${zoneId}" but that zone is not owned by the stage in method.schema.json.`);
+                if (!artifact.owned_by.includes(stage.id)) {
+                    errors.push(`Stage "${stage.id}" writes Artifact "${artifactId}" but that Artifact is not owned by the stage in method.schema.json.`);
                 }
             }
-            for (const artifactPath of Object.keys(stage.acceptance?.artifacts_must_not_contain ?? {})) {
-                const normalizedArtifactPath = artifactPath.replaceAll("\\", "/");
-                const artifactParts = normalizedArtifactPath.split("/").filter(Boolean);
-                if (artifactPath.startsWith("/") ||
-                    artifactPath.startsWith("\\") ||
-                    artifactParts.some((part) => part === "..")) {
-                    errors.push(`Stage "${stage.id}" artifacts_must_not_contain key "${artifactPath}" must be a portable-context relative artifact path.`);
-                    continue;
-                }
-                const matchingZone = zoneById.get(artifactPath);
-                if (matchingZone) {
-                    errors.push(`Stage "${stage.id}" artifacts_must_not_contain key "${artifactPath}" is a zone id. Use the zone path "${matchingZone.path}" instead.`);
-                }
-            }
-        }
-        for (const requiredZone of listBuiltinCompiledZoneSpecs().filter((zone) => zone.id === "runtime")) {
-            const match = zoneById.get(requiredZone.id);
-            if (!match) {
-                errors.push(`method.schema.json is missing required zone "${requiredZone.id}".`);
-                continue;
-            }
-            if (match.kind !== requiredZone.kind) {
-                errors.push(`method.schema.json zone "${requiredZone.id}" should be kind "${requiredZone.kind}".`);
-            }
-            if (match.role !== requiredZone.role) {
-                errors.push(`method.schema.json zone "${requiredZone.id}" should have role "${requiredZone.role}".`);
-            }
         }
     }
     const stageDirs = existsSync(join(dirPath, "compile", "stages"))
@@ -454,8 +427,8 @@ export function validateMethodPackage(dirPath) {
     const counts = {
         starter_docs: collectStarterDocs(dirPath).length,
         compile_stage_docs: stageDirs.length,
-        compiled_zones: methodSchema?.zones.length ?? 0,
-        method_zones: methodSchema?.zones.length ?? 0,
+        compiled_artifacts: methodSchema ? listContextInterfaceArtifacts(methodSchema).length : 0,
+        method_artifacts: methodSchema ? listContextInterfaceArtifacts(methodSchema).length : 0,
     };
     return {
         ok: errors.length === 0,

package/dist/packages/{method-package → methods/package}/method-definitions.d.ts

@@ -1,7 +1,7 @@
 import { type LocalMethodDefinition } from "./local-methods.js";
-import type { RuntimeStageAcceptance, MethodCompilerApi } from "../compiler/lib/schema.js";
-import type { MethodId, RuntimeContractType } from "../contracts/lib/schema.js";
-import { type ContextInterface, type ContextInterfaceZoneId, type MethodInputSpec } from "./context-interface.js";
+import type { MethodCompilerApi } from "../../engine/compile/lib/schema.js";
+import type { MethodId, RuntimeContractType } from "../../contracts/lib/schema.js";
+import { type ContextInterface, type ContextInterfaceArtifactId, type MethodInputSpec } from "./context-interface.js";
 export interface MethodStarterDoc {
     relativePath: string;
     content: string;
@@ -12,9 +12,14 @@ export interface MethodStageDefinition {
     description: string;
     contractType: RuntimeContractType;
     skillDir: string;
-    reads: ContextInterfaceZoneId[];
-    writes: ContextInterfaceZoneId[];
-    acceptance?: RuntimeStageAcceptance;
+    /**
+     * Role hint declared by the Method package. Defaults to `general` when
+     * absent; mapped to a connected agent via the user's role-map at run
+     * time.
+     */
+    role: string;
+    reads: ContextInterfaceArtifactId[];
+    writes: ContextInterfaceArtifactId[];
 }
 export interface MethodDefinition<TId extends string> {
     id: TId;
@@ -53,5 +58,4 @@ export declare function getMethodStagePosition(methodId: MethodId, stage: string
 export declare function getMethodStages(methodId: MethodId, prepDataDir?: string): string[];
 export declare function getActiveCompiledStages(compiledPath: string): string[];
 export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, stage: string): string[];
-export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, stage: string): MethodStageDefinition["acceptance"] | undefined;
 export declare function formatActiveCompiledMethodStageStep(compiledPath: string, stage: string): string;

package/dist/packages/{method-package → methods/package}/method-definitions.js

@@ -2,10 +2,10 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { builtinMethodPackagePath, isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, mergeStagePolicyNotesForStages, } from "./local-methods.js";
 import { listUserMethodDefinitions, loadUserMethodDefinition, } from "./user-methods.js";
-import { warnInterf } from "../shared/logger.js";
-import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
-import { asPreparationDataDir, preparationMethodPackagePath } from "../contracts/lib/preparation-paths.js";
-import { resolveSourceControlPath } from "../project-model/interf.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
+import { asPreparationDataDir, preparationMethodPackagePath } from "../../contracts/lib/preparation-paths.js";
+import { resolveSourceControlPath } from "../../project/interf.js";
 import { deriveMethodInputsFromContextInterface, } from "./context-interface.js";
 const DEFAULT_METHOD_ID = "interf-default";
 let builtinDefaultMethodCache = null;
@@ -16,9 +16,9 @@ function toMethodStages(stages) {
         description: stage.description ?? stage.label,
         contractType: stage.contract_type,
         skillDir: stage.skill_dir ?? stage.id,
+        role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
         reads: [...stage.reads],
         writes: [...stage.writes],
-        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
     }));
 }
 export function standaloneMethodDefinitionFromLocalPackage(local) {
@@ -209,9 +209,6 @@ export function getActiveCompiledStagePolicyNotes(compiledPath, stage) {
     const method = getActiveCompiledMethod(compiledPath);
     return [...(method.stagePolicyNotes?.[stage] ?? [])];
 }
-export function resolveActiveCompiledStageAcceptance(compiledPath, stage) {
-    return getActiveCompiledMethod(compiledPath).stages.find((candidate) => candidate.id === stage)?.acceptance;
-}
 export function formatActiveCompiledMethodStageStep(compiledPath, stage) {
     return formatMethodStageStep(getActiveCompiledMethod(compiledPath), stage);
 }

package/dist/packages/{method-package → methods/package}/method-helpers.d.ts

@@ -1,5 +1,4 @@
-import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../compiler/lib/schema.js";
-import { type MethodStageDefinition } from "./method-definitions.js";
+import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
 export interface MethodReporter {
     line?: (message: string) => void;
     blankLine?: () => void;
@@ -23,4 +22,3 @@ export declare function buildStageInstructions(stageSkillDir: string, localSkill
 export declare function reportLine(reporter: MethodReporter | undefined, message: string): void;
 export declare function reportBlankLine(reporter: MethodReporter | undefined): void;
 export declare function reportValidationFailure(reporter: MethodReporter | undefined, summary: string, errors?: string[]): void;
-export declare function resolveStageAcceptance(methodId: string, stageId: string, prepDataDir?: string): MethodStageDefinition["acceptance"] | undefined;

package/dist/packages/{method-package → methods/package}/method-helpers.js

@@ -1,10 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
-import { isMarkdownFile } from "../shared/file-types.js";
-import { getCompiledMethod, } from "./method-definitions.js";
-import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
+import { isMarkdownFile } from "../../contracts/utils/file-types.js";
+import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
 export function methodCompileStageDirectory(stageDir) {
     return `${COMPILED_METHOD_DIR}/compile/stages/${stageDir}`;
@@ -128,6 +127,3 @@ export function reportValidationFailure(reporter, summary, errors = []) {
         reportLine(reporter, `- ${error}`);
     }
 }
-export function resolveStageAcceptance(methodId, stageId, prepDataDir) {
-    return getCompiledMethod(methodId, { prepDataDir }).stages.find((stage) => stage.id === stageId)?.acceptance;
-}

package/dist/packages/{method-package → methods/package}/method-review-paths.d.ts

@@ -1,4 +1,4 @@
-import type { MethodImprovementContext } from "../compiler/lib/schema.js";
+import type { MethodImprovementContext } from "../../engine/compile/lib/schema.js";
 export interface MethodImprovementReviewSourcePaths {
     compiledRuntime: string | null;
     readinessRuns: string | null;