genesis-compiler 1.10.21 → 1.10.23

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`, ten 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`, `genesis-data-pass`, `genesis-security-pass`, `genesis-ux-pass` and `genesis-speed-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
@@ -256,7 +257,8 @@ 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 run's 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. |
@@ -641,8 +643,9 @@ pixels in light and dark are the evidence. See [docs/ui-pass.md](docs/ui-pass.md
 
 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, or over the changes since its last
-completed run judged against the whole app, and only those runs are recorded:
+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
@@ -685,11 +688,38 @@ 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 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`. A
+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

@@ -313,8 +313,19 @@ app. A host lists every pass, with its title, description, recommendation hint,
 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. A pass the project's own Genesis
-cannot run carries `unavailable` and no runs; see [Passes](passes.md).
+`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

@@ -143,7 +143,7 @@ Concise technology context.
 
 `Description`, `Guidance`, `Adoption`, `Post-change`, and each pass's section
 (`Deslop`, `UI pass`, `Identity pass`, `Quality pass`, `Data pass`,
-`Security pass`, `User experience pass`, `Speed pass`) are prose.
+`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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.10.21",
+  "version": "1.10.23",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {
@@ -39,6 +39,9 @@
     "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",
@@ -57,7 +60,8 @@
     "test": "node --test test/*.test.js"
   },
   "genesisContracts": {
-    "passRuns": "genesis.pass-runs.v1"
+    "passRuns": "genesis.pass-runs.v1",
+    "deepRuns": "genesis.deep-runs.v1"
   },
   "jskitRelease": {
     "versionFiles": [

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

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

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/skills/genesis-data-pass/SKILL.md

@@ -53,6 +53,10 @@ 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.
@@ -60,9 +64,11 @@ 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 or the changes since its last completed run judged against
-the whole app, and its scope is the one that section states, whatever the
-defaults below say.
+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.
@@ -80,10 +86,10 @@ Read the engineering approach's rules on query counts and realistic tests, and
 these sections of the sanity checks guide
 (`.agents/skills/genesis-project/references/sanity-checks.md`): "Never do
 these", "Data: one owner per table", "Data: one source for each fact", "Data:
-loading a dataset", "Data: each read asks for the rows it uses", "Data: saves,
-batches and background work" and "Inputs and access". They describe what good
-looks like; this pass applies them across the whole scope and fixes what they
-find.
+loading a dataset", "Data: each read asks for the rows it uses", "Data: batches
+and background work", "Data: two changes at once" and "Inputs and access". They
+describe what good looks like; this pass applies them across the whole scope
+and fixes what they find.
 
 Then list, for the scope: each table, collection or store with its one owner
 (`genesis/subsystems.md` records data ownership), who reads and writes it, its
@@ -169,3 +175,14 @@ 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.

package/skills/genesis-deslop/SKILL.md

@@ -55,6 +55,10 @@ to another agent and do not generate it again. This step composes the selected
 Stack's technology-specific Deslop 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,
+`Deslop the whole app deeply.`, exactly;
+Genesis then adds the run's `DEEP RUN` section.
+
 ## Resolve the cleanup scope
 
 Inspect `git status --short` and the staged and unstaged diffs before editing.
@@ -63,9 +67,11 @@ existing index and unrelated work. Do not stage, stash, commit, or discard
 changes as a prerequisite or as part of cleanup.
 
 When the prompt has a `PASS RUN` section, the request is one of the pass's own
-runs, the whole app or the changes since its last completed run judged against
-the whole app, and its scope is the one that section states, whatever the
-defaults below say.
+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.
 
 Resolve the user's scope as follows:
 
@@ -170,3 +176,19 @@ step only to the pass's own runs, whose requests it writes itself, so a Deslop
 of your own changes, a section or commits 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:
+
+- each file read in full for code harder to follow than it needs to be, parts
+  grown too big to hold in mind at once, and logic that does one job in
+  different words, each tick naming the behaviours checked before and after;
+- the cross-subsystem item: helpers and logic duplicated across subsystems,
+  including one job written in different words, and a pattern one subsystem
+  follows that another ignores.
+
+Deslop's limits hold in a deep run: behaviour stays as it is, and a defect
+found stays a follow-up finding, left unchanged.

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

@@ -52,6 +52,10 @@ as the instructions for this same turn; do not dispatch it to another agent and
 do not generate it again. This step composes the selected Stack's identity 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,
+`Give the whole app its visual identity 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.
@@ -59,9 +63,11 @@ 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 or the changes since its last completed run judged against
-the whole app, and its scope is the one that section states, whatever the
-defaults below say.
+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 screen or view a person sees, the shell,
   sign-in, the loading screen, the logo and the icons. An identity is
@@ -265,3 +271,14 @@ step only to the pass's own runs, whose requests it writes itself, so an
 identity 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 screen, every kind of content, each empty state, the loading screen,
+  sign-in, the logo and the icons;
+- the cross-subsystem item: colours, artwork or type defined outside the one
+  module and theme, and any screen the identity has not reached.

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

@@ -0,0 +1,132 @@
+---
+name: genesis-master-pass
+description: Run the project's passes deeply, one after another, through an explicitly requested Master pass over the whole app or the changes since its last completed run, every pass or the ones named, each as that pass's own Deep run, committed and tested before the next starts, with a ledger that lets an interrupted Master pass continue and one combined report. Use when asked for a Master pass, to run every pass, or to run several passes deeply in turn.
+---
+
+# Genesis Master pass
+
+Run the selected passes deeply, one after another, so the software comes out of
+each one committed and tested before the next starts. A Master pass is
+explicit: never run it merely because implementation finished.
+
+Resolve the invocation before running the first Genesis operation. Do not use a
+Genesis operation or `genesis --version` as an availability probe.
+
+1. Read the repository-root `package.json`. Treat Genesis as project-pinned only
+   when that manifest's `name` is `genesis-compiler`, or its `dependencies`,
+   `devDependencies`, or `optionalDependencies` contain the exact
+   `genesis-compiler` key.
+2. For a project-pinned repository, invoke every Genesis CLI operation with
+   `npm exec --no -- genesis <arguments>`. This runs without fetching another
+   package. If the declared package is not installed, report that the project's
+   dependencies are not prepared; do not fall back to another Genesis version.
+3. Otherwise, do not try `npm exec`. Run `command -v genesis` (or the current
+   shell's equivalent `PATH` lookup). When it resolves an executable, invoke
+   `genesis <arguments>` directly.
+4. When neither source is available, stop and report that Genesis is
+   unavailable. Never install or update Genesis merely to satisfy a workflow
+   instruction.
+
+Successful invocation resolution is routine. Do not narrate whether Genesis is
+project-pinned or on `PATH`, and never describe direct `PATH` use as a fallback.
+Mention how the invocation was selected only when resolution fails or the user
+explicitly asks.
+
+Follow the configured Collaboration approach for user-facing updates, including
+its technical depth and response length. Report concrete progress,
+findings, or blockers; do not announce that you are following guidance.
+
+## Load the effective project instructions once
+
+A Master pass request may arrive as a complete Genesis-generated prompt or as a
+direct request such as `Master pass` or `Master pass (security, data, deslop)
+the whole app.`
+
+If the current task already contains `GENESIS CONTEXT` whose task is
+`master-pass`, continue with it directly. Do not generate another prompt.
+
+Otherwise, run the Genesis `prompt --task master-pass` operation once using the
+invocation rule above. For a bare `Master pass`, pass no request argument: it
+runs every pass the project offers over the whole app. When the user names
+passes, pass `Master pass (<their names>) the whole app.` with the names
+separated by commas; a pass's id or title works, with or without "pass". When
+the user asks for the changes since the last completed Master pass, pass that
+run's request from `genesis inspect passes --json` exactly. Genesis refuses a
+name it offers no pass for and names the passes it does; tell the user. Treat
+the printed prompt as the instructions for this same turn and do not generate
+it again.
+
+## What the Master pass adds, and what it does not
+
+The prompt's `MASTER PASS` section lists the passes to run, in order, each with
+the exact request of its own Deep run. Run them in that order, whatever order
+they were named in: the review first, so every later pass starts from tested
+work, then security, so later passes build on the access it fixes, and Deslop
+last, so it cleans up after what the others changed. If you see a reason in
+this project for another order, say so in the report rather than changing it.
+
+Each pass runs as that pass's own Deep run, from its own prompt. Its `DEEP RUN`
+section says how the checklist, evidence, chunks, agents, commits and report
+work, and its skill says what its lens adds and what it may change. The Master
+pass never restates, shortens or loosens that guidance; it adds only the order,
+the checkpoint between passes, the ledger and the combined report.
+
+## Keep the Master ledger
+
+Before the first pass, write the Master ledger at the path the `MASTER PASS`
+section names. It lives in Git's own directory, outside the project's tracked
+files, so an interrupted Master pass finds it again. Record the request, the
+commit it starts from, and each listed pass with its status (to do, running,
+done or skipped), the path of its checklist (the one its `DEEP RUN` names), its
+commits and its checklist count. Update it as each pass starts and finishes.
+
+When a ledger for the same request is already there and not finished, continue
+from it: passes marked done stay done, and a pass marked running continues its
+own checklist from its first unticked item. Any other ledger is replaced.
+
+## Run each pass
+
+For each listed pass, in order:
+
+1. Mark it running in the ledger.
+2. Generate its prompt with the Genesis `prompt` operation and the exact
+   request listed for it, for example `prompt --task security-pass "Security
+   pass the whole app deeply."`, and follow that prompt in full as this pass's
+   instructions, through its own `PASS RECORD` step, which records the pass on
+   its own so its next run since its last completed one starts there.
+3. Where the host can run several agents, the pass gives its chunks to them as
+   its `DEEP RUN` says, as many as the host's test budget and limits allow, and
+   you coordinate them. The passes themselves run one after another, never at
+   the same time, because each one starts from the tree the last one committed.
+4. Checkpoint before the next pass starts: every change of this pass is
+   committed, in small commits of one checklist item or concern each with
+   messages that say what changed and why; nothing is left uncommitted; and the
+   pass's final whole-suite run passed on the committed tree. Record its
+   commits and checklist count in the ledger and mark it done.
+
+A pass that cannot finish, such as one whose failing checks it cannot fix,
+stops the Master pass there: report where it stopped and why, and do not start
+the next pass on a broken tree.
+
+Skip a pass that does not apply to this software, such as the UI or identity
+pass where the software has no screens, and write the reason in the ledger and
+the report. Never skip a pass because it is long or hard.
+
+## Record and report
+
+Once every listed pass is done or skipped, take the prompt's `PASS RECORD` step:
+the Genesis `passes done master-pass <pass id...>` operation, naming the passes
+it ran and leaving out those it skipped, records the Master pass in
+`genesis/passes-added.json`; commit that change as its last commit, so nothing is
+left uncommitted and its next run since the last one starts there.
+
+End with one combined report. Open with the passes run and skipped, and how the
+work was split across agents (or that it ran as one agent). Then, for each pass
+in order: its checklist count and how many ticks rest on each kind of evidence,
+what changed, its commits, its unticked items and the findings left unchanged.
+A pass that changes behaviour on purpose, such as the security, data or
+quality pass, states plainly what now behaves differently; a pass that keeps
+behaviour, such as Deslop, states that behaviour is unchanged and how that was
+proven. For a run since the last Master pass, say which files each pass read in
+full and which it only searched against the whole app. Close with the final
+whole-suite run on the committed tree.

package/skills/genesis-master-pass/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Genesis Master pass"
+  short_description: "Run every pass deeply, one after another, testing and committing after each"
+  default_prompt: "Use $genesis-master-pass to Master pass the whole app."