create-egregore 0.19.3 → 0.19.6

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

@@ -0,0 +1,65 @@
+#!/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 `bin/agent.sh search` — 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",
+  ].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: `bin/agent.sh search \"<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/pi/.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/pi/.codex/skills/activity/SKILL.md

@@ -0,0 +1,70 @@
+---
+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. Run `bin/agent.sh sync`.
+3. 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
+   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:
+
+```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.
+
+6. 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.
+
+7. 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/pi/.codex/skills/add/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: add
+description: 'Fallback Codex adapter for the Egregore add workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore add 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/add/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/announce/SKILL.md

@@ -0,0 +1,54 @@
+---
+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. Preview the exact message. Confirm with structured Codex question tooling
+   when available; otherwise render:
+
+```text
+Send this announcement?
+1. Send
+2. Edit
+Other:
+```
+
+4. If the user edits, redraft and preview again. If they approve, run:
+
+```bash
+bash bin/notify.sh group "$MESSAGE"
+```
+
+5. Emit telemetry in the background:
+
+```bash
+bash bin/telemetry.sh emit "command" '{"command":"announce"}' >/dev/null 2>&1 &
+```
+
+6. Confirm whether the group send succeeded.
+
+## Rules
+
+- Always preview before sending.
+- Do not expose notification credentials.
+- Use `bin/notify.sh`; do not call Telegram directly.
+- Do not use Claude Code commands.

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

@@ -0,0 +1,25 @@
+---
+name: answer
+description: 'Fallback Codex adapter for the Egregore answer workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore answer 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/answer/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/archive/SKILL.md

@@ -0,0 +1,41 @@
+---
+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, 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/ask/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ask
+description: Ask an asynchronous Egregore question to a teammate when the user invokes /ask or $ask, or help the current user formulate inward reflection questions.
+---
+
+# Egregore Ask
+
+Native Codex Egregore skill. Use this when the user wants to ask a teammate a
+question, run a topic by someone, or inspect pending questions for themselves.
+
+## Flow
+
+1. Run `bin/agent.sh sync`.
+2. Resolve the current author from `.egregore-state.json`, then git config.
+3. Load people from `memory/people/*.md`. Match target names against filename,
+   `name:`, `github:`, and heading text, case-insensitively. Strip leading `@`.
+4. If the user named a target, draft one to four concrete questions. In
+   connected mode, optionally gather context with `bin/graph.sh` queries, but
+   suppress raw JSON and continue from memory files if graph access fails.
+5. Preview the exact questions and target. Use structured Codex question
+   tooling when available; otherwise render:
+
+```text
+Send these questions?
+1. Send as-is
+2. Edit
+Other:
+```
+
+6. For each approved question, run:
+
+```bash
+bin/agent.sh ask --from "$AUTHOR" --to "$TARGET" --topic "$TOPIC" --question "$QUESTION"
+```
+
+Add harvest flags only when this ask is part of a harvest:
+`--harvest-id`, `--harvest-session-id`, `--turn`, `--question-intent`, and
+`--context-mode`.
+
+7. In connected mode, notify best-effort with:
+
+```bash
+bash bin/notify.sh send "$TARGET" "$AUTHOR has a question about \"$TOPIC\". Ask for \$activity to answer."
+```
+
+8. Report the created `memory/knowledge/questions/...` path.
+
+## Inward Mode
+
+If no target matches, do not create a question file. Generate a small set of
+questions for the user to answer in-session, grounded in current conversation
+and memory context. Offer to save the result as a reflection only after the user
+answers.
+
+## Rules
+
+- Person-targeted asks are asynchronous: store, optionally notify, then stop.
+- Local mode is filesystem-only; skip graph and notification calls.
+- Do not use Claude Code commands.

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

@@ -0,0 +1,25 @@
+---
+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, 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/checkup/SKILL.md

@@ -0,0 +1,41 @@
+---
+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, 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/commit/SKILL.md

@@ -0,0 +1,25 @@
+---
+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, 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/contribute/SKILL.md

@@ -0,0 +1,25 @@
+---
+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, 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/dark-mode/SKILL.md

@@ -0,0 +1,25 @@
+---
+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, 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/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/pi/.codex/skills/deep-reflect/SKILL.md

@@ -0,0 +1,74 @@
+---
+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.
+---
+
+# Egregore Deep Reflect
+
+Native Codex Egregore skill. Use this for evidence-based analysis of how a new
+insight relates to the existing knowledge base.
+
+## Modes
+
+- empty request: deep mode.
+- `focused ...`: focused topic mode.
+- `quick ...` or `category: content`: quick mode.
+
+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.
+
+## 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"`.
+
+## 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:
+
+- 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.
+
+## 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.
+- Do not use Claude Code commands.