@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/engine/compile/runtime-reconcile.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { extname, join, relative } from "node:path";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { compiledArtifactAbsolutePath, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
@@ -38,8 +38,8 @@ function anyPathUpdatedSince(absolutePath, sinceMs) {
     }
     return false;
 }
-function zoneArtifactCount(dirPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(dirPath, { path: zonePath });
+function artifactCount(dirPath, artifactPath, kind) {
+    const absolutePath = compiledArtifactAbsolutePath(dirPath, { path: artifactPath });
     if (!existsSync(absolutePath))
         return 0;
     if (kind === "file")
@@ -52,11 +52,11 @@ function summaryAbstract(content) {
         return null;
     return extractSynthAbstract(parsed.frontmatter, parsed.body);
 }
-function listZoneArtifacts(dirPath, zone) {
-    const absolutePath = compiledZoneAbsolutePath(dirPath, zone);
-    if (!existsSync(absolutePath) || zone.kind === "runtime")
+function listZoneArtifacts(dirPath, artifact) {
+    const absolutePath = compiledArtifactAbsolutePath(dirPath, artifact);
+    if (!existsSync(absolutePath) || artifact.kind === "runtime")
         return [];
-    if (zone.kind === "file") {
+    if (artifact.kind === "file") {
         try {
             return statSync(absolutePath).isFile() ? [absolutePath] : [];
         }
@@ -68,8 +68,8 @@ function listZoneArtifacts(dirPath, zone) {
 }
 function buildInventoryMetadata(options) {
     const metadata = {
-        zone_id: options.zoneId,
-        zone_kind: options.zoneKind,
+        artifact_id: options.artifactId,
+        artifact_kind: options.artifactKind,
         file_extension: extname(options.filePath).toLowerCase() || null,
     };
     if (!options.parsedFrontmatter) {
@@ -98,16 +98,16 @@ function buildStageInventoryEntries(dirPath, stage) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     if (!schema)
         return [];
-    const readableInputZones = stage.reads
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    const outputZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    if (outputZones.length === 0)
+    const readableInputArtifacts = stage.reads
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
+    const outputArtifacts = stage.writes
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
+    if (outputArtifacts.length === 0)
         return [];
     const entries = [];
-    for (const outputZone of outputZones) {
+    for (const outputZone of outputArtifacts) {
         for (const filePath of listZoneArtifacts(dirPath, outputZone)) {
             const relativeOutputPath = relative(dirPath, filePath).replaceAll("\\", "/");
             const parsed = isOutputMarkdownFile(filePath)
@@ -116,36 +116,36 @@ function buildStageInventoryEntries(dirPath, stage) {
             const sourcePath = typeof parsed?.frontmatter.source === "string"
                 ? parsed.frontmatter.source.trim()
                 : "";
-            const sourceZoneId = typeof parsed?.frontmatter.source_zone === "string"
-                ? parsed.frontmatter.source_zone.trim()
+            const sourceArtifactId = typeof parsed?.frontmatter.source_artifact === "string"
+                ? parsed.frontmatter.source_artifact.trim()
                 : "";
-            const inputZone = sourceZoneId.length > 0
-                ? readableInputZones.find((zone) => zone.id === sourceZoneId) ?? null
-                : readableInputZones.length === 1
-                    ? readableInputZones[0]
+            const inputZone = sourceArtifactId.length > 0
+                ? readableInputArtifacts.find((artifact) => artifact.id === sourceArtifactId) ?? null
+                : readableInputArtifacts.length === 1
+                    ? readableInputArtifacts[0]
                     : null;
             entries.push({
                 ...(inputZone && sourcePath.length > 0
                     ? {
-                        input_zone: inputZone.id,
+                        input_artifact: inputZone.id,
                         input_path: sourcePath,
                     }
                     : {}),
-                output_zone: outputZone.id,
+                output_artifact: outputZone.id,
                 output_path: relativeOutputPath,
                 ...(typeof parsed?.frontmatter.state === "string"
                     ? { state: parsed.frontmatter.state }
                     : {}),
                 metadata: buildInventoryMetadata({
-                    zoneId: outputZone.id,
-                    zoneKind: outputZone.kind,
+                    artifactId: outputZone.id,
+                    artifactKind: outputZone.kind,
                     filePath,
                     parsedFrontmatter: parsed,
                 }),
             });
         }
     }
-    return entries.sort((left, right) => `${left.output_zone}:${left.output_path}`.localeCompare(`${right.output_zone}:${right.output_path}`));
+    return entries.sort((left, right) => `${left.output_artifact}:${left.output_path}`.localeCompare(`${right.output_artifact}:${right.output_path}`));
 }
 function writeStageInventory(dirPath, stageId, entries) {
     writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
@@ -160,12 +160,12 @@ export function reconcileCompiledStageRun(dirPath, stage) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     if (!schema)
         return false;
-    const writeZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null);
-    if (writeZones.length === 0)
+    const writeArtifacts = stage.writes
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null);
+    if (writeArtifacts.length === 0)
         return false;
-    if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
+    if (!writeArtifacts.some((artifact) => anyPathUpdatedSince(compiledArtifactAbsolutePath(dirPath, artifact), startedAtMs))) {
         return false;
     }
     writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
@@ -183,8 +183,8 @@ export function reconcileCompiledStageRun(dirPath, stage) {
         started_at: loadRuntimeRun(dirPath)?.started_at ?? now,
         finished_at: now,
         counts: activeRunCounts(dirPath),
-        zone_counts: Object.fromEntries(writeZones.map((zone) => [zone.id, zoneArtifactCount(dirPath, zone.path, zone.kind)])),
-        artifacts: writeZones.map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`),
+        artifact_counts: Object.fromEntries(writeArtifacts.map((artifact) => [artifact.id, artifactCount(dirPath, artifact.path, artifact.kind)])),
+        artifacts: writeArtifacts.map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`),
         summary: loadRuntimeRun(dirPath)?.summary ?? null,
         run_id: loadRuntimeRun(dirPath)?.run_id ?? null,
     };

package/dist/packages/engine/compile/runtime-runs.js

@@ -129,7 +129,6 @@ function startRuntimeRun(options) {
         executor: buildRuntimeExecutorInfo(options.executor),
         instructions: options.contract.instructions,
         counts: options.contract.counts,
-        ...(options.contract.acceptance ? { acceptance: options.contract.acceptance } : {}),
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };

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

@@ -1,6 +1,6 @@
 import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type RuntimeRun, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
-import type { MethodId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
+import { type RuntimeRun, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
+import type { Check, MethodId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
 export type RuntimeRunStatus = "running" | "succeeded" | "failed";
 export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "method" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
@@ -19,11 +19,6 @@ export interface RuntimeStageExecutionOptions {
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
 }
-export interface RuntimeStageAcceptanceValidation {
-    ok: boolean;
-    summary: string;
-    failures: string[];
-}
 export interface RuntimeStageContractOptions {
     compiledName: string;
     stageId: string;
@@ -32,10 +27,14 @@ export interface RuntimeStageContractOptions {
     extraReadArtifacts?: string[];
     stageReadArtifacts: string[];
     stageWriteArtifacts: string[];
+    stageWriteContracts?: Array<{
+        artifact_id: string;
+        path: string;
+        checks: Check[];
+    }>;
     methodNotes?: string[];
     localSkillDocs?: string[];
     instructions: RuntimeStageInstructions;
-    acceptance?: RuntimeStageAcceptance;
 }
 export interface RuntimeRunPatch extends Partial<Pick<RuntimeRun, "counts" | "summary" | "status" | "error" | "exit_code" | "finished_at">> {
 }

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

@@ -1,6 +1,5 @@
-export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
+export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
 export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

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

@@ -1,5 +1,4 @@
 export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";
 export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/engine/compile/state-health.js

@@ -4,10 +4,10 @@ import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
 import { validateCompiled, validateCompiledStage, validateCompiledMethod, } from "./validate.js";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
-import { countCompiledZoneArtifacts } from "./artifact-counts.js";
+import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
 export function computeCompiledHealth(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
@@ -37,9 +37,9 @@ export function computeCompiledHealth(dirPath) {
     const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
     const methodValidation = validateCompiledMethod(dirPath);
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const zoneMetrics = Object.fromEntries((schema?.zones ?? []).map((zone) => [
-        `zone_${zone.id}`,
-        countCompiledZoneArtifacts(dirPath, zone.path, zone.kind),
+    const artifactMetrics = Object.fromEntries((schema ? listCompiledSchemaArtifacts(schema) : []).map((artifact) => [
+        `artifact_${artifact.id}`,
+        countCompiledArtifactsAtPath(dirPath, artifact.path, artifact.kind),
     ]));
     let status = "idle";
     let stage = "idle";
@@ -98,7 +98,7 @@ export function computeCompiledHealth(dirPath) {
             completed_stages: completedStages,
             warnings: state?.warning_count ?? 0,
             errors: (state?.error_count ?? 0) + errors,
-            ...zoneMetrics,
+            ...artifactMetrics,
         },
         checks,
     };

package/dist/packages/engine/compile/state-view.js

@@ -2,7 +2,7 @@ import { basename } from "node:path";
 import { readInterfConfig, resolveSourceFolderPath } from "../../project/interf-detect.js";
 import { loadCompiledSourceSnapshot, loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
 import { writeCompiledSourceFiles, writeCompiledSourceSnapshot, } from "./source-files.js";
 export function ensureCompiledViewSpec(dirPath) {
@@ -63,10 +63,11 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`);
     const method = getActiveCompiledMethod(dirPath);
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const outputDocumentPaths = (schema?.zones ?? [])
-        .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
-        .map((zone) => zone.path);
-    const defaultNote = (schema?.zones ?? []).find((zone) => zone.role === "output" && zone.kind === "file")?.path ?? null;
+    const schemaArtifacts = schema ? listCompiledSchemaArtifacts(schema) : [];
+    const outputDocumentPaths = schemaArtifacts
+        .filter((artifact) => artifact.role === "output" && artifact.kind !== "runtime")
+        .map((artifact) => artifact.path);
+    const defaultNote = schemaArtifacts.find((artifact) => artifact.role === "output" && artifact.kind === "file")?.path ?? null;
     return {
         kind: "compiled-view-spec",
         version: 2,
@@ -85,7 +86,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
             { id: "status", type: "status", title: "Compile Status", path: ".interf/runtime/health.json" },
             { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
             ...(outputDocumentPaths.length > 0
-                ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
+                ? [{ id: "outputs", type: "documents", title: "Output Artifacts", paths: outputDocumentPaths }]
                 : []),
             { id: "method", type: "documents", title: "Method Docs", paths: ["method/README.md", ...method.stages.map((stage) => `method/compile/stages/${stage.skillDir}`)] },
         ],

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

@@ -1,13 +1,13 @@
 import { existsSync } from "node:fs";
 import { discoverSourceFiles } from "./discovery.js";
-import { METHOD_SCHEMA_FILE, findCompiledSchemaZone, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
+import { METHOD_SCHEMA_FILE, findCompiledSchemaArtifact, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
 import { resolveSourceFolderPath } from "../../project/interf-detect.js";
 import { compiledInterfConfigPath, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
-import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
 import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
-import { countCompiledZoneArtifacts } from "./artifact-counts.js";
+import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
+import { evaluateChecks } from "./check-evaluator.js";
 function methodSchemaPresent(dirPath) {
     return methodSchemaExists(methodPackagePathForCompiled(dirPath));
 }
@@ -45,23 +45,57 @@ function readMethodContext(dirPath) {
 function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
     return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
 }
-function zoneWriteCount(compiledPath, schema, stage) {
-    const zoneCounts = {};
+function artifactWriteCount(compiledPath, schema, stage) {
+    const artifactCounts = {};
     let total = 0;
-    for (const zoneId of stage.writes) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone)
+    for (const artifactId of stage.writes) {
+        const artifact = findCompiledSchemaArtifact(schema, artifactId);
+        if (!artifact)
             continue;
-        const count = countCompiledZoneArtifacts(compiledPath, zone.path, zone.kind);
-        zoneCounts[zoneId] = count;
+        const count = countCompiledArtifactsAtPath(compiledPath, artifact.path, artifact.kind);
+        artifactCounts[artifactId] = count;
         total += count;
     }
-    return { total, zoneCounts };
+    return { total, artifactCounts };
 }
-function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
+function stageRecordFromState(state, stageId) {
+    const stages = state?.stages;
+    if (!stages || typeof stages !== "object")
+        return null;
+    const stage = stages[stageId];
+    if (!stage || typeof stage !== "object" || Array.isArray(stage))
+        return null;
+    return stage;
+}
+function artifactsBuiltByStage(schema, stage) {
+    return (schema.artifacts ?? []).filter((artifact) => {
+        if (artifact.built_by_stages.includes(stage.id))
+            return true;
+        if (stage.writes.includes(artifact.id))
+            return true;
+        return artifact.shape.kind === "path" && (stage.writes.includes(artifact.id) || stage.writes.includes(artifact.shape.path));
+    });
+}
+function artifactCheckFailures(compiledPath, artifacts, counts) {
+    const failures = [];
+    for (const artifact of artifacts) {
+        const checks = artifact.checks ?? [];
+        if (checks.length === 0)
+            continue;
+        const targetPath = artifact.shape.kind === "path" ? artifact.shape.path : undefined;
+        const result = evaluateChecks(checks, {
+            rootPath: compiledPath,
+            targetPath,
+            counts,
+        });
+        failures.push(...result.failures);
+    }
+    return failures;
+}
+function mergeValidationCounts(sourceTotal, stageRecord, artifactCounts) {
     const merged = {
         source_total: sourceTotal,
-        ...zoneCounts,
+        ...artifactCounts,
     };
     const stageCounts = stageRecord?.counts;
     if (stageCounts && typeof stageCounts === "object" && !Array.isArray(stageCounts)) {
@@ -121,22 +155,19 @@ export function validateCompiledStage(dirPath, stageId) {
     checks.stage_finished = Boolean(stageRecord?.finished_at);
     checks.stage_succeeded = stageRecord?.status === "succeeded";
     const writeCounts = methodStage && context.schema
-        ? zoneWriteCount(dirPath, context.schema, methodStage)
-        : { total: 0, zoneCounts: {} };
-    const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
+        ? artifactWriteCount(dirPath, context.schema, methodStage)
+        : { total: 0, artifactCounts: {} };
+    const artifactCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.artifactCounts);
     const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
-    let acceptanceErrors = [];
+    let artifactErrors = [];
     if (methodStage && context.schema) {
-        const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
-            stageId,
-            acceptance: methodStage.acceptance,
-            counts: acceptanceCounts,
-        });
-        checks.acceptance_ok = acceptanceValidation.ok;
-        acceptanceErrors = acceptanceValidation.failures;
+        const artifacts = artifactsBuiltByStage(context.schema, methodStage);
+        const failures = artifactCheckFailures(dirPath, artifacts, artifactCounts);
+        checks.artifact_checks_ok = failures.length === 0;
+        artifactErrors = failures.map((proof) => `Artifact check "${proof.check_id}" failed for ${proof.kind}: ${proof.summary}`);
     }
     else {
-        checks.acceptance_ok = false;
+        checks.artifact_checks_ok = false;
     }
     if (required && checks.stage_record_present && !checks.stage_finished) {
         errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
@@ -145,23 +176,23 @@ export function validateCompiledStage(dirPath, stageId) {
         errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
     }
     if (required) {
-        errors.push(...acceptanceErrors);
+        errors.push(...artifactErrors);
     }
     const ok = required ? errors.length === 0 : errors.length === 0;
     const summary = !required
         ? `Stage "${stageId}" is not required yet.`
         : ok
             ? `Stage "${stageId}" verified.`
-            : `Stage "${stageId}" failed — ${errors[0] ?? "acceptance not satisfied."}`;
+            : `Stage "${stageId}" failed — ${errors[0] ?? "artifact checks not satisfied."}`;
     return {
         ok,
         required,
         stage: stageId,
         summary,
         counts: {
-            ...acceptanceCounts,
+            ...artifactCounts,
             write_artifacts: writeCounts.total,
-            declared_write_zones: methodStage?.writes.length ?? 0,
+            declared_write_artifacts: methodStage?.writes.length ?? 0,
         },
         checks,
         errors,
@@ -213,7 +244,7 @@ export function validateCompiledMethod(dirPath) {
         stage: failedStage,
         summary: ok
             ? `Compiled Method verified — ${completedStages}/${context.method.stages.length} stages satisfied.`
-            : `Compiled Method failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
+            : `Compiled Method failed — ${errors[0] ?? "stage artifact checks not satisfied."}`,
         counts: {
             source_total: context.sourceTotal,
             stage_total: context.method.stages.length,

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

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, statSync, } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { compiledKnowledgeRootPath } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
 import { readInterfConfig } from "../../project/interf-detect.js";
@@ -53,8 +52,8 @@ export function validateSynthFiles(files, options) {
     };
 }
 export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
-    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
-    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
+    const artifactPathById = compiledArtifactDirectoryPaths(compiledRoot);
+    const directoryLeafParents = compiledDirectoryLeafParents(artifactPathById);
     const noteIndex = new Set();
     for (const filePath of dedupeFiles(noteIndexRoots)) {
         for (const target of collectWikilinkTargets(filePath)) {
@@ -75,15 +74,15 @@ export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots
             if (!target)
                 continue;
             if (target.includes("/")) {
-                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath)) {
+                if (!wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, filePath)) {
                     brokenLinks += 1;
                 }
                 continue;
             }
             if (!noteIndex.has(target.toLowerCase()) &&
                 !noteIndex.has(noteName(target).toLowerCase()) &&
-                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath) &&
-                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes, filePath)) {
+                !wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, filePath) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), artifactPathById, directoryLeafParents, filePath)) {
                 brokenLinks += 1;
             }
         }
@@ -172,22 +171,25 @@ function countWords(text) {
 function noteName(filePath) {
     return basename(filePath, extname(filePath));
 }
-function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
-    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath)
+function wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
+    return linkPathCandidates(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath)
         .some((candidate) => existsSync(candidate));
 }
-function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
+function linkPathCandidates(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
     const candidates = new Set();
     addPathCandidate(candidates, join(compiledRoot, target));
     if (sourceFilePath && (target.startsWith("./") || target.startsWith("../"))) {
         addPathCandidateIfInside(candidates, compiledRoot, resolve(dirname(sourceFilePath), target));
     }
     const [firstSegment] = target.split("/");
-    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
-        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
+    if (firstSegment) {
+        const parentPath = directoryLeafParents.get(firstSegment);
+        if (parentPath) {
+            addPathCandidate(candidates, join(compiledRoot, parentPath, target));
+        }
     }
     if (firstSegment) {
-        const normalizedPrefix = zonePathById.get(firstSegment);
+        const normalizedPrefix = artifactPathById.get(firstSegment);
         if (normalizedPrefix) {
             const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
             addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
@@ -206,24 +208,24 @@ function addPathCandidateIfInside(candidates, compiledRoot, absolutePath) {
         return;
     addPathCandidate(candidates, candidate);
 }
-function compiledZoneDirectoryPaths(compiledRoot) {
+function compiledArtifactDirectoryPaths(compiledRoot) {
     const methodRoot = methodPackagePathForCompiled(compiledRoot);
     const schema = readCompiledSchemaFile(methodRoot);
     if (!schema)
         return new Map();
-    return new Map(schema.zones
-        .filter((zone) => zone.kind === "directory")
-        .map((zone) => [zone.id, zone.path]));
+    return new Map(listCompiledSchemaArtifacts(schema)
+        .filter((artifact) => artifact.kind === "directory")
+        .map((artifact) => [artifact.id, artifact.path]));
 }
-function compiledKnowledgeRelativePrefixes(zonePathById) {
-    const prefixes = new Set();
-    for (const zonePath of zonePathById.values()) {
-        const [root, leaf, ...rest] = zonePath.split("/");
-        if (root !== "knowledge" || !leaf || rest.length > 0)
+function compiledDirectoryLeafParents(artifactPathById) {
+    const parents = new Map();
+    for (const artifactPath of artifactPathById.values()) {
+        const [root, leaf, ...rest] = artifactPath.split("/");
+        if (!root || !leaf || rest.length > 0)
             continue;
-        prefixes.add(leaf);
+        parents.set(leaf, root);
     }
-    return prefixes;
+    return parents;
 }
 function collectWikilinkTargets(filePath) {
     const targets = new Set();