@interf/compiler 0.16.0 → 0.21.0

package/dist/packages/methods/package/interf-method-package.js

@@ -3,7 +3,7 @@ import { dirname, join } from "node:path";
 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 { 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 ?? []) {
@@ -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"],
                 },
             ],
         },
@@ -457,17 +441,14 @@ export function createScratchLocalMethodPackage(options) {
                 contractType: "method-draft-stage",
                 skillDir: "prepare",
                 role: "general",
-                reads: ["runtime"],
+                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/methods/package/local-methods.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { MethodCompilerApiSchema, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema } from "../../engine/compile/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 {
@@ -18,9 +18,8 @@ export interface LocalMethodStageDefinition {
      * role-map (`~/.interf/agents.json`).
      */
     role?: string;
-    reads: z.infer<typeof MethodStageZoneAccessSchema>;
-    writes: z.infer<typeof MethodStageZoneAccessSchema>;
-    acceptance?: z.infer<typeof RuntimeStageAcceptanceSchema>;
+    reads: MethodStageArtifactReadAccess;
+    writes: MethodStageArtifactWriteAccess;
 }
 export interface LocalMethodDefinition {
     id: string;
@@ -44,6 +43,7 @@ export declare function mergeStagePolicyNotesForStages(stages: readonly {
 export declare function builtinMethodPackagePath(methodId: string): string;
 export declare function methodDefinitionPath(prepDataDir: string, id: string): string;
 export declare function loadMethodDefinitionFromDir(dirPath: string): LocalMethodDefinition | null;
+export declare function isNeutralScaffoldMethodDefinition(definition: Pick<LocalMethodDefinition, "purpose" | "stages" | "method_schema">): boolean;
 export declare function listLocalMethodDefinitions(prepDataDir: string): LocalMethodDefinition[];
 export declare function loadLocalMethodDefinition(prepDataDir: string, id: string): LocalMethodDefinition | null;
 export declare function resolveMethodPackageSourcePath(prepDataDir: string, methodId: string): string | null;

package/dist/packages/methods/package/local-methods.js

@@ -5,11 +5,10 @@ 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, RuntimeStageAcceptanceSchema, MethodPurposeSchema, MethodStageZoneAccessSchema, } from "../../engine/compile/lib/schema.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 { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-method.js";
-import { CONTEXT_INTERFACE_FILE, ContextInterfaceSchema, contextInterfaceExists, contextInterfaceFilePath, readContextInterface, MethodInputSpecSchema, writeContextInterface, } from "./context-interface.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),
@@ -18,9 +17,8 @@ const LocalMethodStageDefinitionSchema = z.object({
     skill_dir: z.string().regex(InterfIdPattern).optional(),
     description: z.string().min(1).optional(),
     role: z.string().min(1).optional(),
-    reads: MethodStageZoneAccessSchema,
-    writes: MethodStageZoneAccessSchema,
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
+    reads: MethodStageArtifactReadAccessSchema,
+    writes: MethodStageArtifactWriteAccessSchema,
 });
 const LocalMethodDefinitionSchema = z.object({
     id: z.string().regex(InterfIdPattern),
@@ -68,7 +66,7 @@ function methodRootPath(prepDataDir) {
     return preparationMethodsRoot(asPreparationDataDir(prepDataDir));
 }
 export function builtinMethodPackagePath(methodId) {
-    return join(PACKAGE_ROOT, "builtin-methods", methodId);
+    return join(PACKAGE_ROOT, "public-repo", "methods", methodId);
 }
 export function methodDefinitionPath(prepDataDir, id) {
     return join(methodRootPath(prepDataDir), id);
@@ -141,6 +139,16 @@ export function loadMethodDefinitionFromDir(dirPath) {
         methodSchemaPath: contextInterfaceFilePath(dirPath),
     };
 }
+export function isNeutralScaffoldMethodDefinition(definition) {
+    const hasScaffoldPurpose = definition.purpose?.label === "From-scratch Method draft" ||
+        Boolean(definition.purpose?.task_hint?.includes("Replace this neutral scaffold"));
+    const hasScaffoldStage = Boolean(definition.stages?.some((stage) => stage.id === "prepare" &&
+        stage.contract_type === "method-draft-stage" &&
+        stage.writes.includes("draft-context")));
+    const hasScaffoldArtifact = listContextInterfaceArtifacts(definition.method_schema).some((artifact) => artifact.id === "draft-context" &&
+        artifact.description.includes("neutral authoring scaffold"));
+    return hasScaffoldPurpose || hasScaffoldStage || hasScaffoldArtifact;
+}
 export function listLocalMethodDefinitions(prepDataDir) {
     const definitions = new Map();
     const root = methodRootPath(prepDataDir);
@@ -154,18 +162,23 @@ export function listLocalMethodDefinitions(prepDataDir) {
                 continue;
             }
             const definition = loadMethodDefinitionFromDir(entryPath);
-            if (definition)
+            if (definition && !isNeutralScaffoldMethodDefinition(definition)) {
                 definitions.set(definition.id, definition);
+            }
         }
     }
     return [...definitions.values()].sort((a, b) => a.label.localeCompare(b.label));
 }
 export function loadLocalMethodDefinition(prepDataDir, id) {
-    return loadMethodDefinitionFromDir(methodDefinitionPath(prepDataDir, id));
+    const definition = loadMethodDefinitionFromDir(methodDefinitionPath(prepDataDir, id));
+    if (!definition || isNeutralScaffoldMethodDefinition(definition))
+        return null;
+    return definition;
 }
 export function resolveMethodPackageSourcePath(prepDataDir, methodId) {
     const localPath = methodDefinitionPath(prepDataDir, methodId);
-    if (loadMethodDefinitionFromDir(localPath))
+    const local = loadMethodDefinitionFromDir(localPath);
+    if (local && !isNeutralScaffoldMethodDefinition(local))
         return localPath;
     const builtinPath = builtinMethodPackagePath(methodId);
     if (loadMethodDefinitionFromDir(builtinPath))
@@ -365,8 +378,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);
@@ -375,79 +389,52 @@ 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 (!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.`);
-                }
-            }
-            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;
+                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.`);
                 }
-                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.`);
+                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 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"))
         ? listFilesRecursive(join(dirPath, "compile", "stages"), (filePath) => basename(filePath) === "SKILL.md")
@@ -455,8 +442,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/methods/package/method-definitions.d.ts

@@ -1,7 +1,7 @@
 import { type LocalMethodDefinition } from "./local-methods.js";
-import type { RuntimeStageAcceptance, MethodCompilerApi } from "../../engine/compile/lib/schema.js";
+import type { MethodCompilerApi } from "../../engine/compile/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 ContextInterface, type ContextInterfaceArtifactId, type MethodInputSpec } from "./context-interface.js";
 export interface MethodStarterDoc {
     relativePath: string;
     content: string;
@@ -18,9 +18,8 @@ export interface MethodStageDefinition {
      * time.
      */
     role: string;
-    reads: ContextInterfaceZoneId[];
-    writes: ContextInterfaceZoneId[];
-    acceptance?: RuntimeStageAcceptance;
+    reads: ContextInterfaceArtifactId[];
+    writes: ContextInterfaceArtifactId[];
 }
 export interface MethodDefinition<TId extends string> {
     id: TId;
@@ -59,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/methods/package/method-definitions.js

@@ -19,7 +19,6 @@ function toMethodStages(stages) {
         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) {
@@ -62,7 +61,7 @@ function getBuiltinDefaultMethod() {
         return builtinDefaultMethodCache;
     const local = loadMethodDefinitionFromDir(builtinMethodPackagePath(DEFAULT_METHOD_ID));
     if (!local) {
-        throw new Error(`Missing built-in Interf Method package at builtin-methods/${DEFAULT_METHOD_ID}.`);
+        throw new Error(`Missing built-in Interf Method package at public-repo/methods/${DEFAULT_METHOD_ID}.`);
     }
     const resolved = standaloneMethodDefinitionFromLocalPackage(local);
     builtinDefaultMethodCache = {
@@ -210,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/methods/package/method-helpers.d.ts

@@ -1,5 +1,4 @@
 import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
-import { type MethodStageDefinition } from "./method-definitions.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/methods/package/method-helpers.js

@@ -3,7 +3,6 @@ import { join, relative, sep } from "node:path";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
 import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { isMarkdownFile } from "../../contracts/utils/file-types.js";
-import { getCompiledMethod, } from "./method-definitions.js";
 import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../../engine/compile/compiled-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
 export function methodCompileStageDirectory(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/project/interf-detect.js

@@ -80,7 +80,7 @@ export function listPortableContextsForSourceFolder(prepDataDir) {
             return [];
     }
     catch (error) {
-        warnInterf(`Warning: failed to inspect Interf Workspace at ${prepDataDir}: ${error instanceof Error ? error.message : String(error)}`);
+        warnInterf(`Warning: failed to inspect Interf preparation data folder at ${prepDataDir}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
     return readdirSync(prepDataDir)
@@ -100,7 +100,7 @@ export function assertCompiledContainer(prepDataDir) {
     if (existsSync(prepDataDir)) {
         const stat = statSync(prepDataDir);
         if (!stat.isDirectory()) {
-            throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
+            throw new Error(`Interf preparation data folder exists and is not a directory: ${prepDataDir}`);
         }
         const unexpectedRootEntries = readdirSync(prepDataDir).filter((entry) => {
             if (entry.startsWith("."))
@@ -121,7 +121,7 @@ export function assertCompiledContainer(prepDataDir) {
                     return !statSync(entryPath).isDirectory();
                 }
                 catch (error) {
-                    warnInterf(`Warning: failed to inspect Interf Workspace path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    warnInterf(`Warning: failed to inspect Interf preparation data path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
                     return true;
                 }
             }
@@ -134,7 +134,7 @@ export function assertCompiledContainer(prepDataDir) {
             }
         });
         if (unexpectedRootEntries.length > 0) {
-            throw new Error(`Interf Workspace contains unexpected entries: ${prepDataDir}`);
+            throw new Error(`Interf preparation data folder contains unexpected entries: ${prepDataDir}`);
         }
     }
     if (!existsSync(prepDataDir)) {
@@ -142,7 +142,7 @@ export function assertCompiledContainer(prepDataDir) {
     }
     const stat = statSync(prepDataDir);
     if (!stat.isDirectory()) {
-        throw new Error(`Interf Workspace exists and is not a directory: ${prepDataDir}`);
+        throw new Error(`Interf preparation data folder exists and is not a directory: ${prepDataDir}`);
     }
     const unexpectedEntries = readdirSync(prepDataDir).filter((entry) => {
         if (entry.startsWith("."))
@@ -172,7 +172,7 @@ export function assertCompiledContainer(prepDataDir) {
         return false;
     });
     if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf Workspace contains invalid Preparation entries: ${prepDataDir}`);
+        throw new Error(`Interf preparation data folder contains invalid Preparation entries: ${prepDataDir}`);
     }
     return prepDataDir;
 }

package/dist/packages/project/interf-scaffold.js

@@ -7,8 +7,8 @@ import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-
 import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
 import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
-import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { ensureCompiledArtifactTargets, listCompiledSchemaArtifacts, readCompiledSchemaFile } from "../engine/compile/compiled-schema.js";
+import { findSourcePreparationConfig, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
 import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../engine/compile/compiled-paths.js";
 import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
 const DEFAULT_INTERFIGNORE = [
@@ -33,11 +33,11 @@ function renderUncompiledCompiledFile(compiledName, relativePath, about) {
 }
 function compiledGitignoreEntries(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zoneEntries = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
+    const artifactEntries = (schema ? listCompiledSchemaArtifacts(schema) : [])
+        .filter((artifact) => artifact.kind !== "runtime")
+        .map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`);
     return [
-        ...zoneEntries,
+        ...artifactEntries,
         ".claude/",
         ".codex/",
         ".agents/",
@@ -52,14 +52,14 @@ function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
     if (!schema) {
         throw new Error(`Missing Method schema at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
-    ensureCompiledZoneTargets(compiledPath, schema);
-    for (const zone of schema.zones) {
-        if (!zone.required || zone.kind !== "file" || zone.role !== "output")
+    ensureCompiledArtifactTargets(compiledPath, schema);
+    for (const artifact of listCompiledSchemaArtifacts(schema)) {
+        if (!artifact.required || artifact.kind !== "file" || artifact.role !== "output")
             continue;
-        const targetPath = join(compiledPath, zone.path);
+        const targetPath = join(compiledPath, artifact.path);
         if (existsSync(targetPath))
             continue;
-        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
+        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, artifact.path, about));
     }
 }
 function localMethodMatches(compiledPath, methodId) {
@@ -99,7 +99,7 @@ export function createCompiled(name, prepDataDir, methodId = DEFAULT_METHOD_ID,
     const compiledPath = ensurePortableContextScaffold(prepDataDir, name, selectedMethod.id);
     const resolvedAbout = about ?? savedCompiled?.about;
     const resolvedSourceFolderPath = savedCompiled
-        ? resolveSourcePreparationPath(prepDataDir, savedCompiled)
+        ? resolveConfiguredSourceFolderPath(prepDataDir) ?? resolveSourcePreparationPath(prepDataDir, savedCompiled)
         : sourceFolderPath;
     const sourceRelativePath = relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
     saveCompiledInterfConfig(compiledPath, {