create-egregore 0.20.2 → 0.21.0-runtime-mvp.1

package/runtime/claude/.claude/skills/dark-mode/SKILL.md

@@ -0,0 +1,410 @@
+---
+name: dark-mode
+description: "Use when authoring or modifying browser-rendered visual output: HTML, CSS, React SSR, artifact templates, markdown renderers, design tokens, themes, or composed pages. Do not invoke for an ordinary /view render—the checked-in renderer already owns its theme contract. The load-bearing rule is that theme-sensitive colors must be emitted as `var(--token)`, never resolved inline hex."
+---
+
+# Dark Mode
+
+## Voice Complex
+
+This skill governs BROWSER VISUAL RENDERING — warm palette, CSS token system, theme behavior. The warm-brown base (#1D1611) and terracotta accent (#D4875A) are the visual expression of the same warmth that runs through all Egregore registers.
+Shared aesthetic: voice-bedrock (`.claude/rules/voice-bedrock.md`).
+For terminal rendering: `tui-design` skill.
+For product copy in rendered pages: `product-voice` skill.
+For prose content in rendered pages: `egregore-voice` skill.
+
+This skill is a behavioral constraint system for Egregore visual output. It exists to stop the most common failure mode before it happens: an otherwise correct dark palette being defeated by SSR-emitted inline styles.
+
+## When to invoke
+
+User says: "dark mode", "theme toggle", "color system", "card surface", "make this work in dark mode", or any request to generate or modify browser-rendered visual output (HTML, CSS, React SSR, Egregore artifacts, design tokens)
+Not this: TUI terminal output → `tui-design` · plain markdown files with no styled HTML
+
+## The Bitter Lesson
+
+**If React SSR renders `style="color:#2A2A2A"`, dark mode loses.** CSS variable overrides only work when the rendered value is itself a variable reference. If a color must adapt across themes, emit `var(--token)` at the render site. Not in comments. Not in a later stylesheet. In the actual rendered style.
+
+Treat this as a hard constraint:
+
+1. Every theme-sensitive color in CSS or inline `style` props must use `var(--token)`.
+2. Theme state lives on `<html data-theme="...">`.
+3. Theme restoration happens before paint, in `<head>`.
+
+Everything else is secondary.
+
+## When To Invoke
+
+- Generating standalone HTML
+- Building or editing React SSR output
+- Writing CSS for Egregore artifacts
+- Modifying markdown renderers that emit inline styles
+- Adding a theme toggle
+- Extending the design system with dark surfaces
+- Producing any browser-rendered visual artifact
+
+## Not This
+
+- An ordinary deterministic `/view` render; the checked-in renderer already
+  owns and tests its theme contract
+- TUI terminal output; use `/tui-design`
+- Plain markdown files that do not render styled HTML
+- Backend or CLI code with no visual surface
+- Non-rendered config changes unrelated to color or theme behavior
+
+## The Egregore Dark Palette
+
+The palette stays warm. The base dark background is `#1D1611`, not pure black. Accent colors stay the same in both modes because terracotta and muted blue already survive the transition cleanly.
+
+### Core CSS Variables
+
+| Token | Light | Dark | Role |
+|---|---|---|---|
+| `--cream` | `#F5F2ED` | `#1D1611` | Page background; inverted selection text in dark |
+| `--black` | `#16100B` | `rgba(255, 255, 255, 0.92)` | Primary text, titles, completed badges |
+| `--dark` | `#2A2A2A` | `rgba(255, 255, 255, 0.75)` | Body text, secondary copy, blocked badge fill |
+| `--border` | `#E0D8CC` | `rgba(255, 255, 255, 0.06)` | Rules, card borders, checkbox outlines |
+| `--muted` | `#8a8578` | `rgba(255, 255, 255, 0.50)` | Metadata, labels, de-emphasized text |
+| `--warm-gray` | `#d4cfc5` | `rgba(255, 255, 255, 0.30)` | Tertiary marks, dim text, faint structure |
+| `--terminal-bg` | `#1D1611` | `#161210` | Code blocks and terminal surfaces |
+
+### Dark-Only Surface Helpers
+
+Use these when a component needs separation beyond the base variable set. The current artifacts shell uses `--card-bg` and `--code-bg`; `--elevated-bg` and `--strong-border` come from the same shipped token palette and are the right extensions when extra depth is needed.
+
+| Token | Light Fallback | Dark | Role |
+|---|---|---|---|
+| `--card-bg` | `#FFFFFF` | `#241E19` | Cards, pills, theme toggle background |
+| `--code-bg` | `rgba(59, 45, 33, 0.06)` | `rgba(212, 135, 90, 0.08)` | Inline code background |
+| `--elevated-bg` | `#FFFFFF` | `#2A231D` | Raised panels or overlays above cards |
+| `--strong-border` | `#d4cfc5` | `rgba(255, 255, 255, 0.10)` | Emphasized borders when `--border` is too faint |
+
+### Palette Rules
+
+- Warm character first: dark surfaces are brown-black, not blue-black and not pure black.
+- Text opacity hierarchy is fixed: `0.92` primary, `0.75` secondary, `0.50` muted, `0.30` dim.
+- `--terracotta` stays `#D4875A` in both modes.
+- `--blue-muted` stays `#7B9DB7` in both modes.
+- Selection inverts: terracotta highlight remains, but dark mode switches the selected text to `#1D1611`.
+
+## Anti-Patterns
+
+| Pattern | Why It Breaks | Instead |
+|---|---|---|
+| `style={{ color: colors.black }}` | React resolves `colors.black` to a hex during SSR, so dark CSS cannot override it later | `style={{ color: 'var(--black)' }}` or a class that resolves to `var(--black)` |
+| `style={{ color: colors.muted }}` in markdown or components | Same SSR trap, just less obvious because muted copy often escapes review | Emit `style={{ color: 'var(--muted)' }}` |
+| `background: white` on cards | The card stays white in dark mode and blows out contrast | `background: var(--card-bg, white)` with a dark override on `[data-theme="dark"]` |
+| `border-bottom: 1px solid rgba(224, 216, 204, 0.5)` | You hardcoded a light border into a supposedly themeable component | `border-bottom: 1px solid var(--border)` or `var(--strong-border, var(--border))` |
+| `#000000` or `#111111` for dark backgrounds | Cold, dead black clashes with Egregore's warm substrate | Use `#1D1611` or `var(--cream)` once dark mode remaps it |
+| `opacity: 0.5` on already-colored text | Multiplies contrast unpredictably and usually makes dark text too faint | Use the precomputed text tokens: `var(--muted)` or `var(--warm-gray)` |
+| `@media (prefers-color-scheme: dark)` as the only mechanism | No manual override, no persistence, no explicit state | Use a three-state `light / auto / dark` system |
+| Separate `.dark-*` classes for every component | Duplicates the design system and drifts fast | Override variables once under `[data-theme="dark"]` and keep component styles shared |
+| Putting theme state on `body` or a wrapper div | Inconsistent scope; portals, overlays, and SSR shells can fall out of sync | Put `data-theme` on `<html>` |
+| Restoring the saved theme after the page renders | Causes a flash of the wrong theme | Apply the saved theme in a blocking `<head>` script before paint |
+| Converting CSS files to variables but leaving inline `colors.*` references behind | Mixed models create false confidence; one stray inline color is enough to break dark mode | Grep every render path for `colors.` and hardcoded hex in inline styles, then replace with `var(--token)` |
+
+## Signature Patterns
+
+1. Variable-first inline styles. Inline styles are allowed only when they emit CSS variables, never resolved palette values.
+2. `data-theme` on `<html>`. No `body.dark`, no component-local theme root.
+3. Three-state theme toggle. Support `light`, `auto`, and `dark`, with persistence.
+4. Auto resolves OS preference first, then local-clock fallback. If the system exposes no preference, dark runs from `19:00` to `07:00`.
+5. No-flash initialization. Restore theme state in `<head>` before anything visible paints.
+6. Card elevation through background lightness, not shadow stacks. In dark mode, depth comes from surface contrast.
+7. Accent colors stay stable. Terracotta and muted blue do not get separate dark variants unless there is a proven contrast failure.
+8. Selection highlight inversion. The highlight stays terracotta; selected text flips to the dark background color.
+
+## Context Modes
+
+### Egregore Artifacts (React SSR)
+
+- Start from `packages/egregore-artifacts/lib/shell.js`, `markdown.js`, `components.js`, and `tokens.js`.
+- In render functions, replace `colors.black`, `colors.muted`, `colors.dark`, and similar inline values with `'var(--black)'`, `'var(--muted)'`, `'var(--dark)'`, and so on.
+- Keep structural values such as spacing, font families, and dimensions in JS as normal. The rule is specifically about theme-sensitive colors.
+- Put the dark variable remap in the shell, not on individual components.
+
+### Standalone HTML
+
+- Emit a full `:root` block plus a `[data-theme="dark"]` override block.
+- Put the theme restore script in `<head>` before visible markup.
+- Mount the toggle in fixed position and hide it in print.
+- Use CSS variable strings in any inline HTML styles you generate.
+
+### Tailwind CSS
+
+- Configure `darkMode: ['selector', '[data-theme=\"dark\"]']`.
+- Keep the root selector on `<html>`.
+- Prefer CSS custom properties for brand tokens, then map Tailwind utilities to those variables.
+- Do not sneak theme-sensitive hex colors into JSX `style` props just because the rest of the page uses Tailwind.
+
+### Vanilla CSS
+
+- Define light tokens in `:root`.
+- Override only variables under `[data-theme="dark"]`.
+- Component rules should read like `color: var(--black)` and `border-color: var(--border)`.
+
+### Email HTML
+
+- This is the one context where `@media (prefers-color-scheme: dark)` with `!important` is correct.
+- Do not build a JS toggle for email.
+- Accept that support is partial and optimize for legibility, not full parity.
+
+## Calibration Examples
+
+### 1. React Component Color Reference
+
+**Off target**
+
+```js
+h('span', { style: { color: colors.muted, fontSize: '13px' } }, `(${author})`)
+```
+
+**On point**
+
+```js
+h('span', { style: { color: 'var(--muted)', fontSize: '13px' } }, `(${author})`)
+```
+
+Why: the first version serializes to a fixed hex during SSR. The second survives theme remapping.
+
+### 2. Card Background And Elevation
+
+**Off target**
+
+```css
+.card {
+  background: white;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.24);
+}
+```
+
+**On point**
+
+```css
+.card {
+  background: var(--card-bg, white);
+  border: 1px solid var(--border);
+}
+
+[data-theme="dark"] .card {
+  --card-bg: #241E19;
+}
+```
+
+Why: dark separation comes from a warmer surface step, not a generic shadow preset.
+
+### 3. Code Block In A Markdown Renderer
+
+**Off target**
+
+```js
+h('code', {
+  style: {
+    background: 'rgba(59, 45, 33, 0.06)',
+    color: colors.black,
+    padding: '2px 5px',
+  },
+}, text)
+```
+
+**On point**
+
+```js
+h('code', {
+  className: 'eg-code',
+}, text)
+```
+
+```css
+.eg-code {
+  background: var(--code-bg, rgba(59, 45, 33, 0.06));
+  color: var(--black);
+}
+
+[data-theme="dark"] .eg-code {
+  --code-bg: rgba(212, 135, 90, 0.08);
+  color: var(--terracotta);
+}
+```
+
+Why: inline code needs a dedicated surface token in dark mode; a light-only rgba wash will disappear.
+
+## Toggle Reference Implementation
+
+This is the canonical Egregore pattern: one HTML attribute, one variable override block, one small engine. Keep the structure; adapt only if the host environment forces it.
+
+### JS Engine
+
+```html
+<script>
+  (function() {
+    var MODES = ['light', 'auto', 'dark'];
+    var ICONS = ['\u2600', '\u25D0', '\u263D'];
+    var LABELS = ['light', 'auto', 'dark'];
+
+    function resolveAuto() {
+      if (window.matchMedia('(prefers-color-scheme: dark)').matches) return 'dark';
+      if (window.matchMedia('(prefers-color-scheme: light)').matches) return 'light';
+      var h = new Date().getHours();
+      return (h >= 19 || h < 7) ? 'dark' : 'light';
+    }
+
+    function applyTheme(mode) {
+      var resolved = mode === 'auto' ? resolveAuto() : mode;
+      document.documentElement.setAttribute('data-theme', resolved);
+    }
+
+    function updateToggle(mode) {
+      var idx = MODES.indexOf(mode);
+      var btn = document.querySelector('.eg-theme-toggle');
+      if (!btn) return;
+      btn.querySelector('.eg-t-icon').textContent = ICONS[idx];
+      btn.querySelector('.eg-t-label').textContent = LABELS[idx];
+    }
+
+    var saved = localStorage.getItem('eg-theme-mode') || 'auto';
+    applyTheme(saved);
+
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function() {
+      if ((localStorage.getItem('eg-theme-mode') || 'auto') === 'auto') applyTheme('auto');
+    });
+
+    window.__egTheme = {
+      cycle: function() {
+        var cur = localStorage.getItem('eg-theme-mode') || 'auto';
+        var next = MODES[(MODES.indexOf(cur) + 1) % 3];
+        localStorage.setItem('eg-theme-mode', next);
+        applyTheme(next);
+        updateToggle(next);
+      },
+      init: function() { updateToggle(saved); }
+    };
+  })();
+</script>
+```
+
+### CSS Shell
+
+```css
+:root {
+  --cream: #F5F2ED;
+  --black: #16100B;
+  --dark: #2A2A2A;
+  --border: #E0D8CC;
+  --muted: #8a8578;
+  --warm-gray: #d4cfc5;
+  --terminal-bg: #1D1611;
+  --terracotta: #D4875A;
+  --blue-muted: #7B9DB7;
+}
+
+[data-theme="dark"] {
+  --cream: #1D1611;
+  --black: rgba(255, 255, 255, 0.92);
+  --dark: rgba(255, 255, 255, 0.75);
+  --border: rgba(255, 255, 255, 0.06);
+  --muted: rgba(255, 255, 255, 0.50);
+  --warm-gray: rgba(255, 255, 255, 0.30);
+  --terminal-bg: #161210;
+}
+
+::selection { background: var(--terracotta); color: var(--cream); }
+[data-theme="dark"] ::selection { color: #1D1611; }
+
+.eg-theme-toggle {
+  position: fixed;
+  top: 1.25rem;
+  right: 1.25rem;
+  width: 36px;
+  height: 36px;
+  border-radius: 50px;
+  border: 1px solid var(--border);
+  background: var(--card-bg, white);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 15px;
+  line-height: 1;
+  transition: background 0.2s, border-color 0.2s, width 0.2s;
+  z-index: 100;
+  padding: 0;
+  gap: 6px;
+  overflow: hidden;
+}
+.eg-theme-toggle:hover {
+  border-color: var(--terracotta);
+  width: 92px;
+  padding: 0 12px;
+}
+[data-theme="dark"] .eg-theme-toggle { --card-bg: #241E19; }
+.eg-theme-toggle .eg-t-icon { flex-shrink: 0; }
+.eg-theme-toggle .eg-t-label {
+  font-family: var(--font-mono);
+  font-size: 10px;
+  letter-spacing: 0.04em;
+  color: var(--muted);
+  white-space: nowrap;
+  width: 0;
+  overflow: hidden;
+  transition: width 0.2s, opacity 0.2s;
+  opacity: 0;
+}
+.eg-theme-toggle:hover .eg-t-label { width: 32px; opacity: 1; }
+
+@media print {
+  body { background: white; }
+  .eg-artifact { padding: 1rem; max-width: none; }
+  .eg-card { break-inside: avoid; }
+  .eg-theme-toggle { display: none; }
+}
+
+@media (max-width: 640px) {
+  .eg-artifact { padding: 2rem 1.25rem 3rem; }
+  .eg-title { font-size: 28px; }
+  .eg-section-title { font-size: 20px; }
+  .eg-meta-row { gap: 10px; }
+  .eg-theme-toggle { top: 0.75rem; right: 0.75rem; width: 32px; height: 32px; font-size: 14px; }
+}
+```
+
+### HTML Hookup
+
+```html
+<html lang="en" data-theme="light">
+  <head>
+    <!-- theme restore script goes here -->
+  </head>
+  <body>
+    <button class="eg-theme-toggle" aria-label="Toggle theme" onclick="__egTheme.cycle()">
+      <span class="eg-t-icon">&#9680;</span>
+      <span class="eg-t-label">auto</span>
+    </button>
+    <script>__egTheme.init();</script>
+  </body>
+</html>
+```
+
+## Pre-Ship Checklist
+
+1. Grep for hardcoded hex colors and `colors.` references in render paths that emit inline styles.
+2. Verify every theme-sensitive inline color is a `var(--token)` string.
+3. Verify both `:root` and `[data-theme="dark"]` blocks exist.
+4. Verify `data-theme` is set on `<html>`, not `body`.
+5. Verify the saved theme is restored in `<head>` before visible markup paints.
+6. Verify the toggle cycles `light -> auto -> dark` and persists to `localStorage`.
+7. Verify auto mode follows OS preference first and local time second.
+8. Verify no surface uses pure black or a cool gray dark background.
+9. Verify cards, code, and elevated surfaces separate by warm lightness steps rather than shadow spam.
+10. Verify selection, print, and mobile behavior still work after the theme system is added.
+
+## Reference Files
+
+Read these conditionally, depending on the task:
+
+- `packages/egregore-artifacts/lib/shell.js` for the canonical shell structure, variable overrides, and toggle wiring.
+- `packages/egregore-artifacts/lib/tokens.js` for the shipped light and dark token values.
+- `packages/egregore-artifacts/lib/markdown.js` for the inline-style `var(--token)` conversion pattern.
+- `packages/egregore-artifacts/lib/components.js` for component-level inline style usage that must stay variable-first.
+- `packages/design-system/tokens.css` for the broader design-system token vocabulary.
+
+If the current checkout does not yet contain the merged dark-mode implementation in those artifact files, inspect the shipped worktree copies under `.claude/worktrees/soul-document-design/packages/egregore-artifacts/lib/`.

package/runtime/claude/.claude/skills/dashboard/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: dashboard
+description: "Explicit personal-status surface for /dashboard or a direct request for the whole personal overview. Do not use it to find or resume one specific prior handoff, project, or work thread; that is semantic organizational recall through Runtime/QMD."
+---
+
+# Dashboard
+
+Use this bounded status card only when the user explicitly asks for Dashboard
+or the whole personal overview. A request to return to one earlier piece of
+work must use attached `EGREGORE_ORG_CONTEXT_V1` evidence or exactly one Search
+workflow query when that evidence is absent. Never use Dashboard as discovery
+fallback.
+
+Render the personal view immediately. The renderer's stdout IS the product
+card: it is fully visible the moment rendering finishes, and it must appear
+exactly once in the conversation. Never copy, regenerate, summarize, or
+repeat the card — or any of its rows — in your reply; add nothing beyond an
+answer to something the user separately asked.
+
+Map the requested range to `P1D`, `P7D`, `P30D`, or `P365D`, then fetch and
+render exactly one authorized Runtime snapshot:
+
+```bash
+bash bin/dashboard-data.sh "$TIME_RANGE" 2>/dev/null \
+  | bash bin/node-run.sh bin/codex-skill-render.mjs dashboard-card -
+```
+
+Do not sync repositories, query memory again, or call implementation
+infrastructure directly. The snapshot owns actor resolution,
+authorization, bounds, canonical lifecycle state, and presentation data.
+
+Connected enrichment is separate and explicit. Set
+`EGREGORE_STATUS_CONNECTED_ENRICH=1` only when the user requests projected
+Connected status. It is capability/permission gated and cannot replace
+canonical handoffs, questions, quests, todos, sessions, or lifecycle metadata.
+
+Never print raw JSON or narrate routine commands. Preserve the shared
+72-column card, omit graph/setup messaging in Local mode, end with `What's
+next?`, and act on the reply in the next turn.
+
+## When to invoke
+
+Explicit personal-status surface for /dashboard or a direct request for the whole personal overview. Do not use it to find or resume one specific prior handoff, project, or work thread; that is semantic organizational recall through Runtime/QMD.

package/runtime/claude/.claude/skills/deep-reflect/REPORT.md

@@ -0,0 +1,140 @@
+# REPORT.md — synthesis, presentation, capture
+
+What the user sees, what gets saved, and how. The engine (`RESEARCH.md`) produces a verified claims table + patterns + gaps; this contract turns them into a report.
+
+## Pattern pruning (before synthesis)
+
+PATTERN ran on pending claims; VERIFY then changed some verdicts. Prune before synthesizing:
+- A pattern whose supporting claims are ALL `killed` → dropped.
+- Some support survives → the pattern's weight caps at the best surviving claim's weight.
+- Support consists only of `downgraded`/`dated` claims → the pattern caps at `secondary`.
+- Bonus-wave claims join a pattern's support only if `verified`/`corrected`.
+
+## Synthesis register
+
+**Stance, not summary.** 2-4 paragraphs that tell the user something they don't already know — this justifies the compute. If it could have been written from the finding list alone, rewrite it.
+
+Address, in whatever order the material demands:
+- **What the answer actually is.** Answer the question first. In cross-ref mode, say plainly how the insight sits: confirmed, contradicted, already known, or genuinely new.
+- **Where the evidence is strong and where it's thin.** Dismiss weak findings explicitly rather than giving everything equal weight.
+- **What's missing.** The insufficiency map is a headline deliverable, not an apology — what the org doesn't know, with the probes that prove it.
+- **One thing to do.** One action that matters most. Everything else is context.
+
+**Register: analyst, not critic.** "The memory shows X" — never "the team is failing to Y." No manufactured drama; positive patterns matter as much as tensions. Never adversarial, never patronizing, never coaching verbs ("crystallizing", "emerging", "sensing").
+
+Anti-patterns: "This is an interesting question…" (you have nothing to say) · "The findings cluster around…" (describing data, not interpreting it) · "worth watching" (demands action or doesn't).
+
+## Derived confidence
+
+Never self-reported. Per finding:
+- **high** — verified + ≥3 independent sources (distinct authors OR distinct top-level dirs) + no `dated` demotion
+- **medium** — verified + 2 sources, or any source `dated`/`corrected`
+- **single-source** — always labeled as such, regardless of how convincing the one source is
+
+Overall confidence (TUI + frontmatter): **high** = every primary finding is high · **mixed** = findings span levels, or an analyst disagreement survived · **medium** = otherwise.
+
+Analyst disagreement is never averaged into a middle confidence — it ships as a finding under Tensions.
+
+## Chat presentation (in order)
+
+1. **ANSWER** — the synthesis paragraphs.
+2. **FINDINGS** — `◆` primary / `◇` secondary, each with inline `path` citations. Ambient findings go to the report file only.
+3. **TENSIONS & DISAGREEMENTS** — contradictions, drift, supersession; analyst disagreement preserved and named.
+4. **WHAT MEMORY DOESN'T HOLD** — verified gaps + the probes that prove them + nearest adjacent work.
+5. **Provenance footer** — one line: `{N} waves · {N} docs read · {N} cited · {N} claims cut in verification · stopped: {stop_reason}`. `claims cut` counts claim verdicts `killed` only; gap refutations are reported separately (they ADD a doc, they don't cut a claim). Docs found by refuted gaps count in docs read.
+
+The **evidence appendix** (per-finding path + excerpt table) goes in the report FILE only — on a deep run it is exactly the terminal wall progressive disclosure forbids.
+
+Then the capture gate fires, writeback runs per the verdict, and the **TUI box renders LAST, reflecting the actual outcome**.
+
+## TUI box
+
+72-char width, exactly 4 line patterns (top `┌`+70×`─`+`┐` · separator `├`+70×`─`+`┤` · content `│`+2 spaces+text padded to 68+`│` · bottom `└`+70×`─`+`┘`). No sub-boxes. Sigil: `◈ DEEP REFLECT` (the faceted eye — looking inward with structure); header right: `{author} · {Mon DD}`.
+
+Body lines: `Q: {question truncated ~55 chars}` · `◆ N primary · ◇ N secondary findings · confidence: {overall}` · `{N} waves · {N} docs read · {N} cited · {N} claims cut in verification`.
+
+Footer after a separator — pick by ACTUAL outcome:
+- Saved, connected, graph writes succeeded: `✓ Saved · graphed · pushed`
+- Saved, local mode — or connected with a failed/offline graph write (add one line: `graph write failed — file is canonical` on capture-time failure): `✓ Saved · pushed`
+- Skipped: `◦ Not saved — ledger at .egregore/research-runs/`
+
+Then `Visible in /activity.` (saved runs only). The word "graphed" appears ONLY when the artifact upsert call actually returned success.
+
+**Output the TUI box directly as a code block. Do not narrate or explain it. DO NOT count characters — approximate padding is fine.**
+
+## Capture gate
+
+One AskUserQuestion, always (unless `--no-capture`, which implies Skip):
+
+- **Save** (default) — write the report, graph it (connected), push
+- **Edit first** — apply the user's edits, then Save
+- **File follow-ups** — for each verified gap: append a 2-3 line stub (`### Open: {gap}` / `Probes that came up empty: {probes}` / `From research run {run-id}`) to the matched quest file — matched = the `--quest` slug if given, else the quest lead most cited in the gap's source claims; no match → offer creating a quest. Gaps about what people think → draft a `/harvest` brief instead. Then re-offer Save/Skip for the report itself (this follow-up branch lives INSIDE the capture gate's dialogue budget)
+- **Skip** — nothing touches `memory/` or the graph; the local ledger is the only residue
+
+`--brief` and probe-collapsed sparse runs default to terminal-only output with a two-option **Save / Skip** gate; Save writes the standard file. This keeps `memory/knowledge/research/` from silting with one-hop lookups.
+
+## Report file
+
+Path: `memory/knowledge/research/{YYYY-MM-DD}-{author}-{slug}.md` (slug ≤50 chars; collision → append 4-char hex). Write via Bash heredoc (`cat > memory/... << 'EOF'`) — memory/ is a symlink outside the project.
+
+```markdown
+---
+title: {question, statement-cased}
+date: {YYYY-MM-DD}
+author: {author}
+type: research
+question: "{the question as researched}"
+mode: {question|crossref}
+band: {brief|standard|deep}
+stop_reason: {answered|saturated|dry|budget|sparse}
+confidence: {high|medium|mixed}
+waves: {N}
+docs_read: {N}
+claims_killed: {N}
+run_id: {dr-...}
+builds_on: [{prior research report paths, if compounding fired}]
+artifacts_consulted: [{every path read}]
+artifacts_cited: [{paths that survived into findings}]
+null_regions:
+  - gap: "{verified gap}"
+    probes: ["{probe}", "{probe}"]
+quests: [{--quest slug or dominant quest leads}]
+topics: [{3-5 topics}]
+---
+
+{ANSWER — the synthesis, verbatim from chat}
+
+## Findings
+{findings with citations, including ambient}
+
+## Tensions
+## What memory doesn't hold
+## Evidence appendix
+| Finding | Source | Excerpt |
+{every surviving claim}
+
+## Provenance
+{waves, probes run, agents spawned, kill/correction counts, stop reason, run id}
+```
+
+`null_regions` is the machine-readable face of "What memory doesn't hold" — future runs' compounding step re-audits it (`RESEARCH.md` §Compounding).
+
+## Writeback (Save path)
+
+1. **Dedupe probe**: `grep -ril "{question terms}" memory/knowledge/research/ | head -3` (same mechanism as compounding) — a near-duplicate prior report surfaces as "extends {path}?"; on confirm, stamp `builds_on` and continue.
+2. **Write the file** (heredoc, above). Progress: `[1/3] ✓ Writing knowledge/research/{date}-{slug}.md`.
+3. **Graph writes — CONNECTED MODE ONLY, all non-fatal** (`2>/dev/null || true`; the file is the canonical record). Do NOT use `bin/graph-op.sh register-artifact` — that op is for published hosted artifacts (requires a URL, sets `published: true`, never sets `filePath`). Instead MERGE the artifact the way `bin/sync-graph.sh` does for knowledge files:
+
+   ```bash
+   bash bin/graph.sh query "MERGE (a:Artifact {id: \$id}) SET a.title = \$title, a.type = 'research', a.topics = \$topics, a.filePath = \$filePath, a.created = coalesce(a.created, datetime()) WITH a MATCH (p:Person {name: \$author}) MERGE (a)-[:CONTRIBUTED_BY]->(p) RETURN a.id" '{"id": "{filename stem}", "title": "...", "topics": [...], "filePath": "knowledge/research/{filename}", "author": "{author}"}' 2>/dev/null || true
+   ```
+
+   `id` = filename stem; `filePath` makes the node reachable by search enrichment and future hop rails. (`sync-graph.sh` also scans `knowledge/research/` on `/save`, so a failed write self-heals on the next save.) Then, same non-fatality:
+   - `PART_OF` → Quest when `--quest` given or quest leads dominated the ledger
+   - `BUILDS_ON` → each prior report in `builds_on`
+   - **Cross-ref mode, verified claims only**: edges from the new report's Artifact node to each cited artifact — `RELATES_TO {signal_type: relation, confidence, weight, run_id}` for `supports`/`duplicates`/`depends-on`, `TENSION_WITH {signal_type: relation, confidence, weight, run_id}` for `contradicts`/`supersedes` — skeptic-surviving edges only, so the cross-reference web grows with quality control
+   - Progress: `[2/3] ✓ Indexed in knowledge graph ({N} edges)` on success; on failure print nothing here and use the local footer + failure note (omit this line entirely in local mode)
+4. **Auto-save**: full `/save` flow — commit memory repo, push to main (pull-rebase-push with retry); commit any egregore-repo changes, push working branch + PR to develop. Progress: `[3/3] ✓ Auto-saved`.
+5. **Telemetry** per `SKILL.md` §Telemetry.
+
+Optional follow-up offer after save: "Render as a `/view` artifact?" — reuses the existing artifact pipeline; never build a bespoke one here.