create-egregore 0.19.8 → 0.19.12

package/runtime/pi/.codex/skills/activity/SKILL.md

@@ -15,15 +15,27 @@ remain enough to render a useful answer.
 
 1. Verify `bin/agent.sh` exists. If it does not, say this is not an Egregore
    checkout.
-2. Run `bin/agent.sh sync`.
-3. Resolve the requested handle:
+2. If the request is `activity done N`, `activity expire N`, or
+   `activity reopen N`, fetch `bin/activity-data.sh` to a temporary JSON file,
+   map `N` to the corresponding `handoffs_to_me[N-1].sessionId`, and run:
+
+```bash
+bash bin/activity-action.sh <done|expire|reopen> "<session-id>"
+```
+
+Report the resulting topic and state. Never accept a raw session ID from the
+visible command when a numbered activity item is available; the number keeps
+the mutation tied to what the user just saw. In local mode, preserve the
+script's explicit unavailable result.
+3. Run `bin/agent.sh sync`.
+4. Resolve the requested handle:
    - If the user named a person, match it against `memory/people/*.md`.
    - Otherwise use `.egregore-state.json` `github_username`, then git user
      fallback.
-4. Run `bash bin/activity-data.sh [handle]` with network escalation and capture
+5. Run `bash bin/activity-data.sh [handle]` with network escalation and capture
    stdout as JSON. This command performs the graph API call internally; a
    normal sandboxed Codex shell can make a healthy graph look unreachable.
-5. Classify the graph status:
+6. Classify the graph status:
 
 ```bash
 node bin/codex-skill-render.mjs classify-graph --mode connected
@@ -37,7 +49,7 @@ say Codex graph network access was not granted; do not claim the graph itself
 was unreachable. Do not retry for `missing_config`, `auth_error`, or
 `server_error`; render the clear reason instead.
 
-6. Render the card with:
+7. Render the card with:
 
 ```bash
 node bin/codex-skill-render.mjs activity-card <json-file>
@@ -47,7 +59,7 @@ Paste the rendered card exactly in the visible response, preferably in a
 `text` fenced block. Do not paraphrase the card into bullets unless the user
 asks for a summary.
 
-7. Offer one compact focus prompt:
+8. Offer one compact focus prompt:
    - `Handoffs` - open pending handoffs.
    - `Questions` - answer or inspect pending questions.
    - `Recent work` - inspect sessions and wraps.

package/runtime/pi/.codex/skills/deep-reflect/SKILL.md

@@ -1,74 +1,109 @@
 ---
 name: deep-reflect
-description: Cross-reference an insight against the Egregore knowledge base using Codex-native staged analysis when the user invokes /deep-reflect or $deep-reflect.
+description: Deep research over the Egregore org memory — multi-hop, evidence-verified synthesis of what the org collectively knows — when the user invokes /deep-reflect or $deep-reflect.
 ---
 
-# Egregore Deep Reflect
+# Egregore Deep Reflect (v4)
 
-Native Codex Egregore skill. Use this for evidence-based analysis of how a new
-insight relates to the existing knowledge base.
+Native Codex Egregore skill. Ask the org's memory a question and return a
+verified, cited synthesis of what it collectively knows — including what it
+doesn't. `/reflect` captures user thought; `/deep-reflect` researches what the
+org already knows.
 
-## Modes
+Full contracts live in `.claude/skills/deep-reflect/` (`SKILL.md` entry,
+`RESEARCH.md` engine, `ROLES.md` agent roles, `REPORT.md` output). Follow them;
+this file is the Codex-runtime adapter.
 
-- empty request: deep mode.
-- `focused ...`: focused topic mode.
-- `quick ...` or `category: content`: quick mode.
+## Modes
 
-Detect directed questions when the user asks how, why, what something means, or
-about a relationship. Preserve the user's lens while still surfacing important
-signals outside the lens.
+- Question (default): interrogative or bare-topic arguments → "what does the
+  org know about X?"
+- Cross-ref: "cross-reference this" / a declarative insight → "how does this
+  insight sit against existing memory?"
+- Depth: `--brief` (1 hop wave), standard (≤3), `--deep` (≤5). Default is
+  dynamic from the corpus probe.
 
 ## Flow
 
-1. Check `egregore.json` mode first. In local mode, do a lightweight reflection
-   from memory files and do not call graph, batch graph, or notification
-   scripts.
-2. In all modes, run `bin/agent.sh search "$TOPIC" -n 6` — hybrid content
-   recall over the whole memory repo. Feed strong hits into the candidate
-   set; in local mode this is the primary context source.
-3. In connected mode, additionally gather graph context with `bin/graph.sh`
-   and suppress raw JSON. Query recent sessions, active quests, recent
-   artifacts, decisions, the topic landscape, and the full artifact
-   landscape.
-4. If the graph is unavailable or has fewer than about ten artifacts, fall back
-   to lightweight reflection and say why in one line.
-5. Select candidate artifacts. Prefer title, type, topics, quest, author, and
-   date metadata first; fetch file contents only for the selected subset.
-6. Use Codex multi-agent or subagent tooling only if it is available in the
-   current session. If not, run a single-model staged analysis:
-   - candidate selection summary
-   - evidence extraction summary
-   - signal analysis
-   - final synthesis
-7. Classify signals as tension, convergence, gap, dependency, phase shift,
-   redundancy, emergence, reinforcement, or a named custom type.
-8. Write a markdown artifact under `memory/knowledge/deep-reflect/` with
-   frontmatter for run id, mode, lens, author, created time, and selected
-   evidence paths.
-9. In connected mode, write best-effort graph edges with `bin/graph.sh` or
-   `bin/graph-batch.sh`. Use `TENSION_WITH` for conflict signals and
-   `RELATES_TO` for other signals.
-10. Save memory and repo changes with `bin/agent.sh save --message "Deep reflect: $TOPIC" --topic "$TOPIC"`.
+1. Check `egregore.json` mode FIRST. Local mode: full engine over files; never
+   call graph, batch-graph, or notification scripts; zero graph vocabulary in
+   output. Connected: graph adds hop rails and writeback, every graph call
+   non-fatal (`2>/dev/null || true`).
+2. FRAME: corpus probe — 2× `bin/agent.sh search "$TOPIC" --fast -n 20` with
+   different wordings + `bin/artifacts.sh find "$TOPIC"` +
+   `grep -ril "$TOPIC" memory/knowledge/ memory/handoffs/ memory/artifacts/`.
+   N = the union of unique paths; set the wave budget from N per
+   `RESEARCH.md` §Budget; decompose the question into 2-4 sub-questions;
+   print a plan line (`Researching: … · ~N relevant docs · budget M waves ·
+   est ~X min`). Under ~5 relevant docs: say memory is too thin and offer
+   `/reflect` or `/harvest` instead of faking research. If search errors or
+   returns nothing while grep hits, rely on grep and note "recall degraded".
+3. SEED: check `memory/knowledge/research/` for prior runs on the topic —
+   their cited artifacts (frontmatter `artifacts_cited`, older reports use
+   `artifacts_consulted`; resolve filename stems with `find`) are pre-warmed
+   leads, and their `null_regions` gaps get re-audited. Build a frontier of
+   ≤12 docs from search probes, frontmatter topic/quest greps, and index
+   ledgers.
+4. HOP WAVES: the Codex runtime has no Workflow tool — run the foreground
+   staged path from `ROLES.md`: per wave, read 8-12 docs (subagents if the
+   session offers them, otherwise staged single-model passes), extract
+   claims-with-verbatim-excerpts and typed leads (doc links, quests, people,
+   sessions, topic terms, named absences). Dedup against the seen-set, score
+   leads, hop until saturation per `RESEARCH.md` (coverage on every
+   sub-question plus low novelty or zero yield; or budget).
+5. PATTERN: two de-correlated passes. Without subagents true blindness is
+   impossible — degrade deliberately: run the TENSION pass FIRST (grouped by
+   topic), then the convergence pass (chronological), so tension-finding is
+   never anchored by an existing convergence story. Disagreement between
+   passes is a finding, never averaged away.
+6. VERIFY: for every claim, whitespace-normalize the excerpt and re-find it in
+   the cited file (miss = miscite = kill; supported paraphrase = correct the
+   excerpt). The mechanical re-check survives self-verification — it is a
+   grep, not a judgment. Re-attack every gap claim with one extra probe; a
+   found doc refutes the gap and joins the ledger. Evidence older than ~90
+   days gets one `--fast` newer-artifact probe. Report the kill count. When
+   the verifying context is the same one that made the claims, mark the
+   report's provenance `verification: self-checked`.
+7. SYNTHESIZE + PRESENT: stance, not summary — answer first, then ◆ primary /
+   ◇ secondary findings with `memory/...` path citations, tensions, and "what
+   memory doesn't hold" (gaps + the probes that prove them). Confidence is
+   derived from evidence structure (verified + ≥3 independent sources = high;
+   single-source always labeled). Register: analyst, not critic.
+8. CAPTURE (user-gated): Save (default) / Edit first / File follow-ups /
+   Skip. On Save write `memory/knowledge/research/YYYY-MM-DD-author-slug.md`
+   with frontmatter (question, mode, stop_reason, waves, docs_read,
+   claims_killed, builds_on, artifacts_consulted, artifacts_cited,
+   null_regions), then connected-mode best-effort graph writes per the main
+   `REPORT.md` §Writeback (MERGE with filePath — do NOT use
+   `graph-op.sh register-artifact`; `RELATES_TO`/`TENSION_WITH` for verified
+   cross-ref claims only), then
+   `bin/agent.sh save --message "Deep research: $TOPIC" --topic "$TOPIC"`.
+   On Skip: nothing is written except the local run ledger under
+   `.egregore/research-runs/`. Render the TUI box AFTER the gate, reflecting
+   the actual outcome.
 
 ## Output
 
-Lead with the strongest finding, then list primary signals, evidence paths, and
-recommended next action. Keep secondary and ambient signals short.
-
-Structured UX parity is required. Then render the Egregore deep-reflect
-confirmation TUI:
+Render the Egregore deep-reflect confirmation TUI after the capture gate:
 
-- Use a 72-column outer box with standard top/separator/content/bottom lines.
-- Header: `DEEP REFLECT`, author, and date.
-- Body: lens/topic, strongest finding, signal counts by type, selected evidence
-  count, artifact path, and recommended next action.
-- Footer: saved/pushed state. In connected mode include graph-link state when
-  available; in local mode omit graph language.
-- Do not show raw graph JSON or replace the confirmation box with plain prose.
+- 72-column outer box, standard top/separator/content/bottom lines only.
+- Header: `◈ DEEP REFLECT`, author, date.
+- Body: question, ◆/◇ finding counts, confidence, waves · docs read · cited ·
+  claims cut in verification.
+- Footer: actual saved/pushed state; say "graphed" only if the graph write
+  succeeded; in local mode omit graph language entirely.
+- Structured UX parity is required: preserve the rendered deep-reflect TUI
+  box, no preamble, no prose-only replacement, and no raw search or graph
+  output.
+- Never show raw graph JSON; never replace the box with prose.
 
 ## Rules
 
-- Never show raw graph JSON.
-- Do not claim evidence you did not inspect.
-- Keep intermediate summaries explicit so the user can audit the reasoning.
+- Search budget: at most ONE non-`--fast` search probe per run (seed only);
+  `--fast` everywhere else. Count result blocks, never the banner hit count.
+- No claim without a verbatim excerpt that survives re-finding in the file.
+- Absence is a first-class finding — cite the probes that prove it.
+- Don't manufacture significance: "memory holds nothing structural on this"
+  is a valid report.
+- At most ONE clarifying question before the run, plus the capture gate.
 - Do not use Claude Code commands.

package/runtime/pi/.codex/skills/deploy-bridge/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: deploy-bridge
+description: 'Deploy the Telegram bridge (egregore_bridge.py) to the VPS agent box and verify it comes back healthy. Org-internal — the bridge does NOT auto-deploy from develop.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore deploy-bridge Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/deploy-bridge/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/pi/.codex/skills/handoff/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: handoff
-description: Create an internal Egregore team handoff when the user invokes /handoff or $handoff, says they are done, asks to hand off work, or wants to pass context to a teammate or future self.
+description: Create an internal Egregore team handoff when the user invokes /handoff or $handoff, asks to hand off work, or wants to pass context to a teammate or future self.
 ---
 
 # Egregore Handoff
@@ -11,6 +11,10 @@ the Egregore scripts. External runnable packets are emissaries; if the user
 asks for one or provides an `egregore.xyz/emissary/e/` link, use the emissary
 tooling instead.
 
+`/handoff` is pure addressed capture. Do not triage incoming handoffs here;
+route “show/close my handoffs” to `$activity`. Personal session closure without
+an addressed recipient belongs to `$wrap`.
+
 ## Flow
 
 1. Run `bin/agent.sh sync`.
@@ -29,7 +33,7 @@ tooling instead.
 
 ```bash
 TMPDIR="$(mktemp -d -t codex-handoff-XXXXXX)"
-TMPDIR="$TMPDIR" bash bin/handoff-run.sh --author "$AUTHOR" --topic "$TOPIC" ${RECIPIENT_ARG} < "$BODY_FILE"
+TMPDIR="$TMPDIR" bash bin/capture-run.sh --mode addressed --author "$AUTHOR" --topic "$TOPIC" ${RECIPIENT_ARG} < "$BODY_FILE"
 ```
 
 Use `--recipient "$RECIPIENT"` only when a clear teammate or future-self

package/runtime/pi/.codex/skills/save/SKILL.md

@@ -17,15 +17,37 @@ which branch, commit, push, pull request, or memory sync steps are required.
 ```bash
 git status --short
 git status --short memory 2>/dev/null || true
-git branch --show-current
+BRANCH=$(git branch --show-current)
+AHEAD=0
+OPEN_PR=""
+case "$BRANCH" in
+  dev/*|feature/*|bugfix/*)
+    git fetch origin develop --quiet 2>/dev/null || true
+    AHEAD=$(git rev-list --count "origin/develop..HEAD" 2>/dev/null || echo 0)
+    if command -v gh >/dev/null 2>&1; then
+      OPEN_PR=$(gh pr list --head "$BRANCH" --base develop --state open \
+        --json url --jq '.[0].url // empty' 2>/dev/null || true)
+    fi
+    ;;
+esac
 ```
 
-3. If there are no repo or memory changes, say everything is already saved and
-   stop.
+3. A clean working tree alone does **not** mean the work is fully saved:
+   - If there are repo or memory changes, continue.
+   - If the task branch is ahead of `origin/develop` and `OPEN_PR` is empty,
+     continue even when the tree is clean. The bridge must push any committed
+     work and create the missing PR.
+   - Stop with "everything is already saved" only when there are no repo or
+     memory changes and either the branch has no commits to integrate
+     (`AHEAD=0`) or an open integration PR already exists.
 4. Synthesize:
    - a short topic from the work,
    - a clear commit message,
-   - a one-line user-facing scope summary.
+   - a one-line user-facing scope summary,
+   - a PR description following `.claude/context/pr-format.md`:
+     `## What` (1–4 bullets), `## Why` (1–3 sentences), and
+     `## Verification` (how the change was checked — required when the
+     diff touches non-markdown files; be honest if unverified).
 5. If the scope is ambiguous or includes unrelated changes, ask for one compact
    confirmation. Use structured Codex question tooling when available;
    otherwise render:
@@ -40,11 +62,13 @@ Other:
 6. Run the bridge command:
 
 ```bash
-bin/agent.sh save --message "$MESSAGE" --topic "$TOPIC"
+bin/agent.sh save --message "$MESSAGE" --topic "$TOPIC" --pr-body "$PR_BODY"
 ```
 
 The bridge owns the mechanical workflow: sync memory, ensure a task branch,
 commit repo changes, push, and create or reuse a pull request when available.
+Always pass the synthesized `--pr-body` — the bridge only auto-generates a
+skeleton body as a last resort, and the CI `pr-format` check gates every PR.
 
 7. Parse the output and report only useful user information:
    - branch name,

package/runtime/pi/.codex/skills/scroll/SKILL.md

@@ -18,7 +18,7 @@ small fork. A scroll requires all three legs: face, harvest, and update loop.
 ## Structured UX parity
 
 The browser artifact is the primary output. Preserve both tabs, deep links from
-honest costs into decisions, the versioned copydock fence, stable URL, and local
+honest costs into decisions, the versioned copydock return block, stable URL, and local
 source path. Do not substitute a prose-only summary or expose raw publish output.
 
 ## Route the invocation
@@ -121,13 +121,64 @@ the same `--id`; never mint a new URL for an update. In local mode, publishing
 is unavailable: open the file locally and report the source path without
 suggesting configuration changes.
 
-Add the URL or local path, source location, version, and fence tag to the
+Add the URL or local path, source location, version, and return-block tag to the
 relevant quest's log/artifacts tables. If no quest is relevant, keep the source
 path as the durable record and state it.
 
+## Creator gate — before any absorb
+
+The scroll record `memory/scrolls/<slug>.md` names `creator: <person-slug>` and
+optionally `trusted: [<person-slug>, …]`. A record missing `creator:` is
+backfilled from unambiguous existing attribution, otherwise ask the user once
+and write it — never silently default the gate open.
+
+Derive the paster from the session person (`.egregore-state.json`, then git
+config) — never from the return block's self-declared `respondent:` line, which
+is attribution metadata, not an authorization credential.
+
+If the paster is not the creator and not in `trusted:`, the return is **gated**:
+
+1. Append a `turn-received` event to `memory/scrolls/.events/<slug>.jsonl`
+   (create the file if absent). Event ids are append-if-absent and MUST match
+   the Claude corpus exactly — both runtimes share one event log:
+   `turn.id = respondent + '|' + base_version + '|' + date + '|' + digest`;
+   digest = FNV-1a 32-bit hex over the UTF-8 bytes of
+   `JSON.stringify([respondent, String(base_version), date, sortedAnswers,
+   sortedOpens])` where `sortedAnswers` = answers sorted by fork id, each
+   mapped to the tuple `[fork, pick-or-UNDECIDED, note-or-empty]` (labels are
+   excluded), and `sortedOpens` = opens sorted by prompt id, each mapped to
+   `[prompt, text-or-UNDECIDED]`; every string is NFC-normalized and
+   CRLF→LF-normalized before hashing. Record `submitted_by: <paster>` on the
+   event (event-log metadata only — never projected into a published ledger)
+   and `merged_into: "pending"`.
+2. Do NOT absorb: no `memory/knowledge/decisions/` writes, no spec/plan edits,
+   no face rewrite, no version bump, no republish of new content. Republishing
+   the unchanged current version to acknowledge the turn is allowed and appends
+   no version event.
+3. Notify the creator — connected: `bash bin/notify.sh send <creator>
+   "<paster> answered your scroll <slug> (vN): <digest> — pending your review"`;
+   local: write an addressed handoff in `memory/handoffs/` naming the scroll,
+   paster, base version, digest, and the dispositions below. The contributor
+   may also send the artifact link directly.
+4. Report the gated state and stop.
+
+**Creator review.** The creator disposes in chat: **accept** (absorb into the
+next version), **decline — <reason>** (mandatory nonblank note; refuse a
+decline without one), per-answer overrides (top-level disposition is the
+default, listed answers override; a turn with zero effectively accepted answers
+is a plain decline; a zero-answer turn takes the top-level disposition), or
+**synthesize** (compose one proposal from all pending turns — consensus
+decides, conflicts become new explicit forks — and publish only on creator
+approval). Every disposition appends `turn-reviewed`
+`{type, turn, disposition: accepted|declined, by, date, note?, answers?}` with
+id `review|<turn.id>` before any composition. An accepted turn stays pending
+until a version actually absorbs it. Declined turns are never absorbed, stay
+attributed in the log, and their reason travels with them. The creator's own
+returns and trusted respondents keep the immediate loop below.
+
 ## Update loop
 
-On a returned fence:
+On a returned block (creator or trusted paster — gated returns stop above):
 
 1. **Absorb.** Parse Q/O lines and notes. Write durable decisions with their
    reasoning to `memory/knowledge/decisions/`, update the underlying spec or

package/runtime/pi/.codex/skills/task/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: task
+description: 'Create, import, inspect, approve, answer, or cancel work in the hosted Egregore Agent Desk. Use for `/task`, `$task`, “send this work to the agents,” “start these tasks,” Markdown development batches, or checking hosted task progress. This skill submits work to the hosted pipeline; it does not implement the task in the current local session.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore task Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/task/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph, publish, and notify steps as best-effort unless that workflow
+   explicitly says they are required.
+4. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+5. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/pi/.codex/skills/tui-design/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: tui-design
-description: 'Fallback Codex adapter for the Egregore tui-design workflow.'
+description: 'TUI Design System for Egregore slash commands. Use when designing or modifying any command''s terminal output to ensure visual consistency. Triggers on: TUI, terminal output, box drawing, command output formatting, sigils, section markers. Do NOT use for browser rendering (use dark-mode) or external prose (use egregore-voice).'
 ---
 
 <!-- generated-by: bin/codex-sync-skills.sh -->

package/runtime/pi/.codex/skills/wrap/SKILL.md

@@ -6,7 +6,10 @@ description: Wrap an Egregore session when the user invokes /wrap or $wrap, or s
 # Egregore Wrap
 
 Native Codex Egregore skill. Use this inside an Egregore checkout with
-`bin/agent.sh`.
+`bin/agent.sh`. The command routes through `bin/capture-run.sh --mode personal`.
+It writes the personal record first, appends graph and handoff-completion events
+to the local WAL, and reconciles them detached; do not wait for or repeat that
+background work.
 
 ## Flow
 

package/runtime/pi/.codex/spec-manifest.json

@@ -14,6 +14,18 @@
       "sourceHash": "ddcbc0083aff",
       "note": "Kept; /update, /contribute, /save tokens rendered as $skill tokens."
     },
+    {
+      "section": "Cross-Runtime Compatibility",
+      "action": "keep",
+      "sourceHash": "75d02e2603f5",
+      "note": "Kept verbatim — framework parity applies equally to Claude Code, Codex, and Pi."
+    },
+    {
+      "section": "Voice",
+      "action": "keep",
+      "sourceHash": "af73d4eaa7cd",
+      "note": "Kept — all runtimes can consult the shared voice rules and register-specific skills."
+    },
     {
       "section": "On Launch — MANDATORY FIRST ACTION",
       "action": "replace",
@@ -23,19 +35,19 @@
     {
       "section": "After Greeting — BRANCH ON FIRST RESPONSE",
       "action": "replace",
-      "sourceHash": "c71340e68c9e",
+      "sourceHash": "bce266fb848b",
       "note": "EnterWorktree -> bin/agent.sh branch with git checkout fallback; AskUserQuestion -> numbered options in plain text; branch-guard mapped to .codex/hooks/branch-guard.js with instruction fallback; plan-mode note dropped (no plan mode on Codex); /branch + /onboarding -> skill tokens. Handoff claiming and repoState auto-checkout kept verbatim (pure git)."
     },
     {
       "section": "Config Files",
       "action": "keep",
-      "sourceHash": "81b7bf09901b",
+      "sourceHash": "8d7f1bd0f2d9",
       "note": "Kept verbatim — shell facts, runtime-neutral."
     },
     {
       "section": "Knowledge Graph",
       "action": "keep",
-      "sourceHash": "5c0953aee955",
+      "sourceHash": "b5d9a149f1a6",
       "note": "Kept verbatim — bin/graph.sh is runtime-neutral."
     },
     {
@@ -71,7 +83,7 @@
     {
       "section": "Git Workflow",
       "action": "keep",
-      "sourceHash": "d058d1f8da11",
+      "sourceHash": "49fd4625fa1e",
       "note": "Kept; slash tokens rendered as $skill tokens. Branch diagram unchanged (code fence)."
     },
     {
@@ -83,7 +95,7 @@
     {
       "section": "Command Awareness",
       "action": "keep",
-      "sourceHash": "e1db878ccaee",
+      "sourceHash": "ce5eb3015427",
       "note": "Prepended the Codex command surface (skill tokens, native vs adapter split, $save abstraction); disambiguation map kept with /x -> $x token rendering. Tokens with no Codex skill (e.g. /loop, a Claude Code harness feature) are left as-is."
     },
     {
@@ -107,8 +119,8 @@
     {
       "section": "Environment Isolation",
       "action": "replace",
-      "sourceHash": "ed47e96248bd",
-      "note": "boundary-check is a Claude PreToolUse hook with no .codex equivalent — behavior stated as a standing instruction; AskUserQuestion remediation -> numbered options."
+      "sourceHash": "086e2c1d9019",
+      "note": "boundary-check is a Claude PreToolUse hook with no .codex equivalent — two-tier model stated as a standing instruction; AskUserQuestion remediation -> numbered options, now including the two consent-grant options (session grant -> .egregore-boundary-consent, instance grant -> .egregore-boundary.local.json read[])."
     }
   ]
 }