genesis-compiler 1.10.5 → 1.10.7

package/README.md

@@ -39,6 +39,7 @@ genesis/
 .genesis/            local, git-ignored (`genesis init` adds the ignore lines)
   machine-city.json  derived detailed source and function map
   program-city.json  derived simple subsystem and operation map
+  call-web.json      derived function call web (`genesis index --call-web`)
 ```
 
 Program paths describe public operations rather than languages or source
@@ -253,7 +254,7 @@ files alone does not refresh its existing context.
 | `genesis stack add <piece...>` | Resolves component dependencies/conflicts, records the selection, materializes missing project contracts, synchronizes declared skills, and prints the one-time preparation prompt. It does not install application packages or run an agent. |
 | `genesis skills sync` | Refreshes selected, unmodified managed skills while preserving customized and unmanaged copies. |
 | `genesis context <path...>` | Returns path-focused Program explanations, indexed functions, selected technology guidance, exact project contracts, and relevant skills. |
-| `genesis index [function-or-path...]` | Regenerates the derived code indexes and optionally searches the existing function/method inventory. |
+| `genesis index [--call-web] [function-or-path...]` | Regenerates the derived code indexes and optionally searches the existing function/method inventory. `--call-web` also writes the derived function call web. |
 | `genesis inspect environment` | Reports declared resources, public defaults, missing input names, and environment-file paths without returning secret values. |
 | `genesis inspect skills` | Reports selected skill freshness and ownership without changing files. |
 | `genesis inspect section <name>` | Returns one exact consumer-owned Stack section without interpreting or executing it. |
@@ -264,8 +265,10 @@ files alone does not refresh its existing context.
 
 Project-scoped options follow the command, for example
 `genesis check --project-root /path/to/project`. Commands support `--json` when
-a host or script needs the normalized result. Run `genesis --help` for the
-compact CLI synopsis.
+a host or script needs the normalized result. A failed command prints its
+diagnostic code and message on standard error; when the failure came from a
+child process such as Git, its bounded output follows, so the actual reason is
+visible without `--json`. Run `genesis --help` for the compact CLI synopsis.
 
 ## Collaboration approach
 
@@ -463,6 +466,18 @@ extractor warning does not stop ordinary work. They are rebuilt from the
 working tree, so they are not committed: `genesis init` adds both paths to the
 project's `.gitignore`.
 
+Machine City also lists entry points: commands, library exports, Program
+operations, tests and inspector-derived pages, components, routes, actions and
+jobs. A page entry is titled by its first registration, such as the URL path
+`/app/project/:slug`, else by the page's title. `genesis index --call-web`
+additionally writes `.genesis/call-web.json`,
+every function site and call site with its `probable`, `exact` or `unresolved`
+targets. The generic baseline is syntax and import scope only, so it is never
+`exact`; an inspector may supply exact facts for its files. The call web is
+written only when Git ignores its path (`genesis init` adds the line). Per-file
+extraction, including installed packages' public entry files, is cached inside
+the Git directory, so unchanged files are not parsed again.
+
 Local package exports whose entry files are excluded from indexing retain their
 declared import paths with unavailable symbol coverage and a diagnostic. They do
 not invalidate the rest of the architecture. After upgrading Genesis, run
@@ -986,6 +1001,9 @@ async callback receiving the fresh architecture facts. A host can run its finite
 inspector inside that callback, avoiding a second source extraction. Genesis
 joins the result and rechecks source, Stack, subsystem and package inputs before
 writing compact derived JSON; failures and cancellation retain the prior index.
+`indexCodebase({ callWeb: true })` also builds the call web; `readCallWeb()`
+returns it only while it matches the saved Machine City, `validateCallWeb()`
+checks a document and `CALL_WEB_SCHEMA` names its schema.
 `ARCHITECTURE_OBSERVATIONS_SCHEMA` identifies the neutral inspector document.
 `validateArchitectureObservations()` checks its evidence against supplied files
 and packages; `connectArchitectureObservations()` joins exact owners and

package/docs/templates.md

@@ -83,7 +83,14 @@ The framework starters live in `seed-django`, `seed-rails`, `seed-spring-boot`,
 source, dependency lockfile, setup/run contracts and focused checks.
 
 Applying fetches the explicitly named branch once, resolves its commit and reads
-its ordinary Git blobs into a temporary project. Genesis rejects arbitrary links,
+its ordinary Git blobs into a temporary project. Both scratch repositories, the
+fetched source and the prepared project, live inside the destination's Git-local
+`genesis-template.lock` directory (`git rev-parse --git-path genesis-template.lock`),
+never in the system temporary directory or the work tree. Every Git command
+therefore runs inside the destination repository, which hosts that confine Git
+to the project accept, and the scratch is removed with the lock when the
+operation succeeds or fails. A linked worktree keeps its lock and scratch in its
+own private Git directory. Genesis rejects arbitrary links,
 submodules, unsafe paths, dependencies and private dotenv files in the template.
 The only link exception is the exact generated Claude skill discovery link
 `.claude/skills/<name>` → `../../.agents/skills/<name>`. Incoming discovery links
@@ -94,9 +101,11 @@ generated links without following links supplied by a template.
 It validates the prepared project before changing the destination. A project
 lock serializes competing imports; the source and authored bootstrap files are
 checked again immediately before the copy. An ordinary copy failure rolls back
-written files. If a process is forcibly killed, inspect any partial work and the
-Git-local `genesis-template.lock` before removing the abandoned lock and retrying;
-Genesis never treats partial application code as an empty destination.
+written files. `SIGINT` and `SIGTERM` let the CLI finish that cleanup. If a process
+is forcibly killed, inspect any partial work and the Git-local
+`genesis-template.lock` before removing the abandoned lock, and the scratch inside
+it, and retrying; Genesis never treats partial application code as an empty
+destination.
 
 The destination keeps its Git history, remotes, branch, meaningful Blueprint,
 collaboration/engineering choices, and authored Stack operation sections.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.10.5",
+  "version": "1.10.7",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {

package/plugins/genesis/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.10.5",
+  "version": "1.10.7",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/src/cli.js

@@ -65,7 +65,7 @@ const USAGE = `Usage:
   genesis templates list
   genesis templates apply <catalogue:technology/variant>
   genesis context <path...>
-  genesis index [function-or-path...]
+  genesis index [--call-web] [function-or-path...]
   genesis parsers list
   genesis parsers install <language...> | --all
   genesis parsers verify <language...> | --all
@@ -87,6 +87,7 @@ Options:
   --task <task>          Select the prompt task (default: work)
   --directory <path>     Parser cache directory (parsers commands only)
   --all                  Select every parser (parsers install/verify only)
+  --call-web             Also build .genesis/call-web.json (index only)
   --json                 Emit one machine-readable result
   --claude-part <1-4>    Emit one bounded Claude session-hook part
   -h, --help             Show this help
@@ -114,6 +115,7 @@ function parseCommand(argv) {
         json: { type: 'boolean', default: false },
         'claude-part': { type: 'string' },
         all: { type: 'boolean', default: false },
+        'call-web': { type: 'boolean', default: false },
         directory: { type: 'string' },
         'project-root': { type: 'string' },
         'stack-package': { type: 'string', multiple: true, default: [] },
@@ -128,6 +130,7 @@ function parseCommand(argv) {
     json: parsed.values.json,
     claudePart: parsed.values['claude-part'],
     all: parsed.values.all,
+    callWeb: parsed.values['call-web'],
     directory: parsed.values.directory,
     projectRoot: parsed.values['project-root'],
     stackPackages: parsed.values['stack-package'],
@@ -150,6 +153,9 @@ function parseCommand(argv) {
   if (options.templateSources.length && command !== 'templates') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --template-source is not applicable to ${command}.`);
   }
+  if (options.callWeb && command !== 'index') {
+    fail('CLI_OPTION_NOT_APPLICABLE', `Option --call-web is not applicable to ${command}.`);
+  }
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
@@ -233,6 +239,14 @@ function line(stream, value = '') {
   stream.write(`${String(value).replace(/\n$/u, '')}\n`);
 }
 
+// A failed command's bounded output usually carries its actual reason.
+function diagnosticOutput(stream, item) {
+  for (const field of ['stdout', 'stderr']) {
+    const output = item.details?.[field];
+    if (typeof output === 'string' && output.trim()) line(stream, output.trim());
+  }
+}
+
 function namedItems(label, values) {
   if (!Array.isArray(values) || values.length === 0) return;
   line(process.stdout, `${label}:`);
@@ -378,6 +392,7 @@ function writeResult(command, result) {
     line(process.stdout, result.summary);
     line(process.stdout, `Machine City: ${result.paths.machine}`);
     line(process.stdout, `Program City: ${result.paths.program}`);
+    if (result.paths.callWeb) line(process.stdout, `Call web: ${result.paths.callWeb}`);
     if (result.totalMatches > 0) {
       line(process.stdout, 'Matching functions:');
       for (const entry of result.matches) {
@@ -413,10 +428,7 @@ function writeResult(command, result) {
   namedItems('Verification commands', result.commands?.map(({ label, argv }) => `${label}: ${argv.join(' ')}`));
   for (const item of result.diagnostics || []) {
     line(process.stdout, `${item.code}: ${item.message}`);
-    for (const field of ['stdout', 'stderr']) {
-      const output = item.details?.[field]?.trim();
-      if (output) line(process.stdout, output);
-    }
+    diagnosticOutput(process.stdout, item);
   }
   if (result.guidance) line(process.stdout, result.guidance);
   if (result.prompt) {
@@ -553,7 +565,7 @@ async function execute({ command, operands, options }, { signal, hostContext = n
     });
   }
   if (command === 'context') return getContext({ paths: operands, projectRoot, stackPackages });
-  if (command === 'index') return indexCodebase({ projectRoot, queries: operands, stackPackages });
+  if (command === 'index') return indexCodebase({ projectRoot, queries: operands, stackPackages, callWeb: options.callWeb });
   if (command === 'inspect') {
     if (operands[0] === 'section') {
       return {
@@ -711,7 +723,10 @@ export async function runCli(argv = process.argv.slice(2)) {
   } catch (error) {
     const diagnostic = asDiagnostic(error);
     if (options.json) line(process.stderr, JSON.stringify(diagnostic));
-    else line(process.stderr, `${diagnostic.code}: ${diagnostic.message}`);
+    else {
+      line(process.stderr, `${diagnostic.code}: ${diagnostic.message}`);
+      diagnosticOutput(process.stderr, diagnostic);
+    }
     return 1;
   } finally {
     process.removeListener('SIGINT', abort);

package/src/index/architecture-observations.js

@@ -5,7 +5,22 @@ import { sha256, stableJson } from './utils.js';
 export const ARCHITECTURE_OBSERVATIONS_SCHEMA = 'genesis.architecture-observations.v1';
 const collections = ['pages', 'registrations', 'components', 'componentUses', 'entryOperations', 'operationUses'];
 const optionalCollections = ['imports'];
+// Call-web collections appear only when an inspector declares them, so
+// documents and merges without them keep their exact v1 shape.
+const callCollections = ['functions', 'calls', 'entryPoints'];
 const states = ['complete', 'partial', 'unsupported', 'unconfigured'];
+export const FUNCTION_KINDS = Object.freeze(['function', 'method', 'constructor', 'arrow', 'closure', 'module']);
+export const CALL_CERTAINTIES = Object.freeze(['exact', 'probable', 'unresolved']);
+export const CALL_METHODS = Object.freeze(['checker', 'di-binding', 'route-action', 'argument-flow', 'import-scope', 'same-file-name', 'self', 'receiver-name', 'none']);
+export const EXACT_CALL_METHODS = Object.freeze(['checker', 'di-binding', 'route-action', 'self', 'argument-flow']);
+export const ENTRY_POINT_KINDS = Object.freeze(['page', 'component', 'route', 'action', 'library-export', 'cli-command', 'job', 'program-operation', 'test']);
+export const MAX_CALL_TARGETS = 16;
+export const MAX_CALLS_PER_FILE = 2000;
+export const MAX_CALLEE_LENGTH = 120;
+// A file's top-level code is `fn:<path>#module`; every other function is named by its start.
+export const functionId = (file, start, kind) => kind === 'module' ? `fn:${file}#module` : `fn:${file}#${start.line}:${start.column}`;
+const before = (left, right) => left.line < right.line || (left.line === right.line && left.column < right.column);
+const notAfter = (left, right) => !before(right, left);
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 const text = value => typeof value === 'string' && value.length > 0 && !/[\0\r\n]/u.test(value);
 const canonical = value => text(value) && value !== '.' && !/[\\]/u.test(value) && !path.posix.isAbsolute(value) && path.posix.normalize(value) === value && !value.split('/').includes('..');
@@ -15,6 +30,45 @@ function requireFact(condition, message) {
   if (!condition) throw new GenesisError('ARCHITECTURE_OBSERVATIONS_INVALID', message);
 }
 
+function validateCallWebFacts(document, ids, inputs, functionReference, operation) {
+  requireFact(document.calls === undefined || Array.isArray(document.functions), 'calls require functions.');
+  const functions = new Map();
+  for (const entry of document.functions || []) {
+    requireFact(inputs.has(entry.file), `${entry.id} must identify a declared input file.`);
+    requireFact(point(entry.start) && point(entry.end) && before(entry.start, entry.end), `${entry.id} has an impossible source range.`);
+    requireFact(entry.id === functionId(entry.file, entry.start, entry.kind), `${entry.id} must be fn:<path>#<start line>:<start column> (fn:<path>#module for module code).`);
+    requireFact(FUNCTION_KINDS.includes(entry.kind) && typeof entry.name === 'string' && !/[\0\r\n]/u.test(entry.name), `${entry.id} needs a known kind and a name (empty when anonymous).`);
+    requireFact(entry.kind !== 'module' || (entry.start.line === 1 && entry.start.column === 1), `${entry.id} module code starts at 1:1.`);
+    requireFact(entry.container == null || text(entry.container), `${entry.id} has an invalid container.`);
+    requireFact(entry.exported === undefined || typeof entry.exported === 'boolean', `${entry.id} has an invalid export flag.`);
+    requireFact(entry.evidence.every(evidence => evidence.path === entry.file), `${entry.id} evidence must be in its own file.`);
+    functions.set(entry.id, entry);
+  }
+  const perFile = new Map();
+  for (const call of document.calls || []) {
+    const from = functions.get(call.fromFunctionId);
+    requireFact(from && Array.isArray(call.targets) && call.targets.every(target => functions.has(target)) && new Set(call.targets).size === call.targets.length, `${call.id} must reference known caller and target functions.`);
+    requireFact(CALL_CERTAINTIES.includes(call.certainty) && CALL_METHODS.includes(call.method), `${call.id} needs a known certainty and method.`);
+    requireFact(typeof call.callee === 'string' && call.callee.length <= MAX_CALLEE_LENGTH && !call.callee.includes('\0'), `${call.id} callee text must be at most ${MAX_CALLEE_LENGTH} characters.`);
+    if (call.certainty === 'exact') requireFact(call.resolution === 'resolved' && call.targets.length === 1 && EXACT_CALL_METHODS.includes(call.method), `${call.id} exact calls need one resolved target from a resolver.`);
+    if (call.certainty === 'probable') requireFact(call.method !== 'none' && ((call.resolution === 'resolved' && call.targets.length === 1) || (call.resolution === 'ambiguous' && call.targets.length >= 2 && call.targets.length <= MAX_CALL_TARGETS)), `${call.id} probable calls need one resolved or 2-${MAX_CALL_TARGETS} ambiguous targets.`);
+    if (call.certainty === 'unresolved') requireFact(call.resolution === 'unresolved' && call.targets.length === 0 && call.method === 'none', `${call.id} unresolved calls have no targets and no method.`);
+    requireFact(call.evidence.every(evidence => evidence.path === from.file && notAfter(from.start, evidence.start) && notAfter(evidence.end, from.end)), `${call.id} evidence must lie inside its caller.`);
+    perFile.set(from.file, (perFile.get(from.file) || 0) + 1);
+    requireFact(perFile.get(from.file) <= MAX_CALLS_PER_FILE, `${from.file} has more than ${MAX_CALLS_PER_FILE} call records; truncate with CALLS_TRUNCATED.`);
+  }
+  for (const entry of document.entryPoints || []) {
+    requireFact(ENTRY_POINT_KINDS.includes(entry.kind) && text(entry.title), `${entry.id} needs a known kind and a title.`);
+    requireFact(inputs.has(entry.file), `${entry.id} must identify a declared input file.`);
+    requireFact(Array.isArray(entry.functionIds), `${entry.id} needs function identities.`);
+    for (const value of entry.functionIds) functionReference(value, entry.id);
+    if (entry.pageId != null) requireFact(ids.get(entry.pageId)?.name === 'pages', `${entry.id} refers to an unknown page.`);
+    if (entry.componentId != null) requireFact(ids.get(entry.componentId)?.name === 'components', `${entry.id} refers to an unknown component.`);
+    if (entry.operationKey != null) operation(entry.operationKey, entry.id);
+    if (entry.actionId != null) requireFact(text(entry.actionId), `${entry.id} has an invalid action identity.`);
+  }
+}
+
 // A finite, framework-independent JSON contract. Inspectors collect evidence;
 // this owner validates identities and joins without executing application code.
 export function validateArchitectureObservations(document, { files = [], packages = [] } = {}) {
@@ -23,7 +77,7 @@ export function validateArchitectureObservations(document, { files = [], package
   requireFact(Array.isArray(document.inputs), 'inputs must be an array.');
   requireFact(object(document.capabilities), 'capabilities must be an object.');
   for (const name of ['pages', 'components', 'entryOperations', 'operationUses']) requireFact(states.includes(document.capabilities[name]), `Missing or invalid ${name} capability.`);
-  if (document.capabilities.imports !== undefined) requireFact(states.includes(document.capabilities.imports), 'Invalid import coverage.');
+  for (const name of ['imports', ...callCollections]) if (document.capabilities[name] !== undefined) requireFact(states.includes(document.capabilities[name]), `Invalid ${name} coverage.`);
   requireFact(Array.isArray(document.diagnostics) && document.diagnostics.every(entry => object(entry) && text(entry.code) && text(entry.message)), 'diagnostics must contain code and message.');
   const filesByPath = new Map(files.map(file => [file.path, file]));
   const inputs = new Map();
@@ -35,8 +89,8 @@ export function validateArchitectureObservations(document, { files = [], package
     inputs.set(input.path, input);
   }
   const ids = new Map();
-  for (const name of [...collections, ...optionalCollections]) {
-    requireFact(Array.isArray(document[name]) || (optionalCollections.includes(name) && document[name] === undefined), `${name} must be an array.`);
+  for (const name of [...collections, ...optionalCollections, ...callCollections]) {
+    requireFact(Array.isArray(document[name]) || (!collections.includes(name) && document[name] === undefined), `${name} must be an array.`);
     for (const record of document[name] || []) {
       requireFact(object(record) && text(record.id) && !ids.has(record.id), `Invalid or duplicate ${name} identity.`);
       requireFact(['resolved', 'unresolved', 'ambiguous'].includes(record.resolution), `${record.id} needs an explicit resolution.`);
@@ -93,10 +147,24 @@ export function validateArchitectureObservations(document, { files = [], package
     if (entry.resolution === 'resolved') source(entry.controllerFile, entry.id);
     if (entry.controllerSymbol != null) requireFact(text(entry.controllerSymbol), `${entry.id} has an invalid symbol.`);
   }
+  // Without a function table (a saved compact copy), caller identities stay opaque strings.
+  const hasFunctions = Array.isArray(document.functions);
+  function functionReference(value, label) {
+    if (hasFunctions) reference(value, ['functions'], label);
+    else requireFact(text(value), `${label} has an invalid function identity.`);
+  }
+  for (const entry of document.entryOperations) {
+    if (entry.controllerFunctionId !== undefined) functionReference(entry.controllerFunctionId, entry.id);
+    if (entry.actionId !== undefined) requireFact(text(entry.actionId), `${entry.id} has an invalid action identity.`);
+  }
   for (const use of document.operationUses) {
-    reference(use.parentId, ['pages', 'components', 'componentUses'], use.id);
+    requireFact(use.parentId != null || use.fromFunctionId !== undefined, `${use.id} needs a page/component parent or a caller function.`);
+    if (use.parentId != null) reference(use.parentId, ['pages', 'components', 'componentUses'], use.id);
+    if (use.fromFunctionId !== undefined) functionReference(use.fromFunctionId, use.id);
     if (use.resolution === 'resolved') operation(use.key, use.id);
+    if (use.keyCertainty !== undefined) requireFact(use.resolution === 'resolved' && ['exact', 'probable'].includes(use.keyCertainty), `${use.id} key certainty applies only to a resolved key.`);
   }
+  validateCallWebFacts(document, ids, inputs, functionReference, operation);
   // Parent graphs must be finite. Shared definitions are not duplicate owners.
   for (const name of ['pages', 'componentUses']) for (const record of document[name]) {
     const seen = new Set([record.id]);
@@ -121,7 +189,9 @@ export function connectArchitectureObservations(document, files, packages = [])
   const connections = document.operationUses.map(use => {
     const matches = use.resolution === 'resolved' ? entries.get(stableJson(use.key)) || [] : [];
     const entry = matches.length === 1 ? matches[0] : null;
-    return { id: `connection:${use.id}`, useId: use.id, parentId: use.parentId, key: use.key || null, resolution: entry ? 'resolved' : matches.length > 1 ? 'ambiguous' : 'unresolved', entryId: entry?.id || null, controllerFileId: entry ? byPath.get(entry.controllerFile).id : null, controllerSymbol: entry?.controllerSymbol || null, evidence: [...use.evidence, ...(entry?.evidence || [])] };
+    // Caller facts appear only for function-level uses; an exact key alone makes an exact bridge.
+    const bridge = use.fromFunctionId === undefined ? {} : { fromFunctionId: use.fromFunctionId, controllerFunctionId: entry?.controllerFunctionId ?? null, certainty: entry ? (use.keyCertainty === 'exact' ? 'exact' : 'probable') : null };
+    return { id: `connection:${use.id}`, useId: use.id, parentId: use.parentId ?? null, key: use.key || null, resolution: entry ? 'resolved' : matches.length > 1 ? 'ambiguous' : 'unresolved', entryId: entry?.id || null, controllerFileId: entry ? byPath.get(entry.controllerFile).id : null, controllerSymbol: entry?.controllerSymbol || null, evidence: [...use.evidence, ...(entry?.evidence || [])], ...bridge };
   });
   return {
     ...document, connections,
@@ -130,9 +200,14 @@ export function connectArchitectureObservations(document, files, packages = [])
   };
 }
 
+const sameFunction = (left, right) => ['file', 'name', 'kind'].every(field => left[field] === right[field])
+  && stableJson([left.start, left.end]) === stableJson([right.start, right.end]);
+
 export function mergeArchitectureObservations(documents, { files = [], packages = [] } = {}) {
   requireFact(Array.isArray(documents) && documents.length > 0, 'At least one observation document is required.');
   const merged = { schema: ARCHITECTURE_OBSERVATIONS_SCHEMA, adapter: '', inputs: [], capabilities: {}, diagnostics: [], ...Object.fromEntries([...collections, ...optionalCollections].map(name => [name, []])) };
+  const declared = callCollections.filter(name => documents.some(document => document?.[name] !== undefined));
+  for (const name of declared) merged[name] = [];
   const adapters = new Set();
   for (const document of documents) {
     requireFact(document?.schema === ARCHITECTURE_OBSERVATIONS_SCHEMA && text(document.adapter) && !adapters.has(document.adapter), 'Every inspector needs a unique adapter identity and the observation schema.');
@@ -141,13 +216,20 @@ export function mergeArchitectureObservations(documents, { files = [], packages
       requireFact(!merged.packageIdentity || merged.packageIdentity === document.packageIdentity, 'Inspectors disagree about the package snapshot.');
       merged.packageIdentity = document.packageIdentity;
     }
-    for (const name of ['inputs', ...collections, ...optionalCollections]) {
-      requireFact(Array.isArray(document[name]) || (optionalCollections.includes(name) && document[name] === undefined), `${name} must be an array.`);
+    for (const name of ['inputs', ...collections, ...optionalCollections, ...declared]) {
+      requireFact(Array.isArray(document[name]) || (!collections.includes(name) && name !== 'inputs' && document[name] === undefined), `${name} must be an array.`);
       const byId = new Map(merged[name].map(record => [name === 'inputs' ? record.path : record.id, record]));
       for (const record of document[name] || []) {
         requireFact(object(record), `Invalid ${name} record.`);
         const id = name === 'inputs' ? record.path : record.id;
         const previous = byId.get(id);
+        if (name === 'functions') {
+          // The same function seen by two inspectors is one record; on
+          // disagreement the inspector earlier in Stack order wins.
+          if (previous && !sameFunction(previous, record)) merged.diagnostics.push({ code: 'FUNCTION_CONFLICT', path: record.file, message: `${document.adapter} and ${previous.adapter} disagree about ${id}; ${previous.adapter} is kept.` });
+          if (!previous) { const kept = { ...record, adapter: document.adapter }; merged[name].push(kept); byId.set(id, kept); }
+          continue;
+        }
         requireFact(!previous || stableJson(previous) === stableJson(record), `Conflicting ${name} identity ${id}.`);
         if (!previous) { merged[name].push(record); byId.set(id, record); }
       }
@@ -163,5 +245,10 @@ export function mergeArchitectureObservations(documents, { files = [], packages
   }
   const importCoverage = documents.map(document => document.capabilities?.imports || 'unconfigured');
   merged.capabilities.imports = new Set(importCoverage).size === 1 ? importCoverage[0] : 'partial';
+  for (const capability of callCollections) {
+    if (!documents.some(document => document.capabilities?.[capability] !== undefined)) continue;
+    const values = documents.map(document => document.capabilities?.[capability] || 'unconfigured');
+    merged.capabilities[capability] = new Set(values).size === 1 ? values[0] : 'partial';
+  }
   return validateArchitectureObservations(merged, { files, packages });
 }

package/src/index/architecture.js

@@ -1,10 +1,12 @@
 import path from 'node:path';
-import { connectArchitectureObservations } from './architecture-observations.js';
+import { connectArchitectureObservations, ENTRY_POINT_KINDS } from './architecture-observations.js';
 import { buildCityPresentation } from './city-presentation.js';
 import { GenesisError } from './errors.js';
 import { sha256, stableJson } from './utils.js';
 
 const owns = (root, file) => root === '.' || file.startsWith(`${root}/`);
+// Function and call tables live in the call web; Machine City keeps the rest.
+const withoutCallTables = ({ functions, calls, ...rest }) => rest;
 
 function resolveReference(file, reference, filesByPath, packages) {
   const specifier = reference.specifier;
@@ -80,7 +82,7 @@ export function buildArchitectureFacts({ machine, subsystemMap, program = null,
   })));
   const symbols = [...machine.functions, ...(machine.symbols || [])].map(symbol => ({ ...symbol, start: symbol.start || { line: symbol.line, column: symbol.column }, rangeAvailable: Boolean(symbol.end) }));
   const sourceHash = sha256(stableJson(files.map(file => ({ path: file.path, hash: file.hash, mode: file.mode }))));
-  let ui = observations ? connectArchitectureObservations(observations, files, packages) : null;
+  let ui = observations ? withoutCallTables(connectArchitectureObservations(observations, files, packages)) : null;
   if (!observations && previous?.ui) {
     // Source-only indexing must not erase unchanged consumer observations.
     // A changed snapshot requires its inspector; never carry guesses forward.
@@ -219,6 +221,23 @@ export function validateArchitectureFacts(snapshot) {
   }
   check(snapshot.capabilities && typeof snapshot.capabilities === 'object' && Array.isArray(snapshot.diagnostics), 'Missing architecture coverage or diagnostics.');
   for (const name of ['symbols', 'dependencies', 'pages', 'runtimeCalls']) check(['complete', 'partial', 'unsupported', 'unconfigured'].includes(snapshot.capabilities[name]), 'Invalid architecture coverage.');
+  for (const name of ['functions', 'calls', 'entryPoints']) check(snapshot.capabilities[name] === undefined || ['complete', 'partial', 'unsupported', 'unconfigured'].includes(snapshot.capabilities[name]), 'Invalid architecture coverage.');
+  const filesByPath = new Map([...files.values()].map(file => [file.path, file]));
+  if (snapshot.entryPoints !== undefined) {
+    check(Array.isArray(snapshot.entryPoints), 'entryPoints must be an array.');
+    const ids = new Set();
+    for (const entry of snapshot.entryPoints) {
+      check(entry && typeof entry.id === 'string' && entry.id.length > 0 && !ids.has(entry.id) && ENTRY_POINT_KINDS.includes(entry.kind) && typeof entry.title === 'string' && entry.title.length > 0, 'Invalid or duplicate entry point.');
+      ids.add(entry.id);
+      check(filesByPath.has(entry.file) && Array.isArray(entry.functionIds) && entry.functionIds.every(id => typeof id === 'string' && id.length > 0), `${entry.id} must name a known file and function identities.`);
+      check(Array.isArray(entry.evidence) && entry.evidence.length > 0 && entry.evidence.every(evidence => filesByPath.get(evidence?.path)?.hash === evidence.hash), `${entry.id} evidence is stale.`);
+    }
+  }
+  if (snapshot.callWeb != null) {
+    const { callWeb } = snapshot;
+    check(callWeb.path === '.genesis/call-web.json' && typeof callWeb.identity === 'string' && typeof callWeb.sourceIdentity === 'string' && callWeb.counts && typeof callWeb.counts === 'object' && callWeb.coverage && typeof callWeb.coverage === 'object', 'Invalid call-web summary.');
+    for (const name of ['functions', 'calls', 'exact', 'probable', 'unresolved']) check(Number.isSafeInteger(callWeb.counts[name]) && callWeb.counts[name] >= 0, 'Invalid call-web counts.');
+  }
   if (snapshot.ui) {
     const recomputed = connectArchitectureObservations(snapshot.ui, snapshot.files, snapshot.packages || []);
     check(stableJson(recomputed.connections) === stableJson(snapshot.ui.connections), 'Controller connections disagree with their evidence.');