genesis-compiler 1.10.20 → 1.10.22

package/README.md

@@ -29,7 +29,8 @@ genesis/
   stack.md           selected components, resources, verification, and project-owned operation contracts
   stack/             optional per-component Description, Guidance, Adoption, Post-change, and pass customization
   subsystems.md      authored responsibilities, Program membership, and data ownership/use
-  passes.json        when each pass last finished, written by its last step (absent until one does)
+  passes.json        when each pass Genesis 1.10.21 knew last finished, written by its last step (absent until one does)
+  passes-added.json  the same for every pass added since, such as the review and the Master pass
   program/           concise public-operation explanations
 .agents/skills/
   genesis-*          Genesis workflow skills
@@ -188,11 +189,11 @@ type a command. It never runs adoption without approval and does nothing in an
 empty or already-adopted project.
 
 `genesis init` creates an empty Blueprint, a focused engineering approach, an
-empty optional Stack, the current `genesis/version`, seven project Agent Skills,
+empty optional Stack, the current `genesis/version`, twelve project Agent Skills,
 and project-local guidance adapters for Codex, Claude Code and OpenCode. The skills are ordinary
 [Agent Skills](https://agentskills.io): `genesis-project`, `genesis-program`,
 and one for each pass (`genesis-deslop`, `genesis-ui-pass`, `genesis-identity-pass`,
-`genesis-quality-pass` and `genesis-data-pass`), each with standard `SKILL.md` and
+`genesis-quality-pass`, `genesis-data-pass`, `genesis-security-pass`, `genesis-ux-pass`, `genesis-speed-pass` and `genesis-review`), and `genesis-master-pass`, which runs them deeply in turn, each with standard `SKILL.md` and
 `agents/openai.yaml` metadata. Open `/hooks` once in Codex to review and trust the guidance hook;
 Claude Code loads its project hooks and OpenCode discovers its local project plugin automatically. All three use the same
 Genesis-owned operating guide for new sessions and after compaction. When the
@@ -232,10 +233,11 @@ packages, initialize project files, migrate contracts, rebuild indexes, or run
 verification.
 
 Projects that declare `genesis-compiler` use the skills from that installed
-project dependency, including when a host embeds a different compiler. An
-unprepared declared dependency is reported instead of substituting the host's
-version. Other projects use the running compiler's packaged skills. Package
-upgrades remain explicit dependency changes.
+project dependency, including when a host embeds a different compiler: the
+skills that release has, so a project pinned to an older release simply does
+not get a skill added since. An unprepared declared dependency is reported
+instead of substituting the host's version. Other projects use the running
+compiler's packaged skills. Package upgrades remain explicit dependency changes.
 
 Inspection, context generation, and session hooks remain read-only and report
 skill maintenance diagnostics. An assistant that already loaded old skills
@@ -255,12 +257,13 @@ files alone does not refresh its existing context.
 | `genesis stack list` | Lists technology components from the installed Stack catalog. |
 | `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 passes done <pass>` | Records in `genesis/passes.json` that a pass finished now; every pass prompt ends with it. |
+| `genesis passes done <pass>` | Records that a pass finished now, in `genesis/passes.json` or, for a pass added since Genesis 1.10.21, `genesis/passes-added.json`; every pass run's prompt ends with it. |
+| `genesis passes done master-pass <pass...>` | Records that a Master pass finished now, with the passes it ran; its prompt ends with it. |
 | `genesis context <path...>` | Returns path-focused Program explanations, indexed functions, selected technology guidance, exact project contracts, and relevant skills. |
 | `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 passes` | Lists every pass with its title, description, recommendation hint, Stack guidance and last run. |
+| `genesis inspect passes` | Lists every pass with its title, description, recommendation hint, Stack guidance, last run, the runs it offers, and why the project's own Genesis cannot run it, if it cannot. |
 | `genesis inspect section <name>` | Returns one exact consumer-owned Stack section without interpreting or executing it. |
 | `genesis prompt [request...]` | Generates the ordinary implementation prompt. Use `--task` for opening, adoption, Deslop, explanation, review, and other explicit prompt tasks. |
 | `genesis verify` | Executes only the ordered finite commands in `## Verification` and records exact evidence. |
@@ -603,6 +606,10 @@ Stack component. Project additions or overrides from
 The main `genesis/stack.md` records component selection and durable project
 operations; it intentionally does not duplicate installed guidance bodies.
 
+`Deslop the whole app.` is the Deslop pass itself: the project's own source in
+every subsystem, recorded when it finishes (see [Passes](docs/passes.md)). A
+bare `Deslop` keeps to the agent's own changes and is never recorded.
+
 The whole dirty diff is not automatically the agent's work. Deslop preserves
 the user's and other agents' changes, including edits in the same files. With
 no changes of its own for the task, it reports that there is nothing to clean
@@ -632,21 +639,30 @@ prose of the selected Stack components, which names the technology's design
 rules and method. Defects become findings; screenshots at 390, 768 and 1280
 pixels in light and dark are the evidence. See [docs/ui-pass.md](docs/ui-pass.md).
 
-### Identity, quality and data passes
+### Identity, quality, data, security, user experience and speed passes
 
-Three more passes run only when asked, over the whole app unless the request
-names a section or your changes:
+Six more passes run only when asked, over the whole app unless the request
+names a section or your changes. Every pass, Deslop and the UI pass included,
+runs as a pass over the whole app, over the changes since its last completed
+run judged against the whole app, or deeply over the whole app, item by item,
+and only those runs are recorded:
 
 ```text
 Give the app its visual identity
 Quality pass
 Data pass the Orders section
+Security pass
+User experience pass the checkout
+Speed pass
 ```
 
 ```bash
 genesis prompt --task identity-pass
 genesis prompt --task quality-pass
 genesis prompt --task data-pass "Data pass the Orders section"
+genesis prompt --task security-pass
+genesis prompt --task ux-pass "User experience pass the checkout"
+genesis prompt --task speed-pass
 genesis inspect passes --json
 ```
 
@@ -655,12 +671,54 @@ drawn in code for each kind of content, a logo, empty states, a loading screen
 and sign-in. The quality pass makes loading, empty, error and refused states,
 edge cases and accessibility hold up, proved by using the software. The data
 pass makes queries, constraints, migrations and indexes hold up at real sizes,
-proved by counts. Each skill holds the portable method and points at the
+proved by counts. The security pass makes every way in refuse what it should
+(access decided from the trusted context, guarded sign-in and sessions, inputs
+checked at the boundary, secrets kept out of code and logs, production
+settings, dependencies and outbound requests), proving each finding by sending
+the input that breaks it and keeping a test that fails without the fix. The
+user experience pass makes the main things people do short and clear (fewer
+steps and decisions, easy to find, plain words, a quick first use, Undo where
+it can be undone), walking each main task before and after and counting the
+steps. The speed pass makes tests, screens and requests take the
+time their work needs (tests prepared once and run in parallel, screens that
+load only what they need, requests batched and work done once), measuring each
+wait before and after and never raising a limit, adding retries or shrinking
+data or coverage to get there. Each skill holds the portable method and points at the
 sanity checks guide; selected Stack components add where each piece lives in
 their technology. `genesis inspect passes` lists every pass, Deslop and the UI
-pass included, for a host to offer, with when each last finished: a pass's last
-step, `genesis passes done <pass>`, records that in the committed
-`genesis/passes.json`. See [docs/passes.md](docs/passes.md).
+pass included, for a host to offer, with when each last finished and the runs
+it offers, each with the request to send: a pass run's last step, `genesis
+passes done <pass>`, records that in the committed `genesis/passes.json` (for a
+pass added since Genesis 1.10.21, `genesis/passes-added.json`). A
+project pinned to an older `genesis-compiler` gets only the passes its own
+release runs; the others say which update adds them. See
+[docs/passes.md](docs/passes.md).
+
+A deep run, such as `Security pass the whole app deeply.`, first writes a
+checklist of every file of the project's own source plus what the pass's lens
+adds (every way in for the security pass, every screen for the UI pass), then
+ticks each item only with evidence a reader can check: a named test in the
+final whole-suite run, a kept measurement or output, a commit, or a command and
+the refusal it saw. It splits the work by subsystem across several agents where
+the host can run them, commits its own work in small steps, and opens its report
+with the count of items ticked. `genesis inspect passes` shows its size, the
+files and lines its checklist starts from. Every pass report, deep or not, says
+what it read in full and what it only searched.
+
+A Master pass runs every pass deeply, one after another, or only the passes
+named, such as `Master pass (security, data, deslop) the whole app.`, always in
+one order: review, security, data, quality, speed, user experience, visual
+identity, UI and Deslop. Each pass is its own Deep run from its own prompt, and is committed
+with the whole test suite passing before the next starts; a ledger lets an
+interrupted Master pass continue, and one combined report covers every pass.
+Once a Master pass is committed, it also runs over the changes since it: each
+pass checks every changed file, the code those changes call or replace, and the
+whole app for what they duplicate or leave dead.
+
+```bash
+genesis prompt --task master-pass
+genesis prompt --task master-pass "Master pass (security, data, deslop) the whole app."
+```
 
 Projects can customize a selected technology through its matching file, such
 as `genesis/stack/jskit.md`:

package/docs/prompt-integration.md

@@ -307,11 +307,25 @@ generates the canonical `ui-pass` prompt once, like Deslop's. A host offers it
 only when `inspectPromptTasks()` reports Stack guidance for `ui-pass`; see
 [UI pass](ui-pass.md).
 
-The identity, quality and data passes are explicit prompt tasks of the same
-family, whose default scope is the whole app. A host lists every pass, with its
-title, description, recommendation hint and last run, through `inspectPasses()`
-or `genesis inspect passes --json`, instead of naming them itself; see
-[Passes](passes.md).
+The identity, quality, data, security, user experience and speed passes are
+explicit prompt tasks of the same family, whose default scope is the whole
+app. A host lists every pass, with its title, description, recommendation hint, last run
+and the runs it offers, through `inspectPasses()` or `genesis inspect passes
+--json`, instead of naming them itself, and sends a run's `request` as written:
+Genesis recognises its own run requests, adds the run's `PASS RUN` scope and
+`PASS RECORD` step, and records nothing else. Every pass prompt, whatever its
+request, carries the `PASS REPORT` section, so its report states what it read
+in full and what it only searched, with its coverage in numbers, and calls a
+run whole only when it covered all of its scope. A deep run's prompt also
+carries the shared `DEEP RUN` section. A pass the project's own Genesis
+cannot run carries `unavailable` and no runs. Each pass's `sinceBase` gives the
+request, and its deep form, of a run over the changes since a base commit the
+host chooses (`{base}` stands for it), such as where a piece of work started;
+Genesis scopes that run to the base and never records it. The listing's `master` entry is
+the Master pass: a host sends its run's `request` for every pass, or its
+`selectedRequest` with the chosen pass titles in place of `{passes}`, and the
+`master-pass` prompt lists each pass's own Deep run request in its `MASTER PASS`
+section; see [Passes](passes.md).
 
 Once Codex identifies relevant source, `genesis context <path...>` returns only
 Program modules citing those paths plus the effective engineering approach,

package/docs/stack-components.md

@@ -115,6 +115,22 @@ Concise technology context.
 - The data owner layer, query counter, migration mechanics and database
   differences of this technology.
 
+## Security pass
+
+- Where this technology decides access, scopes rows, limits repeated
+  requests, keeps sessions and secrets, and switches to production.
+
+## User experience pass
+
+- Where this technology decides navigation, the next action, defaults, where a
+  save lands, what can be undone and the words people read.
+
+## Speed pass
+
+- How this technology runs tests in parallel and prepares them once, splits
+  client code, batches requests and times its server, usually a pointer to its
+  own guidance.
+
 ## Consumer operation
 
 ```json example.consumer-operation.v1
@@ -126,7 +142,8 @@ Concise technology context.
 ````
 
 `Description`, `Guidance`, `Adoption`, `Post-change`, and each pass's section
-(`Deslop`, `UI pass`, `Identity pass`, `Quality pass`, `Data pass`) are prose.
+(`Deslop`, `UI pass`, `Identity pass`, `Quality pass`, `Data pass`,
+`Security pass`, `User experience pass`, `Speed pass`, `Review`) are prose.
 `Requires` and `Conflicts` define component selection. `Skill` names one
 complete authoritative Agent Skill directory. `Indexers` selects installed
 structural adapters.
@@ -276,10 +293,10 @@ A selected component may have one prose-only customization at
 ```
 
 Customizations may add or override only Description, Guidance, Adoption,
-Post-change, and the pass sections (Deslop, UI pass, Identity pass, Quality pass
-and Data pass). They cannot mutate selection, resources, environment
-declarations, Verification, Agent Skill ownership, indexers, or opaque consumer
-sections.
+Post-change, and the pass sections (Deslop, UI pass, Identity pass, Quality
+pass, Data pass, Security pass, User experience pass and Speed pass). They cannot mutate selection, resources,
+environment declarations, Verification, Agent Skill ownership, indexers, or
+opaque consumer sections.
 
 ## Public inspection
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.10.20",
+  "version": "1.10.22",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {
@@ -36,6 +36,12 @@
     "prompts/identity-pass.txt",
     "prompts/quality-pass.txt",
     "prompts/data-pass.txt",
+    "prompts/security-pass.txt",
+    "prompts/ux-pass.txt",
+    "prompts/speed-pass.txt",
+    "prompts/master-pass.txt",
+    "prompts/pass-report.txt",
+    "prompts/pass-deep.txt",
     "prompts/program.txt",
     "prompts/review.txt",
     "prompts/start.txt",
@@ -53,6 +59,10 @@
   "scripts": {
     "test": "node --test test/*.test.js"
   },
+  "genesisContracts": {
+    "passRuns": "genesis.pass-runs.v1",
+    "deepRuns": "genesis.deep-runs.v1"
+  },
   "jskitRelease": {
     "versionFiles": [
       "plugins/genesis/.codex-plugin/plugin.json"

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

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

package/prompts/deslop.txt

@@ -6,6 +6,9 @@ This is an explicitly requested behavior-preserving cleanup. With no stated
 scope, select your own changes for the current task across preceding turns,
 committed or uncommitted. An explicit commit, first-parent count, or range in
 USER REQUEST takes precedence regardless of who authored those changes.
+Deslop's own pass request, "Deslop the whole app.", selects the whole app: the
+project's own source in every subsystem, never generated, vendored or
+dependency files.
 Establish ownership from task and edit history; the entire dirty diff is not
 automatically yours. If ownership is unclear, ask for scope. A dirty worktree
 is allowed: preserve unrelated edits and existing staging, and leave the

package/prompts/master-pass.txt

@@ -0,0 +1,17 @@
+This Master pass task has already been rendered by Genesis. Do not generate
+another Master pass prompt. Read and follow
+`.agents/skills/genesis-master-pass/SKILL.md` completely.
+
+This is an explicitly requested Master pass. It runs the passes listed under
+MASTER PASS deeply, one after another in that order, each as that pass's own
+Deep run from its own prompt. The Master pass adds only the order, the
+checkpoint between passes, the ledger that lets an interrupted Master pass
+continue, and one combined report; each pass's Deep run says how that pass
+works, and each pass keeps its own limits on what it may change. Preserve
+unrelated edits and existing staging: each pass commits only its own work.
+
+Report, for each pass in order, its checklist count, what changed (what now
+behaves differently, or, for a pass that keeps behaviour, that behaviour is
+unchanged and how that was proven), its commits and the findings left
+unchanged; then the passes skipped and why, how the work was split across
+agents, and the final whole-suite run.

package/prompts/pass-deep.txt

@@ -0,0 +1,77 @@
+A deep run works through every item in its scope and ticks each one only with
+evidence a reader can check, because a search finds only what it looks for and
+a report can be trusted only item by item.
+
+Checklist first
+
+- Before changing anything, write the checklist to the file named above, which
+  lives outside the project's tracked files and survives an interrupted run.
+  Start it with this run's request and the commit it starts from.
+- Its items are every file of the project's own source in the scope that
+  PASS RUN states, each read in full, line by line, plus what this pass's skill
+  adds under "Deep run" for its lens.
+- When PASS RUN starts the run from the changes since a commit, its items are
+  instead: every changed or added file; every file those changes call, are
+  called by or replace; the lens's items those changes touch; and, for each
+  change, a cross-check against the whole app for what elsewhere already does
+  what it adds and for older code it should have reused or now leaves dead.
+  That cross-check is how the run is judged against the whole app: a change
+  can duplicate, contradict or bypass code it never touches, so it needs
+  evidence like any other item. The report says plainly which files were read
+  in full and which were only searched against the whole app.
+- A checklist already in that file for the same request that is not finished
+  is continued from its first unticked item rather than started again; any
+  other is replaced.
+
+Ticks need evidence a reader can check
+
+- Tick an item only when it says what was read and checked and points to
+  evidence someone else can verify: a test, by its file and name, that exists
+  and runs in the final whole-suite run; a measurement or output file the run
+  kept; a commit; or the command run and the refusal it saw.
+- Prose alone, such as "checked, looks fine", never ticks an item the pass asks
+  to prove.
+- An item not done stays unticked, with its reason. Never tick an item to
+  finish the run.
+
+Chunks and several agents
+
+- Work in chunks that follow the subsystem map (`genesis/subsystems.md` where
+  the project has one, otherwise its top-level source folders), the biggest
+  files first, because they hide the most.
+- Where your host can run several agents (subagents or parallel workers), give
+  each chunk to its own agent, as many at once as the host's test budget and
+  limits allow, with the checklist as their shared record: one chunk at a time
+  takes far longer than the work needs. Coordinate them yourself, and do the
+  cross-subsystem pass and the final whole-suite run yourself, because only
+  the coordinator sees every chunk.
+- A host that runs one agent works through the chunks in turn and still
+  completes the whole checklist.
+- After the chunks, make one cross-subsystem pass for what no chunk alone can
+  see, as the skill's "Deep run" names it for this pass. It is an item with
+  evidence like any other.
+
+Changes and commits
+
+- The engineering approach's refactor rule, and the "Refactors keep behavior"
+  section of the sanity checks guide, apply to every change. The pass keeps its
+  own limits on what it may change.
+- Commit your own work as you go, in small commits of one checklist item or
+  concern each, every message saying what changed and why, so each step can be
+  reviewed and undone on its own. Stage only this run's changes, never other
+  people's edits.
+- Nothing of this run stays uncommitted at the end; this replaces the skill's
+  instruction to leave the pass as uncommitted work.
+- End with one whole-suite run on the final committed tree.
+
+Report
+
+- Open with the checklist count, for example "212 of 212 items ticked with
+  evidence", then how many ticks rest on each kind of evidence: tests, kept
+  measurements or output, commits, and commands with the refusals they saw.
+- List every unticked item with its reason, and every commit of the run.
+- Say how the run was done: with several agents (how many, over which chunks),
+  or as one agent working through the chunks in turn.
+- A pass whose contract keeps behaviour, such as Deslop, states that behaviour
+  is unchanged and how that was proven; any other pass states plainly what now
+  behaves differently.

package/prompts/pass-report.txt

@@ -0,0 +1,15 @@
+A pass report is how the person learns what was checked, so it never claims
+more coverage than the run had.
+
+- State the method: which parts of the scope you read in full, line by line,
+  and which you only searched or sampled, naming what each search looked for.
+  A search finds only what it was told to look for; code harder to follow than
+  it needs to be, parts grown too big, and logic that does one job in
+  different words show only when the code is read.
+- State the coverage in numbers of the items the pass works through (files,
+  screens, tasks, ways in, waits), for example "41 of 107 files read in full;
+  the rest searched for repeated helpers, unused exports and direct storage
+  calls".
+- Call the run "whole app", "complete" or "full" only when every item in its
+  scope was covered. Otherwise call it partial and name what was not covered
+  and why, so the next run can start there.

package/prompts/review.txt

@@ -47,7 +47,8 @@ Judge each against the matching section and outer limit of
 `.agents/skills/genesis-project/references/sanity-checks.md`.
 
 Edit only tests: add or update the tests the changed behavior lacks, and change
-no product code, Blueprint, Program, Stack or other file. Return a concise
+no product code, Blueprint, Program, Stack or other file; the record step that
+ends this prompt, when there is one, is the only other write. Return a concise
 report ordered by impact with exact file references, the evidence inspected,
 the tests run and written, and the smallest sensible correction.
 

package/prompts/security-pass.txt

@@ -0,0 +1,26 @@
+This security pass task has already been rendered by Genesis. Do not generate
+another security pass prompt. Read and follow
+`.agents/skills/genesis-security-pass/SKILL.md` completely.
+
+This is an explicitly requested security pass. With no stated scope it covers
+the whole app. A named section, your own changes, or an explicit commit,
+first-parent count, or range in USER REQUEST narrows it. Establish ownership of
+your own changes from task and edit history; the entire dirty diff is not
+automatically yours. A dirty worktree is allowed: preserve unrelated edits and
+existing staging, and leave the pass as ordinary uncommitted work for review.
+
+Apply the selected Stack security pass guidance and applicable technology
+skills in addition to the Genesis security pass contract. Stack guidance names
+where its technology decides access, scopes rows, limits repeated requests,
+keeps sessions and secrets, and switches to production; it cannot broaden the
+resolved scope or change who the product allows to do what. Try attacks only
+against local or test copies the run controls, never a production deployment,
+a real person's account or another party's service. Never weaken a protection
+to make something pass.
+
+Report the resolved scope, the map of entry points, each finding with the
+input that broke it and the refusal seen after the fix, the test guarding each
+fix and its failing run without the fix, the protections tried that already
+held, the areas that do not apply and why, the dependency audit, files
+changed, checks actually run, and everything left unfixed with what it needs
+and who must act.

package/prompts/speed-pass.txt

@@ -0,0 +1,28 @@
+This speed pass task has already been rendered by Genesis. Do not generate
+another speed pass prompt. Read and follow
+`.agents/skills/genesis-speed-pass/SKILL.md` completely.
+
+This is an explicitly requested speed pass. With no stated scope it covers the
+whole app. A named section, your own changes, or an explicit commit,
+first-parent count, or range in USER REQUEST narrows it. Establish ownership of
+your own changes from task and edit history; the entire dirty diff is not
+automatically yours. A dirty worktree is allowed: preserve unrelated edits and
+existing staging, and leave the pass as ordinary uncommitted work for review.
+
+Apply the selected Stack speed pass guidance and applicable technology skills
+in addition to the Genesis speed pass contract. Stack guidance names its test
+runner and the machine's test budget, how its build splits client code, its
+request patterns and how to time its server; it cannot broaden the resolved
+scope or change what the software does. Measure each wait before changing
+anything, on a realistic build at realistic sizes, using test databases and
+copies the run controls, never a development or production database or a
+production deployment. Never raise a time limit, add retries, or shrink
+realistic data or coverage to get faster. Query counts, narrowing and indexes
+belong to the data pass; hand those paths to it.
+
+Report the resolved scope, each wait with how it was measured and its numbers
+before and after, each cause found and its fix, the whole test suite's wall
+time before and after with its phases and slowest files, the tests guarding
+each fix, the paths handed to the data pass, the areas that do not apply and
+why, files changed, checks actually run, and everything left unfixed with what
+it needs and who must act.

package/prompts/ui-pass.txt

@@ -6,7 +6,9 @@ This is an explicitly requested behavior-preserving UI pass. With no stated
 scope, select your own changes for the current task across preceding turns,
 committed or uncommitted. An explicit commit, first-parent count, or range in
 USER REQUEST takes precedence regardless of who authored those changes. A named
-section or "the whole app" in USER REQUEST selects that scope instead.
+section or "the whole app" in USER REQUEST selects that scope instead. The
+whole app is the project's own screens in every section, never generated,
+vendored or dependency files.
 Establish ownership from task and edit history; the entire dirty diff is not
 automatically yours. If ownership is unclear, ask for scope. A dirty worktree
 is allowed: preserve unrelated edits and existing staging, and leave the pass

package/prompts/ux-pass.txt

@@ -0,0 +1,25 @@
+This user experience pass task has already been rendered by Genesis. Do not
+generate another user experience pass prompt. Read and follow
+`.agents/skills/genesis-ux-pass/SKILL.md` completely.
+
+This is an explicitly requested user experience pass. With no stated scope it
+covers the whole app. A named section, your own changes, or an explicit commit,
+first-parent count, or range in USER REQUEST narrows it. Establish ownership of
+your own changes from task and edit history; the entire dirty diff is not
+automatically yours. A dirty worktree is allowed: preserve unrelated edits and
+existing staging, and leave the pass as ordinary uncommitted work for review.
+
+Apply the selected Stack user experience pass guidance and applicable
+technology skills in addition to the Genesis user experience pass contract.
+Stack guidance names where its technology decides navigation, the next action,
+defaults, where a save lands, what can be undone and the words people read; it
+cannot broaden the resolved scope or change what the product does. Walk each
+main task through the real interface before changing it and again after.
+Never remove a permission, a validation or the confirmation of an irreversible
+action to save a step.
+
+Report the resolved scope, the main tasks with who does them, each task's
+steps and decisions before and after, what changed and why, the test locking
+in each changed path and its failing run against the old path, the
+screenshots or transcripts taken, files changed, checks actually run, and
+findings left unchanged with what they need and who must decide.

package/skills/genesis-data-pass/SKILL.md

@@ -53,12 +53,23 @@ another agent and do not generate it again. This step composes the selected
 Stack's data pass guidance and any project customization with the portable
 contract below.
 
+When the user asks for a deep run of this pass, pass its Deep request,
+`Data pass the whole app deeply.`, exactly;
+Genesis then adds the run's `DEEP RUN` section.
+
 ## Resolve the scope
 
 Inspect `git status --short` and the staged and unstaged diffs before editing.
 A dirty worktree is allowed. Preserve the existing index and unrelated work; do
 not stage, stash, commit, or discard changes as a prerequisite.
 
+When the prompt has a `PASS RUN` section, the request is one of the pass's own
+runs (the whole app, the changes since its last completed run judged against
+the whole app, or a deep run) or a run over the changes since a base commit the
+request names, and its scope is the one that section states, whatever the
+defaults below say. A deep run's prompt also has a `DEEP RUN`
+section; follow it with "Deep run" below.
+
 - **The whole app (default).** Every table, collection or store, and every
   path that reads or writes them.
 - **A section.** A named area (a module, a subsystem, a set of tables): its
@@ -157,7 +168,21 @@ lock and time notes, the indexes with the query each serves and the plan that
 uses it, the tests added, files changed, checks actually run, and follow-up
 findings left unchanged.
 
-Once the pass has finished, end with the prompt's `PASS RECORD` step: the
-Genesis `passes done data-pass` operation records it in `genesis/passes.json`, an
-uncommitted change that lands in the pass's own commit. A pass that stopped
-early, was abandoned or still has failing checks is not recorded.
+When the prompt ends with a `PASS RECORD` step, take it once the pass has
+finished: the Genesis `passes done data-pass` operation records it in `genesis/passes.json`,
+an uncommitted change that lands in the pass's own commit. Genesis adds that
+step only to the pass's own runs, whose requests it writes itself, so a data
+pass of a section, commits or your own changes is never recorded as the pass;
+neither is a pass that stopped early, was abandoned or still has failing
+checks.
+
+## Deep run
+
+When the prompt has a `DEEP RUN` section, follow it: it says how the checklist,
+evidence, chunks, commits and report work for every pass. This pass adds to the
+checklist:
+
+- every store or table, every query path with its counts at a few rows and at
+  a realistic size, and every migration, constraint and index;
+- the cross-subsystem item: a store read or written by more than one owner,
+  and the same query written in several places.