@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/engine/compile/check-evaluator.js

@@ -0,0 +1,298 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { CheckKindSchema, } from "../../contracts/lib/schema.js";
+import { countBrokenWikilinks, isOutputMarkdownFile, validateSynthFiles, } from "./validate.js";
+/**
+ * Build a Proof envelope from an evaluator outcome. Centralizes the
+ * timestamp + required-flag plumbing so individual evaluators can
+ * focus on the pass/fail decision and a one-line summary.
+ */
+function makeProof(check, passed, summary, details) {
+    return {
+        check_id: check.id,
+        kind: check.kind,
+        passed,
+        required: check.required,
+        summary,
+        ...(details !== undefined ? { details } : {}),
+        evaluated_at: new Date().toISOString(),
+    };
+}
+function resolveTargetPath(check, context) {
+    const target = context.targetPath;
+    if (!target)
+        return null;
+    const root = resolve(context.rootPath);
+    const absolute = resolve(root, target);
+    // Defense in depth — schema-level validation already rejects path
+    // traversal, but a hand-edited Method or stale on-disk fixture could
+    // slip through. Reject anything that escapes the root.
+    if (absolute !== root && !absolute.startsWith(`${root}/`)) {
+        return null;
+    }
+    return absolute;
+}
+function listMarkdownFiles(absolutePath) {
+    if (!existsSync(absolutePath))
+        return [];
+    try {
+        const stats = statSync(absolutePath);
+        if (stats.isFile()) {
+            return isOutputMarkdownFile(absolutePath) ? [absolutePath] : [];
+        }
+        if (stats.isDirectory()) {
+            return listFilesRecursive(absolutePath, isOutputMarkdownFile);
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}
+function countFiles(absolutePath) {
+    if (!existsSync(absolutePath))
+        return 0;
+    try {
+        const stats = statSync(absolutePath);
+        if (stats.isFile())
+            return 1;
+        if (stats.isDirectory()) {
+            return listFilesRecursive(absolutePath, () => true).length;
+        }
+    }
+    catch {
+        return 0;
+    }
+    return 0;
+}
+const EVALUATORS = {
+    file_exists(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for file_exists check.");
+        }
+        if (!existsSync(target)) {
+            return makeProof(check, false, "File or directory does not exist.", { path: context.targetPath });
+        }
+        try {
+            const stats = statSync(target);
+            if (stats.isFile() && stats.size === 0) {
+                return makeProof(check, false, "File exists but is empty.", { path: context.targetPath });
+            }
+            return makeProof(check, true, `Path exists (${stats.isDirectory() ? "directory" : "file"}).`);
+        }
+        catch {
+            return makeProof(check, false, "Could not stat target path.", { path: context.targetPath });
+        }
+    },
+    min_file_count(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for min_file_count check.");
+        }
+        const min = typeof check.params?.min === "number" ? check.params.min : 1;
+        const actual = countFiles(target);
+        if (actual >= min) {
+            return makeProof(check, true, `${actual} file(s) (≥ ${min}).`, { actual, min });
+        }
+        return makeProof(check, false, `Found ${actual} file(s); expected at least ${min}.`, { actual, min });
+    },
+    min_file_count_matches_source(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for min_file_count_matches_source check.");
+        }
+        const matchKey = typeof check.params?.match === "string" ? check.params.match : "source_total";
+        const expected = context.counts?.[matchKey];
+        if (typeof expected !== "number") {
+            return makeProof(check, false, `Cannot evaluate: count "${matchKey}" not available in context.`, { matchKey });
+        }
+        const actual = countFiles(target);
+        if (actual >= expected) {
+            return makeProof(check, true, `${actual} of ${expected} source files covered.`, { actual, expected });
+        }
+        return makeProof(check, false, `Only ${actual} of ${expected} source files covered.`, { actual, expected, matchKey });
+    },
+    frontmatter_valid(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for frontmatter_valid check.");
+        }
+        const files = listMarkdownFiles(target);
+        if (files.length === 0) {
+            return makeProof(check, true, "No markdown files to validate.");
+        }
+        const validation = validateSynthFiles(files);
+        if (validation.invalid_frontmatter === 0) {
+            return makeProof(check, true, `${files.length} markdown file(s) have valid frontmatter.`);
+        }
+        return makeProof(check, false, `${validation.invalid_frontmatter} of ${files.length} markdown file(s) have invalid frontmatter.`, { invalid: validation.invalid_frontmatter, total: files.length });
+    },
+    frontmatter_required_keys(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for frontmatter_required_keys check.");
+        }
+        const keys = Array.isArray(check.params?.keys) ? check.params.keys.filter((k) => typeof k === "string") : [];
+        if (keys.length === 0) {
+            return makeProof(check, false, "frontmatter_required_keys check requires `params.keys: string[]`.");
+        }
+        const files = listMarkdownFiles(target);
+        if (files.length === 0) {
+            return makeProof(check, true, "No markdown files to validate.");
+        }
+        const validation = validateSynthFiles(files, { requiredFrontmatterKeys: keys });
+        if (validation.invalid_frontmatter === 0) {
+            return makeProof(check, true, `All ${files.length} markdown file(s) have required keys: ${keys.join(", ")}.`);
+        }
+        return makeProof(check, false, `${validation.invalid_frontmatter} of ${files.length} file(s) missing required keys (${keys.join(", ")}).`, { invalid: validation.invalid_frontmatter, total: files.length, requiredKeys: keys });
+    },
+    wikilinks_valid(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target) {
+            return makeProof(check, false, "No target path provided for wikilinks_valid check.");
+        }
+        const broken = countBrokenWikilinks(context.rootPath, [context.rootPath], [target]);
+        if (broken === 0) {
+            return makeProof(check, true, "All wikilinks resolve.");
+        }
+        return makeProof(check, false, `${broken} broken wikilink(s).`, { broken });
+    },
+    must_not_contain(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target || !existsSync(target)) {
+            return makeProof(check, false, "Target path does not exist.", { path: context.targetPath });
+        }
+        const phrases = Array.isArray(check.params?.phrases)
+            ? check.params.phrases.filter((p) => typeof p === "string")
+            : [];
+        if (phrases.length === 0) {
+            return makeProof(check, false, "must_not_contain check requires `params.phrases: string[]`.");
+        }
+        try {
+            const stats = statSync(target);
+            const files = stats.isFile() ? [target] : listFilesRecursive(target, () => true);
+            const offenders = [];
+            for (const file of files) {
+                const content = readFileSync(file, "utf8");
+                for (const phrase of phrases) {
+                    if (content.includes(phrase)) {
+                        offenders.push(`${file}: contains "${phrase}"`);
+                        break;
+                    }
+                }
+            }
+            if (offenders.length === 0) {
+                return makeProof(check, true, `No forbidden phrases found across ${files.length} file(s).`);
+            }
+            return makeProof(check, false, `${offenders.length} file(s) contain forbidden phrases.`, { offenders, phrases });
+        }
+        catch (error) {
+            return makeProof(check, false, `Error reading target: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+    must_contain(check, context) {
+        const target = resolveTargetPath(check, context);
+        if (!target || !existsSync(target)) {
+            return makeProof(check, false, "Target path does not exist.", { path: context.targetPath });
+        }
+        const phrases = Array.isArray(check.params?.phrases)
+            ? check.params.phrases.filter((p) => typeof p === "string")
+            : [];
+        if (phrases.length === 0) {
+            return makeProof(check, false, "must_contain check requires `params.phrases: string[]`.");
+        }
+        try {
+            const stats = statSync(target);
+            // For directories, must_contain checks across ALL files (every phrase
+            // must appear in at least one file). For files, all phrases must
+            // appear in that single file.
+            if (stats.isFile()) {
+                const content = readFileSync(target, "utf8");
+                const missing = phrases.filter((phrase) => !content.includes(phrase));
+                if (missing.length === 0) {
+                    return makeProof(check, true, `All ${phrases.length} required phrase(s) present.`);
+                }
+                return makeProof(check, false, `${missing.length} required phrase(s) missing.`, { missing });
+            }
+            const files = listFilesRecursive(target, () => true);
+            const remaining = new Set(phrases);
+            for (const file of files) {
+                const content = readFileSync(file, "utf8");
+                for (const phrase of [...remaining]) {
+                    if (content.includes(phrase))
+                        remaining.delete(phrase);
+                }
+                if (remaining.size === 0)
+                    break;
+            }
+            if (remaining.size === 0) {
+                return makeProof(check, true, `All ${phrases.length} required phrase(s) found across files.`);
+            }
+            return makeProof(check, false, `${remaining.size} required phrase(s) missing across all files.`, { missing: [...remaining] });
+        }
+        catch (error) {
+            return makeProof(check, false, `Error reading target: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+    qa_match(check, context) {
+        const expected = typeof check.params?.expected === "string" ? check.params.expected : "";
+        const strictness = typeof check.params?.strictness === "string" ? check.params.strictness : "loose";
+        const answer = context.agentAnswer ?? "";
+        if (!expected) {
+            return makeProof(check, false, "qa_match check requires `params.expected: string`.");
+        }
+        if (!answer) {
+            return makeProof(check, false, "No agent answer available for qa_match evaluation.");
+        }
+        if (strictness === "strict") {
+            const passed = answer.trim() === expected.trim();
+            return makeProof(check, passed, passed ? "Answer matches expected exactly." : "Answer does not match expected.");
+        }
+        // Loose: case-insensitive substring match either direction.
+        const a = answer.trim().toLowerCase();
+        const e = expected.trim().toLowerCase();
+        const passed = a.includes(e) || e.includes(a);
+        return makeProof(check, passed, passed ? "Answer matches expected (loose)." : "Answer does not match expected.");
+    },
+};
+/**
+ * Evaluate a single Check against a context, returning a Proof.
+ */
+export function evaluateCheck(check, context) {
+    const evaluator = EVALUATORS[check.kind];
+    if (!evaluator) {
+        return {
+            check_id: check.id,
+            kind: check.kind,
+            passed: false,
+            required: check.required,
+            summary: `Unknown check kind: ${check.kind}`,
+            evaluated_at: new Date().toISOString(),
+        };
+    }
+    return evaluator(check, context);
+}
+/**
+ * Evaluate a list of checks. Aggregate ready/not_ready verdict over
+ * the proofs: `ready` if every required check passed, otherwise
+ * `not_ready`. Soft checks (required: false) that fail produce a
+ * proof but don't change the verdict.
+ */
+export function evaluateChecks(checks, context) {
+    const proofs = checks.map((check) => evaluateCheck(check, context));
+    const failures = proofs.filter((proof) => !proof.passed && proof.required);
+    return {
+        proofs,
+        ready: failures.length === 0,
+        failures,
+    };
+}
+/**
+ * Type guard for the canonical CheckKinds. Useful at parse boundaries
+ * where a string came from on-disk JSON.
+ */
+export function isCheckKind(value) {
+    return CheckKindSchema.safeParse(value).success;
+}

package/dist/packages/engine/compile/compiled-schema.d.ts

@@ -1,29 +1,19 @@
-import { type BuiltinCompiledZoneId } from "../../methods/package/builtin-compiled-method.js";
-import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "./lib/schema.js";
+import { type MethodCompiledSchema, type MethodCompiledArtifact, type MethodArtifactId } from "./lib/schema.js";
 export interface MethodSchemaStageLike {
     id: string;
     writes: readonly string[];
 }
-export { BUILTIN_COMPILED_ZONE_IDS } from "../../methods/package/builtin-compiled-method.js";
 export declare const METHOD_SCHEMA_FILE = "method.schema.json";
 export declare function methodSchemaFilePath(rootPath: string): string;
 export declare function resolveMethodSchemaPath(rootPath: string): string | null;
 export declare function methodSchemaExists(rootPath: string): boolean;
 export declare function methodSchemaRelativePath(): string;
-export declare function listCompiledSchemaZones(schema: MethodCompiledSchema): MethodCompiledZone[];
-export declare function findCompiledSchemaZone(schema: MethodCompiledSchema, zoneId: MethodZoneId): MethodCompiledZone | null;
-export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<MethodCompiledZone, "path">): string;
-export declare function compiledContractArtifactPath(zone: Pick<MethodCompiledZone, "path" | "kind">): string;
-export declare function compiledContractArtifactPathsForZoneIds(schema: MethodCompiledSchema, zoneIds: readonly MethodZoneId[]): string[];
-export declare function builtinCompiledZoneRelativePath(zoneId: BuiltinCompiledZoneId): string;
-export declare function builtinCompiledZoneAbsolutePath(compiledPath: string, zoneId: BuiltinCompiledZoneId): string;
-export declare function compiledSummariesPath(compiledPath: string): string;
-export declare function compiledKnowledgeEntitiesPath(compiledPath: string): string;
-export declare function compiledKnowledgeClaimsPath(compiledPath: string): string;
-export declare function compiledKnowledgeIndexesPath(compiledPath: string): string;
-export declare function compiledKnowledgeRootPath(compiledPath: string): string;
-export declare function compiledHomePath(compiledPath: string): string;
-export declare function ensureCompiledZoneTargets(compiledPath: string, schema: MethodCompiledSchema): void;
+export declare function listCompiledSchemaArtifacts(schema: MethodCompiledSchema): MethodCompiledArtifact[];
+export declare function findCompiledSchemaArtifact(schema: MethodCompiledSchema, artifactId: MethodArtifactId): MethodCompiledArtifact | null;
+export declare function compiledArtifactAbsolutePath(compiledPath: string, artifact: Pick<MethodCompiledArtifact, "path">): string;
+export declare function compiledContractArtifactPath(artifact: Pick<MethodCompiledArtifact, "path" | "kind">): string;
+export declare function compiledContractArtifactPathsForArtifactIds(schema: MethodCompiledSchema, artifactIds: readonly MethodArtifactId[]): string[];
+export declare function ensureCompiledArtifactTargets(compiledPath: string, schema: MethodCompiledSchema): void;
 export declare function buildMethodSchema(stages: MethodSchemaStageLike[], label?: string): MethodCompiledSchema;
 export declare function writeMethodSchemaFile(rootPath: string, stages: MethodSchemaStageLike[], label?: string): MethodCompiledSchema;
 export declare function writeMethodSchemaDocument(rootPath: string, schema: MethodCompiledSchema): MethodCompiledSchema;

package/dist/packages/engine/compile/compiled-schema.js

@@ -2,11 +2,9 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { warnInterf } from "../../contracts/utils/logger.js";
 import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
-import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "../../methods/package/builtin-compiled-method.js";
+import { listBuiltinCompiledArtifactSpecs, requiredCompiledArtifactOwners, } from "../../methods/package/builtin-compiled-method.js";
 import { MethodCompiledSchemaSchema, } from "./lib/schema.js";
-export { BUILTIN_COMPILED_ZONE_IDS } from "../../methods/package/builtin-compiled-method.js";
 export const METHOD_SCHEMA_FILE = "method.schema.json";
-const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
 export function methodSchemaFilePath(rootPath) {
     return join(rootPath, METHOD_SCHEMA_FILE);
 }
@@ -20,96 +18,83 @@ export function methodSchemaExists(rootPath) {
 export function methodSchemaRelativePath() {
     return `method/${METHOD_SCHEMA_FILE}`;
 }
-export function listCompiledSchemaZones(schema) {
-    return [...schema.zones];
+export function listCompiledSchemaArtifacts(schema) {
+    return schema.artifacts.map(artifactToMethodArtifact);
 }
-export function findCompiledSchemaZone(schema, zoneId) {
-    return schema.zones.find((zone) => zone.id === zoneId) ?? null;
+export function findCompiledSchemaArtifact(schema, artifactId) {
+    return listCompiledSchemaArtifacts(schema).find((artifact) => artifact.id === artifactId) ?? null;
 }
-export function compiledZoneAbsolutePath(compiledPath, zone) {
-    return join(compiledPath, zone.path);
+export function compiledArtifactAbsolutePath(compiledPath, artifact) {
+    return join(compiledPath, artifact.path);
 }
-export function compiledContractArtifactPath(zone) {
-    if (zone.kind === "file")
-        return zone.path;
-    return zone.path.endsWith("/") ? zone.path : `${zone.path}/`;
+export function compiledContractArtifactPath(artifact) {
+    if (artifact.kind === "file")
+        return artifact.path;
+    return artifact.path.endsWith("/") ? artifact.path : `${artifact.path}/`;
 }
-export function compiledContractArtifactPathsForZoneIds(schema, zoneIds) {
-    return zoneIds.map((zoneId) => {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            throw new Error(`Compiled schema is missing declared zone "${zoneId}".`);
+export function compiledContractArtifactPathsForArtifactIds(schema, artifactIds) {
+    return artifactIds.map((artifactId) => {
+        const artifact = findCompiledSchemaArtifact(schema, artifactId);
+        if (!artifact) {
+            throw new Error(`Compiled schema is missing declared Artifact "${artifactId}".`);
         }
-        return compiledContractArtifactPath(zone);
+        return compiledContractArtifactPath(artifact);
     });
 }
-export function builtinCompiledZoneRelativePath(zoneId) {
-    const zone = BUILTIN_COMPILED_ZONE_SPEC_BY_ID.get(zoneId);
-    if (!zone) {
-        throw new Error(`Missing built-in compiled zone "${zoneId}".`);
-    }
-    return zone.path;
-}
-export function builtinCompiledZoneAbsolutePath(compiledPath, zoneId) {
-    return join(compiledPath, builtinCompiledZoneRelativePath(zoneId));
-}
-export function compiledSummariesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.SUMMARIES);
-}
-export function compiledKnowledgeEntitiesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES);
-}
-export function compiledKnowledgeClaimsPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS);
-}
-export function compiledKnowledgeIndexesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES);
-}
-export function compiledKnowledgeRootPath(compiledPath) {
-    return dirname(compiledKnowledgeEntitiesPath(compiledPath));
-}
-export function compiledHomePath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.HOME);
-}
-export function ensureCompiledZoneTargets(compiledPath, schema) {
-    for (const zone of schema.zones) {
-        if (zone.kind === "directory" || zone.kind === "runtime") {
-            mkdirSync(compiledZoneAbsolutePath(compiledPath, zone), { recursive: true });
+export function ensureCompiledArtifactTargets(compiledPath, schema) {
+    for (const artifact of listCompiledSchemaArtifacts(schema)) {
+        if (artifact.kind === "directory" || artifact.kind === "runtime") {
+            mkdirSync(compiledArtifactAbsolutePath(compiledPath, artifact), { recursive: true });
             continue;
         }
-        mkdirSync(dirname(compiledZoneAbsolutePath(compiledPath, zone)), { recursive: true });
+        mkdirSync(dirname(compiledArtifactAbsolutePath(compiledPath, artifact)), { recursive: true });
     }
 }
-function pushZone(zones, zone) {
-    if (zones.some((existing) => existing.path === zone.path))
-        return;
-    zones.push(zone);
-}
 function normalizeMethodSchema(schema) {
     return {
         ...schema,
         kind: "method-schema",
     };
 }
-export function buildMethodSchema(stages, label = "Method schema") {
-    const zones = [];
-    for (const zone of listBuiltinCompiledZoneSpecs()) {
-        pushZone(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,
-        });
+function artifactToMethodArtifact(artifact) {
+    if (artifact.shape.kind !== "path") {
+        return {
+            id: artifact.id,
+            role: "output",
+            path: artifact.id,
+            kind: "directory",
+            required: true,
+            owned_by: [...artifact.built_by_stages],
+            description: artifact.description,
+        };
     }
+    return {
+        id: artifact.id,
+        role: "output",
+        path: artifact.shape.path,
+        kind: artifact.shape.artifact_kind,
+        required: true,
+        owned_by: [...artifact.built_by_stages],
+        description: artifact.description,
+    };
+}
+export function buildMethodSchema(stages, label = "Method schema") {
     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 writeMethodSchemaFile(rootPath, stages, label) {

package/dist/packages/engine/compile/compiled-stage-plan.d.ts

@@ -5,6 +5,7 @@ import type { RuntimeStageInstructions } from "./lib/schema.js";
 export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<MethodStageDefinition, "id" | "reads" | "writes">): {
     reads: string[];
     writes: string[];
+    writeContracts: RuntimeStageContractDraft["artifacts"]["write_contracts"];
 };
 export declare function buildStageCounts(compiledPath: string, stageDefinition: MethodStageDefinition): Record<string, number>;
 export declare function buildStageContract(compiledPath: string, stageDefinition: MethodStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;

package/dist/packages/engine/compile/compiled-stage-plan.js

@@ -2,14 +2,14 @@ import { join } from "node:path";
 import { buildRuntimeStageContract, } from "./runtime.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { compiledContractArtifactPath, compiledContractArtifactPathsForArtifactIds, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../../methods/package/method-helpers.js";
-import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } from "../../methods/package/method-definitions.js";
+import { getActiveCompiledStagePolicyNotes, } from "../../methods/package/method-definitions.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readInterfConfig } from "../../project/interf-detect.js";
 import { resolveCompiledContext, } from "./compiled-target.js";
-function zoneArtifactCount(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
+function artifactCount(compiledPath, artifactPath, kind) {
+    const absolutePath = join(compiledPath, artifactPath);
     try {
         if (kind === "file") {
             return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
@@ -27,28 +27,45 @@ export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
         throw new Error(`Missing Method schema for stage "${stageDefinition.id}" at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
     return {
-        reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
-        writes: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.writes),
+        reads: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.reads),
+        writes: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.writes),
+        writeContracts: stageDefinition.writes.map((artifactId) => {
+            const artifact = schema.artifacts.find((candidate) => candidate.id === artifactId);
+            if (!artifact) {
+                throw new Error(`Compiled schema is missing declared Artifact "${artifactId}".`);
+            }
+            const path = artifact.shape.kind === "path"
+                ? compiledContractArtifactPath({
+                    path: artifact.shape.path,
+                    kind: artifact.shape.artifact_kind,
+                })
+                : artifact.id;
+            return {
+                artifact_id: artifact.id,
+                path,
+                checks: artifact.checks ?? [],
+            };
+        }),
     };
 }
 export function buildStageCounts(compiledPath, stageDefinition) {
     const context = resolveCompiledContext(compiledPath);
     const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zoneCounts = {};
+    const artifactCounts = {};
     if (schema) {
-        for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
-            const zone = findCompiledSchemaZone(schema, zoneId);
-            if (!zone)
+        for (const artifactId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
+            const artifact = findCompiledSchemaArtifact(schema, artifactId);
+            if (!artifact)
                 continue;
-            zoneCounts[zoneId] = zoneArtifactCount(compiledPath, zone.path, zone.kind);
+            artifactCounts[artifactId] = artifactCount(compiledPath, artifact.path, artifact.kind);
         }
     }
     return {
         source_total: sourceTotal,
-        read_zone_total: stageDefinition.reads.length,
-        write_zone_total: stageDefinition.writes.length,
-        ...zoneCounts,
+        read_artifact_total: stageDefinition.reads.length,
+        write_artifact_total: stageDefinition.writes.length,
+        ...artifactCounts,
     };
 }
 export function buildStageContract(compiledPath, stageDefinition, instructions) {
@@ -65,10 +82,10 @@ export function buildStageContract(compiledPath, stageDefinition, instructions)
         ],
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
+        stageWriteContracts: stageArtifacts.writeContracts,
         methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
         localSkillDocs: instructions.local_docs,
         instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, stageDefinition.id),
     });
 }
 export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {

package/dist/packages/engine/compile/compiled-stage-runner.js

@@ -44,7 +44,7 @@ export async function runCompiledStage(options) {
             statusLines: [
                 `Emit exactly one startup line: STATUS: loaded ${stageDefinition.label.toLowerCase()} stage.`,
                 "Emit STATUS: reading declared inputs after you confirm the shell contract and local docs.",
-                "Emit STATUS: writing declared outputs after the stage starts updating the compiled zones.",
+                "Emit STATUS: writing declared outputs after the stage starts updating the compiled Artifacts.",
                 `Emit DONE: ${stageDefinition.id} complete when the declared outputs and proof are on disk.`,
             ],
             reporter: options.reporter,

package/dist/packages/engine/compile/index.d.ts

@@ -3,7 +3,6 @@ export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
 export * as runtime from "./runtime.js";
-export * as runtimeAcceptance from "./runtime-acceptance.js";
 export * as runtimeContracts from "./runtime-contracts.js";
 export * as runtimeInventory from "./runtime-inventory.js";
 export * as runtimePaths from "./runtime-paths.js";

package/dist/packages/engine/compile/index.js

@@ -3,7 +3,6 @@ export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
 export * as runtime from "./runtime.js";
-export * as runtimeAcceptance from "./runtime-acceptance.js";
 export * as runtimeContracts from "./runtime-contracts.js";
 export * as runtimeInventory from "./runtime-inventory.js";
 export * as runtimePaths from "./runtime-paths.js";