archctx 0.9.0 → 0.9.2

package/bin/archctx.mjs

@@ -53,6 +53,9 @@ function stableYaml(value, indent = 0) {
       return `[]
 `;
     return value.map((item) => {
+      if (Array.isArray(item))
+        return `${pad}- ${canonicalize(item)}
+`;
       if (item !== null && typeof item === "object") {
         return `${pad}- ${stableYaml(item, indent + 2).trimStart()}`;
       }
@@ -2374,8 +2377,9 @@ var init_failure = __esm(() => {
     "model-missing": { code: "AC_MODEL_ADOPTION_REQUIRED", message: "Architecture debt requires an adopted model.", fields: ["checks"] },
     "changed-path-invalid": { code: "AC_SCHEMA_INVALID", message: "Changed paths must be an array of repository-relative POSIX paths.", fields: ["checks"] },
     "debt-report-invalid": { code: "AC_SCHEMA_INVALID", message: "Architecture debt evidence violates its contract.", fields: ["checks"] },
-    "projection-manifest-upgrade-required": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest requires supported re-baselining." },
+    "projection-manifest-upgrade-required": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest requires supported re-baselining. First restore the original model if missing; the manifest digest cannot recover it. With the reviewed model available, follow docs/runbooks/architecture-documentation-projections.md before running archctx docs apply --approved --profile <default|repo-harness/v1>." },
     "projection-manifest-invalid": { code: "AC_PRECONDITION_FAILED", message: "The committed projection manifest violates its contract." },
+    "architecture-model-ignored": { code: "AC_PRECONDITION_FAILED", action: "commit-architecture-model", message: "Git ignore rules exclude architecture model paths, so the model cannot be committed and a manifest digest cannot rebuild it. Remove or narrow the rule, commit the model, then retry adoption. The diagnostic command prints each deciding rule.", facts: { pathCount: "uint", paths: "optional:diagnosticPaths", commands: "optional:diagnosticCommands", omittedPathCount: "uint" } },
     "projection-footprint-uncovered": { code: "AC_PRECONDITION_FAILED", message: "Declared source footprints lack a projection target." },
     "index-missing": { code: "AC_CODE_FACTS_UNAVAILABLE", message: "Required code facts have no available index. Run codegraph init." },
     "code-facts-not-ready": { code: "AC_CODE_FACTS_NOT_READY", message: "Repository code facts are not ready. Run archctx doctor --json and follow the reported action.", facts: { issues: "codeFactsIssues" } },
@@ -2813,6 +2817,89 @@ var init_failure = __esm(() => {
   };
 });
 
+// packages/contracts/src/runtime-topology.ts
+function isRuntimeTopologyNodeKind(kind) {
+  return typeof kind === "string" && RUNTIME_TOPOLOGY_NODE_KINDS.includes(kind);
+}
+function runtimeTopologyModelIssues(model) {
+  const issues = [];
+  const nodesById = new Map;
+  for (const node of model.nodes)
+    if (typeof node.id === "string")
+      nodesById.set(node.id, node);
+  const namespacesByProcess = new Map;
+  const mountersByMount = new Map;
+  for (const relation of model.relations) {
+    if (typeof relation.id !== "string" || typeof relation.kind !== "string" || !Object.hasOwn(RUNTIME_TOPOLOGY_RELATION_ENDPOINT_KINDS, relation.kind))
+      continue;
+    const rule = RUNTIME_TOPOLOGY_RELATION_ENDPOINT_KINDS[relation.kind];
+    let endpointsValid = true;
+    for (const field of ["source", "target"]) {
+      const endpoint = relation[field];
+      const node = typeof endpoint === "string" ? nodesById.get(endpoint) : undefined;
+      if (!node) {
+        issues.push({ entityId: relation.id, field, invariant: "topology-relation-endpoint-missing" });
+        endpointsValid = false;
+      } else if (!rule[field].includes(node.kind)) {
+        issues.push({ entityId: relation.id, field, invariant: field === "source" ? "topology-relation-source-kind-invalid" : "topology-relation-target-kind-invalid" });
+        endpointsValid = false;
+      }
+    }
+    if (!endpointsValid)
+      continue;
+    const source = relation.source;
+    const target = relation.target;
+    if (relation.kind === "runs-in")
+      namespacesByProcess.set(source, [...namespacesByProcess.get(source) ?? [], target]);
+    if (relation.kind === "mounts")
+      mountersByMount.set(target, [...mountersByMount.get(target) ?? [], source]);
+  }
+  for (const [processId, namespaces] of namespacesByProcess) {
+    if (new Set(namespaces).size > 1)
+      issues.push({ entityId: processId, field: "runs-in", invariant: "topology-process-namespace-ambiguous" });
+  }
+  for (const [mountId, mounters] of mountersByMount) {
+    if (new Set(mounters).size > 1)
+      issues.push({ entityId: mountId, field: "mounts", invariant: "topology-mount-mounter-ambiguous" });
+  }
+  for (const [id, node] of nodesById) {
+    if (node.kind !== "namespace" || node.parent === undefined)
+      continue;
+    const parent = typeof node.parent === "string" ? nodesById.get(node.parent) : undefined;
+    if (!parent) {
+      issues.push({ entityId: id, field: "parent", invariant: "topology-namespace-parent-missing" });
+      continue;
+    }
+    if (parent.kind !== "namespace") {
+      issues.push({ entityId: id, field: "parent", invariant: "topology-namespace-parent-kind-invalid" });
+      continue;
+    }
+    const seen = new Set([id]);
+    let cursor = parent;
+    while (cursor && cursor.kind === "namespace" && typeof cursor.id === "string") {
+      if (seen.has(cursor.id)) {
+        issues.push({ entityId: id, field: "parent", invariant: "topology-namespace-parent-cycle" });
+        break;
+      }
+      seen.add(cursor.id);
+      cursor = typeof cursor.parent === "string" ? nodesById.get(cursor.parent) : undefined;
+    }
+  }
+  return issues.sort((left, right) => compare(left.entityId, right.entityId) || compare(left.field, right.field) || compare(left.invariant, right.invariant));
+}
+function compare(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+var RUNTIME_TOPOLOGY_NODE_KINDS, RUNTIME_TOPOLOGY_RELATION_ENDPOINT_KINDS;
+var init_runtime_topology = __esm(() => {
+  RUNTIME_TOPOLOGY_NODE_KINDS = ["process", "namespace", "mount"];
+  RUNTIME_TOPOLOGY_RELATION_ENDPOINT_KINDS = {
+    spawns: { source: ["process"], target: ["process"] },
+    "runs-in": { source: ["process"], target: ["namespace"] },
+    mounts: { source: ["process", "namespace"], target: ["mount"] }
+  };
+});
+
 // packages/contracts/src/validator.ts
 function jsonSchemaResolver(documents) {
   const byId = new Map;
@@ -3156,6 +3243,10 @@ function nativeContextModelIssues(model, schemas, recordPaths) {
       if (relation[field] !== undefined && !nodes.has(relation[field]))
         add(relation, field, "relation-node-missing");
   }
+  const relations = new Map(model.relations.map((relation) => [relation.id, relation]));
+  for (const issue of runtimeTopologyModelIssues(model)) {
+    add(relations.get(issue.entityId) ?? nodes.get(issue.entityId) ?? issue.entityId, issue.field, issue.invariant);
+  }
   for (const flow of model.flows) {
     if (nodes.get(flow.capabilityId)?.kind !== "capability")
       add(flow, "capabilityId", "flow-capability-missing");
@@ -3198,6 +3289,7 @@ var NATIVE_CONTEXT_SCHEMA_VERSION = "archcontext.native-context-export/v1", NATI
 var init_native_context = __esm(() => {
   init_failure();
   init_schema();
+  init_runtime_topology();
   init_validator();
   NATIVE_CONTEXT_LIMITS = Object.freeze({
     inputFiles: 1e4,
@@ -3781,6 +3873,8 @@ var init_projection_manifest = __esm(() => {
     "diagram-mermaid": true,
     "diagram-structurizr": true,
     "diagram-likec4": true,
+    "diagram-runtime-topology": true,
+    "runtime-topology-summary": true,
     "agent-context": true
   };
   SCOPE_KINDS = { repository: true, entity: true, relation: true, decision: true, diagram: true, changelog: true };
@@ -3873,7 +3967,7 @@ function compareVersionTriples(left, right) {
   }
   return 0;
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.9.0", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.9.2", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.4.3", ARCHCONTEXT_NODE_RANGE = ">=22.22 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v2", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/refactor.ts
 function refactorNamespaceIssues(value, label = "product.id") {
@@ -4978,6 +5072,7 @@ var init_src = __esm(() => {
   init_projection_writer();
   init_projection_manifest();
   init_refactor();
+  init_runtime_topology();
   init_schema();
   init_failure();
   init_validator();
@@ -17691,6 +17786,15 @@ var FIXED_TARGETS = [
   layoutTarget("projection_target.diagram.structurizr", "diagram-structurizr", { kind: "diagram", id: "architecture" }, "docs/architecture/diagrams/architecture.structurizr.json", "generated", "structurizr-json"),
   layoutTarget("projection_target.diagram.likec4", "diagram-likec4", { kind: "diagram", id: "architecture" }, "docs/architecture/diagrams/architecture.likec4", "generated", "likec4")
 ];
+var RUNTIME_TOPOLOGY_DIAGRAM_PATH = "docs/architecture/diagrams/runtime-topology.mmd";
+var RUNTIME_TOPOLOGY_SUMMARY_PATH = "docs/architecture/runtime-topology.md";
+var RUNTIME_TOPOLOGY_TARGETS = [
+  layoutTarget("projection_target.diagram.runtime-topology", "diagram-runtime-topology", { kind: "diagram", id: "runtime-topology" }, RUNTIME_TOPOLOGY_DIAGRAM_PATH, "generated", "mermaid"),
+  layoutTarget("projection_target.runtime-topology.summary", "runtime-topology-summary", { kind: "diagram", id: "runtime-topology" }, RUNTIME_TOPOLOGY_SUMMARY_PATH, "generated", "markdown")
+];
+function hasRuntimeTopologyNodes(nodes) {
+  return nodes.some((node) => isRuntimeTopologyNodeKind(node.kind));
+}
 function parseRepoHarnessNodeProfile(node) {
   const match = /^capability\.([a-z0-9]+(?:-[a-z0-9]+)*)\.([a-z0-9]+(?:-[a-z0-9]+)*)$/.exec(node.id);
   if (!match || node.kind !== "capability") {
@@ -17718,7 +17822,7 @@ function parseRepoHarnessNodeProfile(node) {
   };
 }
 function entitySummaryTargetNodes(nodes, profile) {
-  return profile === REPO_HARNESS_PROJECTION_PROFILE ? nodes.filter((node) => node.kind === "capability") : [...nodes];
+  return profile === REPO_HARNESS_PROJECTION_PROFILE ? nodes.filter((node) => node.kind === "capability") : nodes.filter((node) => !isRuntimeTopologyNodeKind(node.kind));
 }
 function resolveArchitectureDocumentationLayout(input) {
   const profile = input.profile ?? "default";
@@ -17728,7 +17832,8 @@ function resolveArchitectureDocumentationLayout(input) {
     return layoutTarget(`projection_target.entity.${stableId(node.id)}`, "entity-summary", { kind: "entity", id: node.id, entityKind: node.kind }, path, "mixed", "markdown");
   });
   const relationTargets = (profile === REPO_HARNESS_PROJECTION_PROFILE ? [] : input.relations).map((relation) => layoutTarget(`projection_target.relation.${stableId(relation.id)}`, "relation-summary", { kind: "relation", id: relation.id }, `docs/architecture/relations/${pathSegment(relation.id)}.md`, "mixed", "markdown"));
-  const targets = [FIXED_TARGETS[0], ...entityTargets, ...relationTargets, ...FIXED_TARGETS.slice(1)].map((target) => ({ ...target, path: requiredPath(target.path, target.targetId) }));
+  const topologyTargets = hasRuntimeTopologyNodes(input.nodes) ? RUNTIME_TOPOLOGY_TARGETS : [];
+  const targets = [FIXED_TARGETS[0], ...entityTargets, ...relationTargets, ...FIXED_TARGETS.slice(1), ...topologyTargets].map((target) => ({ ...target, path: requiredPath(target.path, target.targetId) }));
   assertUniqueTargets(targets);
   return {
     profile,
@@ -20100,12 +20205,52 @@ function normalizeNativeModel(model) {
     flows: [...model.flows ?? []].sort((a, b) => a.id.localeCompare(b.id))
   };
 }
+var ARCHITECTURE_NODE_LAYER_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+function nativeNodeLayer(node) {
+  const layer = node.layer;
+  if (layer === undefined)
+    return;
+  if (typeof layer !== "string" || !ARCHITECTURE_NODE_LAYER_PATTERN.test(layer)) {
+    throw new Error(`architecture-node-layer-invalid: ${node.id} (${JSON.stringify(layer)})`);
+  }
+  return layer;
+}
+function architectureLayerGroups(model) {
+  const nodesByLayer = new Map;
+  const ungroupedNodes = [];
+  const layerByNodeId = new Map;
+  for (const node of [...model.nodes].sort((a, b) => a.id.localeCompare(b.id))) {
+    const layer = nativeNodeLayer(node);
+    if (layer === undefined) {
+      ungroupedNodes.push(node);
+      continue;
+    }
+    const members = nodesByLayer.get(layer);
+    if (members)
+      members.push(node);
+    else
+      nodesByLayer.set(layer, [node]);
+    layerByNodeId.set(node.id, layer);
+  }
+  const layers = [...nodesByLayer.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([layer, nodes]) => ({ layer, nodes }));
+  return { layers, ungroupedNodes, layerByNodeId };
+}
+function mermaidLayerId(layer) {
+  return `layer__${layer.replace(/-/g, "_")}`;
+}
 function exportMermaidModel(model) {
   const normalized = normalizeNativeModel(model);
+  const grouping = architectureLayerGroups(normalized);
+  const nodeLine = (indent, node) => `${indent}${mermaidId(node.id)}["${escapeMermaid(node.name)}"]`;
   const lines = ["%% Generated by ArchContext. Native model remains source of truth.", "flowchart LR"];
-  for (const node of normalized.nodes) {
-    lines.push(`  ${mermaidId(node.id)}["${escapeMermaid(node.name)}"]`);
+  for (const group of grouping.layers) {
+    lines.push(`  subgraph ${mermaidLayerId(group.layer)}["${escapeMermaid(group.layer)}"]`);
+    for (const node of group.nodes)
+      lines.push(nodeLine("    ", node));
+    lines.push("  end");
   }
+  for (const node of grouping.ungroupedNodes)
+    lines.push(nodeLine("  ", node));
   for (const relation of normalized.relations) {
     lines.push(`  ${mermaidId(relation.source)} -->|"${escapeMermaid(relation.kind)}"| ${mermaidId(relation.target)}`);
   }
@@ -20122,22 +20267,15 @@ function exportDocumentationLikeC4Model(model) {
   const normalized = normalizeNativeModel(model);
   const lines = [
     "// Generated by ArchContext. Native model remains source of truth.",
-    "specification {",
-    "  element capability",
-    "  element module",
-    "  element component",
-    "  element interface",
-    "  element datastore",
-    "  element external_system",
-    "}",
+    ...likeC4SpecificationLines(normalized.nodes),
     "",
     "model {"
   ];
   for (const node of normalized.nodes)
-    lines.push(`  ${mermaidId(node.id)} = ${documentationLikeC4Kind(node.kind)} "${escapeDsl(node.name)}"`);
+    lines.push(`  ${mermaidId(node.id)} = ${likeC4ElementKind(node.kind)} "${escapeDsl(node.name)}"`);
   for (const relation of normalized.relations)
     lines.push(`  ${mermaidId(relation.source)} -> ${mermaidId(relation.target)} "${escapeDsl(relation.kind)}"`);
-  lines.push("}", "", "views {", "  view index {", "    include *", "    autoLayout TopBottom", "  }", "}");
+  lines.push("}", "", ...likeC4IndexViewLines(architectureLayerGroups(normalized), mermaidId));
   const content = `${lines.join(`
 `)}
 `;
@@ -20147,18 +20285,73 @@ function exportDocumentationLikeC4Model(model) {
     files: [{ path: "docs/architecture/diagrams/architecture.likec4", content }]
   };
 }
+function likeC4SpecificationLines(nodes) {
+  const topologyKinds = RUNTIME_TOPOLOGY_NODE_KINDS.filter((kind) => nodes.some((node) => node.kind === kind));
+  return [
+    "specification {",
+    "  element capability",
+    "  element module",
+    "  element component",
+    "  element interface",
+    "  element datastore",
+    "  element external_system",
+    ...topologyKinds.map((kind) => `  element ${kind}`),
+    "}"
+  ];
+}
+function likeC4ElementKind(kind) {
+  if (kind === "external-system")
+    return "external_system";
+  if (kind === "datastore")
+    return "datastore";
+  if (["capability", "module", "component", "interface"].includes(kind))
+    return kind;
+  if (isRuntimeTopologyNodeKind(kind))
+    return kind;
+  return "component";
+}
+function architectureStructurizrElementType(kind) {
+  if (kind === "capability")
+    return "Software System";
+  if (kind === "module")
+    return "Container";
+  if (kind === "datastore")
+    return "Database";
+  if (kind === "external-system")
+    return "External System";
+  if (kind === "namespace")
+    return "Deployment Node";
+  if (kind === "process")
+    return "Container Instance";
+  if (kind === "mount")
+    return "Infrastructure Node";
+  return "Component";
+}
+function likeC4IndexViewLines(grouping, elementId) {
+  const groupLines = grouping.layers.flatMap((group) => [
+    `    group "${escapeDsl(group.layer)}" {`,
+    ...group.nodes.map((node) => `      include ${elementId(node.id)}`),
+    "    }"
+  ]);
+  return ["views {", "  view index {", ...groupLines, "    include *", "    autoLayout TopBottom", "  }", "}"];
+}
 function exportDocumentationStructurizrWorkspace(model) {
   const normalized = normalizeNativeModel(model);
+  const { layerByNodeId } = architectureLayerGroups(normalized);
   const workspace = {
     schemaVersion: "archcontext.structurizr-export/v1",
     name: "ArchContext Architecture",
     model: {
-      elements: normalized.nodes.map((node) => ({
-        id: node.id,
-        name: node.name,
-        type: documentationStructurizrElementType(node.kind),
-        tags: [node.kind]
-      })),
+      elements: normalized.nodes.map((node) => {
+        const layer = layerByNodeId.get(node.id);
+        return {
+          id: node.id,
+          name: node.name,
+          type: architectureStructurizrElementType(node.kind),
+          tags: [node.kind],
+          ...layer === undefined ? {} : { group: layer }
+        };
+      }),
       relationships: normalized.relations.map((relation) => ({
         id: relation.id,
         sourceId: relation.source,
@@ -20181,6 +20374,209 @@ function exportDocumentationStructurizrWorkspace(model) {
     files: [{ path: "docs/architecture/diagrams/architecture.structurizr.json", content }]
   };
 }
+var RUNTIME_TOPOLOGY_NAMESPACE_TYPES = ["host", "container", "pod", "kubernetes", "pid", "mount", "net", "user"];
+var RUNTIME_TOPOLOGY_MOUNT_TARGET_PATTERN = /^\/([^/\u0000]+(\/[^/\u0000]+)*)?$/;
+function runtimeTopologyView(model) {
+  const issues = runtimeTopologyModelIssues(model);
+  if (issues.length > 0) {
+    throw new Error(`runtime-topology-model-invalid: ${issues.map((issue) => `${issue.entityId} ${issue.field} ${issue.invariant}`).join("; ")}`);
+  }
+  const byId = (left, right) => compareStrings3(left.id, right.id);
+  const nodes = [...model.nodes].sort(byId);
+  const relations = [...model.relations].sort(byId);
+  const nodesById = new Map(nodes.map((node) => [node.id, node]));
+  const namespaces = nodes.filter((node) => node.kind === "namespace").map((node) => ({
+    node,
+    type: runtimeTopologyNamespaceType(node),
+    ...typeof node.parent === "string" ? { parentId: node.parent } : {},
+    namespaceIds: [],
+    processIds: []
+  }));
+  const namespaceById = new Map(namespaces.map((namespace) => [namespace.node.id, namespace]));
+  for (const namespace of namespaces) {
+    if (namespace.parentId !== undefined)
+      namespaceById.get(namespace.parentId).namespaceIds.push(namespace.node.id);
+  }
+  const namespaceByProcessId = new Map(relations.filter((relation) => relation.kind === "runs-in").map((relation) => [relation.source, relation.target]));
+  const processes = nodes.filter((node) => node.kind === "process").map((node) => {
+    const namespaceId = namespaceByProcessId.get(node.id);
+    return namespaceId === undefined ? { node } : { node, namespaceId };
+  });
+  for (const topologyProcess of processes) {
+    if (topologyProcess.namespaceId !== undefined)
+      namespaceById.get(topologyProcess.namespaceId).processIds.push(topologyProcess.node.id);
+  }
+  const mounts = nodes.filter((node) => node.kind === "mount").map(runtimeTopologyMount);
+  const mounterByMountId = new Map(relations.filter((relation) => relation.kind === "mounts").map((relation) => [relation.target, relation.source]));
+  const stacksByMounterId = new Map;
+  for (const mount of mounts) {
+    const mounterId = mounterByMountId.get(mount.node.id);
+    if (mounterId === undefined)
+      continue;
+    stacksByMounterId.set(mounterId, [...stacksByMounterId.get(mounterId) ?? [], mount]);
+  }
+  const mountStacks = [...stacksByMounterId.entries()].sort(([left], [right]) => compareStrings3(left, right)).map(([mounterId, stack]) => ({
+    mounterId,
+    mounts: stack.sort((left, right) => left.order - right.order || compareStrings3(left.node.id, right.node.id))
+  }));
+  const deployments = relations.filter((relation) => relation.kind === "deployed-on" && isRuntimeTopologyNodeKind(nodesById.get(relation.target)?.kind));
+  const linkedNodeIds = new Set;
+  for (const relation of deployments) {
+    const source = nodesById.get(relation.source);
+    if (!source)
+      throw new Error(`runtime-topology-relation-endpoint-missing: ${relation.id} (${relation.source})`);
+    if (!isRuntimeTopologyNodeKind(source.kind))
+      linkedNodeIds.add(source.id);
+  }
+  return {
+    nodesById,
+    namespaces,
+    rootNamespaceIds: namespaces.filter((namespace) => namespace.parentId === undefined).map((namespace) => namespace.node.id),
+    processes,
+    mountStacks,
+    unmountedMounts: mounts.filter((mount) => !mounterByMountId.has(mount.node.id)),
+    spawns: relations.filter((relation) => relation.kind === "spawns"),
+    mounts: relations.filter((relation) => relation.kind === "mounts"),
+    deployments,
+    linkedNodes: nodes.filter((node) => linkedNodeIds.has(node.id))
+  };
+}
+function runtimeTopologyNamespaceType(node) {
+  const value = node.namespace;
+  const type = value !== null && typeof value === "object" && !Array.isArray(value) ? value.type : undefined;
+  if (typeof type !== "string" || !RUNTIME_TOPOLOGY_NAMESPACE_TYPES.includes(type)) {
+    throw new Error(`runtime-topology-namespace-invalid: ${node.id}`);
+  }
+  return type;
+}
+function runtimeTopologyMount(node) {
+  const value = node.mount;
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`runtime-topology-mount-invalid: ${node.id}`);
+  const { source, target, mode, order } = value;
+  if (source !== undefined && (typeof source !== "string" || source === "") || typeof target !== "string" || !RUNTIME_TOPOLOGY_MOUNT_TARGET_PATTERN.test(target) || mode !== "ro" && mode !== "rw" || typeof order !== "number" || !Number.isInteger(order) || order < 0) {
+    throw new Error(`runtime-topology-mount-invalid: ${node.id}`);
+  }
+  return { node, ...source === undefined ? {} : { source }, target, mode, order };
+}
+function runtimeTopologyMountStackId(mounterId) {
+  return `mounts__${mermaidId(mounterId)}`;
+}
+function runtimeTopologyMountLabel(mount) {
+  return `${mount.node.name} (${mount.target}, ${mount.mode}, order ${mount.order})`;
+}
+function exportRuntimeTopologyMermaid(model) {
+  const view = runtimeTopologyView(model);
+  const namespaceById = new Map(view.namespaces.map((namespace) => [namespace.node.id, namespace]));
+  const nodeLine = (indent, node, label = node.name) => `${indent}${mermaidId(node.id)}["${escapeMermaid(label)}"]`;
+  const lines = ["%% Generated by ArchContext. Native model remains source of truth.", "flowchart TB"];
+  const pushNamespace = (namespaceId, depth) => {
+    const namespace = namespaceById.get(namespaceId);
+    const indent = "  ".repeat(depth);
+    lines.push(`${indent}subgraph ${mermaidId(namespaceId)}["${escapeMermaid(`${namespace.node.name} (${namespace.type})`)}"]`);
+    for (const processId of namespace.processIds)
+      lines.push(nodeLine(`${indent}  `, view.nodesById.get(processId)));
+    for (const childId of namespace.namespaceIds)
+      pushNamespace(childId, depth + 1);
+    lines.push(`${indent}end`);
+  };
+  for (const namespaceId of view.rootNamespaceIds)
+    pushNamespace(namespaceId, 1);
+  for (const topologyProcess of view.processes)
+    if (topologyProcess.namespaceId === undefined)
+      lines.push(nodeLine("  ", topologyProcess.node));
+  for (const stack of view.mountStacks) {
+    const mounter = view.nodesById.get(stack.mounterId);
+    lines.push(`  subgraph ${runtimeTopologyMountStackId(stack.mounterId)}["${escapeMermaid(`Mounts: ${mounter.name}`)}"]`, "    direction TB");
+    for (const mount of stack.mounts)
+      lines.push(nodeLine("    ", mount.node, runtimeTopologyMountLabel(mount)));
+    for (let index = 1;index < stack.mounts.length; index += 1) {
+      lines.push(`    ${mermaidId(stack.mounts[index - 1].node.id)} ~~~ ${mermaidId(stack.mounts[index].node.id)}`);
+    }
+    lines.push("  end");
+  }
+  for (const mount of view.unmountedMounts)
+    lines.push(nodeLine("  ", mount.node, runtimeTopologyMountLabel(mount)));
+  for (const node of view.linkedNodes)
+    lines.push(nodeLine("  ", node));
+  for (const relation of [...view.spawns, ...view.mounts, ...view.deployments].sort((left, right) => compareStrings3(left.id, right.id))) {
+    lines.push(`  ${mermaidId(relation.source)} -->|"${escapeMermaid(relation.kind)}"| ${mermaidId(relation.target)}`);
+  }
+  const content = `${lines.join(`
+`)}
+`;
+  return {
+    format: "mermaid",
+    digest: digestJson({ format: "mermaid", content }),
+    files: [{ path: RUNTIME_TOPOLOGY_DIAGRAM_PATH, content }]
+  };
+}
+function renderRuntimeTopologySummary(model, summaryPath) {
+  const view = runtimeTopologyView(model);
+  const cell = (value) => value.replaceAll("|", "\\|");
+  const named = (id) => {
+    const node = view.nodesById.get(id);
+    return `\`${id}\`${node ? ` ${cell(node.name)}` : ""}`;
+  };
+  const list = (ids) => ids.length === 0 ? "none" : ids.map((id) => `\`${id}\``).join(", ");
+  const lines = [
+    "# Runtime Topology",
+    "",
+    "The architecture model declares this topology. No code facts verify it.",
+    "",
+    `- Diagram: [Mermaid](${posix.relative(posix.dirname(summaryPath), RUNTIME_TOPOLOGY_DIAGRAM_PATH)})`,
+    "",
+    "## Namespaces",
+    ""
+  ];
+  if (view.namespaces.length === 0)
+    lines.push("- No namespaces recorded.");
+  else {
+    lines.push("| Namespace | Type | Parent | Namespaces | Processes |", "| --- | --- | --- | --- | --- |");
+    for (const namespace of view.namespaces) {
+      lines.push(`| ${named(namespace.node.id)} | ${namespace.type} | ${namespace.parentId === undefined ? "none" : `\`${namespace.parentId}\``} | ${list(namespace.namespaceIds)} | ${list(namespace.processIds)} |`);
+    }
+  }
+  lines.push("", "## Processes", "");
+  if (view.processes.length === 0)
+    lines.push("- No processes recorded.");
+  else {
+    lines.push("| Process | Namespace | Spawns | Deployed here |", "| --- | --- | --- | --- |");
+    for (const topologyProcess of view.processes) {
+      const id = topologyProcess.node.id;
+      const spawned = view.spawns.filter((relation) => relation.source === id).map((relation) => relation.target);
+      const deployed = view.deployments.filter((relation) => relation.target === id).map((relation) => relation.source);
+      lines.push(`| ${named(id)} | ${topologyProcess.namespaceId === undefined ? "none" : `\`${topologyProcess.namespaceId}\``} | ${list([...new Set(spawned)].sort(compareStrings3))} | ${list([...new Set(deployed)].sort(compareStrings3))} |`);
+    }
+  }
+  lines.push("", "## Mount Stacks", "");
+  const mountRows = (stack) => [
+    "| Order | Mount | Source | Target | Mode |",
+    "| --- | --- | --- | --- | --- |",
+    ...stack.map((mount) => `| ${mount.order} | ${named(mount.node.id)} | ${mount.source === undefined ? "none" : `\`${cell(mount.source)}\``} | \`${cell(mount.target)}\` | ${mount.mode} |`)
+  ];
+  if (view.mountStacks.length === 0 && view.unmountedMounts.length === 0)
+    lines.push("- No mounts recorded.");
+  for (const [index, stack] of view.mountStacks.entries()) {
+    if (index > 0)
+      lines.push("");
+    lines.push(`### ${named(stack.mounterId)}`, "", ...mountRows(stack.mounts));
+  }
+  if (view.unmountedMounts.length > 0) {
+    if (view.mountStacks.length > 0)
+      lines.push("");
+    lines.push("### Not mounted", "", ...mountRows(view.unmountedMounts));
+  }
+  const otherDeployments = view.deployments.filter((relation) => view.nodesById.get(relation.target)?.kind !== "process");
+  if (otherDeployments.length > 0) {
+    lines.push("", "## Other Deployments", "");
+    for (const relation of otherDeployments)
+      lines.push(`- \`${relation.source}\` -> \`${relation.target}\` — ${relation.intent}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
 function loadNativeModelFromArchContext(root) {
   return nativeModelFromYamlObjects({
     nodes: readYamlObjects(resolve6(root, ".archcontext/model/nodes")),
@@ -20199,6 +20595,7 @@ function nativeModelFromYamlObjects(input) {
       throw new Error(`architecture-node-schema-version-unsupported: ${node.id || "unknown"} (${String(node.schemaVersion)})`);
     }
     assertArchitectureNodeSourceV2(node);
+    nativeNodeLayer(node);
   }
   const flows = input.flows;
   for (const flow of flows)
@@ -20383,8 +20780,15 @@ function renderTargetGeneratedBody(target, model, input) {
     return exportDocumentationStructurizrWorkspace(model).files[0].content;
   if (target.type === "diagram-likec4")
     return exportDocumentationLikeC4Model(model).files[0].content;
+  if (target.type === "diagram-runtime-topology")
+    return exportRuntimeTopologyMermaid(model).files[0].content;
+  if (target.type === "runtime-topology-summary")
+    return renderRuntimeTopologySummary(model, target.path);
   return "";
 }
+function architectureIndexLink(path) {
+  return path.replace(/^docs\/architecture\//, "");
+}
 function renderArchitectureIndex(model, layout2) {
   const lines = [
     "# Architecture Index",
@@ -20409,6 +20813,7 @@ function renderArchitectureIndex(model, layout2) {
     "- [Mermaid](diagrams/architecture.mmd)",
     "- [Structurizr JSON](diagrams/architecture.structurizr.json)",
     "- [LikeC4](diagrams/architecture.likec4)",
+    ...layout2.targets.flatMap((target) => target.type === "diagram-runtime-topology" ? [`- [Runtime topology Mermaid](${architectureIndexLink(target.path)})`] : target.type === "runtime-topology-summary" ? [`- [Runtime topology](${architectureIndexLink(target.path)})`] : []),
     "- [Decision index](decisions/index.md)",
     "- [Architecture changelog](changelog.md)"
   ];
@@ -20862,26 +21267,6 @@ function isManagedArchitectureDocumentationMarkdownPath(path) {
 function pathSegment2(id) {
   return stableId(id).replace(/\./g, "-");
 }
-function documentationLikeC4Kind(kind) {
-  if (kind === "external-system")
-    return "external_system";
-  if (kind === "datastore")
-    return "datastore";
-  if (["capability", "module", "component", "interface"].includes(kind))
-    return kind;
-  return "component";
-}
-function documentationStructurizrElementType(kind) {
-  if (kind === "capability")
-    return "Software System";
-  if (kind === "module")
-    return "Container";
-  if (kind === "datastore")
-    return "Database";
-  if (kind === "external-system")
-    return "External System";
-  return "Component";
-}
 function escapeDsl(value) {
   return value.replace(/"/g, "'");
 }
@@ -21545,7 +21930,7 @@ function sameOwners(left, right) {
 
 // packages/core/module-statistics/src/index.ts
 function evaluateDependencyConstraints(input) {
-  const constraints = [...input.constraints].sort((left, right) => compare(left.id, right.id));
+  const constraints = [...input.constraints].sort((left, right) => compare2(left.id, right.id));
   const certification = certifyCodeFacts(input.codeFacts, input.worktreeDigest, input.truncated, input.importNodeLimitExceeded ?? false);
   if (constraints.length === 0) {
     return {
@@ -21602,7 +21987,7 @@ function evaluateDependencyConstraints(input) {
     reasonCodes.add("unresolved-import");
   if (input.workspacePackagesResolved === false)
     reasonCodes.add("workspace-resolution-failed");
-  const sortedViolations = [...violations.values()].sort((left, right) => compare(left.constraintId, right.constraintId) || compare(left.fromPath, right.fromPath) || compare(left.toPath, right.toPath));
+  const sortedViolations = [...violations.values()].sort((left, right) => compare2(left.constraintId, right.constraintId) || compare2(left.fromPath, right.fromPath) || compare2(left.toPath, right.toPath));
   return {
     schemaVersion: "archcontext.dependency-constraint-evaluation/v1",
     status: sortedViolations.length > 0 ? "violated" : reasonCodes.size > 0 ? "undetermined" : "pass",
@@ -21679,7 +22064,7 @@ function measureCapabilityDependencies(input) {
     const cellKey = JSON.stringify([from.capability, to.capability]);
     let cell = cells.get(cellKey);
     if (cell === undefined) {
-      const relationIds = [...new Set(declaringRelations.get(cellKey) ?? [])].sort(compare);
+      const relationIds = [...new Set(declaringRelations.get(cellKey) ?? [])].sort(compare2);
       cell = { from: from.capability, to: to.capability, imports: 0, calls: null, declared: from.capability === to.capability || relationIds.length > 0, relationIds };
       cells.set(cellKey, cell);
     }
@@ -21687,14 +22072,14 @@ function measureCapabilityDependencies(input) {
     attributedEdges.push({ fromPath: edge.from, toPath: edge.to, fromCapability: from.capability, toCapability: to.capability });
   }
   const edgeLimit = input.edgeLimit ?? CAPABILITY_DEPENDENCIES_EDGE_LIMIT;
-  attributedEdges.sort((left, right) => compare(left.fromPath, right.fromPath) || compare(left.toPath, right.toPath));
+  attributedEdges.sort((left, right) => compare2(left.fromPath, right.fromPath) || compare2(left.toPath, right.toPath));
   const listed = attributedEdges.slice(0, edgeLimit);
   return {
     schemaVersion: CAPABILITY_DEPENDENCIES_SCHEMA_VERSION,
     ownershipRule: "parent-chain",
     filter: { from: input.from ?? null, into: input.into ?? null },
-    capabilities: input.nodes.filter((node) => node.kind === "capability").map((node) => node.id).sort(compare),
-    matrix: [...cells.values()].sort((left, right) => compare(left.from, right.from) || compare(left.to, right.to)),
+    capabilities: input.nodes.filter((node) => node.kind === "capability").map((node) => node.id).sort(compare2),
+    matrix: [...cells.values()].sort((left, right) => compare2(left.from, right.from) || compare2(left.to, right.to)),
     imports: {
       coverage: certification.coverage,
       reasonCodes: [...certification.reasonCodes].sort(),
@@ -21730,7 +22115,7 @@ function isRepositoryLocalSpecifier(specifier, workspacePackages) {
     return true;
   return workspacePackages.some((workspacePackage) => specifier === workspacePackage.name || specifier.startsWith(`${workspacePackage.name}/`));
 }
-function compare(left, right) {
+function compare2(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function measureModuleStatistics(input) {
@@ -21815,7 +22200,7 @@ function modelDigest(model, constraints) {
     nodes: [...model.nodes].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
     relations: [...model.relations].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
     flows: [...model.flows ?? []].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
-    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare(left.id, right.id)) }
+    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare2(left.id, right.id)) }
   });
 }
 function countViolationsByNode(evaluation) {
@@ -22712,6 +23097,29 @@ function listGitVisibleFiles(root, pathspec) {
     }
   }).sort((left, right) => left.localeCompare(right));
 }
+function ignoredRepositoryPaths(root, paths) {
+  if (paths.length === 0)
+    return [];
+  const result = spawnSync2("git", ["check-ignore", "--verbose", "--no-index", "-z", "--stdin"], {
+    cwd: root,
+    encoding: "utf8",
+    input: paths.map((path) => `${path}\x00`).join(""),
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0 && result.status !== 1) {
+    const detail = result.error?.message ?? (result.stderr.trim() || `git check-ignore exited ${result.status}`);
+    throw new GitVisibleFilesUnavailableError(root, detail);
+  }
+  const fields = result.stdout.split("\x00");
+  const ignored = [];
+  for (let index = 0;index + 3 < fields.length; index += 4) {
+    const [source, line, pattern, path] = fields.slice(index, index + 4);
+    if (pattern.startsWith("!"))
+      continue;
+    ignored.push({ path, source, line: Number(line), pattern });
+  }
+  return ignored;
+}
 function readHeadSha(root) {
   try {
     return execFileSync("git", ["rev-parse", "HEAD"], {
@@ -26080,7 +26488,7 @@ function buildObservations(snapshot, structure, model) {
       evidence: evidence.evidenceGap()
     });
   }
-  return drafts.map((draft, index) => ({ draft, order: draft.kind === "cycle" ? index : 0 })).sort((left, right) => compare2(left.draft.kind, right.draft.kind) || left.order - right.order || compare2(left.draft.subjectSelectorId, right.draft.subjectSelectorId)).map(({ draft }) => ({
+  return drafts.map((draft, index) => ({ draft, order: draft.kind === "cycle" ? index : 0 })).sort((left, right) => compare3(left.draft.kind, right.draft.kind) || left.order - right.order || compare3(left.draft.subjectSelectorId, right.draft.subjectSelectorId)).map(({ draft }) => ({
     kind: draft.kind,
     subjectSelectorId: draft.subjectSelectorId,
     affectedNodeIds: draft.affectedNodeIds,
@@ -26270,13 +26678,13 @@ function signalIdFor(draft) {
 }
 function modelDigest2(model, constraints) {
   return digestJson({
-    nodes: [...model.nodes].sort((left, right) => compare2(left.id, right.id)),
-    relations: [...model.relations].sort((left, right) => compare2(left.id, right.id)),
-    flows: [...model.flows ?? []].sort((left, right) => compare2(left.id, right.id)),
-    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare2(left.id, right.id)) }
+    nodes: [...model.nodes].sort((left, right) => compare3(left.id, right.id)),
+    relations: [...model.relations].sort((left, right) => compare3(left.id, right.id)),
+    flows: [...model.flows ?? []].sort((left, right) => compare3(left.id, right.id)),
+    ...constraints.length === 0 ? {} : { constraints: [...constraints].sort((left, right) => compare3(left.id, right.id)) }
   });
 }
-function compare2(left, right) {
+function compare3(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function isNumber(value) {
@@ -26298,17 +26706,49 @@ var architecture_node_schema_default = {
   type: "object",
   additionalProperties: false,
   required: ["schemaVersion", "id", "kind", "name", "status", "summary"],
+  allOf: [
+    {
+      if: { properties: { kind: { const: "namespace" } }, required: ["kind"] },
+      then: { required: ["namespace"] },
+      else: { not: { required: ["namespace"] } }
+    },
+    {
+      if: { properties: { kind: { const: "mount" } }, required: ["kind"] },
+      then: { required: ["mount"] },
+      else: { not: { required: ["mount"] } }
+    }
+  ],
   properties: {
     schemaVersion: { const: "archcontext.node/v2" },
     id: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
     kind: {
       type: "string",
-      enum: ["capability", "module", "component", "interface", "event", "datastore", "external-system", "deployment"]
+      enum: ["capability", "module", "component", "interface", "event", "datastore", "external-system", "deployment", "process", "namespace", "mount"]
     },
     name: { type: "string" },
     status: { type: "string", enum: ["active", "planned", "deprecated", "removed"] },
     parent: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+    layer: { type: "string", pattern: "^[a-z][a-z0-9]*(-[a-z0-9]+)*$" },
     summary: { type: "string" },
+    namespace: {
+      type: "object",
+      additionalProperties: false,
+      required: ["type"],
+      properties: {
+        type: { type: "string", enum: ["host", "container", "pod", "kubernetes", "pid", "mount", "net", "user"] }
+      }
+    },
+    mount: {
+      type: "object",
+      additionalProperties: false,
+      required: ["target", "mode", "order"],
+      properties: {
+        source: { type: "string", minLength: 1 },
+        target: { type: "string", pattern: "^/([^/\\u0000]+(/[^/\\u0000]+)*)?$" },
+        mode: { type: "string", enum: ["ro", "rw"] },
+        order: { type: "integer", minimum: 0 }
+      }
+    },
     responsibilities: { type: "array", items: { type: "string" }, minItems: 1 },
     source: {
       type: "object",
@@ -26397,7 +26837,7 @@ var architecture_relation_schema_default = {
     id: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
     kind: {
       type: "string",
-      enum: ["depends-on", "calls", "publishes", "subscribes", "reads", "writes", "implements", "deployed-on"]
+      enum: ["depends-on", "calls", "publishes", "subscribes", "reads", "writes", "implements", "deployed-on", "spawns", "runs-in", "mounts"]
     },
     source: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
     target: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
@@ -27105,6 +27545,22 @@ function createDefaultProjectionTargetManifest() {
         ownership: "generated",
         format: "likec4"
       },
+      {
+        id: "projection_rule.diagram.runtime-topology",
+        targetType: "diagram-runtime-topology",
+        scope: { kind: "diagram", id: "runtime-topology" },
+        pathTemplate: "docs/architecture/diagrams/runtime-topology.mmd",
+        ownership: "generated",
+        format: "mermaid"
+      },
+      {
+        id: "projection_rule.runtime-topology.summary",
+        targetType: "runtime-topology-summary",
+        scope: { kind: "diagram", id: "runtime-topology" },
+        pathTemplate: "docs/architecture/runtime-topology.md",
+        ownership: "generated",
+        format: "markdown"
+      },
       {
         id: "projection_rule.agent-context.claude",
         targetType: "agent-context",
@@ -27250,10 +27706,19 @@ class YamlModelStore {
       }
     }
     const files = listModelFiles(workspace.root);
+    const topologyRecords = { nodes: [], relations: [] };
+    const topologyRecordPaths = new Map;
     for (const file of files) {
       if (file.path.startsWith(".archcontext/model/") && /\.ya?ml$/.test(file.path)) {
         try {
           const value = parseJsonOrStableYaml(file.body, file.path);
+          for (const [directory, records] of [["nodes", topologyRecords.nodes], ["relations", topologyRecords.relations]]) {
+            if (!file.path.startsWith(`.archcontext/model/${directory}/`) || !isJsonRecord2(value))
+              continue;
+            records.push(value);
+            if (typeof value.id === "string")
+              topologyRecordPaths.set(value.id, file.path);
+          }
           if (file.path.startsWith(".archcontext/model/nodes/")) {
             const { issues } = validateJsonSchema(architecture_node_schema_default, value);
             for (const issue of issues) {
@@ -27274,6 +27739,9 @@ class YamlModelStore {
         errors.push(`${file.path}: expected archcontext.flow/v1, got ${file.schemaVersion || "missing"}`);
       }
     }
+    for (const issue of runtimeTopologyModelIssues(topologyRecords)) {
+      errors.push(`${topologyRecordPaths.get(issue.entityId) ?? issue.entityId}: ${issue.field}: ${issue.invariant}`);
+    }
     const adr = validateAdrAppliesTo(files);
     const constraints = readDependencyConstraints(files);
     const reviewPolicy = readReviewPolicy(files);
@@ -27294,6 +27762,21 @@ class YamlModelStore {
     return { digest: digestJson(changeSet), summary: "ChangeSet preview generated" };
   }
 }
+var ARCHITECTURE_MODEL_COMMITTED_PATHS = Object.freeze([
+  ".archcontext/manifest.yaml",
+  ".archcontext/product.yaml",
+  ".archcontext/model/nodes/",
+  ".archcontext/model/relations/",
+  ".archcontext/model/flows/",
+  ".archcontext/decisions/",
+  ".archcontext/policies/",
+  ".archcontext/practices/",
+  ".archcontext/projections/"
+]);
+function architectureModelIgnoreProbePaths(root) {
+  const directories = ARCHITECTURE_MODEL_COMMITTED_PATHS.filter((path) => path.endsWith("/")).map((path) => path.slice(0, -1));
+  return [...new Set([...ARCHITECTURE_MODEL_COMMITTED_PATHS, ...collectArchContextFiles(root, directories)])];
+}
 function listModelFiles(root) {
   const paths = collectArchContextFiles(root, [
     ".archcontext/manifest.yaml",
@@ -27311,7 +27794,7 @@ function listModelFiles(root) {
     return {
       path,
       body,
-      schemaVersion: extractSchemaVersion(body),
+      schemaVersion: extractSchemaVersion(body, path),
       digest: digestJson({ path, body })
     };
   });
@@ -27357,7 +27840,15 @@ function readdirOrFile(path) {
     return "file";
   }
 }
-function extractSchemaVersion(body) {
+function extractSchemaVersion(body, path) {
+  if (path.startsWith(".archcontext/model/") && /\.ya?ml$/.test(path)) {
+    try {
+      const parsed = parseJsonOrStableYaml(body, path);
+      return typeof parsed?.schemaVersion === "string" ? parsed.schemaVersion : "";
+    } catch {
+      return "";
+    }
+  }
   const match = body.match(/schemaVersion:\s*"?([^"\n]+)"?/);
   if (match)
     return match[1].trim();
@@ -27370,6 +27861,9 @@ function extractSchemaVersion(body) {
     return "archcontext.generated/v1";
   return "";
 }
+function isJsonRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function withTrailingNewline(body) {
   return body.endsWith(`
 `) ? body : `${body}
@@ -31307,13 +31801,10 @@ class HttpContext7Transport {
     url.searchParams.set("libraryName", input.libraryName);
     url.searchParams.set("query", input.query);
     url.searchParams.set("fast", input.fast ? "true" : "false");
-    const response = await fetchWithTimeout(url, {
+    const { payload } = await fetchJsonWithTimeout(url, {
       method: "GET",
       headers: authHeaders(input.apiKey)
-    }, input.timeoutMs);
-    if (!response.ok)
-      throw httpStatusError("Context7 search failed", response);
-    const { payload } = await parseJsonResponse(response, "Context7 search");
+    }, input.timeoutMs, "Context7 search");
     return parseSearchResponse(payload);
   }
   async getContext(input) {
@@ -31322,13 +31813,10 @@ class HttpContext7Transport {
     url.searchParams.set("query", input.query);
     url.searchParams.set("type", "json");
     url.searchParams.set("fast", "true");
-    const response = await fetchWithTimeout(url, {
+    const { payload } = await fetchJsonWithTimeout(url, {
       method: "GET",
       headers: authHeaders(input.apiKey)
-    }, input.timeoutMs);
-    if (!response.ok)
-      throw httpStatusError("Context7 context fetch failed", response);
-    const { payload } = await parseJsonResponse(response, "Context7 context fetch");
+    }, input.timeoutMs, "Context7 context fetch");
     return parseDocumentationResponse(payload).slice(0, input.maxResults);
   }
 }
@@ -31426,11 +31914,14 @@ function normalizeSourceUri(value) {
     return;
   }
 }
-async function fetchWithTimeout(input, init, timeoutMs) {
+async function fetchJsonWithTimeout(input, init, timeoutMs, label) {
   const controller = new AbortController;
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    return await withLocalEgress2("context7", () => fetch(input, { ...init, redirect: "error", signal: controller.signal }));
+    const response = await withLocalEgress2("context7", () => fetch(input, { ...init, redirect: "error", signal: controller.signal }));
+    if (!response.ok)
+      throw httpStatusError(`${label} failed`, response);
+    return await parseJsonResponse(response, label);
   } catch (error) {
     if (isAbortError(error)) {
       throw new Context7ProviderError("timeout", "Context7 provider request timed out", { retryable: true, cause: error });
@@ -32663,6 +33154,11 @@ async function runArchitectureDocsProjectionCommand(input, cwd, daemon) {
   try {
     const subcommand = input.action ?? "plan";
     const root = findRepositoryRoot(cwd);
+    if (subcommand === "adopt") {
+      const ignored = architectureModelIgnoredEnvelope("docs.adopt", root);
+      if (ignored)
+        return ignored;
+    }
     let profile;
     let projection;
     let acceptedChange;
@@ -32778,6 +33274,23 @@ async function runArchitectureDocsProjectionCommand(input, cwd, daemon) {
     throw publicOperationFailure(error);
   }
 }
+function ignoredArchitectureModelPaths(root) {
+  const ignored = ignoredRepositoryPaths(root, architectureModelIgnoreProbePaths(root));
+  const directories = ignored.filter((entry) => entry.path.endsWith("/")).map((entry) => entry.path);
+  return ignored.filter((entry) => entry.path.endsWith("/") || !directories.some((directory) => entry.path.startsWith(directory)));
+}
+function architectureModelIgnoredEnvelope(requestId, root) {
+  const ignored = ignoredArchitectureModelPaths(root);
+  if (ignored.length === 0)
+    return;
+  const paths = ignored.map((entry) => entry.path).slice(0, 8);
+  return publicFailureEnvelope(requestId, "AC_PRECONDITION_FAILED", "architecture-model-ignored", {
+    pathCount: ignored.length,
+    paths,
+    commands: [`git check-ignore --verbose --no-index -- ${paths.join(" ")}`],
+    omittedPathCount: ignored.length - paths.length
+  });
+}
 function committedArchitectureDocsProfile(root) {
   return existsSync9(resolve13(root, ARCHITECTURE_DOCS_PROJECTION_MANIFEST_PATH)) ? loadArchitectureDocumentationProfile(root) : "default";
 }
@@ -33088,6 +33601,11 @@ async function runProjectionProtocolCommand(invocation, cwd, daemon) {
       if (replay)
         return replay;
     }
+    if (request.mode === "adopt") {
+      const ignored = architectureModelIgnoredEnvelope("projection.run", root);
+      if (ignored)
+        return ignored;
+    }
     let observed;
     let acceptedChange = request.acceptedChange;
     let declinedUnprovableNodeIds;
@@ -34652,6 +35170,7 @@ init_projection_recovery();
 init_projection_writer();
 init_projection_manifest();
 init_refactor();
+init_runtime_topology();
 init_schema();
 init_failure();
 init_validator();
@@ -39648,6 +40167,7 @@ class AgentJobService {
       supersededByJobId: input.supersededByJobId,
       now: input.now ?? this.context.clock()
     });
+    this.context.abortOwnedAudit(job.job.jobId);
     return okEnvelope("jobs.cancel", { job });
   }
   async runtimeAgentJobInScope(scope, jobId) {
@@ -47060,7 +47580,7 @@ function upgradeExistingLocalStoreTarget2(paths, integrityCheck) {
 var RUNTIME_AGENT_JOB_STATUSES = ["queued", "running", "succeeded", "failed", "cancelled", "superseded", "expired"];
 var CHANGESET_MODEL_TRANSITION_SCHEMA_VERSION = "archcontext.changeset-model-transition/v1";
 function assertChangeSetModelTransition(value, label = "changeset-model-transition-invalid") {
-  if (!isJsonRecord2(value) || Object.keys(value).sort().join(",") !== "after,before,schemaVersion" || value.schemaVersion !== CHANGESET_MODEL_TRANSITION_SCHEMA_VERSION || typeof value.before !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.before) || typeof value.after !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.after)) {
+  if (!isJsonRecord3(value) || Object.keys(value).sort().join(",") !== "after,before,schemaVersion" || value.schemaVersion !== CHANGESET_MODEL_TRANSITION_SCHEMA_VERSION || typeof value.before !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.before) || typeof value.after !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.after)) {
     throw new Error(label);
   }
   return { schemaVersion: CHANGESET_MODEL_TRANSITION_SCHEMA_VERSION, before: value.before, after: value.after };
@@ -51348,10 +51868,10 @@ function readChangeSetJournalTaskSessionId(metadataJson, journalId) {
   } catch {
     throw new Error(`changeset-journal-metadata-malformed: ${journalId}`);
   }
-  if (!isJsonRecord2(metadata))
+  if (!isJsonRecord3(metadata))
     throw new Error(`changeset-journal-metadata-malformed: ${journalId}`);
   const reason = metadata.reason;
-  if (!isJsonRecord2(reason) || typeof reason.taskSessionId !== "string" || reason.taskSessionId === "") {
+  if (!isJsonRecord3(reason) || typeof reason.taskSessionId !== "string" || reason.taskSessionId === "") {
     throw new Error(`changeset-journal-reason-malformed: ${journalId}`);
   }
   return reason.taskSessionId;
@@ -51384,7 +51904,7 @@ function committedChangeSetJournalFiles(filesJson, journalId) {
   if (!Array.isArray(parsed))
     throw new Error(`changeset-journal-files-malformed: ${journalId}`);
   return parsed.map((entry) => {
-    if (!isJsonRecord2(entry) || typeof entry.path !== "string" || typeof entry.operation !== "string") {
+    if (!isJsonRecord3(entry) || typeof entry.path !== "string" || typeof entry.operation !== "string") {
       throw new Error(`changeset-journal-file-malformed: ${journalId}`);
     }
     if (typeof entry.bodyHash !== "string" || entry.bodyHash === "") {
@@ -51404,7 +51924,7 @@ function committedChangeSetProjectionOwned(metadataJson, journalId) {
   } catch {
     throw new Error(`changeset-journal-metadata-malformed: ${journalId}`);
   }
-  return isJsonRecord2(metadata) && metadata.projectionOwned === true;
+  return isJsonRecord3(metadata) && metadata.projectionOwned === true;
 }
 function committedChangeSetModelTransition(metadataJson, journalId) {
   let metadata;
@@ -51413,7 +51933,7 @@ function committedChangeSetModelTransition(metadataJson, journalId) {
   } catch {
     throw new Error(`changeset-journal-metadata-malformed: ${journalId}`);
   }
-  if (!isJsonRecord2(metadata))
+  if (!isJsonRecord3(metadata))
     throw new Error(`changeset-journal-metadata-malformed: ${journalId}`);
   if (metadata.modelTransition === undefined)
     return;
@@ -51427,7 +51947,7 @@ function readChangeSetJournalMetadata(db, journalId) {
 }
 function withChangeSetJournalArchitectureLedger(metadata, patch) {
   const existing = metadata.architectureLedger;
-  const architectureLedger = isJsonRecord2(existing) ? { ...existing, ...patch } : {
+  const architectureLedger = isJsonRecord3(existing) ? { ...existing, ...patch } : {
     schemaVersion: "archcontext.changeset-ledger-recovery/v1",
     ...patch
   };
@@ -51449,12 +51969,12 @@ function changeSetJournalPlannedLedgerEvent(metadata) {
   const architectureLedger = metadata.architectureLedger;
   if (architectureLedger === undefined)
     return;
-  if (!isJsonRecord2(architectureLedger))
+  if (!isJsonRecord3(architectureLedger))
     throw new Error("changeset-ledger-recovery-metadata-malformed");
   const plannedEvent = architectureLedger.plannedEvent;
   if (plannedEvent === undefined)
     return;
-  if (!isJsonRecord2(plannedEvent))
+  if (!isJsonRecord3(plannedEvent))
     throw new Error("changeset-ledger-recovery-planned-event-malformed");
   const event = plannedEvent;
   try {
@@ -51464,7 +51984,7 @@ function changeSetJournalPlannedLedgerEvent(metadata) {
   }
   return event;
 }
-function isJsonRecord2(value) {
+function isJsonRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function recoverJournalFiles(root, files) {
@@ -54391,7 +54911,7 @@ class ProjectionWriterFailure extends Error {
 function projectionWriterPaths(repositoryRoot, remote, base, env = process.env) {
   const key = createHash13("sha256").update(`${remote}\x00${base}`, "utf8").digest("hex").slice(0, 16);
   const dir = join23(runtimeStatePaths(repositoryRoot, env).repositoryStateDir, "projection-writer", key);
-  return { dir, worktree: join23(dir, "worktree"), state: join23(dir, "state.json"), lock: join23(dir, "lock") };
+  return { dir, baseRef: `refs/archctx/projection-writer/${key}/base`, worktree: join23(dir, "worktree"), state: join23(dir, "state.json"), lock: join23(dir, "lock") };
 }
 async function runProjectionPublishCommand(options) {
   const env = options.env ?? process.env;
@@ -54483,10 +55003,21 @@ async function runLockedProjectionPublish(input) {
   const failed = (failure, fields = {}, extra = {}) => finish("failed", { ...fields, error: writerError(failure) }, extra);
   try {
     const pushRemote = projectionWriterPushUrl(repositoryRoot, remote);
+    const fetchUrls = git(repositoryRoot, ["remote", "get-url", "--all", "--", remote]).trim().split(`
+`).filter(Boolean);
+    const tracksPublication = fetchUrls.length === 1 && fetchUrls[0] === pushRemote;
     while (iterations < PROJECTION_WRITER_MAX_ITERATIONS) {
       iterations += 1;
-      remoteGit(repositoryRoot, ["fetch", "--no-tags", remote, `+refs/heads/${base}:refs/remotes/${remote}/${base}`], env);
-      baseSha = git(repositoryRoot, ["rev-parse", "--verify", `refs/remotes/${remote}/${base}^{commit}`]).trim();
+      remoteGit(repositoryRoot, [
+        "fetch",
+        "--no-tags",
+        "--no-write-fetch-head",
+        "--",
+        pushRemote,
+        `+refs/heads/${base}:${paths.baseRef}`,
+        ...tracksPublication ? [`+refs/heads/${base}:refs/remotes/${remote}/${base}`] : []
+      ], env);
+      baseSha = git(repositoryRoot, ["rev-parse", "--verify", `${paths.baseRef}^{commit}`]).trim();
       const successMatches = state.lastSuccessfulBranch === branch && state.lastSuccessfulSha === baseSha;
       const pending = state.publisherPending?.branch === branch && state.publisherPending.baseSha === baseSha ? state.publisherPending : successMatches && state.lastSuccessfulCommit && state.lastSuccessfulPublisher !== publisherIdentity ? { branch, baseSha, commitSha: state.lastSuccessfulCommit, files: state.lastSuccessfulFiles } : null;
       if (!pending && successMatches && state.lastSuccessfulPublisher === publisherIdentity && (state.lastSuccessfulCommit === null || lsRemoteBranch(repositoryRoot, pushRemote, branch, env) === state.lastSuccessfulCommit)) {
@@ -54535,8 +55066,15 @@ async function runLockedProjectionPublish(input) {
         throw new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-apply-status-unsupported", `projection apply ended with status ${projectionStatus}; the writer publishes only noop, applied and applied-partial results`);
       }
       const changed = worktreeChangedPaths(paths.worktree);
-      if (changed.length === 0)
+      if (changed.length === 0) {
+        const tip = lsRemoteBranch(repositoryRoot, pushRemote, base, env);
+        if (tip === null) {
+          return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-base-missing", `${remote} has no branch ${base}`), { projectionStatus });
+        }
+        if (tip !== baseSha)
+          continue;
         return finish("up-to-date", { projectionStatus });
+      }
       const written = new Set(result.files.filter((file) => file.action !== "unchanged").map((file) => file.path));
       const offending = changed.filter((path) => !written.has(path) || !isProjectionOwnedPath(path, ownedPatterns));
       if (offending.length > 0) {
@@ -54551,7 +55089,7 @@ async function runLockedProjectionPublish(input) {
         return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-commit-failed", `git commit failed in the writer worktree; configure a git identity (user.name, user.email) for the repository or set GIT_AUTHOR_*/GIT_COMMITTER_*: ${errorMessage2(error)}`), { projectionStatus, files: changed });
       }
       const commitSha = git(paths.worktree, ["rev-parse", "HEAD"]).trim();
-      const tip = lsRemoteBranch(repositoryRoot, remote, base, env);
+      const tip = lsRemoteBranch(repositoryRoot, pushRemote, base, env);
       if (tip === null) {
         return failed(new ProjectionWriterFailure("AC_PRECONDITION_FAILED", "projection-writer-base-missing", `${remote} has no branch ${base}`), { projectionStatus, files: changed });
       }
@@ -54900,8 +55438,8 @@ function createGhProjectionPublisher(options = {}) {
       const env = { ...stringEnv(process.env), GH_PROMPT_DISABLED: "1" };
       delete env.GH_REPO;
       const gh = (args) => withLocalEgress2("projection-publishing", () => exec("gh", [...args, "--repo", repository], { cwd: input.worktree, env, timeoutMs }), admissionEnv);
-      const listed = await gh(["pr", "list", "--head", input.branch, "--base", input.base, "--state", "open", "--json", "number,url", "--limit", "1"]);
-      const open = parseGhPullRequestList(listed.stdout);
+      const listed = await gh(["pr", "list", "--head", input.branch, "--base", input.base, "--state", "open", "--json", "number,url,isCrossRepository,headRefName,baseRefName", "--limit", "100"]);
+      const open = parseGhPullRequestList(listed.stdout, input.branch, input.base);
       if (open) {
         await gh(["pr", "edit", String(open.number), "--title", input.title, "--body-file", input.bodyFile]);
         return { number: open.number, ...open.url ? { url: open.url } : {} };
@@ -55049,16 +55587,24 @@ function readCommandFirstLine(command) {
     closeSync9(fd);
   }
 }
-function parseGhPullRequestList(stdout) {
-  const parsed = JSON.parse(stdout.trim() === "" ? "[]" : stdout);
+function parseGhPullRequestList(stdout, branch, base) {
+  const parsed = JSON.parse(stdout);
   if (!Array.isArray(parsed))
     throw new Error("gh pr list returned an unexpected shape");
-  const first = parsed[0];
-  if (!first)
-    return;
-  if (typeof first.number !== "number" || !Number.isInteger(first.number) || first.number <= 0)
-    throw new Error("gh pr list returned a pull request without a number");
-  return { number: first.number, ...typeof first.url === "string" && first.url !== "" ? { url: first.url } : {} };
+  if (parsed.length >= 100)
+    throw new Error("gh pr list reached the 100-result limit; resolve rolling PR ambiguity manually");
+  const matches = [];
+  for (const row of parsed) {
+    if (!row || typeof row !== "object" || Array.isArray(row) || typeof row.isCrossRepository !== "boolean" || row.headRefName !== branch || row.baseRefName !== base || typeof row.number !== "number" || !Number.isInteger(row.number) || row.number <= 0) {
+      throw new Error("gh pr list returned a pull request without verified identity");
+    }
+    if (!row.isCrossRepository) {
+      matches.push({ number: row.number, ...typeof row.url === "string" && row.url !== "" ? { url: row.url } : {} });
+    }
+  }
+  if (matches.length > 1)
+    throw new Error("gh pr list returned multiple same-repository rolling pull requests");
+  return matches[0];
 }
 function parsePublisherCommandOutput(stdout) {
   let parsed;
@@ -57954,23 +58500,31 @@ class ArchctxRuntimeRpcServer {
     this.server = undefined;
     const connection = this.connection;
     this.connection = undefined;
+    const errors = [];
+    const cleanup = async (action) => {
+      try {
+        await action();
+      } catch (error) {
+        errors.push(error);
+      }
+    };
     if (server) {
-      await new Promise((resolveClose, rejectClose) => {
+      await cleanup(() => new Promise((resolveClose, rejectClose) => {
         server.close((error) => error ? rejectClose(error) : resolveClose());
-      });
-    }
-    await this.daemon.stop();
-    try {
-      if (connection)
-        await removePrivateControlFile(connection.connectionPath);
-    } finally {
-      if (this.lockFd !== undefined)
-        closeSync11(this.lockFd);
-      this.lockFd = undefined;
+      }));
     }
+    await cleanup(() => this.daemon.stop());
     if (connection)
-      await removePrivateControlFile(connection.lockPath);
-    this.options.onStop?.();
+      await cleanup(() => removePrivateControlFile(connection.connectionPath));
+    const lockFd = this.lockFd;
+    this.lockFd = undefined;
+    if (lockFd !== undefined)
+      await cleanup(() => closeSync11(lockFd));
+    if (connection)
+      await cleanup(() => removePrivateControlFile(connection.lockPath));
+    await cleanup(() => this.options.onStop?.());
+    if (errors.length > 0)
+      throw errors[0];
   }
   armIdleTimer() {
     if (this.idleTimeoutMs <= 0 || !this.server)
@@ -58486,6 +59040,7 @@ class ArchctxDaemon {
         localStore: this.localStore
       });
       this.agentJobs = new AgentJobService({
+        abortOwnedAudit: (jobId) => this.auditRunAbortControllers.get(jobId)?.abort(),
         assertRunning: () => this.assertRunning(),
         openSession: (root) => this.openSession(root),
         architectureLedgerScope: (root) => this.architectureLedgerScope(root),
@@ -59312,11 +59867,13 @@ class ArchctxDaemon {
         return okEnvelope("status", status);
       const repositoryId = repositoryFingerprint(root);
       const session = this.sessions.get(repositoryId);
+      const ignoredModelPaths = ignoredArchitectureModelPaths(root);
       return okEnvelope("status", {
         ...status,
         repositoryId,
         headSha: session?.workspace.headSha ?? readHeadSha(root),
-        worktreeDigest: computeWorktreeDigest(root, listGitVisibleFiles(root))
+        worktreeDigest: computeWorktreeDigest(root, listGitVisibleFiles(root)),
+        ...ignoredModelPaths.length === 0 ? {} : { architectureModelIgnoredPaths: ignoredModelPaths }
       });
     } catch (error) {
       throw publicOperationFailure(error);
@@ -60031,26 +60588,19 @@ function exportLikeC4Model(model) {
   const normalized = normalizeNativeModel(model);
   const lines = [
     "// Generated by ArchContext. Native model remains source of truth.",
-    "specification {",
-    "  element capability",
-    "  element module",
-    "  element component",
-    "  element interface",
-    "  element datastore",
-    "  element external_system",
-    "}",
+    ...likeC4SpecificationLines(normalized.nodes),
     "",
     "model {"
   ];
   for (const node of normalized.nodes) {
     lines.push(`  // archctx-node ${JSON.stringify(node)}`);
-    lines.push(`  ${likec4Id(node.id)} = ${likec4Kind(node.kind)} "${escapeDsl2(node.name)}"`);
+    lines.push(`  ${likec4Id(node.id)} = ${likeC4ElementKind(node.kind)} "${escapeDsl2(node.name)}"`);
   }
   for (const relation of normalized.relations) {
     lines.push(`  // archctx-relation ${JSON.stringify(relation)}`);
     lines.push(`  ${likec4Id(relation.source)} -> ${likec4Id(relation.target)} "${escapeDsl2(relation.kind)}"`);
   }
-  lines.push("}", "", "views {", "  view index {", "    include *", "    autoLayout TopBottom", "  }", "}");
+  lines.push("}", "", ...likeC4IndexViewLines(architectureLayerGroups(normalized), likec4Id));
   const content = `${lines.join(`
 `)}
 `;
@@ -60080,15 +60630,6 @@ function importLikeC4InitialModel(content) {
 function likec4Id(id) {
   return stableId(id).replace(/-/g, "_").replace(/\./g, "_").replace(/::/g, "__");
 }
-function likec4Kind(kind) {
-  if (kind === "external-system")
-    return "external_system";
-  if (kind === "datastore")
-    return "datastore";
-  if (["capability", "module", "component", "interface"].includes(kind))
-    return kind;
-  return "component";
-}
 function escapeDsl2(value) {
   return value.replace(/"/g, "'");
 }
@@ -60097,17 +60638,22 @@ function escapeDsl2(value) {
 init_src();
 function exportStructurizrWorkspace(model, name = "ArchContext Export") {
   const normalized = normalizeNativeModel(model);
+  const { layerByNodeId } = architectureLayerGroups(normalized);
   const workspace = {
     schemaVersion: "archcontext.structurizr-export/v1",
     name,
     model: {
-      elements: normalized.nodes.map((node) => ({
-        id: node.id,
-        name: node.name,
-        type: structurizrElementType(node.kind),
-        tags: [node.kind],
-        archcontextNative: node
-      })),
+      elements: normalized.nodes.map((node) => {
+        const layer = layerByNodeId.get(node.id);
+        return {
+          id: node.id,
+          name: node.name,
+          type: architectureStructurizrElementType(node.kind),
+          tags: [node.kind],
+          ...layer === undefined ? {} : { group: layer },
+          archcontextNative: node
+        };
+      }),
       relationships: normalized.relations.map((relation) => ({
         id: relation.id,
         sourceId: relation.source,
@@ -60151,17 +60697,6 @@ function importStructurizrInitialModel(content) {
     warnings: ["Structurizr import is initialization-only; Native ArchContext remains source of truth."]
   };
 }
-function structurizrElementType(kind) {
-  if (kind === "capability")
-    return "Software System";
-  if (kind === "module")
-    return "Container";
-  if (kind === "datastore")
-    return "Database";
-  if (kind === "external-system")
-    return "External System";
-  return "Component";
-}
 
 // packages/surfaces/mcp-local/src/tool-schemas.ts
 var text2 = { type: "string", minLength: 1 };
@@ -60735,17 +61270,49 @@ var architecture_node_schema_default2 = {
   type: "object",
   additionalProperties: false,
   required: ["schemaVersion", "id", "kind", "name", "status", "summary"],
+  allOf: [
+    {
+      if: { properties: { kind: { const: "namespace" } }, required: ["kind"] },
+      then: { required: ["namespace"] },
+      else: { not: { required: ["namespace"] } }
+    },
+    {
+      if: { properties: { kind: { const: "mount" } }, required: ["kind"] },
+      then: { required: ["mount"] },
+      else: { not: { required: ["mount"] } }
+    }
+  ],
   properties: {
     schemaVersion: { const: "archcontext.node/v2" },
     id: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
     kind: {
       type: "string",
-      enum: ["capability", "module", "component", "interface", "event", "datastore", "external-system", "deployment"]
+      enum: ["capability", "module", "component", "interface", "event", "datastore", "external-system", "deployment", "process", "namespace", "mount"]
     },
     name: { type: "string" },
     status: { type: "string", enum: ["active", "planned", "deprecated", "removed"] },
     parent: { type: "string", pattern: "^([a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)*::)?[a-z][a-z0-9]*(\\.[a-z0-9][a-z0-9-]*)+$" },
+    layer: { type: "string", pattern: "^[a-z][a-z0-9]*(-[a-z0-9]+)*$" },
     summary: { type: "string" },
+    namespace: {
+      type: "object",
+      additionalProperties: false,
+      required: ["type"],
+      properties: {
+        type: { type: "string", enum: ["host", "container", "pod", "kubernetes", "pid", "mount", "net", "user"] }
+      }
+    },
+    mount: {
+      type: "object",
+      additionalProperties: false,
+      required: ["target", "mode", "order"],
+      properties: {
+        source: { type: "string", minLength: 1 },
+        target: { type: "string", pattern: "^/([^/\\u0000]+(/[^/\\u0000]+)*)?$" },
+        mode: { type: "string", enum: ["ro", "rw"] },
+        order: { type: "integer", minimum: 0 }
+      }
+    },
     responsibilities: { type: "array", items: { type: "string" }, minItems: 1 },
     source: {
       type: "object",