genesis-compiler 1.5.2 → 1.7.0

package/README.md

@@ -28,7 +28,8 @@ genesis/
   engineering.md     selected engineering profile and project-specific requirements
   stack.md           selected components, resources, verification, and project-owned operation contracts
   stack/             optional per-component Description, Guidance, Adoption, Post-change, and Deslop customization
-  program/           concise explanations grouped into conceptual subsystems
+  subsystems.md      authored responsibilities, Program membership, and data ownership/use
+  program/           concise public-operation explanations
 .agents/skills/
   genesis-*          Genesis workflow skills
   <technology>/      authoritative skills installed by selected Stack pieces
@@ -897,6 +898,10 @@ import {
   installCodex,
   listEngineeringProfiles,
   listStackPieces,
+  listParsers,
+  installParsers,
+  verifyParsers,
+  parserEnvironment,
   migrate,
   projectSessionContext,
   projectTurnContext,
@@ -910,6 +915,9 @@ import {
 
 `initialize()` installs the project files, Genesis workflow skills, selected
 Stack skills, and local Codex hooks.
+Extra language parsers install on first use, outside the project's dependencies.
+The CLI can also prepare and verify parsers for an offline host; see
+[language parser management](docs/parsers.md).
 `migrate()` updates recognized older Genesis project-file formats and returns
 the resulting structural check for hosts such as Vibe64.
 `adoptProject()` also returns the initial `adopt` prompt for an existing
@@ -977,3 +985,60 @@ project operations, and records exact verification evidence. Code, tests, Git
 review, and the user's chosen agent remain responsible for implementation. It
 does not claim universal semantic convergence, exhaustive coverage, or
 whole-product correctness.
+
+## Authored subsystems (version zero)
+
+`genesis/subsystems.md` is the single authored map connecting architectural
+responsibilities to Program operations and data. Program directories are only
+navigation; Genesis never infers subsystem membership from them. Blueprint
+remains non-technical product intent. Source, migrations and runtime behavior
+remain evidence; the map does not define application behavior or database DDL.
+
+```markdown
+# Subsystems
+
+## `forms` Forms
+
+Owns reusable form authoring, rendering, and answer validation.
+
+### Program
+- `genesis/program/forms/render.md`
+
+### Data owned
+- Table `database` `default` `form_definitions`
+
+### Data used
+- Nothing.
+```
+
+Each subsystem has a unique lowercase hyphenated id, title, responsibility
+prose, and exactly the three shown sections. Each Program module is assigned
+exactly once, by its complete project-relative path. Each table has at most one
+owner. Data used names a table owned by another declared subsystem. Empty
+sections explicitly say `- Nothing.`; an empty initialized map contains
+`# Subsystems` followed by `- Nothing.`. Data-only and code-only subsystems are
+valid. No subsystem hierarchy is inferred from paths.
+
+Table references contain three distinct values: declared Stack resource **id**,
+schema, and table. `default` selects that resource's default schema; other schema
+names are literal. Never put host database names or environment values here.
+Genesis validates declarations and resource references without opening a database.
+Hosts resolve table references against their inspected schema and show missing
+references and unassigned tables explicitly; the map is not a complete schema
+inventory. Table/column descriptions and relationships remain database metadata.
+
+`inspectSubsystems({ projectRoot })` and `genesis inspect subsystems --json`
+return `genesis.subsystems.v0`, normalized entries, status and a deterministic
+identity. Program inspection additionally validates membership and referenced
+modules. Context includes the relevant subsystem through its Program Sources;
+`context .` includes all subsystems. Program City uses authored titles and table
+associations, including data-only districts, and changes its hash when the map
+changes. Opening context stays concise; detailed associations load on demand.
+
+Adoption, Program refresh, work prompts, session guidance and installed workflow
+skills maintain the map alongside Program in the same turn. Review checks it
+read-only; Blueprint-only work leaves it alone. Ordinary private helper edits
+need no map change. Existing projects do not need a bulk update: missing or empty maps preserve
+Program access and instruct the agent to author the map from source before its
+next implementation task. Until then, operations have no declared subsystem;
+there is no folder-based compatibility reader or automatic ownership inference. Initialization creates an empty map without replacing one.

package/docs/parsers.md

@@ -0,0 +1,46 @@
+# Language parsers
+
+Genesis installs extra language parsers automatically the first time it indexes
+matching source. JavaScript, TypeScript and TSX use its built-in core parser.
+No project dependency or lockfile is changed.
+
+```sh
+genesis parsers list
+genesis parsers install python cpp
+genesis parsers install --all
+genesis parsers verify --all
+```
+
+These commands work outside a Git repository and support `--json`. Downloads
+and verification progress go to stderr. The language names come from `parsers
+list`; C and C++ are separate parsers (`c` and `cpp`), and shell uses `bash`.
+
+Use `--directory /absolute/path` or `GENESIS_PARSER_ROOT` to choose a cache.
+Otherwise Genesis uses `$XDG_CACHE_HOME/genesis/parsers`, falling back to
+`~/.cache/genesis/parsers`. Installations are pinned by language, package version,
+OS and CPU. npm must be available for installation. Genesis uses the public npm
+registry, disables package lifecycle scripts, verifies each native parser, and
+retains only its current-platform binary and loader. Prebuilt native support is
+required; Genesis does not compile a missing parser on the user's machine.
+
+For a prepared host or release artifact:
+
+```sh
+genesis parsers install --all --directory /absolute/release/parsers
+genesis parsers verify --all --directory /absolute/release/parsers
+export GENESIS_PARSER_ROOT=/absolute/release/parsers
+export GENESIS_PARSER_AUTO_INSTALL=0
+```
+
+The cache can be relocated on the same OS/CPU. Verify it again at its destination
+before activation. Missing or broken parsers fail verification; indexing reports
+an actionable diagnostic. A damaged installed version is preserved for inspection:
+remove only that reported version directory deliberately, then rerun install.
+Successful installations are reusable offline and require no runtime writes.
+
+The library exports `listParsers`, `installParsers`, `verifyParsers`, and
+`parserEnvironment`. The first three accept `directory`; install/verify accept
+`languages` or `all` and an abort `signal`. Install accepts `onProgress`.
+`parserEnvironment({ directory, autoInstall, environment })` returns the two
+normalized environment values for a host and its commands. Preparing or verifying
+all parsers uses short-lived children; native indexing runs in a finite child and releases parser memory on exit.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.5.2",
+  "version": "1.7.0",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {
@@ -43,25 +43,18 @@
     "plugins/opencode",
     "profiles",
     "skills",
-    "src"
+    "src",
+    "docs/parsers.md"
   ],
   "scripts": {
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@ast-grep/lang-bash": "^0.0.8",
-    "@ast-grep/lang-c": "^0.0.6",
-    "@ast-grep/lang-cpp": "^0.0.6",
-    "@ast-grep/lang-csharp": "^0.0.6",
-    "@ast-grep/lang-go": "^0.0.6",
-    "@ast-grep/lang-java": "^0.0.7",
-    "@ast-grep/lang-kotlin": "^0.0.7",
-    "@ast-grep/lang-php": "^0.0.7",
-    "@ast-grep/lang-python": "^0.0.6",
-    "@ast-grep/lang-ruby": "^0.0.7",
-    "@ast-grep/lang-rust": "^0.0.7",
     "@ast-grep/napi": "^0.45.1",
     "mdast-util-from-markdown": "^2.0.3",
     "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@ast-grep/lang-python": "0.0.6"
   }
 }

package/prompts/adopt.txt

@@ -60,3 +60,18 @@ execute them. Finish with a clear inventory of what was imported, what remains
 unconfigured or blocked, and what would require a separately approved
 implementation port. Never claim the project is ready merely because Stack
 components were selected.
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/prompts/describe.txt

@@ -12,6 +12,21 @@ If the codebase is too large for one careful pass, use subagents as you judge
 appropriate, reconcile their findings, and remain responsible for one coherent
 result. Identify anything not inspected or genuinely uncertain.
 
-Edit only `genesis/blueprint.md` and explanatory Markdown below
+Edit only `genesis/blueprint.md`, `genesis/subsystems.md`, and explanatory Markdown below
 `genesis/program/`. Summarize every explanatory file created, updated, or
 removed.
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/prompts/program.txt

@@ -4,9 +4,24 @@ in complete Program-refresh mode.
 Explain the code that currently exists using the smallest useful
 subsystem-oriented Program. Read implementation, tests, Blueprint, and current
 Program material. Use Machine City as a navigation aid, then verify relevant
-source directly. Edit only explanatory Markdown below `genesis/program/`.
+source directly. Edit only `genesis/subsystems.md` and explanatory Markdown below `genesis/program/`.
 Delete stale or duplicate modules and do not edit code, tests, configuration,
 Blueprint, Stack, or `.genesis/`.
 
 When finished, summarize Program files created, updated, or removed and report
 genuine ambiguity.
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/prompts/review.txt

@@ -10,3 +10,5 @@ evidence from inference and state questions that require human intent.
 
 Do not edit any file. Return a concise report ordered by impact with exact file
 references, the evidence inspected, and the smallest sensible correction.
+
+Review `genesis/subsystems.md` responsibilities, Program membership, and data ownership/use against source and schema. Report missing, stale, or conflicting associations without editing them.

package/prompts/work.txt

@@ -38,3 +38,18 @@ explicit decision, and add the selection with the Genesis
 `stack add <piece...>` operation before relying on technology-specific
 operations. Do not end after only updating
 or summarizing the Blueprint while the Stack remains empty.
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/skills/genesis-program/SKILL.md

@@ -21,7 +21,8 @@ private design choice, or ambiguity into product intent.
 
 ## Program
 
-Organize Program beneath conceptual subsystem directories:
+Organize Program in readable directories; membership is declared only in
+`genesis/subsystems.md`, independently of directory names:
 
 ```text
 genesis/program/billing/invoices.md
@@ -64,3 +65,58 @@ The caller determines whether this is initial description, complete Program
 refresh, focused post-change reconciliation, Blueprint-only work, or read-only
 review. Respect the caller's edit boundary. Report ambiguity rather than
 inventing intent.
+
+## Subsystems
+
+Maintain `genesis/subsystems.md` alongside Program in description and refresh
+work. Blueprint-only work does not change the map; review remains read-only.
+The map is the authored association authority, but responsibilities and table
+references remain fallible explanations of application source and schema.
+
+Use this exact version-zero grammar:
+
+```markdown
+# Subsystems
+
+## `forms` Forms
+
+Owns reusable form rendering, validation, and submission capture.
+
+### Program
+- `genesis/program/forms/render.md`
+
+### Data owned
+- Table `database` `default` `form_definitions`
+
+### Data used
+- Nothing.
+```
+
+Use one stable lowercase hyphenated id and a human title per subsystem. Each
+entry needs responsibility prose and exactly the three sections shown. Empty
+sections say `- Nothing.`; a new empty map contains only `# Subsystems` and
+`- Nothing.`. Every Program module belongs to exactly one subsystem. No folder
+inference, globs, duplicated operations, or duplicated table owners.
+
+A table identity is three separate exact backticked values: the declared Stack
+resource id, schema, and table. `default` means the resource's default schema;
+use an explicit schema where applicable. Never record a host database name,
+credential, SQL expression, or environment value. Data used references a table
+owned by another declared subsystem. A subsystem may own data without Program
+operations, or operations without data. Read the real schema/migrations before
+assigning ownership; report uncertainty instead of inventing associations.
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/skills/genesis-project/SKILL.md

@@ -152,3 +152,20 @@ required inputs and resources, declared project operations, and focused evidence
 with what actually exists. Report files changed, checks actually run,
 anything not proven, and anything still requiring attention. Never claim that
 an unrun check passed or that passing checks prove the whole product.
+
+## Subsystem maintenance
+
+Maintain `genesis/subsystems.md` in the same implementation turn when a change
+adds, removes, or changes a subsystem responsibility, Program membership, or
+data ownership/use. Read the map before changing related code. Reuse existing
+subsystems unless a distinct responsibility is evidenced. Declare each Program
+module exactly once; folders do not determine membership. Keep table references
+grounded in schema/migrations; Genesis does not inspect databases. Private
+helper changes need no map edit when these associations remain unchanged.
+
+If `genesis/subsystems.md` is missing, or is empty in an existing explained
+application, create it from the actual source, schema, and existing Program
+before implementation. This is ordinary explanatory adoption, not a blocker or
+a reason to ask permission again. Preserve the existing Program and source;
+inspect the relevant responsibilities and complete the smallest truthful map.
+Initialization can create the empty file, but only the agent authors its meaning.

package/src/cli.js

@@ -14,12 +14,16 @@ import {
   inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
+  inspectSubsystems,
   inspectProject,
   inspectSkills,
   installCodex,
   listEngineeringProfiles,
   listStackPieces,
   listTemplates,
+  listParsers,
+  installParsers,
+  verifyParsers,
   migrate,
   setCollaboration,
   setEngineeringProfile,
@@ -44,6 +48,7 @@ import {
 import { projectSessionContext, projectTurnContext } from './index/session-context.js';
 import { installedFirstPartyStackPackages } from './index/stack-catalog.js';
 import { readStack } from './index/stack.js';
+import { withParserCancellation } from './index/code-indexers/parsers.js';
 
 const USAGE = `Usage:
   genesis init
@@ -61,7 +66,11 @@ const USAGE = `Usage:
   genesis templates apply <catalogue:technology/variant>
   genesis context <path...>
   genesis index [function-or-path...]
+  genesis parsers list
+  genesis parsers install <language...> | --all
+  genesis parsers verify <language...> | --all
   genesis migrate
+  genesis inspect subsystems
   genesis inspect environment
   genesis inspect project
   genesis inspect skills
@@ -76,6 +85,8 @@ Options:
   --stack-package <name> Add an installed external Stack package (repeatable)
   --template-source <namespace=repository[#branch]> Add a template catalogue (repeatable)
   --task <task>          Select the prompt task (default: work)
+  --directory <path>     Parser cache directory (parsers commands only)
+  --all                  Select every parser (parsers install/verify only)
   --json                 Emit one machine-readable result
   -h, --help             Show this help
 
@@ -84,7 +95,7 @@ prompt to the agent you already use. Review all edits through the ordinary Git
 diff, then run genesis verify for the Stack's concrete checks.
 `;
 
-const COMMANDS = new Set(['adopt', 'check', 'codex', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'skills', 'stack', 'templates', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'parsers', 'prompt', 'skills', 'stack', 'templates', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -100,6 +111,8 @@ function parseCommand(argv) {
       strict: true,
       options: {
         json: { type: 'boolean', default: false },
+        all: { type: 'boolean', default: false },
+        directory: { type: 'string' },
         'project-root': { type: 'string' },
         'stack-package': { type: 'string', multiple: true, default: [] },
         'template-source': { type: 'string', multiple: true, default: [] },
@@ -111,6 +124,8 @@ function parseCommand(argv) {
   }
   const options = {
     json: parsed.values.json,
+    all: parsed.values.all,
+    directory: parsed.values.directory,
     projectRoot: parsed.values['project-root'],
     stackPackages: parsed.values['stack-package'],
     templateSources: parsed.values['template-source'].map((source) => {
@@ -123,13 +138,23 @@ function parseCommand(argv) {
     task: parsed.values.task,
   };
   const operands = parsed.positionals;
+  if (command !== 'parsers' && (options.all || options.directory !== undefined)) {
+    fail('CLI_OPTION_NOT_APPLICABLE', 'Options --all and --directory apply only to parsers commands.');
+  }
   if (options.templateSources.length && command !== 'templates') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --template-source is not applicable to ${command}.`);
   }
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
-  if (command === 'templates') {
+  if (command === 'parsers') {
+    const [action, ...languages] = operands;
+    if (!['list', 'install', 'verify'].includes(action)) fail('CLI_PARSER_ACTION_REQUIRED', 'Use parsers list, install, or verify.');
+    if (action === 'list' && (languages.length || options.all)) fail('CLI_EXTRA_ARGUMENT', 'parsers list accepts no languages or --all.');
+    if (action !== 'list' && (options.all ? languages.length : !languages.length)) {
+      fail('PARSER_SELECTION_INVALID', 'Choose parser names or --all.');
+    }
+  } else if (command === 'templates') {
     if (!(operands[0] === 'list' && operands.length === 1) && !(operands[0] === 'apply' && operands.length === 2)) {
       fail('CLI_TEMPLATE_ACTION_REQUIRED', 'Use templates list or templates apply <catalogue:technology/variant>.');
     }
@@ -182,12 +207,12 @@ function parseCommand(argv) {
   } else if (command === 'context' && operands.length === 0) {
     fail('CONTEXT_PATH_REQUIRED', 'Command context requires at least one project path.');
   } else if (command === 'inspect') {
-    const ordinaryInspection = operands.length === 1 && ['environment', 'project', 'skills'].includes(operands[0]);
+    const ordinaryInspection = operands.length === 1 && ['environment', 'project', 'skills', 'subsystems'].includes(operands[0]);
     const sectionInspection = operands.length >= 2 && operands[0] === 'section';
     if (!ordinaryInspection && !sectionInspection) {
       fail(
         'CLI_INSPECT_TARGET_REQUIRED',
-        'Command inspect requires project, environment, skills, or section <name>.',
+        'Command inspect requires project, environment, skills, subsystems, or section <name>.',
       );
     }
   } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session', 'turn'].includes(operands[0]))) {
@@ -272,7 +297,9 @@ function writeInspection(result) {
   line(process.stdout, `${title}: ${result.status}`);
   namedItems('Components', result.components);
   namedItems('Runtimes', result.runtimeRequirements);
-  if (result.inspection === 'environment') {
+  if (result.inspection === 'subsystems') {
+    namedItems('Subsystems', result.subsystems.map(({ id, title }) => `${id}: ${title}`));
+  } else if (result.inspection === 'environment') {
     namedItems('Public defaults', result.environmentDefaults.map(({ name, value }) => `${name}=${value}`));
     namedItems('Environment files', result.files.map(({ format, path: filePath }) => `${format}: ${filePath}`));
   } else if (result.inspection === 'section') {
@@ -286,6 +313,12 @@ function writeInspection(result) {
 }
 
 function writeResult(command, result) {
+  if (command === 'parsers') {
+    line(process.stdout, `Parser directory: ${result.directory}`);
+    if (result.parsers) for (const parser of result.parsers) line(process.stdout, `${parser.language}: ${parser.status}${parser.message ? ` — ${parser.message}` : ''}`);
+    else line(process.stdout, `Parsers verified: ${result.languages.join(', ')}`);
+    return;
+  }
   if (command === 'inspect' && result.inspection === 'skills') {
     line(process.stdout, `Agent Skills: ${result.status}`);
     for (const skill of result.skills) line(process.stdout, `  - ${skill.name}: ${skill.status}`);
@@ -425,6 +458,13 @@ async function cliStackPackages(projectRoot, supplied) {
 }
 
 async function execute({ command, operands, options }, { signal } = {}) {
+  if (command === 'parsers') {
+    const parserOptions = {
+      languages: operands.slice(1), all: options.all, directory: options.directory, signal,
+      onProgress: (message) => line(process.stderr, message),
+    };
+    return { list: listParsers, install: installParsers, verify: verifyParsers }[operands[0]](parserOptions);
+  }
   const projectRoot = options.projectRoot || process.cwd();
   const stackPackages = await cliStackPackages(projectRoot, options.stackPackages || []);
   if (command === 'init') return initialize({ projectRoot, stackPackages });
@@ -511,7 +551,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
         }),
       };
     }
-    const inspections = { environment: inspectEnvironment, project: inspectProject, skills: inspectSkills };
+    const inspections = { subsystems: inspectSubsystems, environment: inspectEnvironment, project: inspectProject, skills: inspectSkills };
     return {
       inspection: operands[0],
       ...await inspections[operands[0]]({ projectRoot, stackPackages }),
@@ -578,7 +618,7 @@ async function optionalProjectFormat(projectRoot) {
 }
 
 function requiresCurrentProjectFormat(command, operands) {
-  if (['check', 'codex', 'hook', 'migrate'].includes(command)) return false;
+  if (['check', 'codex', 'hook', 'migrate', 'parsers'].includes(command)) return false;
   if (command === 'engineering') {
     return operands[0] === 'set' || (operands[0] === 'show' && operands.length === 1);
   }
@@ -607,7 +647,7 @@ export async function runCli(argv = process.argv.slice(2)) {
       return 0;
     }
     options = parsed.options;
-    const projectFormat = await optionalProjectFormat(options.projectRoot || process.cwd());
+    const projectFormat = parsed.command === 'parsers' ? null : await optionalProjectFormat(options.projectRoot || process.cwd());
     const formatDiagnostic = projectFormatDiagnostic(projectFormat);
     if (formatDiagnostic && !options.json) {
       line(process.stderr, `WARNING: ${formatDiagnostic.message}`);
@@ -615,13 +655,10 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (formatDiagnostic && requiresCurrentProjectFormat(parsed.command, parsed.operands)) {
       fail(formatDiagnostic.code, formatDiagnostic.message, formatDiagnostic.details);
     }
-    const finiteCommand = parsed.command === 'verify';
-    if (finiteCommand) {
-      process.once('SIGINT', abort);
-      process.once('SIGTERM', abort);
-    }
+    process.once('SIGINT', abort);
+    process.once('SIGTERM', abort);
     const result = withProjectFormatWarning(
-      await execute(parsed, { signal: controller.signal }),
+      await withParserCancellation(controller.signal, () => execute(parsed, { signal: controller.signal })),
       projectFormat,
       formatDiagnostic,
     );

package/src/index/code-index.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import { astGrepCodeIndexers } from './code-indexers/ast-grep.js';
+import { extractCodeIndexes } from './code-indexers/ast-grep.js';
 import { asDiagnostic } from './errors.js';
 import { buildCityPresentation } from './city-presentation.js';
 import { cityPathExcluded } from './stack-city-presentation.js';
@@ -28,8 +28,6 @@ export const GENESIS_DERIVED_ARTIFACTS = Object.freeze([
   }),
 ]);
 
-const INDEXERS = astGrepCodeIndexers;
-
 function directoryId(value) {
   return `directory:${value || '.'}`;
 }
@@ -43,7 +41,7 @@ function subsystemId(value) {
 }
 
 function operationId(module) {
-  return `operation:${module.subsystem}/${module.name}`;
+  return `operation:${module.path}`;
 }
 
 function parentDirectory(value) {
@@ -70,18 +68,10 @@ function directoryRecords(paths) {
 }
 
 function subsystemRecords(subsystems) {
-  const paths = new Set();
-  for (const subsystem of subsystems) {
-    const segments = subsystem.split('/');
-    for (let count = 1; count <= segments.length; count += 1) {
-      paths.add(segments.slice(0, count).join('/'));
-    }
-  }
-  return [...paths].sort().map((subsystem) => ({
-    id: subsystemId(subsystem),
-    path: subsystem,
-    title: path.posix.basename(subsystem).replace(/-/gu, ' '),
-    parentId: subsystem.includes('/') ? subsystemId(parentDirectory(subsystem)) : null,
+  return subsystems.map((entry) => ({
+    id: subsystemId(entry.id), path: entry.id, title: entry.title,
+    description: entry.description, parentId: null,
+    dataOwned: entry.dataOwned, dataUsed: entry.dataUsed,
   }));
 }
 
@@ -195,7 +185,7 @@ async function programCity(projectRoot) {
       implementationMap: module.implementationMap,
       path: module.path,
       subsystem: module.subsystem,
-      districtId: subsystemId(module.subsystem),
+      districtId: module.subsystem === null ? null : subsystemId(module.subsystem),
       sources: module.sources,
       sourceFileIds: module.sources.map(fileId),
     }));
@@ -203,9 +193,9 @@ async function programCity(projectRoot) {
       schema: 'genesis.program-city.v1',
       schemaVersion: 1,
       status: program.status,
-      programHash: sha256(stableJson(operations)),
+      programHash: sha256(stableJson({ operations, subsystems: program.subsystemMap })),
       diagnostics: [],
-      districts: subsystemRecords(program.subsystems),
+      districts: subsystemRecords(program.subsystemMap.subsystems),
       buildings: operations,
       links: operations.flatMap((operation) => operation.sourceFileIds.map((targetId) => ({
         kind: 'implemented-by',
@@ -270,22 +260,7 @@ export async function buildProjectIndex({
     ))
     .map(([filePath, state]) => ({ path: filePath, hash: state.hash, mode: state.mode }));
   const indexers = [...new Set(stack.components.flatMap((component) => component.indexers || []))].sort();
-  const contributions = [];
-  const diagnostics = [];
-  for (const id of indexers) {
-    const indexer = INDEXERS.get(id);
-    if (!indexer) {
-      diagnostics.push({ code: 'CODE_INDEXER_UNAVAILABLE', message: `No installed code indexer exists for ${id}.` });
-      continue;
-    }
-    try {
-      const contribution = await indexer.extract({ files, projectRoot: root });
-      contributions.push({ ...contribution, extractor: id });
-      diagnostics.push(...(contribution.diagnostics || []).map((diagnostic) => ({ ...diagnostic, extractor: id })));
-    } catch (error) {
-      diagnostics.push({ ...asDiagnostic(error), code: 'CODE_INDEXER_FAILED', extractor: id });
-    }
-  }
+  const { contributions, diagnostics } = await extractCodeIndexes({ indexers, files, projectRoot: root });
   const machine = machineCity({
     cityRegions: stack.cityRegions,
     components: stack.components.map(({ id }) => id),