create-egregore 0.19.32 → 0.20.0

package/runtime/prime/.codex/hooks/search-hint.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+"use strict";
+// search-hint.js — UserPromptSubmit hook (Codex runtime).
+//
+// Mirror of .claude/hooks/search-hint.sh: when the user's prompt is
+// recall-shaped ("find the handoff about…", "did we decide…"), inject a
+// routing hint toward `bash bin/search.sh query` — one ranked call over
+// memory/ — instead of improvised ls/grep/graph exploration.
+//
+// Advisory only, never blocks, rate-limited once per session, exits 0.
+// If the Codex runtime does not fire UserPromptSubmit, this file is inert.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function readStdin() {
+  try { return fs.readFileSync(0, "utf-8"); } catch { return ""; }
+}
+function parseJson(raw) {
+  try { return JSON.parse(raw || "{}"); } catch { return {}; }
+}
+
+const input = parseJson(readStdin());
+const prompt = String(input.prompt || input.user_prompt || "");
+if (!prompt) process.exit(0);
+
+const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+if (!fs.existsSync(path.join(root, "bin", "search.sh"))) process.exit(0);
+
+// Already oriented toward search.
+if (/(\/search\b|search\.sh|\bsearch (the )?memory\b)/i.test(prompt)) process.exit(0);
+
+const RECALL = new RegExp(
+  [
+    "\\b(find|locate|dig up|look up|pull up)\\b.*\\b(handoff|decision|notes?|docs?|meeting|harvest|quest|reflection)s?\\b",
+    "\\bdid we (decide|discuss|agree|say|talk about|cover)\\b",
+    "\\bdo we have (any )?(notes?|docs?|anything|something)( on| about)?\\b",
+    "\\bwhat did we (decide|say|agree|discuss)\\b",
+    "\\bhave we (discussed|decided|covered|talked about|looked at)\\b",
+    "\\bnotes on\\b",
+    "\\bhandoff (from|about)\\b",
+    "\\bwho worked on\\b",
+    "\\bdidn.?t (someone|we) already\\b",
+    "\\bwas there (a|any) (handoff|decision|discussion|meeting)\\b",
+    "\\b(our|company|org|organization|team)\\b.*\\b(pricing|price|tiers?|plans?|paid|free|strategy|policy|positioning|ownership|decision)\\b",
+    "\\b(pricing|price|tiers?|plans?|paid|free)\\b.*\\b(our|company|org|organization|team)\\b",
+  ].join("|"),
+  "i"
+);
+if (!RECALL.test(prompt)) process.exit(0);
+
+// Rate-limit once per session.
+let sid = "default";
+try { sid = fs.readFileSync(path.join(root, ".egregore-session-id"), "utf-8").trim() || "default"; } catch {}
+const flag = path.join(os.tmpdir(), `egregore-search-hint-${sid}`);
+if (fs.existsSync(flag)) process.exit(0);
+try { fs.writeFileSync(flag, "1"); } catch {}
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "UserPromptSubmit",
+    additionalContext:
+      "Routing hint: this prompt asks for recall from org memory. FIRST action: `bash bin/search.sh query \"<the concept, not the literal sentence>\"` — one ranked call over all of memory/ (hybrid keyword+semantic; graph-state annotations attach automatically in connected mode). Read the top hits and cite paths. Do NOT improvise ls/grep/graph exploration first — hand-written graph queries against invented labels (e.g. :Handoff — handoffs are :Session nodes) return empty. Full spec: the search skill.",
+  },
+}) + "\n");
+process.exit(0);

package/runtime/prime/.codex/hooks.json

@@ -0,0 +1,30 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/search-hint.js\"",
+            "timeout": 5,
+            "statusMessage": "Checking recall routing"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash|apply_patch|Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$(git rev-parse --show-toplevel)/.codex/hooks/branch-guard.js\"",
+            "timeout": 5,
+            "statusMessage": "Checking Egregore branch policy"
+          }
+        ]
+      }
+    ]
+  }
+}

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

@@ -0,0 +1,82 @@
+---
+name: activity
+description: Show Egregore team activity, pending handoffs, and open questions when the user invokes /activity or $activity, or asks what is happening in an Egregore checkout.
+---
+
+# Egregore Activity
+
+Native Codex Egregore skill. Use this only inside an Egregore checkout.
+
+Show the live team activity view without sending the user through Claude Code.
+The graph API is useful when reachable, but the filesystem and memory repo must
+remain enough to render a useful answer.
+
+## Flow
+
+1. Verify `bin/agent.sh` exists. If it does not, say this is not an Egregore
+   checkout.
+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.
+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.
+6. Classify the graph status:
+
+```bash
+node bin/codex-skill-render.mjs classify-graph --mode connected
+```
+
+If the network-enabled command still returns `retry` because `graph_reason` is
+`unreachable`, render the filesystem fallback and mention that the graph service
+was unreachable after a network-enabled attempt. If network escalation is denied
+or unavailable, run the command without escalation, render the fallback, and
+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.
+
+7. Render the card with:
+
+```bash
+node bin/codex-skill-render.mjs activity-card <json-file>
+```
+
+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.
+
+8. Offer one compact focus prompt:
+   - `Handoffs` - open pending handoffs.
+   - `Questions` - answer or inspect pending questions.
+   - `Recent work` - inspect sessions and wraps.
+   - `Dashboard` - switch to the personal dashboard.
+   - `Done` - stop.
+
+Use structured Codex question tooling when it is available. Otherwise render a
+numbered list plus `Other:` and wait for the user.
+
+## Rules
+
+- Never show raw JSON.
+- Do not narrate each command step unless something blocks the workflow; the
+  final visible response should lead with the rendered card.
+- Structured UX parity is required: preserve the rendered activity TUI card,
+  no preamble, no prose-only replacement, and no raw collector output.
+- Do not call `egregore-handoff`.
+- Do not use Claude Code commands.
+- Keep graph, pull request, and publish data best-effort; local memory remains
+  the source of truth when connected services are down.

package/runtime/prime/.codex/skills/announce/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: announce
+description: Draft, confirm, and send an Egregore group announcement from Codex when the user invokes /announce or $announce.
+---
+
+# Egregore Announce
+
+Native Codex Egregore skill. Use this to send concise team announcements
+through the existing Egregore notification path.
+
+## Flow
+
+1. Draft a message from the user request and current context. Keep it under
+   500 characters unless the user provided exact text.
+2. If the announcement references a memory artifact, publish it first and add
+   the returned URL only when publication succeeds:
+
+```bash
+bash bin/publish-artifact.sh document "$FILE_PATH" --title "$TITLE" --author "$AUTHOR" --description "$DESCRIPTION"
+```
+
+Use `handoff`, `quest`, or `document` as the artifact type when appropriate.
+Never fabricate a URL.
+
+3. Follow `.claude/context/notification-consent.md`. Create a plan without
+   sending:
+
+```bash
+PLAN_JSON=$(bash bin/notify.sh plan group "$MESSAGE")
+```
+
+4. Preview the plan's exact organization, all deliveries/channels, and exact
+   final message. Confirm in a separate checkpoint with structured Codex
+   question tooling when available; otherwise render those fields followed by:
+
+```text
+Send this announcement?
+1. Send
+2. Edit
+3. Cancel
+```
+
+5. If the user edits, cancel the old plan, redraft, plan, and preview again.
+   If they cancel, cancel the plan and stop. Only after they select Send for
+   that exact preview, run:
+
+```bash
+APPROVAL_JSON=$(bash bin/notify.sh approve "$PLAN_ID" "$DIGEST" APPROVE_EXACT_NOTIFICATION)
+APPROVAL_TOKEN=$(printf '%s' "$APPROVAL_JSON" | jq -r '.approval_token')
+bash bin/notify.sh dispatch "$PLAN_ID" "$APPROVAL_TOKEN"
+```
+
+6. Emit telemetry in the background:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"announce"}' >/dev/null 2>&1 &
+```
+
+7. Confirm whether the exact approved group send succeeded.
+
+## Rules
+
+- The request to announce is not dispatch consent. Always use a dedicated
+  exact-delivery checkpoint.
+- Do not expose notification credentials.
+- Use `bin/notify.sh`; do not call Telegram directly.
+- Do not use Claude Code commands.

package/runtime/prime/.codex/skills/archive/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: archive
+description: 'Fallback Codex adapter for the Egregore archive workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore archive 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.
+
+## Structured UX parity
+
+This workflow has a Claude skill with user-visible structured output. After
+reading `.claude/skills/archive/SKILL.md`, reproduce the same visible UX in Codex:
+
+- Preserve TUI boxes, markdown tables, rich cards, browser artifact rendering,
+  exact confirmation blocks, and "no preamble" rules from the source skill.
+- Use the source skill's frame width, section order, labels, status footer,
+  and examples as the contract for the final response.
+- Never replace a required box/table/card/artifact view with a prose summary
+  unless the user explicitly asks for a summary.
+- When the source says to output a TUI box directly, paste that box as the
+  visible response, preferably in a `text` fenced block.
+- Never show raw JSON, raw command output, or unformatted script output when
+  the source skill requires formatted status or rendered output.
+
+1. Read `.claude/skills/archive/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/branch/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: branch
+description: 'Fallback Codex adapter for the Egregore branch workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore branch 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/branch/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/checkup/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: checkup
+description: 'Fallback Codex adapter for the Egregore checkup workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore checkup 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.
+
+## Structured UX parity
+
+This workflow has a Claude skill with user-visible structured output. After
+reading `.claude/skills/checkup/SKILL.md`, reproduce the same visible UX in Codex:
+
+- Preserve TUI boxes, markdown tables, rich cards, browser artifact rendering,
+  exact confirmation blocks, and "no preamble" rules from the source skill.
+- Use the source skill's frame width, section order, labels, status footer,
+  and examples as the contract for the final response.
+- Never replace a required box/table/card/artifact view with a prose summary
+  unless the user explicitly asks for a summary.
+- When the source says to output a TUI box directly, paste that box as the
+  visible response, preferably in a `text` fenced block.
+- Never show raw JSON, raw command output, or unformatted script output when
+  the source skill requires formatted status or rendered output.
+
+1. Read `.claude/skills/checkup/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/commit/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: commit
+description: 'Fallback Codex adapter for the Egregore commit workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore commit 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/commit/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/contribute/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: contribute
+description: 'Fallback Codex adapter for the Egregore contribute workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore contribute 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/contribute/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/create-skill/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: create-skill
+description: 'Create a skill your org owns — scaffolded in this Egregore, protected from framework updates, shared with teammates via /save.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore create-skill 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/create-skill/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/dark-mode/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: dark-mode
+description: 'Use when generating or modifying any visual output that renders in a browser or artifact viewer: HTML pages, CSS, React SSR components, Egregore artifacts, markdown renderers, web components, design-system tokens, Tailwind themes, or standalone demos. Triggers on requests involving dark mode, theme toggles, color systems, card surfaces, browser rendering, or visual polish. The load-bearing lesson: if React SSR emits an inline hex color through `style={}`, CSS dark-mode overrides cannot reach it, so every theme-sensitive color must be emitted as `var(--token)` rather than a resolved hex. Do not use for TUI output, plain markdown files, or non-visual code.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore dark-mode 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/dark-mode/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/prime/.codex/skills/dashboard/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: dashboard
+description: Show the current user's Egregore dashboard, recent sessions, open threads, and current work from Codex when the user invokes /dashboard or $dashboard, or asks for their dashboard.
+---
+
+# Egregore Dashboard
+
+Native Codex Egregore skill. Render the personal dashboard immediately from
+`bin/dashboard-data.sh` and the shared renderer.
+
+## Flow
+
+1. Map user range words to ISO-ish ranges:
+   - empty or `week` -> `P7D`
+   - `today` -> `P1D`
+   - `month` -> `P30D`
+   - `all` -> `P365D`
+2. Run `bash bin/dashboard-data.sh "" "$TIME_RANGE"` 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.
+3. Classify graph status:
+
+```bash
+node bin/codex-skill-render.mjs classify-graph --mode connected
+```
+
+If the network-enabled command still returns `retry` because the reason is
+`unreachable`, render the filesystem fallback and mention that the graph service
+was unreachable after a network-enabled attempt. If network escalation is denied
+or unavailable, run the command without escalation, render the fallback, and
+say Codex graph network access was not granted; do not claim the graph itself
+was unreachable.
+
+4. Render:
+
+```bash
+node bin/codex-skill-render.mjs dashboard-card <json-file>
+```
+
+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.
+
+5. End with a compact next-action prompt. Use structured Codex question
+   tooling when available; otherwise render numbered choices plus `Other:`.
+
+## Rules
+
+- Never show raw JSON.
+- Do not narrate each command step unless something blocks the workflow; the
+  final visible response should lead with the rendered card.
+- Structured UX parity is required: preserve the rendered dashboard TUI card,
+  no preamble, no prose-only replacement, and no raw collector output.
+- Do not call `bin/graph.sh` directly; `bin/dashboard-data.sh` is the data
+  boundary.
+- In local mode, do not mention graph setup; memory files are the source of
+  truth.
+- Do not use Claude Code commands.

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

@@ -0,0 +1,109 @@
+---
+name: 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 (v4)
+
+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.
+
+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.
+
+## Modes
+
+- 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. 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
+
+Render the Egregore deep-reflect confirmation TUI after the capture gate:
+
+- 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
+
+- 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.