@interf/compiler 0.33.0 → 0.50.0

package/dist/packages/runtime/build/source-manifest.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { SourceFilesSchema, SourceManifestSchema, SourceStateSchema, StageInputsSchema, } from "../../contracts/lib/schema.js";
 import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { isFilesystemArtifact } from "../../contracts/utils/filesystem.js";
 import { contextGraphRuntimeSourceManifestPath, contextGraphRuntimeSourceFilesPath, contextGraphRuntimeSourceStatePath, contextGraphRuntimeStageInputsPath, } from "./context-graph-paths.js";
 import { writeJsonAtomic } from "./atomic-fs.js";
 function shortHash(value, length = 16) {
@@ -47,6 +48,26 @@ export function buildShellSourceState(sourceState, stageInputs) {
         })),
     });
 }
+/**
+ * Drop OS-generated filesystem junk (`.DS_Store`, AppleDouble forks, `Thumbs.db`,
+ * etc.) from the Source Manifest before it is materialized into runtime coverage
+ * inputs. These are not Source content, so they must never become required
+ * `expected` inputs — otherwise a Source folder shows "not ready" purely because
+ * Finder/Explorer left a sidecar behind. Matched by filename only (provable),
+ * never by an agent's `not-relevant` label, so a genuinely skipped content file
+ * still counts toward readiness. `source_total` is recomputed to stay equal to
+ * the filtered file count.
+ */
+export function dropFilesystemArtifacts(manifest) {
+    const files = manifest.files.filter((file) => !isFilesystemArtifact(file.path));
+    if (files.length === manifest.files.length)
+        return manifest;
+    return SourceManifestSchema.parse({
+        ...manifest,
+        source_total: files.length,
+        files,
+    });
+}
 export function sourceManifestToSourceFiles(manifest) {
     return SourceFilesSchema.parse({
         kind: "interf-source-files",
@@ -129,10 +150,10 @@ export function writeBuildStageInputs(options) {
     return stageInputs;
 }
 export function writeBuildSourceRuntimeFromManifest(options) {
-    const sourceManifest = SourceManifestSchema.parse({
+    const sourceManifest = dropFilesystemArtifacts(SourceManifestSchema.parse({
         ...options.sourceManifest,
         run_id: options.runId ?? options.sourceManifest.run_id,
-    });
+    }));
     writeJson(contextGraphRuntimeSourceManifestPath(options.contextGraphPath), sourceManifest);
     const sourceFiles = sourceManifestToSourceFiles(sourceManifest);
     writeJson(contextGraphRuntimeSourceFilesPath(options.contextGraphPath), sourceFiles);
@@ -166,6 +187,13 @@ export function loadContextGraphSourceManifest(contextGraphPath) {
         return null;
     return readJsonFileWithSchema(filePath, "context-graph source manifest", SourceManifestSchema);
 }
+// COMPAT — source-files.json / source-state.json file fallbacks are read by
+// loaders only when no Source Manifest exists (pre-refactor builds). Every
+// current Build writes the Source Manifest first via
+// writeBuildSourceRuntimeFromManifest; the manifest is the authority. Removal
+// path: once no live Context Graph predates Source Manifest, drop the file
+// fallbacks and have these loaders return null whenever the manifest is
+// missing.
 export function loadContextGraphSourceFiles(contextGraphPath) {
     const manifest = loadContextGraphSourceManifest(contextGraphPath);
     if (manifest)

package/dist/packages/runtime/build/stage-evidence.js

@@ -2,20 +2,25 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } fro
 import { dirname, join, relative } from "node:path";
 import { StageEvidenceSchema, } from "../../contracts/lib/schema.js";
 import { buildPlanPackagePathForContextGraph, contextGraphRuntimeLogsRoot, } from "./context-graph-paths.js";
+import { relativePathEqualsOrWithin } from "../agents/lib/shell-paths.js";
 import { findBuildPlanContextArtifact, readBuildPlanContextFile, } from "./context-graph-schema.js";
 import { StageEvidenceReconciliationSchema, } from "./lib/schema.js";
 import { loadBuildStageInputs } from "./source-manifest.js";
 import { loadExecutionStageLedger, updateExecutionStageLedger, } from "./runtime-runs.js";
-function normalizeRelativePath(path) {
+/**
+ * Relativize a stage evidence/output-ref path so it is always graph-relative.
+ *
+ * This is intentionally MORE permissive than the canonical `normalizeLayerPath`
+ * (`contracts/lib/context-graph-layer.ts`): its leading regex is `/^\.?\//`, so
+ * it strips a bare leading `/` as well as a leading `./`. An agent-reported
+ * output ref may arrive as `/outputs/...` or `/runtime/...`; this strips the
+ * absolute-looking prefix so the downstream `runtime/`/`outputs/` membership
+ * tests compare graph-relative paths. It is NOT the canonical layer-path
+ * normalization and must not be swapped for it.
+ */
+function normalizeGraphRelativeRefPath(path) {
     return path.replaceAll("\\", "/").replace(/^\.?\//, "").replace(/\/+$/g, "");
 }
-function relativePathEqualsOrWithin(basePath, candidatePath) {
-    const base = normalizeRelativePath(basePath);
-    const candidate = normalizeRelativePath(candidatePath);
-    if (base.length === 0 || candidate.length === 0)
-        return false;
-    return candidate === base || candidate.startsWith(`${base}/`);
-}
 export function supportsStageEvidenceHarness(stage) {
     return stage.contractType === "build-file-evidence";
 }
@@ -69,6 +74,7 @@ function renderStageHarnessMarkdown(contract) {
         "",
         "Write `runtime/stage-evidence.json` before you emit DONE.",
         "Each evidence item must reference real assigned Source paths or declared output paths.",
+        "Do NOT list `runtime/reviewed-inputs.json` or any other `runtime/*` path in `output_refs`. Those files are runtime control surfaces, not stage outputs; the runner records them separately. Evidence outputs must live under a declared artifact path.",
         "Agent status lines and self-reported completion do not count as accepted evidence.",
         "",
         "Minimum shape:",
@@ -191,7 +197,22 @@ function reconcileParsedStageEvidence(options) {
     const allowedSourcePaths = new Set((stageInputs?.inputs ?? []).map((input) => input.path));
     const allowedSourceIds = new Set((stageInputs?.inputs ?? []).map((input) => input.source_file_id));
     const acceptedItems = [];
-    for (const item of options.evidence.items) {
+    const droppedRuntimeRefs = [];
+    for (const rawItem of options.evidence.items) {
+        const { item, droppedRuntimeRefs: itemDropped } = normalizeEvidenceItem({
+            contextGraphPath: options.contextGraphPath,
+            item: rawItem,
+        });
+        if (itemDropped.length > 0)
+            droppedRuntimeRefs.push(...itemDropped.map((p) => `${item.id}: ${p}`));
+        // If an item was entirely composed of runtime/* output refs (with no source refs),
+        // dropping those refs leaves nothing to validate. Skip with a warning instead of
+        // rejecting — the agent already records that coverage via runtime/reviewed-inputs.json.
+        const itemWasPurelyRuntime = itemDropped.length > 0 &&
+            item.output_refs.length === 0 &&
+            item.source_refs.length === 0;
+        if (itemWasPurelyRuntime)
+            continue;
         const reason = invalidItemReason({
             contextGraphPath: options.contextGraphPath,
             item,
@@ -224,12 +245,16 @@ function reconcileParsedStageEvidence(options) {
     }
     const acceptedItemIds = new Set(acceptedItems.map((item) => item.id));
     const acceptedEdges = [];
+    const warnings = [...(options.evidence.warnings ?? [])];
+    for (const dropped of droppedRuntimeRefs) {
+        warnings.push(`Dropped output ref ${dropped}; runtime/* paths are control surfaces, not stage outputs.`);
+    }
     for (const edge of options.evidence.edges) {
         if (edge.stage_id !== options.stage.id) {
             rejected.push({ kind: "edge", id: `${edge.from}:${edge.to}`, reason: "Edge stage does not match the active stage." });
         }
         else if (!acceptedItemIds.has(edge.from) || !acceptedItemIds.has(edge.to)) {
-            rejected.push({ kind: "edge", id: `${edge.from}:${edge.to}`, reason: "Edge endpoints must both be accepted evidence items." });
+            warnings.push(`Dropped evidence edge ${edge.from}:${edge.to}; endpoints were not both accepted evidence items.`);
         }
         else {
             acceptedEdges.push(edge);
@@ -243,9 +268,53 @@ function reconcileParsedStageEvidence(options) {
             edges: acceptedEdges,
         },
         rejected,
-        warnings: options.evidence.warnings ?? [],
+        warnings,
     });
 }
+function normalizeEvidenceItem(options) {
+    const droppedRuntimeRefs = [];
+    const output_refs = [];
+    for (const outputRef of options.item.output_refs) {
+        const normalized = normalizeEvidenceOutputRef({
+            contextGraphPath: options.contextGraphPath,
+            outputRef,
+        });
+        if (normalizeGraphRelativeRefPath(normalized.path).startsWith("runtime/")) {
+            droppedRuntimeRefs.push(normalized.path);
+            continue;
+        }
+        output_refs.push(normalized);
+    }
+    return {
+        item: { ...options.item, output_refs },
+        droppedRuntimeRefs,
+    };
+}
+function normalizeEvidenceOutputRef(options) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForContextGraph(options.contextGraphPath));
+    const artifact = schema ? findBuildPlanContextArtifact(schema, options.outputRef.artifact_id) : null;
+    if (!artifact)
+        return options.outputRef;
+    const path = normalizeGraphRelativeRefPath(options.outputRef.path);
+    const artifactRoot = normalizeGraphRelativeRefPath(artifact.path);
+    const outputMount = `outputs/${options.outputRef.artifact_id}`;
+    if (path === outputMount) {
+        return { ...options.outputRef, path: artifactRoot };
+    }
+    if (path.startsWith(`${outputMount}/`)) {
+        return {
+            ...options.outputRef,
+            path: normalizeGraphRelativeRefPath(`${artifactRoot}/${path.slice(outputMount.length + 1)}`),
+        };
+    }
+    if (path.startsWith("outputs/")) {
+        const stripped = normalizeGraphRelativeRefPath(path.slice("outputs/".length));
+        if (relativePathEqualsOrWithin(artifactRoot, stripped)) {
+            return { ...options.outputRef, path: stripped };
+        }
+    }
+    return options.outputRef;
+}
 function invalidItemReason(options) {
     if (options.item.stage_id !== options.stage.id)
         return "Item stage does not match the active stage.";

package/dist/packages/runtime/build/stage-manifest.d.ts

@@ -0,0 +1,45 @@
+import { type ExpectedInputsFile, type GraphManifest, type SourceManifest, type StageManifest, type StageInputs } from "../../contracts/lib/schema.js";
+import type { BuildPlanStageDefinition } from "../../build-plans/package/build-plan-definitions.js";
+export declare function persistStageReviewedInputsFromShell(options: {
+    contextGraphPath: string;
+    shellRoot: string;
+    stageId: string;
+}): {
+    ok: boolean;
+    summary: string;
+};
+export declare function writeStageExpectedInputs(options: {
+    contextGraphPath: string;
+    stage: Pick<BuildPlanStageDefinition, "id" | "reads" | "writes" | "contractType">;
+    generatedAt?: string;
+}): ExpectedInputsFile | null;
+export declare function writeSourceStageManifest(options: {
+    contextGraphPath: string;
+    buildPlanId: string;
+    sourceManifest: SourceManifest;
+    runId?: string | null;
+    generatedAt?: string;
+}): StageManifest;
+export declare function loadStageManifest(contextGraphPath: string, stageId: string): StageManifest | null;
+export declare function listStageManifests(contextGraphPath: string): StageManifest[];
+export declare function writeStageManifestFromOutputs(options: {
+    contextGraphPath: string;
+    buildPlanId: string;
+    projectId: string;
+    runId?: string | null;
+    stage: BuildPlanStageDefinition;
+    generatedAt?: string;
+}): StageManifest | null;
+export declare function loadGraphManifest(contextGraphPath: string): GraphManifest | null;
+export declare function writeGraphManifest(options: {
+    contextGraphPath: string;
+    projectId: string;
+    buildPlanId: string;
+    intent?: string | null;
+    runId?: string | null;
+    graphId?: string | null;
+    generatedAt?: string;
+}): GraphManifest;
+export declare function reviewedInputsFilePath(contextGraphPath: string, stageId: string): string;
+export declare function expectedInputsFilePath(contextGraphPath: string, stageId: string): string;
+export declare function loadStageInputsForManifest(contextGraphPath: string, stageId: string): StageInputs | null;