genesis-compiler 1.10.6 → 1.10.8

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. |
@@ -293,6 +294,10 @@ than in a host-private policy or a repeated user-message prefix:
 
 - `concise`
 
+## Long checks
+
+- `conservative`
+
 ## Project requirements
 
 - Nothing.
@@ -302,7 +307,7 @@ Inspect or change it without parsing Markdown yourself:
 
 ```bash
 genesis collaboration show
-genesis collaboration set direct balanced expert conclusions "Be candid."
+genesis collaboration set direct balanced expert conclusions normal "Be candid."
 ```
 
 Genesis owns the supported choices and their concise expansions. Authored
@@ -314,6 +319,26 @@ Updates should describe actual progress, findings, decisions, or blockers,
 rather than announce compliance with guidance or reassure the user about
 unrelated behavior staying unchanged.
 
+The Long checks choice sets how agents handle test suites, builds and other long
+checks. `conservative` runs each one as a single unattended, time-limited
+command that writes its output to a local file and ends with one completion
+signal; the agent does not watch it while it runs and passes this on to agents
+it delegates checks to. It saves the most tokens, and results arrive only when
+each check ends. `normal` lets the agent follow a check's progress and stop a
+clearly broken run early, reacting sooner for more tokens. Both keep the
+Engineering baseline's time limit, local output files, exit status and concise
+evidence reading.
+
+The choice belongs to the person, so Genesis never makes it for them. `genesis
+init`, migration and `setCollaboration()` calls that do not pass `longChecks`
+leave `## Long checks` out. While it is absent, `longChecks` is `null` and the
+session guidance asks the agent to put both options to the person once, early,
+before the first long check, to record the answer with `genesis collaboration
+set` (the guidance spells out the command with the current choices), and to use
+`conservative` until then. Once the section exists, the guidance carries only
+the chosen option. A present section with any other value is rejected with the
+valid choices listed.
+
 Persistent hosts should install `projectSessionContext()` once when a provider
 conversation is created or refreshed. They may then generate task prompts with
 `sessionContextInstalled: true`, preventing the stable Collaboration and
@@ -465,6 +490,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
@@ -988,6 +1025,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/prompt-integration.md

@@ -180,8 +180,8 @@ Genesis keeps each instruction at one useful level:
 - `genesis/blueprint.md`, `genesis/program/`, and `genesis/stack.md` are the
   project's own intent, explanation, and selected technical composition.
 - `genesis/collaboration.md` selects Genesis-owned tone, response-length,
-  assumed-experience, and explanation-style instructions plus optional authored
-  project requirements.
+  assumed-experience, explanation-style, and long-checks instructions plus
+  optional authored project requirements.
 - `profiles/engineering/*.md` owns the installed versioned engineering
   profiles. `genesis/engineering.md` selects one profile and records explicit
   project requirements. A universal complexity gate is composed ahead of the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "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.6",
+  "version": "1.10.8",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/profiles/engineering/baseline.md

@@ -5,5 +5,5 @@
 - Do not overengineer or overcomplicate the solution. Do not add speculative abstractions, layers, dependencies, infrastructure, compatibility paths, distributed patterns, cryptography, enterprise patterns, or other advanced machinery unless an explicit requirement or a concrete constraint makes it necessary.
 - If good software requires material complexity beyond these rules, stop before writing it. Explain the requirement, why the direct design is insufficient, and the smallest added complexity proposed, then ask the user to approve or clarify the tradeoff.
 - During implementation, run the relevant checks and batch related cases when they share setup. Follow the project's verification policy for broad or final checks; do not repeat them merely because an item finishes or a session resumes. Preserve required coverage and isolation.
-- Keep complete test output in local artifacts and preserve exit status. Read concise counts, timings and actionable failure excerpts first, expanding evidence only when needed. Do not load full passing reports or repeatedly poll unchanged logs into agent context. Retain startup and cleanup failures; retry only after a change or new evidence justifies it.
+- Bound each long check by a time limit so it ends even when it hangs; write its complete output to a local file and preserve its exit status. Afterwards read concise counts, timings and actionable failure excerpts first, expanding evidence only when needed; never load full passing reports into agent context. Retain startup and cleanup failures; retry only after a change or new evidence justifies it.
 - For browser verification, batch related actions and return only the relevant values or page region. Capture screenshots at meaningful visual checkpoints or failures, not after every action. Preserve required viewport, identity and security coverage; prefer existing automated cases for repeated checks.

package/src/cli.js

@@ -55,7 +55,7 @@ const USAGE = `Usage:
   genesis adopt [product guidance...]
   genesis codex install
   genesis collaboration show
-  genesis collaboration set <tone> <response-length> <experience> <explanation-style> [project requirements...]
+  genesis collaboration set <tone> <response-length> <experience> <explanation-style> <long-checks> [project requirements...]
   genesis engineering list
   genesis engineering show [profile]
   genesis engineering set <profile>
@@ -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}.`);
   }
@@ -172,10 +178,10 @@ function parseCommand(argv) {
     if (action === 'show' && operands.length !== 1) {
       fail('CLI_EXTRA_ARGUMENT', 'Command collaboration show accepts no extra arguments.');
     }
-    if (action === 'set' && operands.length < 5) {
+    if (action === 'set' && operands.length < 6) {
       fail(
         'CLI_COLLABORATION_VALUES_REQUIRED',
-        'Command collaboration set requires tone, response length, experience, and explanation style.',
+        'Command collaboration set requires tone, response length, experience, explanation style, and long checks.',
       );
     }
   } else if (command === 'stack') {
@@ -273,6 +279,7 @@ function writeCollaboration(result) {
   line(process.stdout, `Response length: ${result.responseLength}`);
   line(process.stdout, `Assumed experience: ${result.experience}`);
   line(process.stdout, `Explanation style: ${result.explanationStyle}`);
+  line(process.stdout, `Long checks: ${result.longChecks || 'unset (conservative until chosen)'}`);
   if (result.requirements) {
     line(process.stdout, 'Project requirements:');
     line(process.stdout, result.requirements);
@@ -386,6 +393,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) {
@@ -509,7 +517,8 @@ async function execute({ command, operands, options }, { signal, hostContext = n
         responseLength: operands[2],
         experience: operands[3],
         explanationStyle: operands[4],
-        ...(operands.length > 5 ? { requirements: operands.slice(5).join(' ') } : {}),
+        longChecks: operands[5],
+        ...(operands.length > 6 ? { requirements: operands.slice(6).join(' ') } : {}),
       }),
     };
   }
@@ -558,7 +567,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 {

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.');