@interf/compiler 0.33.0 → 0.50.0

package/dist/packages/runtime/context-graph-semantic-graph.js

@@ -0,0 +1,416 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, join, posix } from "node:path";
+import { parseJsonFrontmatter } from "../contracts/utils/parse.js";
+import { knowledgeNoteKind, layerForPath, normalizeLayerPath, } from "../contracts/lib/context-graph-layer.js";
+import { ContextGraphSemanticGraphSchema, } from "./schemas/index.js";
+// Upper bound on markdown notes rendered into the semantic graph. This is a
+// pathological-input guard, NOT a display budget: it must comfortably exceed a
+// realistic Context Graph's note count so the canvas renders the WHOLE graph and
+// agrees with the GraphManifest node count, instead of truncating to the first
+// N alphabetical notes and showing a different, smaller graph than readiness
+// counted. The old value (180) silently dropped the bulk of a ~500-note graph —
+// turning real, connected content into off-canvas "islands". A real Context
+// Graph stays well under this ceiling; only a runaway build approaches it.
+const MAX_MARKDOWN_NOTES = 5000;
+const WIKILINK_PATTERN = /\[\[([^\]\n]+)\]\]/g;
+const MARKDOWN_LINK_PATTERN = /!?\[[^\]\n]*\]\(([^)\n]+)\)/g;
+function shortHash(value, length = 16) {
+    return createHash("sha256")
+        .update(value)
+        .digest("hex")
+        .slice(0, length);
+}
+function noteKey(value) {
+    return normalizeLayerPath(value)
+        .replace(/\.md$/i, "")
+        .trim()
+        .toLowerCase();
+}
+function slugKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['"]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function withoutMarkdownExtension(path) {
+    return path.replace(/\.md$/i, "");
+}
+function markdownBasename(path) {
+    return basename(path, extname(path));
+}
+function addGraphFile(files, contextGraphPath, relativePath) {
+    const absolutePath = join(contextGraphPath, relativePath);
+    if (!existsSync(absolutePath) || !statSync(absolutePath).isFile())
+        return;
+    if (!relativePath.toLowerCase().endsWith(".md"))
+        return;
+    files.push(normalizeLayerPath(relativePath));
+}
+function collectMarkdownFiles(files, contextGraphPath, relativeDir) {
+    const absoluteDir = join(contextGraphPath, relativeDir);
+    if (!existsSync(absoluteDir) || !statSync(absoluteDir).isDirectory())
+        return;
+    const entries = readdirSync(absoluteDir, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        const relativePath = normalizeLayerPath(join(relativeDir, entry.name));
+        if (entry.isDirectory()) {
+            collectMarkdownFiles(files, contextGraphPath, relativePath);
+            continue;
+        }
+        if (entry.isFile())
+            addGraphFile(files, contextGraphPath, relativePath);
+    }
+}
+function listMarkdownFiles(contextGraphPath) {
+    const files = [];
+    collectMarkdownFiles(files, contextGraphPath, ".");
+    return Array.from(new Set(files)).slice(0, MAX_MARKDOWN_NOTES);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringValues(value) {
+    if (Array.isArray(value))
+        return value.flatMap((item) => stringValues(item));
+    if (typeof value === "string")
+        return value.trim().length > 0 ? [value.trim()] : [];
+    if (value && typeof value === "object") {
+        const record = value;
+        return [
+            stringValue(record.path),
+            stringValue(record.locator),
+            stringValue(record.source_path),
+            stringValue(record.ref),
+            stringValue(record.summary),
+        ].filter((item) => Boolean(item));
+    }
+    return [];
+}
+function sourceRefsFromFrontmatter(frontmatter) {
+    return Array.from(new Set([
+        ...stringValues(frontmatter.source_refs),
+        ...stringValues(frontmatter.source_ref),
+        ...stringValues(frontmatter.source_path),
+    ]));
+}
+function aliasesFromFrontmatter(frontmatter) {
+    return Array.from(new Set([
+        stringValue(frontmatter.title),
+        stringValue(frontmatter.label),
+        stringValue(frontmatter.alias),
+        ...stringValues(frontmatter.aliases),
+    ].filter((item) => Boolean(item))));
+}
+function firstHeading(body) {
+    const heading = body.split("\n").find((line) => /^#{1,3}\s+\S/.test(line));
+    return heading ? heading.replace(/^#{1,3}\s+/, "").trim() : null;
+}
+function firstParagraph(body) {
+    const paragraph = body
+        .split(/\n\s*\n/)
+        .map((block) => block.replace(/\s+/g, " ").trim())
+        .find((block) => block.length > 0 && !block.startsWith("#"));
+    if (!paragraph)
+        return null;
+    return paragraph.length > 180 ? `${paragraph.slice(0, 177)}...` : paragraph;
+}
+function inferNoteKind(path) {
+    // Layer (home / artifact / summary / knowledge) and the knowledge
+    // claim·entity·index sub-kind come from the central `context-graph-layer`
+    // module, the single owner of the `knowledge/claims/` / `claim-` conventions,
+    // so this classifier and the StageManifest one can never drift. The only
+    // semantic-graph-specific refinement kept local is the loose "leaf merely
+    // contains `index`" nicety; the central module deliberately excludes it.
+    const layer = layerForPath(path);
+    if (layer === "home")
+        return "home";
+    if (layer === "artifacts")
+        return "artifact";
+    if (layer === "summaries")
+        return "summary";
+    const knowledgeKind = knowledgeNoteKind(path);
+    if (knowledgeKind === "claim")
+        return "claim";
+    if (knowledgeKind === "entity")
+        return "entity";
+    if (knowledgeKind === "index" || markdownBasename(normalizeLayerPath(path)).includes("index"))
+        return "index";
+    if (layer === "knowledge")
+        return "knowledge";
+    return "note";
+}
+function noteLabel(path, frontmatter, body) {
+    const leaf = markdownBasename(path);
+    const title = stringValue(frontmatter.title) ?? stringValue(frontmatter.label) ?? firstHeading(body);
+    return title && title.length <= 48 ? title : leaf;
+}
+function noteSummary(label, frontmatter, body) {
+    const explicit = stringValue(frontmatter.summary) ?? stringValue(frontmatter.abstract) ?? stringValue(frontmatter.description);
+    if (explicit)
+        return explicit.length > 220 ? `${explicit.slice(0, 217)}...` : explicit;
+    const title = stringValue(frontmatter.title) ?? firstHeading(body);
+    if (title && title !== label)
+        return title;
+    return firstParagraph(body);
+}
+function parseWikilinks(content) {
+    const links = [];
+    for (const match of content.matchAll(WIKILINK_PATTERN)) {
+        const raw = match[1]?.split("|")[0]?.split("#")[0]?.trim();
+        if (raw)
+            links.push(raw);
+    }
+    return Array.from(new Set(links));
+}
+function parseMarkdownLinks(content) {
+    const links = [];
+    for (const match of content.matchAll(MARKDOWN_LINK_PATTERN)) {
+        const raw = match[1]?.split("#")[0]?.trim();
+        if (!raw || /^https?:\/\//i.test(raw))
+            continue;
+        if (!raw.toLowerCase().endsWith(".md"))
+            continue;
+        try {
+            links.push(decodeURIComponent(raw));
+        }
+        catch {
+            links.push(raw);
+        }
+    }
+    return Array.from(new Set(links));
+}
+function parseNote(contextGraphPath, path) {
+    const content = readFileSync(join(contextGraphPath, path), "utf8");
+    const parsed = parseJsonFrontmatter(content);
+    const frontmatter = parsed?.frontmatter ?? {};
+    const body = parsed?.body ?? content;
+    const label = noteLabel(path, frontmatter, body);
+    return {
+        body,
+        id: `note:${path}`,
+        kind: inferNoteKind(path),
+        label,
+        path,
+        sourceRefs: sourceRefsFromFrontmatter(frontmatter),
+        summary: noteSummary(label, frontmatter, body),
+        aliases: aliasesFromFrontmatter(frontmatter),
+        wikilinks: Array.from(new Set([
+            ...parseWikilinks(content),
+            ...parseMarkdownLinks(content),
+        ])),
+    };
+}
+function addIndexTarget(index, key, nodeId) {
+    const normalized = noteKey(key);
+    if (normalized.length > 0 && !index.has(normalized))
+        index.set(normalized, nodeId);
+    const slug = slugKey(key);
+    if (slug.length > 0 && !index.has(slug))
+        index.set(slug, nodeId);
+}
+function buildNoteIndex(notes) {
+    const index = new Map();
+    for (const note of notes) {
+        addIndexTarget(index, note.path, note.id);
+        addIndexTarget(index, withoutMarkdownExtension(note.path), note.id);
+        addIndexTarget(index, markdownBasename(note.path), note.id);
+        if (note.path.endsWith("/summary.md")) {
+            addIndexTarget(index, withoutMarkdownExtension(note.path), note.id);
+        }
+        for (const alias of note.aliases)
+            addIndexTarget(index, alias, note.id);
+    }
+    return index;
+}
+function resolveWikilink(sourcePath, rawTarget, index) {
+    const clean = normalizeLayerPath(rawTarget);
+    const sourceDir = normalizeLayerPath(posix.dirname(sourcePath));
+    const relativeCandidate = normalizeLayerPath(posix.normalize(posix.join(sourceDir, clean)));
+    const candidates = [
+        clean,
+        withoutMarkdownExtension(clean),
+        relativeCandidate,
+        withoutMarkdownExtension(relativeCandidate),
+        markdownBasename(clean),
+    ];
+    for (const candidate of candidates) {
+        const match = index.get(noteKey(candidate)) ?? index.get(slugKey(candidate));
+        if (match)
+            return match;
+    }
+    return null;
+}
+function sourceLabel(ref, matchedFile) {
+    if (matchedFile)
+        return matchedFile.path;
+    const firstSegment = ref.split("›")[0]?.split("#")[0]?.trim() ?? ref;
+    if (/^https?:\/\//i.test(firstSegment)) {
+        try {
+            return new URL(firstSegment).hostname;
+        }
+        catch {
+            return firstSegment;
+        }
+    }
+    return firstSegment.length > 64 ? `${firstSegment.slice(0, 61)}...` : firstSegment;
+}
+function findSourceFile(ref, sourceManifest) {
+    const files = sourceManifest?.files ?? [];
+    const lowerRef = ref.toLowerCase();
+    return files.find((file) => {
+        const path = file.path.toLowerCase();
+        const leaf = basename(file.path).toLowerCase();
+        return lowerRef === path || lowerRef.startsWith(path) || lowerRef.includes(path) || lowerRef.includes(leaf);
+    }) ?? null;
+}
+function addNode(nodes, node) {
+    if (!nodes.has(node.id))
+        nodes.set(node.id, node);
+}
+function addEdge(edges, edge) {
+    if (!edges.has(edge.id))
+        edges.set(edge.id, edge);
+}
+function sourceNodeId(ref, matchedFile) {
+    return `source:${shortHash(matchedFile?.path ?? ref)}`;
+}
+function degreeCounts(edges) {
+    const links = new Map();
+    const backlinks = new Map();
+    for (const edge of edges) {
+        links.set(edge.source, (links.get(edge.source) ?? 0) + 1);
+        backlinks.set(edge.target, (backlinks.get(edge.target) ?? 0) + 1);
+    }
+    return { backlinks, links };
+}
+export function buildContextGraphSemanticGraph(options) {
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    if (!existsSync(options.contextGraphPath)) {
+        return ContextGraphSemanticGraphSchema.parse({
+            kind: "interf-context-graph-semantic-graph",
+            version: 1,
+            generated_at: generatedAt,
+            nodes: [],
+            edges: [],
+            stats: { notes: 0, links: 0, source_refs: 0, unresolved_links: 0 },
+        });
+    }
+    const notes = listMarkdownFiles(options.contextGraphPath).map((path) => parseNote(options.contextGraphPath, path));
+    const noteIndex = buildNoteIndex(notes);
+    const nodes = new Map();
+    const edges = new Map();
+    const projectNodeId = `project:${options.projectId}`;
+    addNode(nodes, {
+        id: projectNodeId,
+        kind: "project",
+        label: options.projectId,
+        path: options.contextGraphPath,
+        summary: "Latest Context Graph root.",
+        source_refs: [],
+        link_count: 0,
+        backlink_count: 0,
+    });
+    for (const note of notes) {
+        addNode(nodes, {
+            id: note.id,
+            kind: note.kind,
+            label: note.label,
+            path: note.path,
+            summary: note.summary,
+            source_refs: note.sourceRefs,
+            link_count: 0,
+            backlink_count: 0,
+        });
+    }
+    const home = notes.find((note) => note.kind === "home");
+    if (home) {
+        addEdge(edges, {
+            id: `${projectNodeId}->${home.id}:contains`,
+            kind: "contains",
+            source: projectNodeId,
+            target: home.id,
+            label: "contains",
+            detail: `${options.projectId} starts at ${home.path}.`,
+        });
+    }
+    if (options.entrypointPath) {
+        const entrypointId = noteIndex.get(noteKey(options.entrypointPath)) ?? noteIndex.get(noteKey(withoutMarkdownExtension(options.entrypointPath)));
+        if (entrypointId) {
+            addEdge(edges, {
+                id: `${projectNodeId}->${entrypointId}:handoff`,
+                kind: "handoff",
+                source: projectNodeId,
+                target: entrypointId,
+                label: "handoff",
+                detail: `${options.entrypointPath} is the primary downstream agent entrypoint.`,
+            });
+        }
+    }
+    let unresolvedLinks = 0;
+    for (const note of notes) {
+        for (const rawTarget of note.wikilinks) {
+            const targetId = resolveWikilink(note.path, rawTarget, noteIndex);
+            if (!targetId) {
+                unresolvedLinks += 1;
+                continue;
+            }
+            addEdge(edges, {
+                id: `${note.id}->${targetId}:links-to`,
+                kind: "links-to",
+                source: note.id,
+                target: targetId,
+                label: "links to",
+                detail: `${note.path} links to ${rawTarget}.`,
+            });
+        }
+        for (const ref of note.sourceRefs) {
+            const matchedFile = findSourceFile(ref, options.sourceManifest);
+            const id = sourceNodeId(ref, matchedFile);
+            const label = sourceLabel(ref, matchedFile);
+            addNode(nodes, {
+                id,
+                kind: "source",
+                label,
+                path: matchedFile?.locator ?? matchedFile?.path ?? null,
+                summary: ref,
+                source_refs: [ref],
+                link_count: 0,
+                backlink_count: 0,
+            });
+            addEdge(edges, {
+                id: `${note.id}->${id}:source-ref:${shortHash(ref, 10)}`,
+                kind: "source-ref",
+                source: note.id,
+                target: id,
+                label: "source ref",
+                detail: `${note.path} cites ${label}.`,
+            });
+        }
+    }
+    const edgeList = [...edges.values()];
+    const counts = degreeCounts(edgeList);
+    const nodeList = [...nodes.values()].map((node) => ({
+        ...node,
+        link_count: counts.links.get(node.id) ?? 0,
+        backlink_count: counts.backlinks.get(node.id) ?? 0,
+    }));
+    return ContextGraphSemanticGraphSchema.parse({
+        kind: "interf-context-graph-semantic-graph",
+        version: 1,
+        generated_at: generatedAt,
+        nodes: nodeList,
+        edges: edgeList,
+        stats: {
+            notes: notes.length,
+            links: edgeList.filter((edge) => edge.kind === "links-to").length,
+            source_refs: edgeList.filter((edge) => edge.kind === "source-ref").length,
+            unresolved_links: unresolvedLinks,
+        },
+    });
+}

package/dist/packages/runtime/execution/lib/schema.d.ts

@@ -307,14 +307,14 @@ export declare const RunObservabilitySchema: z.ZodObject<{
         generated_at: z.ZodString;
         project: z.ZodString;
         status: z.ZodEnum<{
-            failed: "failed";
             ready: "ready";
+            "not-ready": "not-ready";
+            failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>;
         ready: z.ZodBoolean;
@@ -334,14 +334,14 @@ export declare const RunObservabilitySchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -383,14 +383,14 @@ export declare const RunObservabilitySchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -670,14 +670,14 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
         generated_at: z.ZodString;
         project: z.ZodString;
         status: z.ZodEnum<{
-            failed: "failed";
             ready: "ready";
+            "not-ready": "not-ready";
+            failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>;
         ready: z.ZodBoolean;
@@ -697,14 +697,14 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -746,14 +746,14 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -918,14 +918,14 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         generated_at: z.ZodString;
         project: z.ZodString;
         status: z.ZodEnum<{
-            failed: "failed";
             ready: "ready";
+            "not-ready": "not-ready";
+            failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>;
         ready: z.ZodBoolean;
@@ -945,14 +945,14 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -994,14 +994,14 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -1357,14 +1357,14 @@ export declare const BuildRunSchema: z.ZodObject<{
             generated_at: z.ZodString;
             project: z.ZodString;
             status: z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>;
             ready: z.ZodBoolean;
@@ -1384,14 +1384,14 @@ export declare const BuildRunSchema: z.ZodObject<{
                 }>;
                 ok: z.ZodBoolean;
                 status: z.ZodOptional<z.ZodEnum<{
-                    failed: "failed";
                     ready: "ready";
+                    "not-ready": "not-ready";
+                    failed: "failed";
                     "not-configured": "not-configured";
                     "not-built": "not-built";
                     building: "building";
                     built: "built";
                     checking: "checking";
-                    "not-ready": "not-ready";
                     stale: "stale";
                 }>>;
                 summary: z.ZodString;
@@ -1433,14 +1433,14 @@ export declare const BuildRunSchema: z.ZodObject<{
                 }>;
                 ok: z.ZodBoolean;
                 status: z.ZodOptional<z.ZodEnum<{
-                    failed: "failed";
                     ready: "ready";
+                    "not-ready": "not-ready";
+                    failed: "failed";
                     "not-configured": "not-configured";
                     "not-built": "not-built";
                     building: "building";
                     built: "built";
                     checking: "checking";
-                    "not-ready": "not-ready";
                     stale: "stale";
                 }>>;
                 summary: z.ZodString;
@@ -1483,14 +1483,14 @@ export declare const BuildRunSchema: z.ZodObject<{
         generated_at: z.ZodString;
         project: z.ZodString;
         status: z.ZodEnum<{
-            failed: "failed";
             ready: "ready";
+            "not-ready": "not-ready";
+            failed: "failed";
             "not-configured": "not-configured";
             "not-built": "not-built";
             building: "building";
             built: "built";
             checking: "checking";
-            "not-ready": "not-ready";
             stale: "stale";
         }>;
         ready: z.ZodBoolean;
@@ -1510,14 +1510,14 @@ export declare const BuildRunSchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -1559,14 +1559,14 @@ export declare const BuildRunSchema: z.ZodObject<{
             }>;
             ok: z.ZodBoolean;
             status: z.ZodOptional<z.ZodEnum<{
-                failed: "failed";
                 ready: "ready";
+                "not-ready": "not-ready";
+                failed: "failed";
                 "not-configured": "not-configured";
                 "not-built": "not-built";
                 building: "building";
                 built: "built";
                 checking: "checking";
-                "not-ready": "not-ready";
                 stale: "stale";
             }>>;
             summary: z.ZodString;
@@ -1595,9 +1595,9 @@ export declare const BuildRunSchema: z.ZodObject<{
     artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
         artifact_id: z.ZodString;
         status: z.ZodEnum<{
+            ready: "ready";
             failed: "failed";
             skipped: "skipped";
-            ready: "ready";
             not_ready: "not_ready";
         }>;
         built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1614,6 +1614,9 @@ export declare const BuildRunSchema: z.ZodObject<{
                 frontmatter_required_keys: "frontmatter_required_keys";
                 frontmatter_nonempty_keys: "frontmatter_nonempty_keys";
                 source_refs_required: "source_refs_required";
+                summary_backlinks_present: "summary_backlinks_present";
+                knowledge_web_connectivity: "knowledge_web_connectivity";
+                graph_notes_connected: "graph_notes_connected";
                 wikilinks_valid: "wikilinks_valid";
                 must_not_contain: "must_not_contain";
                 must_contain: "must_contain";