@interf/compiler 0.16.0 → 0.18.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;

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),
@@ -365,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);
@@ -375,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"))
@@ -455,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/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) {
@@ -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-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, {

package/dist/packages/project/source-config.js

@@ -241,7 +241,8 @@ export function saveCompiledInterfConfig(compiledPath, config) {
 export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
     const current = readInterfConfig(compiledPath);
     const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
-    const preparationAbsolutePath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
+    const preparationAbsolutePath = resolveConfiguredSourceFolderPath(prepDataDir) ??
+        resolveSourcePreparationPath(prepDataDir, preparationConfig);
     const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
     const methodId = methodIdForSourcePreparationConfig(preparationConfig)
         ?? methodIdForSourcePreparationConfig(current)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
@@ -14,18 +14,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./contracts": {
-      "types": "./dist/packages/contracts/index.d.ts",
-      "import": "./dist/packages/contracts/index.js"
-    },
-    "./execution": {
-      "types": "./dist/packages/engine/execution/index.d.ts",
-      "import": "./dist/packages/engine/execution/index.js"
-    },
-    "./local-service": {
-      "types": "./dist/packages/engine/index.d.ts",
-      "import": "./dist/packages/engine/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -54,6 +42,7 @@
     "dist",
     "builtin-methods",
     "agent-skills",
+    "LICENSE.md",
     "TRADEMARKS.md"
   ],
   "publishConfig": {
@@ -67,13 +56,14 @@
     "claude",
     "codex"
   ],
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "author": "Interf Inc.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/interf-labs/interf.git"
+    "url": "git+https://github.com/interf-labs/compiler.git"
   },
   "bugs": {
-    "url": "https://github.com/interf-labs/interf/issues"
+    "url": "https://github.com/interf-labs/compiler/issues"
   },
   "homepage": "https://interf.com",
   "engines": {

package/dist/packages/engine/compile/runtime-acceptance.d.ts

@@ -1,9 +0,0 @@
-import { type CompiledState, type RuntimeStageAcceptance, type RuntimeStageContract } from "./lib/schema.js";
-import { type RuntimeStageAcceptanceValidation } from "./runtime-types.js";
-export declare function stageRecordFromState(state: CompiledState | null, stageId: string): Record<string, unknown> | null;
-export declare function validateResolvedStageAcceptance(dirPath: string, options: {
-    stageId: string;
-    acceptance?: RuntimeStageAcceptance;
-    counts?: Record<string, number>;
-}): RuntimeStageAcceptanceValidation;
-export declare function validateStageContractAcceptance(dirPath: string, contract?: RuntimeStageContract | null): RuntimeStageAcceptanceValidation;