@interf/compiler 0.16.0 → 0.18.0

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

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { createMethodAuthoringShell } from "../../engine/agents/lib/shells.js";
+import { createMethodAuthoringShell, } from "../../engine/agents/lib/shells.js";
 import { createScratchLocalMethodPackage } from "../package/interf-method-package.js";
-import { CONTEXT_INTERFACE_FILE } from "../package/context-interface.js";
+import { CONTEXT_INTERFACE_FILE, listContextInterfaceArtifacts } from "../package/context-interface.js";
 import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../package/local-methods.js";
 import { runMethodEditSession } from "./method-edit-session.js";
 /**
@@ -66,29 +66,27 @@ function buildMethodAuthoringPrompt() {
         "Treat `task_prompt` as the user's preparation-and-evidence brief: source data, output shape, and evidence that should show the data is ready.",
         `Then read \`method/README.md\`, \`method/method.json\`, and \`method/${CONTEXT_INTERFACE_FILE}\`.`,
         "The `method/` directory starts as a neutral Method package scaffold, not as a suggested Method.",
-        "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this agent work actually needs.",
+        "Replace the scaffold purpose, inputs, Artifacts, stages, stage docs, checks, and query guidance with the Method this agent work actually needs.",
         "Read `runtime/source-files.json` and inspect the listed source locators before editing the package.",
         "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
         "Edit only files under `method/`.",
         "Keep the Method package valid for the current compiler API and `method.schema.json`.",
-        "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
-        "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+        "Choose stage ids, stage order, artifact reads, artifact writes, artifact checks, and stage docs from the source data and preparation-and-evidence brief.",
+        "Use kebab-case ids everywhere: stage ids, skill_dir values, Artifact ids, reads/writes values, and package ids. Never use underscores.",
         "Each stage MAY declare a `role`: one of `extractor`, `summarizer`, `structurer`, `verifier`, or `general`. Pick the role that best matches what the stage's prompt asks the agent to do. Omit `role` (or use `general`) when the stage doesn't fit any specialized role. Custom role names are allowed; the engine treats unknown roles as `general`.",
         "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
-        "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
-        "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
-        "For file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`.",
-        "Before stopping, verify every zone-count acceptance key is declared in `method.schema.json`.",
+        "Put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks.",
+        "Use only the CheckKind values listed in `runtime/authoring-context.json`; do not invent aliases.",
+        "Keep Artifact checks and the producing stage docs aligned: every checked output requirement must be described in the stage doc that writes that Artifact.",
         "For every stage in `method.json`, create `method/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's kebab-case `skill_dir`.",
-        "Every zone path in `method.schema.json` must be unique and non-overlapping. Do not declare both `knowledge/indexes` and `knowledge/indexes/some-file.md` as separate zones.",
+        "Every Artifact path in `method.schema.json` must be unique and non-overlapping.",
         "Make the package materially specific to this Preparation task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
         "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
-        "Keep the portable-context entrypoint canonical: if the Method writes an agent entrypoint, declare zone id `home` with path `home.md` and make the final shaping stage own it.",
-        "Do not move the main entrypoint to `knowledge/home.md` or any other nested path.",
+        "If the Method writes an agent entrypoint, declare it as an Artifact and make the final shaping stage own it.",
         "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
         "Do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path.",
-        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read Artifacts.",
         "Do not make one stage point at files or notes that are only created later by another stage.",
         "Prefer conservative retrieval routing over speculative note sprawl.",
         "Do not narrate plans or ask follow-up questions.",
@@ -96,7 +94,87 @@ function buildMethodAuthoringPrompt() {
         "As soon as the Method edits are complete, stop.",
     ].join("\n");
 }
-function validateAuthoredMethodPackage(methodPath) {
+function stableJson(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value ?? {});
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`)
+        .join(",")}}`;
+}
+function checkMatchesRequirement(actual, required) {
+    return actual.id === required.id &&
+        actual.kind === required.kind &&
+        (actual.required ?? true) === (required.required ?? true) &&
+        stableJson(actual.params) === stableJson(required.params);
+}
+function producingStagesForArtifact(definition, artifactId) {
+    return (definition.stages ?? []).filter((stage) => Array.isArray(stage.writes) && stage.writes.includes(artifactId));
+}
+function readProducingStageDocs(methodPath, stages) {
+    return stages
+        .map((stage) => join(methodPath, "compile", "stages", stage.skill_dir ?? stage.id, "SKILL.md"))
+        .filter((filePath) => existsSync(filePath))
+        .map((filePath) => readFileSync(filePath, "utf8"))
+        .join("\n");
+}
+function validateMustContainStageDocs(methodPath, definition) {
+    const artifacts = definition.method_schema.artifacts ?? [];
+    const errors = [];
+    for (const artifact of artifacts) {
+        const producingStages = producingStagesForArtifact(definition, artifact.id);
+        if (producingStages.length === 0)
+            continue;
+        const producingStageDocs = readProducingStageDocs(methodPath, producingStages);
+        for (const check of artifact.checks ?? []) {
+            if (check.kind !== "must_contain")
+                continue;
+            const phrases = check.params?.phrases;
+            if (!Array.isArray(phrases))
+                continue;
+            for (const phrase of phrases) {
+                if (typeof phrase !== "string")
+                    continue;
+                if (!producingStageDocs.includes(phrase)) {
+                    errors.push(`Artifact \`${artifact.id}\` check \`${check.id}\` requires phrase not present in producing stage docs.`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+function validateArtifactRequirements(methodPath, definition, requirements) {
+    const artifacts = definition.method_schema.artifacts ?? [];
+    const errors = [];
+    for (const requirement of requirements) {
+        const artifact = artifacts.find((candidate) => candidate.id === requirement.id);
+        if (!artifact) {
+            errors.push(`Missing required Artifact \`${requirement.id}\`.`);
+            continue;
+        }
+        if (artifact.shape.kind !== requirement.shape.kind ||
+            artifact.shape.path !== requirement.shape.path ||
+            artifact.shape.artifact_kind !== requirement.shape.artifact_kind) {
+            errors.push(`Artifact \`${requirement.id}\` does not match required shape.`);
+        }
+        for (const check of requirement.checks) {
+            if (!artifact.checks.some((candidate) => checkMatchesRequirement(candidate, check))) {
+                errors.push(`Artifact \`${requirement.id}\` is missing required check \`${check.id}\`.`);
+            }
+        }
+        const producingStages = producingStagesForArtifact(definition, requirement.id);
+        if (producingStages.length === 0) {
+            errors.push(`Artifact \`${requirement.id}\` is not written by any stage.`);
+        }
+    }
+    return errors;
+}
+function validateAuthoredMethodPackage(methodPath, artifactRequirements = []) {
     const validation = validateMethodPackage(methodPath);
     if (!validation.ok)
         return validation;
@@ -107,18 +185,20 @@ function validateAuthoredMethodPackage(methodPath) {
     const placeholderStage = definition.stages?.find((stage) => stage.id === "prepare" &&
         stage.contract_type === "method-draft-stage" &&
         stage.writes.includes("draft-context"));
-    const placeholderZone = definition.method_schema.zones.find((zone) => zone.id === "draft-context");
+    const placeholderArtifact = listContextInterfaceArtifacts(definition.method_schema).find((artifact) => artifact.id === "draft-context");
     const placeholderPurpose = definition.purpose?.label === "From-scratch Method draft" ||
         definition.purpose?.task_hint?.includes("Replace this neutral scaffold");
     if (placeholderStage) {
         errors.push("Authored Method still contains the neutral scaffold stage `prepare`.");
     }
-    if (placeholderZone) {
-        errors.push("Authored Method still contains the neutral scaffold zone `draft-context`.");
+    if (placeholderArtifact) {
+        errors.push("Authored Method still contains the neutral scaffold artifact `draft-context`.");
     }
     if (placeholderPurpose) {
         errors.push("Authored Method still contains the neutral scaffold purpose.");
     }
+    errors.push(...validateArtifactRequirements(methodPath, definition, artifactRequirements));
+    errors.push(...validateMustContainStageDocs(methodPath, definition));
     return {
         ok: validation.ok && errors.length === 0,
         summary: errors.length === 0
@@ -143,13 +223,14 @@ export async function runMethodAuthoringDraft(options) {
         sourceFolderPath: options.sourceFolderPath,
         taskPrompt: options.taskPrompt,
         checks: options.checks ?? [],
+        artifactRequirements: options.artifactRequirements ?? [],
     });
     const session = await runMethodEditSession({
         executor: options.executor,
         methodPath,
         shell,
         prompt: buildMethodAuthoringPrompt(),
-        validate: validateAuthoredMethodPackage,
+        validate: (methodPath) => validateAuthoredMethodPackage(methodPath, options.artifactRequirements ?? []),
         maxValidationRepairAttempts: 1,
         onStatus: options.onStatus,
     });

package/dist/packages/methods/authoring/method-edit-session.js

@@ -94,12 +94,12 @@ export async function runMethodEditSession(options) {
             "",
             "Rules:",
             "- Edit only files under `method/`.",
-            "- Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+            "- Use kebab-case ids everywhere: stage ids, skill_dir values, Artifact ids, reads/writes values, and package ids. Never use underscores.",
             "- Keep every stage `skill_dir` matched by `method/compile/stages/<skill_dir>/SKILL.md`.",
-            "- Keep `method.schema.json` zone paths unique and non-overlapping.",
-            "- Keep zone-count acceptance keys declared in `method.schema.json`.",
-            "- Keep `artifacts_must_not_contain` keys as portable-context relative artifact paths such as `home.md`, not zone ids.",
-            "- Preserve root `home.md` as the main portable-context entrypoint when the Method writes an entrypoint.",
+            "- Keep `method.schema.json` Artifact paths unique and non-overlapping.",
+            "- Put deterministic validation on Artifact `checks[]`; do not add stage `acceptance` blocks.",
+            "- Use only CheckKind values listed in `runtime/authoring-context.json`; replace invented aliases with valid kinds.",
+            "- If the Method writes an agent entrypoint, keep it declared as an Artifact owned by the producing stage.",
             "- Stop as soon as the package should validate.",
         ].join("\n");
         appendFileSync(options.shell.promptLogPath, `\n\n---\n\n${prompt}\n`);

package/dist/packages/methods/authoring/method-improvement.js

@@ -67,7 +67,7 @@ function buildMethodImprovementPrompt() {
         "Edit only files under `method/`.",
         "Do not edit checks, test specs, source files, or generated portable-context outputs.",
         "Keep the Method package valid for the current compiler API and `method.schema.json`.",
-        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read Artifacts.",
         "Do not make one stage point at files or notes that are only created later by another stage.",
         "Prefer small, defensible changes to Method docs, stage docs, stage policies, or schema ownership over random churn.",
         "Do not narrate plans or ask follow-up questions.",

package/dist/packages/methods/package/builtin-compiled-method.d.ts

@@ -1,37 +1,37 @@
-import { type CompiledZoneKind } from "../../engine/compile/method-primitives.js";
+import { type CompiledArtifactKind } from "../../engine/compile/method-primitives.js";
 declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";
     readonly SHAPE: "shape";
 };
 type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
-export declare const BUILTIN_COMPILED_ZONE_IDS: {
+export declare const BUILTIN_COMPILED_ARTIFACT_IDS: {
     readonly SUMMARIES: "summaries";
     readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
     readonly KNOWLEDGE_CLAIMS: "knowledge-claims";
     readonly KNOWLEDGE_INDEXES: "knowledge-indexes";
-    readonly HOME: "home";
+    readonly HOME: "atlas";
     readonly RUNTIME: "runtime";
 };
-export type BuiltinCompiledZoneId = typeof BUILTIN_COMPILED_ZONE_IDS[keyof typeof BUILTIN_COMPILED_ZONE_IDS];
-export interface BuiltinCompiledZoneSpec {
-    id: BuiltinCompiledZoneId;
+export type BuiltinCompiledArtifactId = typeof BUILTIN_COMPILED_ARTIFACT_IDS[keyof typeof BUILTIN_COMPILED_ARTIFACT_IDS];
+export interface BuiltinCompiledArtifactSpec {
+    id: BuiltinCompiledArtifactId;
     role: "input" | "working" | "output" | "runtime";
     path: string;
-    kind: CompiledZoneKind;
+    kind: CompiledArtifactKind;
     required: boolean;
     description: string;
 }
 export interface BuiltinCompiledStageAccessPattern {
     id: BuiltinCompiledStageId;
     contract_type: string;
-    reads: BuiltinCompiledZoneId[];
-    writes: BuiltinCompiledZoneId[];
+    reads: BuiltinCompiledArtifactId[];
+    writes: BuiltinCompiledArtifactId[];
 }
-export declare function listBuiltinCompiledZoneSpecs(): BuiltinCompiledZoneSpec[];
+export declare function listBuiltinCompiledArtifactSpecs(): BuiltinCompiledArtifactSpec[];
 export declare function listBuiltinCompiledFallbackStages(): BuiltinCompiledStageAccessPattern[];
-export declare function requiredCompiledZoneOwners<TStage extends {
+export declare function requiredCompiledArtifactOwners<TStage extends {
     id: string;
     writes: readonly string[];
-}>(stages: readonly TStage[], zoneId: BuiltinCompiledZoneId): string[];
+}>(stages: readonly TStage[], artifactId: BuiltinCompiledArtifactId): string[];
 export {};

package/dist/packages/methods/package/builtin-compiled-method.js

@@ -8,20 +8,20 @@ const BUILTIN_COMPILED_STAGE_IDS = {
     STRUCTURE: "structure",
     SHAPE: "shape",
 };
-export const BUILTIN_COMPILED_ZONE_IDS = {
+export const BUILTIN_COMPILED_ARTIFACT_IDS = {
     SUMMARIES: "summaries",
     KNOWLEDGE_ENTITIES: "knowledge-entities",
     KNOWLEDGE_CLAIMS: "knowledge-claims",
     KNOWLEDGE_INDEXES: "knowledge-indexes",
-    HOME: "home",
+    HOME: "atlas",
     RUNTIME: "runtime",
 };
-const BUILTIN_ZONE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ZONE_IDS));
+const BUILTIN_ARTIFACT_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ARTIFACT_IDS));
 const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
 const BuiltinMethodStageSchema = z.object({
     id: z.string(),
     contract_type: z.string(),
-    reads: z.array(z.string()).min(1),
+    reads: z.array(z.string()),
     writes: z.array(z.string()).min(1),
 });
 const BuiltinMethodPackageSchema = z.object({
@@ -29,9 +29,9 @@ const BuiltinMethodPackageSchema = z.object({
 });
 let builtinCompiledContractCache = null;
 const BUILTIN_DEFAULT_METHOD_ROOT = join(PACKAGE_ROOT, "builtin-methods", "interf-default");
-function assertBuiltinZoneId(value) {
-    if (!BUILTIN_ZONE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf Method schema declares unsupported zone id "${value}".`);
+function assertBuiltinArtifactId(value) {
+    if (!BUILTIN_ARTIFACT_ID_SET.has(value)) {
+        throw new Error(`Built-in Interf Method schema declares unsupported Artifact id "${value}".`);
     }
     return value;
 }
@@ -54,25 +54,28 @@ function loadBuiltinCompiledContract() {
     if (!method) {
         throw new Error(`Missing or invalid built-in Method package at ${methodPath}.`);
     }
-    const zones = schema.zones.map((zone) => ({
-        id: assertBuiltinZoneId(zone.id),
-        role: zone.role,
-        path: zone.path,
-        kind: zone.kind,
-        required: zone.required,
-        description: zone.description,
-    }));
+    const artifacts = schema.artifacts.map((artifact) => {
+        const path = artifact.shape.path;
+        return {
+            id: assertBuiltinArtifactId(artifact.id),
+            role: "output",
+            path,
+            kind: artifact.shape.artifact_kind,
+            required: true,
+            description: artifact.description,
+        };
+    });
     const stages = method.stages.map((stage) => ({
         id: assertBuiltinStageId(stage.id),
         contract_type: stage.contract_type,
-        reads: stage.reads.map(assertBuiltinZoneId),
-        writes: stage.writes.map(assertBuiltinZoneId),
+        reads: stage.reads.map(assertBuiltinArtifactId),
+        writes: stage.writes.map(assertBuiltinArtifactId),
     }));
-    builtinCompiledContractCache = { zones, stages };
+    builtinCompiledContractCache = { artifacts, stages };
     return builtinCompiledContractCache;
 }
-export function listBuiltinCompiledZoneSpecs() {
-    return loadBuiltinCompiledContract().zones.map((zone) => ({ ...zone }));
+export function listBuiltinCompiledArtifactSpecs() {
+    return loadBuiltinCompiledContract().artifacts.map((artifact) => ({ ...artifact }));
 }
 export function listBuiltinCompiledFallbackStages() {
     return loadBuiltinCompiledContract().stages.map((stage) => ({
@@ -81,8 +84,8 @@ export function listBuiltinCompiledFallbackStages() {
         writes: [...stage.writes],
     }));
 }
-export function requiredCompiledZoneOwners(stages, zoneId) {
+export function requiredCompiledArtifactOwners(stages, artifactId) {
     return Array.from(new Set(stages
-        .filter((stage) => stage.writes.includes(zoneId))
+        .filter((stage) => stage.writes.includes(artifactId))
         .map((stage) => stage.id)));
 }

package/dist/packages/methods/package/context-interface.d.ts

@@ -1,30 +1,42 @@
 import { z } from "zod";
-import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "../../engine/compile/lib/schema.js";
+import { type MethodCompiledSchema, type MethodCompiledArtifact, type MethodArtifactId } from "../../engine/compile/lib/schema.js";
 export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
-    zones: z.ZodArray<z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        role: z.ZodEnum<{
-            runtime: "runtime";
-            output: "output";
-            input: "input";
-            working: "working";
-        }>;
-        path: z.ZodString;
-        kind: z.ZodEnum<{
-            runtime: "runtime";
-            file: "file";
-            directory: "directory";
-        }>;
-        required: z.ZodBoolean;
-        owned_by: z.ZodArray<z.ZodString>;
         description: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>], "kind">;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const MethodInputSpecSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
@@ -33,24 +45,25 @@ export declare const MethodInputSpecSchema: z.ZodObject<{
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type ContextInterface = MethodCompiledSchema;
-export type ContextInterfaceZone = MethodCompiledZone;
-export type ContextInterfaceZoneId = MethodZoneId;
+export type ContextInterfaceArtifact = MethodCompiledArtifact;
+export type ContextInterfaceArtifactId = MethodArtifactId;
 export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
 interface ContextInterfaceStageLike {
     id: string;
     writes: readonly string[];
 }
 interface ContextInterfaceSummary {
-    inputZones: ContextInterfaceZone[];
-    workingZones: ContextInterfaceZone[];
-    outputZones: ContextInterfaceZone[];
-    runtimeZones: ContextInterfaceZone[];
+    inputArtifacts: ContextInterfaceArtifact[];
+    workingArtifacts: ContextInterfaceArtifact[];
+    outputArtifacts: ContextInterfaceArtifact[];
+    runtimeArtifacts: ContextInterfaceArtifact[];
 }
+export declare function listContextInterfaceArtifacts(contextInterface: ContextInterface): ContextInterfaceArtifact[];
 export declare function contextInterfaceFilePath(rootPath: string): string;
 export declare function resolveContextInterfacePath(rootPath: string): string | null;
 export declare function contextInterfaceExists(rootPath: string): boolean;
-export declare function contextInterfaceZoneAbsolutePath(compiledPath: string, zone: Pick<ContextInterfaceZone, "path">): string;
-export declare function contextInterfaceArtifactPath(zone: Pick<ContextInterfaceZone, "path" | "kind">): string;
+export declare function contextInterfaceArtifactAbsolutePath(compiledPath: string, artifact: Pick<ContextInterfaceArtifact, "path">): string;
+export declare function contextInterfaceArtifactPath(artifact: Pick<ContextInterfaceArtifact, "path" | "kind">): string;
 export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
 export declare function deriveMethodInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): MethodInputSpec[];
 export declare function buildContextInterface(stages: ContextInterfaceStageLike[], label?: string): ContextInterface;

package/dist/packages/methods/package/context-interface.js

@@ -3,8 +3,8 @@ import { join } from "node:path";
 import { z } from "zod";
 import { warnInterf } from "../../contracts/utils/logger.js";
 import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
-import { MethodCompiledSchemaSchema, MethodZoneIdSchema, } from "../../engine/compile/lib/schema.js";
-import { listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-method.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) {