npm - @kaddo/cli - Versions diffs - 3.77.0 → 3.79.0 - Mend

@kaddo/cli 3.77.0 → 3.79.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/admin-dist/assets/{index-D0l52rub.js → index-sZtkPyjd.js} +2 -2
package/dist/admin-dist/index.html +1 -1
package/dist/admin-server/index.js +26 -2
package/dist/core.js +332 -15
package/dist/index.js +333 -45
package/package.json +1 -1

package/dist/admin-dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>admin</title>
-    <script type="module" crossorigin src="/assets/index-D0l52rub.js"></script>
+    <script type="module" crossorigin src="/assets/index-sZtkPyjd.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BPQdYfAp.css">
   </head>
   <body>

package/dist/admin-server/index.js CHANGED Viewed

@@ -69,6 +69,7 @@ import {
   getWorkItemCaptureDefinition as coreGetCaptureDefinition,
   buildRefinementHandoff as coreBuildRefinementHandoff,
   getSystemMapProjection as coreGetSystemMapProjection,
+  buildTopologyEnrichmentHandoff as coreBuildTopologyHandoff,
   WorkItemWriteError,
   exists,
   join,
@@ -139,6 +140,11 @@ function getCaptureDefinition() {
 function getSystemMap(dir) {
   return coreGetSystemMapProjection(dir);
 }
+function getTopologyHandoff(dir) {
+  const config = loadConfig(dir);
+  if (!config) throw new CoreError("PROJECT_NOT_FOUND", "No Kaddo project was found.");
+  return coreBuildTopologyHandoff(dir, config.project.name ?? "this project");
+}
 function getRefinementHandoff(dir, workItemId) {
   assertValidWorkItemId(workItemId);
   try {
@@ -590,7 +596,12 @@ var SystemMapNodeSchema = z.object({
   path: z.string().optional(),
   workItemRef: z.string().optional(),
   knowledgeRef: z.object({ id: z.string(), layer: z.string() }).optional(),
-  moduleId: z.string().optional()
+  moduleId: z.string().optional(),
+  purpose: z.string().optional(),
+  implementationRefs: z.array(z.string()).optional(),
+  knowledgeRefs: z.array(z.object({ id: z.string(), layer: z.string() })).optional(),
+  provenance: z.string().optional(),
+  evidence: z.array(z.string()).optional()
 });
 var SystemMapRelationshipSchema = z.object({
   id: z.string(),
@@ -618,9 +629,20 @@ var SystemMapProjectionSchema = z.object({
     coverage: z.enum(["good", "partial", "sparse", "empty"]),
     available: z.boolean(),
     dimensions: z.object({ system: z.number(), knowledge: z.number(), delivery: z.number(), implementation: z.number(), unknown: z.number() }),
-    topologyAvailable: z.boolean()
+    topologyAvailable: z.boolean(),
+    topologyStatus: z.enum(["unavailable", "partial", "available"]),
+    semanticEntityCount: z.number(),
+    technicalRelationshipCount: z.number(),
+    topologyFindings: z.array(z.object({ level: z.enum(["blocking", "warning"]), message: z.string() }))
   })
 });
+var TopologyEnrichmentHandoffSchema = z.object({
+  projectName: z.string(),
+  recommendedAgent: z.string(),
+  recommendedSkill: z.string(),
+  targetFile: z.string(),
+  text: z.string()
+});
 var ErrorResponseSchema = z.object({
   error: z.object({
     code: z.string(),
@@ -782,6 +804,7 @@ async function createAdminServer(opts) {
   app.get("/api/v1/admin/route", coreRoute(getProjectRoute));
   app.get("/api/v1/admin/findings", coreRoute(getFindings));
   app.get("/api/v1/admin/system", coreRoute(getSystemMap));
+  app.get("/api/v1/admin/system/topology-handoff", coreRoute(getTopologyHandoff));
   app.get("/api/v1/admin/knowledge/inventory", coreRoute(getKnowledgeInventory));
   app.get("/api/v1/admin/knowledge/artifact/:artifactId", async (request) => {
     try {
@@ -940,6 +963,7 @@ export {
   SystemMapNodeSchema,
   SystemMapProjectionSchema,
   SystemMapRelationshipSchema,
+  TopologyEnrichmentHandoffSchema,
   ValidationResultSchema,
   WorkItemCreateSchema,
   WorkItemCreateWithAnswersSchema,

package/dist/core.js CHANGED Viewed

@@ -116,8 +116,8 @@ function loadConfig(dir) {
   const parsed = configSchema.safeParse(raw ?? {});
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => {
-      const path3 = i.path.join(".");
-      return path3 ? `  - ${path3}: ${i.message}` : `  - ${i.message}`;
+      const path4 = i.path.join(".");
+      return path4 ? `  - ${path4}: ${i.message}` : `  - ${i.message}`;
     }).join("\n");
     throw new ConfigError(`Invalid .kaddo/config.yml:
 ${issues}`);
@@ -352,11 +352,11 @@ function moduleArtifactCoverage(dir, id) {
   };
 }
 function loadMappedModules(dir) {
-  const path3 = join(dir, DESCRIPTOR_PATH);
-  if (!exists(path3)) return [];
+  const path4 = join(dir, DESCRIPTOR_PATH);
+  if (!exists(path4)) return [];
   let parsed;
   try {
-    parsed = parseYaml3(readFile(path3));
+    parsed = parseYaml3(readFile(path4));
   } catch {
     return [];
   }
@@ -1590,7 +1590,7 @@ function sectionParagraph(md, title) {
   }
   return "";
 }
-function parseCapsule(id, path3, md) {
+function parseCapsule(id, path4, md) {
   const { data } = matter2(md);
   const updatedAt = data.updated_at ? String(data.updated_at) : void 0;
   let ageDays = null;
@@ -1600,7 +1600,7 @@ function parseCapsule(id, path3, md) {
   }
   return {
     id,
-    path: path3,
+    path: path4,
     system: data.system ? String(data.system) : id,
     owner: data.owner ? String(data.owner) : void 0,
     updatedAt,
@@ -1662,9 +1662,9 @@ function buildGraph(dir, config, opts = {}, now = /* @__PURE__ */ new Date()) {
   ];
   const presentLayers = [];
   for (const layer of layerDocs) {
-    const path3 = layer.files.map((f) => `${KNOWLEDGE2}/${f}`).find((rel) => exists(join(dir, rel)));
-    if (path3) {
-      addNode({ id: layer.id, type: layer.type, label: layer.label, path: path3 });
+    const path4 = layer.files.map((f) => `${KNOWLEDGE2}/${f}`).find((rel) => exists(join(dir, rel)));
+    if (path4) {
+      addNode({ id: layer.id, type: layer.type, label: layer.label, path: path4 });
       presentLayers.push(layer.id);
     }
   }
@@ -3060,10 +3060,10 @@ function resolveNextStep(dir, now = /* @__PURE__ */ new Date()) {
   const q = (rel) => analyzeKnowledgeArtifact(dir, rel);
   const resolveAgent = (agent) => {
     const file = agent.endsWith(".md") ? agent : `${agent}.md`;
-    const path3 = agentInstallPath(file);
-    const installed = isFile(join(dir, path3));
+    const path4 = agentInstallPath(file);
+    const installed = isFile(join(dir, path4));
     const group = agentGroupOf(file);
-    return { agentPath: path3, agentInstalled: installed, installCommand: installed ? void 0 : `kaddo add agents --group ${group}` };
+    return { agentPath: path4, agentInstalled: installed, installCommand: installed ? void 0 : `kaddo add agents --group ${group}` };
   };
   const moduleRepo = isModule(config);
   const coreRepo = isCore(config);
@@ -8712,6 +8712,263 @@ function buildRefinementHandoff(dir, workItemId) {
   };
 }
+// src/core/system-topology.ts
+import { parse as parseYaml8, stringify as stringifyYaml4 } from "yaml";
+import fs3 from "fs";
+import path3 from "path";
+import crypto2 from "crypto";
+var TOPOLOGY_FILE = "knowledge/tech/system-topology.yml";
+var SYSTEM_ENTITY_KINDS = /* @__PURE__ */ new Set([
+  "system",
+  "application",
+  "service",
+  "component",
+  "api",
+  "interface",
+  "datastore",
+  "queue",
+  "job",
+  "external-system",
+  "module",
+  "unknown"
+]);
+var TECHNICAL_RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+  "contains",
+  "depends-on",
+  "calls",
+  "reads-from",
+  "writes-to",
+  "publishes-to",
+  "subscribes-to",
+  "integrates-with",
+  "runs-on",
+  "implemented-by"
+]);
+var PROVENANCE = /* @__PURE__ */ new Set(["declared", "derived", "agent-reviewed"]);
+function isRelative(p2) {
+  return typeof p2 === "string" && p2.trim() !== "" && !/^([a-zA-Z]:[\\/]|\/)/.test(p2) && !p2.includes("..");
+}
+function strList(v) {
+  return Array.isArray(v) ? v.map((x) => typeof x === "string" ? x.trim() : "").filter(Boolean) : [];
+}
+function loadSystemTopology(dir) {
+  const filePath = join(dir, TOPOLOGY_FILE);
+  if (!exists(filePath)) return { entities: [], relationships: [], findings: [], declared: false };
+  const parsed = parseTopologyContent(readFile(filePath), dir);
+  return { ...parsed, declared: true };
+}
+function parseTopologyContent(raw, dir) {
+  let parsed;
+  try {
+    parsed = parseYaml8(raw) ?? {};
+  } catch {
+    return { entities: [], relationships: [], findings: [{ level: "blocking", message: "The topology could not be parsed." }] };
+  }
+  const sourceRevision = typeof parsed.source_revision === "string" ? parsed.source_revision : void 0;
+  const findings = [];
+  const validModules = /* @__PURE__ */ new Set(["core", ...loadMappedModules(dir).map((m) => m.id)]);
+  const rawEntities = Array.isArray(parsed.entities) ? parsed.entities : [];
+  const entities = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const raw2 of rawEntities) {
+    if (!raw2 || typeof raw2 !== "object") continue;
+    const e = raw2;
+    const id = typeof e.id === "string" ? e.id.trim() : "";
+    if (!id) {
+      findings.push({ level: "warning", message: "A topology entity is missing an id and was skipped." });
+      continue;
+    }
+    if (seenIds.has(id)) {
+      findings.push({ level: "blocking", message: `Duplicate topology entity id "${id}".` });
+      continue;
+    }
+    const kind = typeof e.kind === "string" ? e.kind.trim() : "unknown";
+    if (!SYSTEM_ENTITY_KINDS.has(kind)) {
+      findings.push({ level: "warning", message: `Entity "${id}" has an unknown kind "${kind}"; treated as unknown.` });
+    }
+    const moduleRaw = typeof e.module === "string" ? e.module.trim() : void 0;
+    if (moduleRaw && !validModules.has(moduleRaw)) findings.push({ level: "warning", message: `Entity "${id}" references unregistered module "${moduleRaw}".` });
+    const rawImpl = e.implementation ?? e.implementation_refs;
+    const implementation = strList(rawImpl).filter((p2) => {
+      if (isRelative(p2)) return true;
+      findings.push({ level: "warning", message: `Entity "${id}" implementation ref "${p2}" is not a safe relative path and was dropped.` });
+      return false;
+    });
+    const prov = e.provenance;
+    const provOrigin = typeof prov === "string" ? prov : prov && typeof prov === "object" && typeof prov.origin === "string" ? String(prov.origin) : void 0;
+    const provenance = provOrigin && PROVENANCE.has(provOrigin) ? provOrigin : void 0;
+    const evidence = strList(e.evidence ?? (prov && typeof prov === "object" ? prov.evidence_refs : void 0)).filter(isRelative);
+    seenIds.add(id);
+    entities.push({
+      id,
+      kind: SYSTEM_ENTITY_KINDS.has(kind) ? kind : "unknown",
+      label: typeof e.label === "string" && e.label.trim() ? e.label.trim() : id,
+      ...typeof e.purpose === "string" && e.purpose.trim() ? { purpose: e.purpose.trim() } : {},
+      ...moduleRaw && validModules.has(moduleRaw) ? { moduleId: moduleRaw } : {},
+      implementationRefs: implementation,
+      knowledgeRefs: strList(e.knowledge ?? e.knowledge_refs),
+      ...provenance ? { provenance } : {},
+      evidence
+    });
+  }
+  const entityIds = new Set(entities.map((e) => e.id));
+  const rawRels = Array.isArray(parsed.relationships) ? parsed.relationships : [];
+  const relationships = [];
+  const seenRels = /* @__PURE__ */ new Set();
+  for (const raw2 of rawRels) {
+    if (!raw2 || typeof raw2 !== "object") continue;
+    const r = raw2;
+    const from = typeof r.from === "string" ? r.from.trim() : typeof r.source === "string" ? r.source.trim() : "";
+    const to = typeof r.to === "string" ? r.to.trim() : typeof r.target === "string" ? r.target.trim() : "";
+    const type = typeof r.type === "string" ? r.type.trim() : "";
+    if (!from || !to || !type) {
+      findings.push({ level: "warning", message: "A topology relationship is missing from/to/type and was skipped." });
+      continue;
+    }
+    if (!TECHNICAL_RELATIONSHIP_TYPES.has(type)) {
+      findings.push({ level: "warning", message: `Relationship type "${type}" is not recognized and was skipped.` });
+      continue;
+    }
+    if (!entityIds.has(from) || !entityIds.has(to)) {
+      findings.push({ level: "blocking", message: `Relationship ${from} \u2192 ${to} references an unknown entity endpoint.` });
+      continue;
+    }
+    const key = `${from}~${type}~${to}`;
+    if (seenRels.has(key)) {
+      findings.push({ level: "warning", message: `Duplicate relationship ${from} ${type} ${to} was skipped.` });
+      continue;
+    }
+    seenRels.add(key);
+    const prov = r.provenance;
+    relationships.push({ from, to, type, evidence: strList(r.evidence ?? prov?.evidence_refs).filter(isRelative) });
+  }
+  return { entities, relationships, findings, ...sourceRevision ? { sourceRevision } : {} };
+}
+function validateSystemTopology(dir) {
+  return loadSystemTopology(dir).findings;
+}
+var TopologyWriteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TopologyWriteError";
+    this.code = code;
+  }
+};
+function topologyRevision(dir) {
+  const filePath = join(dir, TOPOLOGY_FILE);
+  const raw = exists(filePath) ? readFile(filePath) : "";
+  return crypto2.createHash("sha256").update(raw, "utf-8").digest("hex");
+}
+function validateTopologyProposal(dir, proposalYaml) {
+  const { entities, relationships, findings } = parseTopologyContent(proposalYaml, dir);
+  const blocking = findings.filter((f) => f.level === "blocking").length;
+  const warning = findings.filter((f) => f.level === "warning").length;
+  return { findings, blocking, warning, canApply: blocking === 0, entityCount: entities.length, relationshipCount: relationships.length };
+}
+function serializeTopology(entities, relationships) {
+  const doc = {
+    entities: entities.map((e) => ({
+      id: e.id,
+      kind: e.kind,
+      label: e.label,
+      ...e.purpose ? { purpose: e.purpose } : {},
+      ...e.moduleId ? { module: e.moduleId } : {},
+      ...e.implementationRefs.length ? { implementation: e.implementationRefs } : {},
+      ...e.knowledgeRefs.length ? { knowledge: e.knowledgeRefs } : {},
+      ...e.provenance ? { provenance: e.provenance } : {},
+      ...e.evidence.length ? { evidence: e.evidence } : {}
+    })),
+    relationships: relationships.map((r) => ({ from: r.from, to: r.to, type: r.type, ...r.evidence.length ? { evidence: r.evidence } : {} }))
+  };
+  return stringifyYaml4(doc);
+}
+function atomicWrite2(filePath, content) {
+  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs3.writeFileSync(tmp, content, "utf-8");
+  try {
+    fs3.renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      fs3.rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function applyTopologyProposal(dir, proposalYaml, expectedRevision) {
+  const validation = validateTopologyProposal(dir, proposalYaml);
+  if (!validation.canApply) throw new TopologyWriteError("TOPOLOGY_INVALID", "The topology proposal has blocking findings and cannot be applied.");
+  const current = topologyRevision(dir);
+  if (expectedRevision != null && expectedRevision !== current) {
+    throw new TopologyWriteError("TOPOLOGY_CONFLICT", "The topology changed after this proposal was created. Refresh and validate the proposal again.");
+  }
+  const proposal = parseTopologyContent(proposalYaml, dir);
+  const existing = loadSystemTopology(dir);
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const e of existing.entities) entityMap.set(e.id, e);
+  let entitiesNew = 0, entitiesUpdated = 0;
+  for (const e of proposal.entities) {
+    if (entityMap.has(e.id)) entitiesUpdated++;
+    else entitiesNew++;
+    entityMap.set(e.id, e);
+  }
+  const relKey = (r) => `${r.from}~${r.type}~${r.to}`;
+  const relMap = /* @__PURE__ */ new Map();
+  for (const r of existing.relationships) relMap.set(relKey(r), r);
+  let relationshipsNew = 0;
+  for (const r of proposal.relationships) {
+    if (!relMap.has(relKey(r))) relationshipsNew++;
+    relMap.set(relKey(r), r);
+  }
+  const raw = serializeTopology([...entityMap.values()], [...relMap.values()]);
+  const finalCheck = validateTopologyProposal(dir, raw);
+  if (!finalCheck.canApply) throw new TopologyWriteError("TOPOLOGY_INVALID", "The merged topology is invalid; no changes were written.");
+  atomicWrite2(join(dir, TOPOLOGY_FILE), raw);
+  return { revision: topologyRevision(dir), entitiesNew, entitiesUpdated, relationshipsNew };
+}
+function buildTopologyEnrichmentHandoff(dir, projectName) {
+  const mappedModules = loadMappedModules(dir).map((m) => m.id);
+  const lines = [
+    `Enrich the semantic system topology for the Kaddo project "${projectName}".`,
+    "",
+    "Use the canonical architecture-agent and graph-metadata-review skill (via Kaddo MCP or skills).",
+    "Inspect the actual repository and relevant mapped modules \u2014 do not infer architecture from",
+    "filenames or directory names."
+  ];
+  if (mappedModules.length > 0) {
+    lines.push("", `This is a multirepo project. Inspect the relevant mapped modules (${mappedModules.join(", ")}) before finalizing the topology.`);
+  }
+  lines.push(
+    "",
+    "Build a topology PROPOSAL first \u2014 do not write canonical metadata directly. For each entity",
+    "capture, only when supported by evidence:",
+    "- a stable id and semantic kind (application/service/component/api/interface/datastore/queue/job/external-system);",
+    "- a responsibility/purpose (what it does, not how);",
+    "- the owning module/repository;",
+    "- implementation references (relative paths);",
+    "- relevant Knowledge references (capability/ADR ids), not Kaddo operational assets;",
+    "- provenance/evidence.",
+    "",
+    "Capture evidence-backed technical relationships: contains, calls, depends-on, reads-from,",
+    "writes-to, integrates-with, runs-on. Preserve Unknown when evidence is insufficient.",
+    "",
+    "Validate the proposal through Kaddo before applying it. Do not write canonical topology metadata",
+    `unless (1) Kaddo validation succeeds and (2) the human explicitly confirms the write. The canonical`,
+    `artifact is ${TOPOLOGY_FILE}; Core validates and applies it \u2014 do not hand-edit it.`,
+    "",
+    "Do not implement application changes. Do not run mutating Git operations."
+  );
+  return {
+    projectName,
+    recommendedAgent: "architecture-agent",
+    recommendedSkill: "graph-metadata-review",
+    targetFile: TOPOLOGY_FILE,
+    text: lines.join("\n")
+  };
+}
 // src/core/system-map.ts
 function dimensionOf(type) {
   switch (type) {
@@ -8770,7 +9027,20 @@ function emptyProjection(name, structure) {
     nodes: [],
     relationships: [],
     groups: [],
-    metadata: { projectName: name, structure, nodeCount: 0, relationshipCount: 0, coverage: "empty", available: false, dimensions: emptyDimensions(), topologyAvailable: false }
+    metadata: {
+      projectName: name,
+      structure,
+      nodeCount: 0,
+      relationshipCount: 0,
+      coverage: "empty",
+      available: false,
+      dimensions: emptyDimensions(),
+      topologyAvailable: false,
+      topologyStatus: "unavailable",
+      semanticEntityCount: 0,
+      technicalRelationshipCount: 0,
+      topologyFindings: []
+    }
   };
 }
 function getSystemMapProjection(dir) {
@@ -8796,6 +9066,38 @@ function getSystemMapProjection(dir) {
     type: e.type,
     label: EDGE_LABELS[e.type] ?? e.type.replace(/_/g, " ")
   }));
+  const knowledgeById = /* @__PURE__ */ new Map();
+  for (const ref of knowledgeByPath.values()) knowledgeById.set(ref.id, ref);
+  const topology = loadSystemTopology(dir);
+  const existingIds = new Set(nodes.map((n) => n.id));
+  for (const e of topology.entities) {
+    const nodeId = `sys:${e.id}`;
+    const node = {
+      id: nodeId,
+      type: e.kind,
+      label: e.label,
+      dimension: "system",
+      implementationRefs: e.implementationRefs,
+      knowledgeRefs: e.knowledgeRefs.map((k) => knowledgeById.get(k)).filter(Boolean),
+      evidence: e.evidence
+    };
+    if (e.purpose) node.purpose = e.purpose;
+    if (e.moduleId) node.moduleId = e.moduleId;
+    if (e.provenance) node.provenance = e.provenance;
+    nodes.push(node);
+    existingIds.add(nodeId);
+    for (const ref of e.implementationRefs) {
+      const fileId = `file:${ref}`;
+      if (!existingIds.has(fileId)) {
+        nodes.push({ id: fileId, type: "file", label: ref.split("/").pop() || ref, dimension: "implementation", path: ref });
+        existingIds.add(fileId);
+      }
+      relationships.push({ id: `${nodeId}~implemented-by~${fileId}`, source: nodeId, target: fileId, type: "implemented-by", label: "implemented by" });
+    }
+  }
+  for (const r of topology.relationships) {
+    relationships.push({ id: `sys:${r.from}~${r.type}~sys:${r.to}`, source: `sys:${r.from}`, target: `sys:${r.to}`, type: r.type, label: r.type.replace(/-/g, " ") });
+  }
   const usedGroups = new Set(nodes.map((n) => n.moduleId).filter(Boolean));
   const allGroups = [
     { id: "core", label: "core", repositoryId: "core", available: true },
@@ -8805,6 +9107,9 @@ function getSystemMapProjection(dir) {
   const groups = allGroups.filter((g) => usedGroups.has(g.id) || g.available === false);
   const dimensions = emptyDimensions();
   for (const n of nodes) dimensions[n.dimension]++;
+  const semanticEntityCount = topology.entities.length;
+  const technicalRelationshipCount = relationships.filter((r) => TECHNICAL_RELATIONSHIP_TYPES.has(r.type)).length;
+  const topologyStatus = semanticEntityCount === 0 ? "unavailable" : topology.relationships.length > 0 ? "available" : "partial";
   return {
     system: { name: config.project.name },
     nodes,
@@ -8818,7 +9123,11 @@ function getSystemMapProjection(dir) {
       coverage: hints.quality,
       available: nodes.length > 0,
       dimensions,
-      topologyAvailable: dimensions.system > 0
+      topologyAvailable: dimensions.system > 0,
+      topologyStatus,
+      semanticEntityCount,
+      technicalRelationshipCount,
+      topologyFindings: topology.findings
     }
   };
 }
@@ -8858,14 +9167,18 @@ function toNode(n, knowledgeByPath, wiModules, groupIds) {
   return node;
 }
 export {
+  TOPOLOGY_FILE,
+  TopologyWriteError,
   WorkItemNotFoundError,
   WorkItemWriteError,
   analyzeCrossRepoEvidence,
   analyzeScopeCoverage,
+  applyTopologyProposal,
   buildProjectExplanation,
   buildProjectRoute,
   buildReadinessReport,
   buildRefinementHandoff,
+  buildTopologyEnrichmentHandoff,
   computeRefinementStatus,
   createWorkItem,
   cwd,
@@ -8887,8 +9200,12 @@ export {
   lifecycleStateOf,
   loadConfig,
   loadMappedModules,
+  loadSystemTopology,
   readFile,
+  topologyRevision,
   transitionWorkItem,
   updateWorkItem,
+  validateSystemTopology,
+  validateTopologyProposal,
   validateWorkItem
 };