genesis-compiler 1.2.12 → 1.2.13

package/docs/stack-components.md

@@ -1,8 +1,8 @@
 # Stack components
 
-Genesis core knows no framework, language, database, package manager, or
-environment-variable name, and it ships no technology pieces. A Stack package
-is an ordinary npm package with one static manifest pointer:
+Genesis core knows no framework, language, database, package manager, host, or
+consumer operation. A Stack package is an ordinary npm package with one static
+manifest pointer:
 
 ```json
 {
@@ -11,472 +11,198 @@ is an ordinary npm package with one static manifest pointer:
 }
 ```
 
-Each piece is one Markdown file in that declared directory. Genesis reads the
-manifest and Markdown only; it never imports or executes package code. Catalog
-names are explicit, collisions fail, and the selected package is recorded in
-the project's `## Stack packages` section. The first-party optional
-`genesis-stack` package contains the complete curated catalog; Genesis core does
-not depend on it. A framework contributes to that catalog rather than requiring
-a compiler release or a separate catalog package.
+Each piece is one Markdown file in that directory. Genesis reads the manifest
+and Markdown only; it never imports or executes package code. Package names are
+explicit, collisions fail, and selected packages are recorded in the project's
+`## Stack packages` section.
+
+## Piece format
+
+A piece may use the Genesis-owned sections below:
 
 ````markdown
 # Stack piece: example
 
 ## Description
 
-What this component contributes.
+Concise technology context.
 
 ## Requires
 
 - `nodejs`
 
+## Conflicts
+
+- Nothing.
+
 ## Skill
 
-- Package: `@example/agent-docs`
+- Package: `example-agent-docs`
 - Path: `skills/example`
 
 ## Indexers
 
 - `javascript`
 
-## City regions
-
-- Ignore `**/test/**`
-- Ignore `**/tests/**`
-- Ignore `**/__tests__/**`
-- Ignore `**/*.test.*`
-- Ignore `**/*.spec.*`
-- Match `packages` as `Packages`: `packages/**`
-- Match `source` as `Source`: `src/**`
-- Fallback `everything-else` as `Everything else`
-
 ## Resources
 
-```json genesis-resource
-{
-  "id": "service",
-  "kind": "example-service",
-  "environmentAlternatives": [
-    { "required": ["SERVICE_URL"] },
-    { "required": ["SERVICE_HOST", "SERVICE_PORT"] }
-  ]
-}
-```
+- Resource `database` kind `postgresql`: `DATABASE_URL` OR `DB_HOST` + `DB_NAME`
 
 ## Environment defaults
 
-- Default `EXAMPLE_DRIVER`: `example`
-
-## Guidance
+- Default `DB_CLIENT`: `pg`
 
-### Technology-specific behavior
+## Environment files
 
-- Concise supplemental guidance used during implementation, explanation,
-  review, and cleanup.
+- Dotenv: `.env`
 
-## Adoption
+## Verification
 
-- Evidence and technology-specific contracts an agent must reconcile when
-  importing an existing application.
+- Verify `application`: `npm` `run` `verify`
 
-## Environment files
+## Guidance
 
-- Dotenv `.env`
+- General project-work guidance.
 
-## Workspace setup
+## Adoption
 
-- Prepare `Install dependencies` with `example-runtime`: `example-install` `--locked`
-- Prepare `Install web dependencies` with `nodejs` in `web`: `npm` `install`
+- Existing-project import guidance.
 
 ## Deslop
 
-- Concise technology-specific cleanup guidance.
+- Technology-specific cleanup guidance.
 
-## Commands
+## Consumer operation
 
-- Verify `tests`: `npm` `test`
+```json example.consumer-operation.v1
+{
+  "version": 1,
+  "data": "owned entirely by the consumer"
+}
+```
+````
 
-## Launch
+`Description`, `Guidance`, `Adoption`, and `Deslop` are prose. `Requires` and
+`Conflicts` define component selection. `Skill` names one complete authoritative
+Agent Skill directory. `Indexers` selects installed structural adapters.
+`Resources`, `Environment defaults`, `Environment files`, and `Verification`
+use the small Genesis grammars documented below. Every other `##` section is an
+opaque extension.
 
-### Target `app`: Run app
+## Genesis-owned declarations
 
-- Default.
-- Workdir: `.`
-- Preferred port: `3000`
-- URL path: `/`
-- Ready when: `GET` `/api/health` returns `200`
-- Runtimes: `nodejs`
-- Prepare `Build`: `npm` `run` `build`
-- Serve `Start`: `npm` `run` `server` `--` `--host` `{host}` `--port` `{port}`
+Resources describe required external inputs as alternatives of environment
+variable names. Genesis can report which names are absent, but never reads a
+service, provisions infrastructure, or returns a supplied value. A project
+`## Resources` section replaces all component resource defaults.
 
-#### Preview identity
+Environment defaults are public, non-secret constants. Component defaults
+compose by variable name; identical values collapse and conflicting values
+fail. A project `## Environment defaults` section replaces component defaults.
+Explicit process values always win.
 
-- Command: `tools/preview-identity`
-- Protocol: `genesis.preview-identity.command.v1`
-- Identity types: `email` `login` `user-id`
-- Enabled environment: `APP_PREVIEW_IDENTITY_ENABLED`
-- Secret environment: `APP_PREVIEW_IDENTITY_SECRET`
-- Runtimes: `nodejs`
-- Timeout ms: `10000`
-````
+Environment files describe safe project-relative dotenv projection paths.
+Genesis returns only the format and path. It does not materialize the file,
+choose which values belong there, or store secrets. A project declaration
+replaces component declarations; otherwise paths compose.
 
-`Description` and `Requires` are the only required sections. `Requires` forms
-dependency closure. Optional `Conflicts` uses the same list format. `Skill`
-selects one complete [Agent Skills](https://agentskills.io) directory, either
-from Genesis or from the declared npm package. Its `SKILL.md`, `references/`,
-`scripts/`, `assets/`, and `agents/` metadata are copied together to
-`.agents/skills/<skill-name>/`; the agent loads them progressively instead of
-Genesis expanding every manual into every prompt. Relative Markdown links and
-images must resolve within that copied Skill root. Missing targets and paths
-that escape the root are invalid, even if an escaped path happens to exist in
-the source package or project. `Resources` declares generic
-alternative environment-name sets reported by prompt generation and checked
-before verification. `allowEmpty` may name a required variable whose empty
-string is valid. `Environment defaults` declares public non-secret constants
-owned by a concrete integration; explicit host values take precedence.
-`Guidance` is supplemental prose used by work, review, Program,
-description, and cleanup prompts, as well as path-focused context. `Adoption`
-adds technology-specific evidence and contract requirements to the dedicated
-existing-application import prompt. `Deslop`
-adds cleanup-only prose to explicit cleanup and the automatic Codex cleanup
-continuation. With no selected component, only the `genesis-deslop` skill
-applies. `Commands` accepts only argument-safe `Verify` entries and runs only
-through `genesis verify`.
-
-A project may own a complete `## Resources` section in `genesis/stack.md` using
-the same fenced `json genesis-resource` objects, or `- Nothing.` to declare
-none. Its presence replaces every selected component Resource declaration.
-This lets an existing application preserve its real queue, database, mail,
-object-storage, or service environment names rather than inherit a framework's
-vocabulary. Without a project section, component Resources compose as before.
-
-`Workspace setup` is an optional exact, ordered recipe for a host preparing a
-fresh workspace. Each entry uses this readable, shell-free form:
+Verification contains exact argv tokens:
 
 ```markdown
-- Prepare `label` with `runtime` `another-runtime` in `optional/workdir` when `optional/marker` exists: `command` `argument`
+## Verification
+
+- Verify `tests`: `npm` `test`
+- Verify `build`: `npm` `run` `build`
 ```
 
-Every command and argument is a separate backticked value and is returned as
-an `argv` array. Runtime names are opaque technology ids. Omitted `in` means
-the project root; otherwise the working directory must be canonical and
-project-relative. The optional `when` path is also canonical and
-project-relative. Until it exists, inspection reports the recipe as
-`unconfigured`; this lets a host safely re-inspect after an agent creates a
-technology substrate without knowing that technology's filenames. `- Nothing.`
-is valid only as the entire section and lets a
-project explicitly disable component setup. Genesis validates and reports the
-recipe but never chooses a runtime, runs a command, installs a dependency, or
-infers a package manager. Generic language pieces such as `nodejs` and `php`
-therefore declare no installer; a concrete piece such as `jskit` may declare
-one.
-
-Precedence is intentionally small and deterministic:
-
-1. A project `## Workspace setup` section in `genesis/stack.md` replaces every
-   selected component default.
-2. Without a project section, exactly one selected component recipe is used.
-3. With no declaration the result is `unconfigured`; with several component
-   recipes it is `blocked` as ambiguous. Genesis never merges them.
-
-General Stack resources do not gate Workspace setup. In particular, missing
-database variables do not prevent an otherwise independent dependency install.
-
-Each `Environment defaults` entry is one `Default` bullet with a backticked
-environment name and value. Selected
-component defaults compose by name; identical declarations collapse and
-different values fail rather than silently choosing one. Defaults participate
-in Stack identity, resource preflight, prompt context, Launch inspection, and
-verification execution. The `genesis-stack` JSKIT database integrations use this contract for
-their deterministic `DB_CLIENT` driver ids; generic database pieces do not.
-Secrets and deployment-specific connection values remain host inputs and must
-never be declared as defaults.
-
-A project `## Environment defaults` section in `genesis/stack.md` likewise
-replaces every component default and accepts `- Nothing.` as a complete empty
-declaration. It is the complete declaration of public, non-secret constants
-expected by the actual application; Genesis never keeps a framework default
-beside it implicitly. `genesis stack add` preserves both project-owned sections
-while changing component selection.
-
-`Environment files` optionally declares project-relative dotenv projections a
-host may materialize from its own resolved project environment. Genesis
-validates and returns only the format and path; it never reads environment
-values, writes a file, stores a secret, or chooses which variables belong in a
-projection. A project `## Environment files` section in `genesis/stack.md`
-replaces component declarations, including with `- Nothing.`. Without a
-project section, component declarations compose and identical paths collapse.
-The declaration is useful independently of Launch and Workspace setup.
-
-`Launch` is an optional readable declarative recipe for hosts that need to
-offer a preview without guessing how a concrete technology starts. Repeat a
-``### Target `id`: label`` block to declare several targets. Default, Workdir,
-Preferred port, URL path, and Runtimes are optional; their normalized defaults
-are false, `.`, null, `/`, and no runtime requirements. Every target declares
-one HTTP readiness predicate with a project path and an exact successful status
-from 200 through 399. Every Prepare or Serve command and argument is a separate backticked value returned as an `argv`
-array, never a shell program. A target has exactly one final Serve step; any
-earlier steps must be Prepare steps. Workdir is canonical and project-relative,
-Preferred port is only a hint from 1024 through 65535, and URL path is an
-application path rather than a URL. The only substitutions are `{host}` and
-`{port}`, supplied by the host. A project can use `- Nothing.` as its complete
-Launch section to disable component targets.
-
-Genesis validates and reports Launch data but does not select a runtime,
-reserve a port, start a process, probe readiness, or control a browser. The host
-executes the declared predicate and owns its timeout and retry policy.
-
-The optional `#### Preview identity` block is specific to hosts that implement
-the declared `genesis.preview-identity.command.v1` protocol. Its executable is
-a committed, application-owned project-relative file; the
-normalized command is an argv array, not a shell program. Identity types may
-contain `email`, `login`, and `user-id`. Enabled environment and Secret
-environment are optional variable
-names the application recognizes; Genesis validates and returns names only and
-never reads or returns their values. Runtimes lists opaque runtimes required
-to execute this command, independently of the server target requirements, and
-Timeout ms defaults to 10000 with a maximum of 30000. Genesis does not execute
-the command, select identities, provide secrets, authenticate users, or control
-the browser. Those remain host responsibilities. The complete transport
-contract is defined in
-[`preview-identity-command.md`](preview-identity-command.md).
-
-`runtimeRequirements` contains opaque technology ids. A host explicitly maps
-the ids it supports to its own pinned runtime packs; for example, it may map
-`nodejs` to its Node 26 pack. Genesis never chooses versions, expands
-dependencies such as `composer`, or treats an unknown id as something similar.
-Declare each independently required runtime. Generic language pieces such as
-`nodejs` and `php` provide no Launch recipe. A concrete piece such as `jskit`
-may declare its app-owned `npm run develop` command; Genesis does not invent
-missing targets or supervise framework-specific subprocesses.
-
-`Deployment` is a separate optional readable production recipe. It must not be
-inferred from Launch because preview preparation and production publication have
-different safety, dependency, migration, artifact, and rollback concerns. Its
-complete form is:
+Genesis is the consumer of this section. `genesis verify` runs the declared
+commands directly without a shell after generic resource preflight and records
+the exact successful code, Stack, and command hashes. A project Verification
+section replaces component defaults.
 
-```markdown
-## Deployment
-
-- Workdir: `.`
-- Runtimes: `nodejs`
-- Recreate on restore: `node_modules`
-- Ready when: `GET` `/api/health` returns `200`
-- Prepare `Install production dependencies`: `npm` `install` `--omit=dev`
-- Build `Build`: `npm` `run` `build`
-- Migrate `Prepare database`: `npm` `run` `db:prepare`
-- Serve `Start`: `npm` `start`
-```
+## Opaque extensions
 
-Every command and argument is a separate backticked value returned as an argv
-array; shell source is rejected. Workdir is canonical and project-relative.
-Prepare, Build, and Migrate steps are optional and retain their declared order.
-There is exactly one final Serve step and one exact HTTP readiness predicate
-whose successful status is from 200 through 399. Runtime ids remain abstract.
-
-`Recreate on restore` lists project-relative paths that a host may remove when
-retaining an inactive release. Every listed path must be completely recreated
-by the Deployment Prepare steps, which a host runs after restoring the release
-and before Serve. Declaring these paths without a Prepare step is invalid.
-An entry without `/` matches that path segment at every depth, so
-`node_modules` covers root and nested workspace dependency trees. `*` stays
-within one segment and `**` may cross path separators. A matched directory
-includes its complete subtree.
-This is application and Stack knowledge: for example, JSKIT declares
-`node_modules`, while compiled output such as `dist` remains part of the
-artifact because Prepare does not rebuild it. Genesis normalizes the paths but
-does not remove, archive, restore, or reconstruct anything itself.
-
-A project `## Deployment` section replaces every component recipe as one unit,
-including with `- Nothing.`. Without a project section, exactly one selected
-component recipe may apply; several are blocked as ambiguous and never merged.
-Genesis returns the Stack's existing resource declarations with the recipe but
-does not check production values, provision services, execute commands, package
-artifacts, start processes, probe health, route traffic, manage TLS, or retain
-releases. Those are host responsibilities. This keeps the same project portable:
-Genesis alone explains the production requirements, while a host such as Vibe64
-Online can map `mysql` or `postgresql` to a pinned managed service.
-
-`Indexers` selects installed structural adapters for the derived Machine City.
-The shared ast-grep engine owns traversal, bounds, diagnostics, JSON, and
-queries; each adapter owns only language extensions, callable syntax, names,
-containers, signatures, and public/internal visibility. Several Stack pieces
-may contribute indexers, and duplicates are collapsed. Index output is
-navigation data, not proof that every dynamic callable or framework edge was
-discovered.
-
-`City regions` is an optional complete presentation contract for Machine City.
-Leading `Ignore` entries are canonical project-relative glob patterns using
-only `*` within a path segment and `**` across segments. Genesis excludes their
-matching files before it emits Machine City buildings or functions. This keeps
-test/spec source out of the product City without requiring a host-side filter.
-Each subsequent ordered `Match` entry declares one canonical project-relative
-`path/**` prefix, stable id, and human title. Exactly one final `Fallback` entry
-owns every remaining indexed path. Ignore patterns, ids, and prefixes must be
-unique, prefixes must not overlap, and no more than one selected component may
-declare the contract. Genesis resolves every indexed file and structural
-district to a region and a campus while generating
-`.genesis/machine-city.json`; a City renderer consumes those emitted facts and
-must not reclassify or filter paths. Under a matched prefix, the first directory
-is a campus, while files directly below the prefix belong to the prefix campus.
-Under the fallback, each top-level directory is a campus and project-root files
-belong to the project-root campus. The `genesis-stack` JSKIT piece excludes exact
-`test`, `tests`, and `__tests__` path segments plus `*.test.*` and `*.spec.*`
-files, then declares `Packages`, `Source`, and `Everything else`.
-
-Do not create a Genesis-owned generic skill merely because a component is
-named `nodejs`, `php`, or another common technology. Official, user, and host
-skills with those names must coexist normally. Use `## Skill` only for an
-authoritative directory this Stack component selects; put concise supplemental
-rules in `## Guidance`, existing-project import requirements in `## Adoption`,
-and cleanup-only additions in `## Deslop`.
-
-A selected component may have one project customization at
-`genesis/stack/<id>.md`:
+Any other `##` heading is consumer-owned data. Genesis validates only the
+section name and composition. It does not parse the body, infer its purpose,
+validate a private schema, map runtimes, execute commands, or prove success.
 
-```markdown
-# Stack customization: example
+Composition is intentionally small:
 
-## Add
+1. A project section replaces component declarations with the same name.
+2. Without a project section, one component declaration is returned unchanged.
+3. Competing component declarations produce `STACK_SECTION_AMBIGUOUS`; Genesis
+   never merges their bodies.
 
-### Description
+Call `inspectStackSection({ name, projectRoot })` or:
 
-Additional project context.
+```bash
+genesis inspect section 'Consumer operation' --json
+```
 
-### Guidance
+The result uses `genesis.stack-section.v1` and contains the exact lines,
+content, source, section hash, Stack hash, and generic composition diagnostics.
+The named consumer then owns all interpretation and action. This boundary works
+equally for web applications, libraries, command-line tools, native programs,
+firmware, desktop software, and future systems Genesis has never seen.
 
-- Additional implementation, explanation, review, and cleanup guidance.
+## Selection and identity
 
-### Adoption
+`genesis stack add` records selected packages and component dependency closure
+without discarding project declarations. Stack identity includes component ids,
+resources, environment declarations, Verification commands, City presentation,
+and every opaque extension body. Changing any executable or consumer-owned
+contract therefore stales prior Genesis verification evidence even though
+Genesis does not interpret the extension.
 
-- Additional existing-project import requirements.
+Prose and Agent Skill contents are instructions rather than verification
+evidence. Changes to Description, Guidance, Adoption, Deslop, or the installed
+Skill do not rewrite what an already-run command proved.
 
-### Deslop
+`City regions` and `Indexers` control only the derived structural maps. Indexers
+identify language adapters. City regions can exclude test/spec paths and group
+indexed files into deterministic regions and campuses. Both projections are
+navigation data, not proof of complete runtime behavior.
 
-- Additional cleanup guidance.
+## Project customization
 
-## Override
+A selected component may have one prose-only customization at
+`genesis/stack/<id>.md`:
 
-### Description
+```markdown
+# Stack customization: example
 
-Replacement component description.
+## Add
 
 ### Guidance
 
-- Replacement installed general guidance.
+- Additional project guidance.
 
-### Adoption
-
-- Replacement existing-project import requirements.
+## Override
 
 ### Deslop
 
 - Replacement cleanup guidance.
 ```
 
-Each field is optional. `Override` replaces only that installed field; `Add`
-then follows the installed or overridden value. These customization files
-cannot alter dependencies, conflicts, Agent Skill source, indexers, resources,
-environment defaults, environment files, commands, Workspace setup, or Launch declarations.
-`genesis stack add` preserves the files and composes their effective prose after
-dependency resolution.
-
-A project may select component ids in `genesis/stack.md`; replace component
-Resources and Environment defaults with complete application-owned contracts;
-replace component environment-file declarations; replace component Workspace
-setup defaults with one project recipe; replace component Verify defaults with
-its own `## Commands`; and replace every component Launch target with one
-project `## Launch` contract. With no corresponding project section, selected
-component declarations compose; conflicts are rejected rather than guessed.
-`genesis stack add` preserves every existing project-owned contract section.
-Adding another language, framework, database, or integration is therefore an
-isolated Stack/indexer contribution rather than a prompt or controller special
-case.
-
-Description, Guidance, Adoption, Agent Skill, and Deslop prose are instructions, not
-verification evidence. Changes to them do not stale an exact successful
-verification record; selected component ids, resources, environment files,
-environment defaults, Workspace setup, launch targets, and verification
-commands remain part of the Stack identity.
-
-Hosts inspect normalized environment requirements independently:
-
-```js
-import { inspectEnvironment } from 'genesis-compiler';
-
-const projectEnvironment = await inspectEnvironment({ environment, projectRoot });
-```
-
-The result has `status` (`ready`, `missing-inputs`, or `unconfigured`),
-`stackHash`, selected `components`, public non-secret `environmentDefaults`,
-declared `resources`, value-free `diagnostics`, and normalized `files`. Each default has
-`name`, `value`, and component `sources`; each file contains `format`, `path`,
-and `source`. Supplied environment values never cross this API boundary.
-
-Shell and non-Node hosts can inspect the same normalized contracts without
-importing the JavaScript API or parsing Markdown:
-
-```bash
-genesis inspect environment --json
-genesis inspect workspace --json
-genesis inspect launch --json
-genesis inspect deployment --json
-```
-
-These are projections of the same public inspectors. They do not create a
-second parser or take ownership of execution.
-
-Fresh-workspace hosts read setup from the package root:
-
-```js
-import { inspectWorkspaceSetup } from 'genesis-compiler';
-
-const setup = await inspectWorkspaceSetup({ projectRoot, environment });
-```
-
-The setup result has `status` (`ready`, `blocked`, or `unconfigured`),
-`stackHash`, an exact ready-recipe `recipeHash`, selected `components`, its `source`, distinct
-`runtimeRequirements`, normalized ordered `steps`, and `diagnostics`. Each step
-contains `label`, `argv`, `runtimeRequirements`, `workdir`, and an optional
-`readyWhen` project path. `blocked` means component recipes conflict, not that
-an unrelated Stack resource is absent. An absent `readyWhen` marker produces
-the unconfigured diagnostic `STACK_WORKSPACE_SETUP_WAITING`, never a failed or
-blocked result.
-The optional environment object is accepted for a consistent host inspection
-boundary, but Workspace setup v1 neither reads nor returns its values.
-
-Standalone users may execute the same normalized recipe with their own
-environment and installed toolchain:
-
-```bash
-genesis prepare
-```
+Customizations may add or override only Description, Guidance, Adoption, and
+Deslop. They cannot mutate selection, resources, environment declarations,
+Verification, Agent Skill ownership, indexers, or opaque consumer sections.
 
-`genesis prepare` runs each declared argv directly without a shell, in order,
-and stops at the first failure. It honors project-relative workdirs and
-conditional paths. It does not provision databases, compilers, credentials,
-runtimes, or other resources. Managed hosts remain free to consume
-`inspectWorkspaceSetup()` and enforce their own execution, identity, runtime,
-and permission policies.
+## Public inspection
 
-Preview hosts read the normalized Launch contract independently:
+Hosts may inspect Genesis-owned environment declarations separately:
 
 ```js
-import { inspectLaunch } from 'genesis-compiler';
+import { inspectEnvironment, inspectStackSection } from 'genesis-compiler';
 
-const launch = await inspectLaunch({ projectRoot, environment });
+const environment = await inspectEnvironment({ projectRoot });
+const operation = await inspectStackSection({
+  name: 'Consumer operation',
+  projectRoot,
+});
 ```
 
-The result has `status` (`ready`, `blocked`, or `unconfigured`), `stackHash`,
-selected `components`, public `environmentDefaults`, distinct
-`runtimeRequirements`, declared `resources`,
-normalized `targets`, and resource `diagnostics`. Each target reports its
-`source`, `available`, and `disabledReason`, plus its normalized
-`previewIdentity` declaration when present. Supplied environment values are
-inspected but never returned. Here, `available` means only that the Stack's declared
-resource inputs are present: the host must still reject runtime requirements it
-cannot map. `unconfigured` means there are no targets, `blocked` means declared
-resource inputs are missing, and `ready` means neither condition applies. The
-caller still owns exact runtimes, port allocation, process lifecycle, readiness
-and proxy policy, identity selection and command execution, secrets, browser
-binaries, Git, and credentials.
+`inspectEnvironment()` uses `genesis.environment.v1` and never returns supplied
+values. `inspectStackSection()` uses `genesis.stack-section.v1` and never
+interprets the section. There is no generic Genesis API that executes an opaque
+operation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.12",
+  "version": "1.2.13",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
   "repository": {
@@ -25,7 +25,6 @@
     ".agents/plugins/marketplace.json",
     "bin",
     "docs/assurance-model.md",
-    "docs/preview-identity-command.md",
     "docs/stack-components.md",
     "docs/prompt-integration.md",
     "prompts/blueprint.txt",

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

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