dreamcontext 0.9.2 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dreamcontext",
-  "version": "0.9.2",
+  "version": "0.10.2",
   "description": "dreamcontext — the persistent brain for your AI agents. Remembers what you built, knows how your project works.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "skill",
     "skill-initializer",
     "skill-curator",
+    "skill-deep-research",
     "skill-packs",
     "agents",
     "README.md",
@@ -51,14 +52,19 @@
     "commander": "^13.1.0",
     "fast-glob": "^3.3.3",
     "gray-matter": "^4.0.3",
-    "nanoid": "^5.1.2"
+    "nanoid": "^5.1.2",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.60.0",
     "@types/node": "^22.13.4",
+    "@types/ws": "^8.18.1",
     "sharp": "^0.34.5",
     "tsup": "^8.4.0",
     "typescript": "^5.7.3",
     "vitest": "^3.0.6"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
   }
 }

package/skill/SKILL.md

@@ -196,7 +196,7 @@ When in doubt about a command or flag, open [cli-reference.md](references/cli-re
 
 10. **Use `dreamcontext-explore`, not `Explore`.** The default Explore agent is blocked via a PreToolUse hook. `dreamcontext-explore` checks curated context first, saving thousands of tokens.
 
-11. **Tag before you create.** Before tagging a task/feature/knowledge, consult `dreamcontext taxonomy vocab` and reuse canonical faceted tags (`topic:recall`, `domain:security`) before inventing new ones. Fragmenting tags degrades recall.
+11. **Tag before you create.** Before tagging a task/feature/knowledge, consult `dreamcontext taxonomy vocab` and reuse canonical faceted tags (`topic:recall`, `domain:security`) before inventing new ones. Fragmenting tags degrades recall. To heal accumulated drift in one shot, run `dreamcontext taxonomy audit --fix` (bulk-normalizes alias/normalizable tags to canonical across the corpus — safe, idempotent, `--dry-run` to preview; orphans are reported, never guessed).
 
 12. **Be surgical.** Only touch what changed. ~150-line soft limit on context files — extract detail to knowledge, keep a summary + reference. LIFO inserts go at the top (CHANGELOG, task changelog, constraint sections).
 
@@ -240,15 +240,15 @@ Sleep debt accumulates automatically via hooks (per Write/Edit). The SessionStar
 
 | Debt | Level | Required behavior |
 |------|-------|-------------------|
-| 0–3 | Alert | No action |
-| 4–6 | Drowsy | After completing a task, **inform the user and offer** consolidation |
-| 7–9 | Sleepy | At session start, **inform the user and recommend** consolidation before new work |
-| 10+ | Must sleep | **Consolidate now**, before or right after the current task |
+| 0–7 | Alert | No action |
+| 8–13 | Drowsy | After completing a task, **inform the user and offer** consolidation |
+| 14–19 | Sleepy | At session start, **inform the user and recommend** consolidation before new work |
+| 20+ | Must sleep | **Consolidate now**, before or right after the current task |
 
-A ★★★ bookmark or 3+ sessions since last sleep also triggers an advisory.
+A ★★★ bookmark or 5+ sessions since last sleep also triggers an advisory.
 
-**Post-task check (MANDATORY):** after completing any task or major implementation, check debt. If ≥4, tell the user: *"Sleep debt is [N]. I can consolidate now to preserve this work. Want me to run it?"* Never silently finish.
-**Auto-sleep (act without asking):** task completed with debt ≥7, or major implementation finished with debt ≥4.
+**Post-task check (MANDATORY):** after completing any task or major implementation, check debt. If ≥8, tell the user: *"Sleep debt is [N]. I can consolidate now to preserve this work. Want me to run it?"* Never silently finish.
+**Auto-sleep (act without asking):** task completed with debt ≥14, or major implementation finished with debt ≥8.
 
 **The flow (main agent runs this directly — sub-agents can't reliably fan out):**
 1. Tell the user you're consolidating.
@@ -301,7 +301,8 @@ Status: `todo → in_progress → in_review → completed`. Sections: `why`, `us
 
 ## Sub-Agents
 
-- **`dreamcontext-explore`** — context-accelerated codebase exploration. Use for ALL exploration (default Explore is blocked). Uses the SubagentStart briefing to narrow searches.
+- **`dreamcontext-explore`** — context-accelerated codebase exploration. Use for ALL exploration (default Explore is blocked). Uses the SubagentStart briefing to narrow searches. It is the **fast, single-pass** searcher — one agent, tight budget, one answer.
+- **`dreamcontext-deep-research` skill** — the **iterative, sub-agent-driven corpus-synthesis** orchestrator: the heavy counterpart to `dreamcontext-explore`. Invoke it via the `Skill` tool (or `/dreamcontext-deep-research`) when a question needs **synthesis across a large or multi-project / federated corpus** and one explore pass comes back thin or fragmented — "synthesize/reconcile everything we know about X across my vaults", "deep dive and cite it", "explore is too shallow for this". It fans out parallel `dreamcontext-explore` searchers over the whole curated corpus **and connected peer vaults**, adversarially verifies the load-bearing claims, and returns a **synthesized, cited** report — not raw hits. Read-only. **Escalation rule:** start with `dreamcontext-explore`; escalate to deep-research when one pass and one answer leave a cross-corpus question half-answered. Don't fan out a 10-agent research run at a tiny single-project brain.
 - **`initializer` skill** — the **interactive, sub-agent-driven brain bootstrap**. Invoke it via the `Skill` tool when this project has **no `_dream_context/`** or a **sparse** one (empty `knowledge/`, zero features, untouched template stubs). It orchestrates scout → confirm-hierarchy → progressive ingest → verify, migrating whatever material the user has into the proper knowledge/feature/task hierarchy. It drives its own sub-agents (`initializer-scout`, `initializer-ingestor`, `initializer-verifier`) and handles codebase-only repos too (a light scout + ingest pass) — there is no separate bootstrap agent.
 - **Sleep specialists** (`sleep-tasks`, `sleep-state`, `sleep-product`, `sleep-migration`) — dispatched by the main agent during the sleep flow only.
 

package/skill/references/cli-reference.md

@@ -47,8 +47,9 @@ Every command and flag, grouped. All commands are prefixed with `dreamcontext`.
 | `tasks status <name> <todo\|in_progress\|in_review\|completed> [reason...]` | Change status (logs to changelog). On the first move to `in_progress`, stamps `start_date` with today if it is unset (a planned start is never overwritten). |
 | `tasks complete <name> [summary...]` | Mark completed (convenience). |
 | `tasks delete <name>` | Delete a task (propagates to remote backend on sync). `--yes`. |
-| `tasks doctor [name]` | Validate the Workflow flowchart is in sync with Acceptance Criteria (all tasks if name omitted). |
-| `tasks sync [push\|pull\|both]` | Sync with the remote backend (no-op on local). `--hook`, `--json`. |
+| `tasks rename <name> <new-name>` | Rename a task: rewrites the name, moves the file to the new slug, and re-keys the sync mapping by the stable dcId so the **same** remote task/issue is updated on next sync — never duplicated. Use this instead of hand-editing `name:` + renaming the file. |
+| `tasks doctor [name]` | Validate the Workflow flowchart is in sync with Acceptance Criteria (all tasks if name omitted). `--remote` also checks the remote backend for assignee drift (needs a token). |
+| `tasks sync [push\|pull\|both]` | Sync with the remote backend (no-op on local). `--hook`, `--reconcile` (heal pre-existing assignee drift below the watermark — #78), `--json`. |
 | `tasks members` | People with access to the remote list (assignee candidates). `--json`. |
 | `tasks provision` | Create recommended + override-declared custom fields on the remote backend (ClickUp list fields / GitHub labels). Reuses any that already exist by name. |
 | `tasks sync-hooks install\|uninstall` | Manage best-effort git sync triggers (post-commit, pre-push). |
@@ -142,6 +143,7 @@ See [sleep.md](sleep.md) for the full flow.
 |---|---|
 | `taxonomy vocab` | Show the resolved vocabulary (defaults + `core/taxonomy.json`). `--json`, `--facet <facet>`. |
 | `taxonomy audit` | Audit corpus tags against the vocabulary (read-only). `--json`. |
+| `taxonomy audit --fix` | **Bulk-normalize** alias/normalizable tags → canonical faceted form across every knowledge/feature/task file. Safe + idempotent: already-canonical tags are untouched; orphan tags with no alias/canonical target are reported, never guessed. `--dry-run` previews the rewrite plan and writes nothing; `--json` for automation. Workflow is alias-then-fix: teach a mapping with `taxonomy alias`, then `audit --fix`. |
 | `taxonomy init` | Scaffold `core/taxonomy.json` (idempotent). |
 | `taxonomy add <tag>` | Add a tag to the vocabulary. |
 | `taxonomy alias <alias> <canonical>` | Add an alias→canonical mapping. |

package/skill/references/integrations.md

@@ -115,16 +115,21 @@ dreamcontext dashboard --launcher      # vault-agnostic launcher mode (resolves
 ```
 A SessionStart hook auto-opens it when a session starts and no server is running (opt out with `DREAMCONTEXT_AUTO_DASHBOARD=0`).
 
+The sidebar is grouped into **Workspace** (Sleepy, Tasks, Council), **Memory** (Core, Knowledge, Features, Taxonomy), **Brain** (Map, Sleep Cycle), and **Control** (Packs, Settings), plus a "What is this?" page.
+
 **What's in it:**
-- **Kanban board** — drag-and-drop, multi-select filters (status/priority/urgency/tags/version, +assignee on a cloud backend) with type-ahead, sorting, grouping; Notion-style task detail panel to create tasks, change status, edit start/due dates and custom fields, add changelog entries. The **version filter is sprint-aware** — current / planning / released sprints with set-current + mark-complete actions (backed by `state/.active-version.json`).
+- **Sleepy** (Workspace) — the dashboard's Search + Ask surface: a scoped recall widget that runs the same engine as the CLI (empty query = browse; typing = live debounced BM25; "Intelligent" = a Haiku intent pass), plus an in-app **interactive Claude Code** agent (multi-session tabs, split panes; desktop-gated, read-only by default). This is the dashboard twin of the desktop Sleepy notch.
+- **Tasks board** — drag-and-drop Kanban with **saved views** (each carrying its own persisted filter/sort/grouping), a two-pane **include/exclude** filter (status/priority/tags/version/assignee) with type-ahead, a **Versions** popover, toggleable card **Properties** badges, and an **At-Risk alert**; view prefs persist shared (`overrides/board.json`) or local (`state/board.local.json`). Notion-style task detail panel to create tasks, change status, edit start/due dates and custom fields, add changelog entries. The **version filter is sprint-aware** — current / planning / released sprints with set-current + mark-complete actions (backed by `state/.active-version.json`).
 - **Eisenhower matrix** — priority×urgency quadrant planning; **Scatter view** uses RICE scores.
 - **Time-axis task views** — **Timeline (Gantt)** rendering each task's start→due range, a **Calendar**, and an **Activity heatmap** of completion cadence (all driven by the same `start_date`/`due_date` range).
 - **Core editor** — split-pane markdown editing + live preview for soul/user/memory/etc.
 - **Knowledge manager** — search, pin/unpin; **Feature PRD viewer**; **SQL ER diagram** preview for data-structures.
+- **Taxonomy** (Memory) — view and edit the tag vocabulary (facets, aliases) from the UI; mirrors `dreamcontext taxonomy`.
+- **Packs** (Control) — browse and install/refresh skill packs from the UI.
 - **Version manager** — plan and release versions.
 - **Settings — cloud tasks** — enter the ClickUp/GitHub API token from the UI (written to gitignored `state/.secrets.json`, masked, never echoed), Test Connection, and **preview-then-provision** custom fields (a dry run lists what would be created vs. already exists); plus a **Task Format & Custom Fields** editor for `overrides/task.md` (raw template + structured field schema).
-- **Sleep tracker** — debt gauge, session-history timeline, and a list of every manual change made through the dashboard (recorded to `.sleep.json` so the agent consolidates your edits during sleep).
-- **Brain graph** — interactive network of memory/knowledge/features/decisions with explicit + inferred edges.
+- **Sleep Cycle** (sleep tracker) — debt gauge, session-history timeline, and a list of every manual change made through the dashboard (recorded to `.sleep.json` so the agent consolidates your edits during sleep).
+- **Map** (brain graph) — interactive network of memory/knowledge/features/decisions with explicit + inferred edges.
 - **Council Hall** — every debate as a searchable card grid; detail view with Overview / Agents / Matrix tabs.
 - **"What is this?"** explainer page with live faculty diagrams.
 

package/skill/references/knowledge-and-recall.md

@@ -102,6 +102,11 @@ Writes a CHANGELOG entry (`type=note`, `scope=quick`); the sleep cycle reconcile
 - BM25 is keyword/stemming-based, not semantic — "ML practitioner" won't match "data scientist" (haiku mode mitigates this).
 - Recall does **not** replace the SessionStart snapshot (soul/user/memory/active-tasks/knowledge-index are always pre-loaded). It is not a vector DB or mem0; the corpus is the same set the sleep agents curate.
 
+### Two depths of search: explore vs deep-research
+Recall feeds two read surfaces — pick by how much synthesis the question needs:
+- **`dreamcontext-explore`** (fast, single-pass): one sub-agent, recall-then-grep, one answer. Use for "where is X?" / "how does Y work?" on one project. This is the default and handles the vast majority of lookups.
+- **`dreamcontext-deep-research` skill** (iterative, multi-agent): when a question needs **synthesis across a large or multi-project / federated corpus** and one explore pass comes back thin. The main agent decomposes the question, fans out parallel `dreamcontext-explore` searchers across the corpus **and connected peer vaults**, loops to close gaps, **adversarially verifies** the load-bearing claims, then writes a **synthesized, cited** report. Invoke via `/dreamcontext-deep-research`. **Escalation rule:** start with explore; escalate only when one pass and one answer leave a cross-corpus question half-answered. It is read-only — synthesis, not mutation.
+
 ---
 
 ## Root-cause analysis pattern
@@ -123,12 +128,15 @@ Consistent tags make recall sharp; fragmented near-duplicate tags degrade it. Be
 dreamcontext taxonomy vocab [--facet <facet>] [--json]   # resolved vocabulary (defaults + core/taxonomy.json)
 dreamcontext taxonomy resolve <tag>                       # normalized form, classification, canonical
 dreamcontext taxonomy audit [--json]                      # surface non-canonical / orphan tags (read-only)
+dreamcontext taxonomy audit --fix [--dry-run] [--json]    # BULK-normalize alias/normalizable tags → canonical
 dreamcontext taxonomy init                                # scaffold core/taxonomy.json (idempotent)
 dreamcontext taxonomy add <facet:value>                   # add a new vocabulary tag
 dreamcontext taxonomy alias <alias> <canonical>           # merge a shorthand into a canonical tag
 ```
 Standard bare tags: `architecture`, `api`, `frontend`, `backend`, `database`, `devops`, `security`, `testing`, `design`, `decisions`, `onboarding`, `domain`. **Never hand-edit `core/taxonomy.json`** — mutate via the CLI. `sleep-product` runs taxonomy maintenance during consolidation.
 
+**Bulk-healing tag drift (`audit --fix`).** `taxonomy audit` only *reports* drift; `taxonomy audit --fix` *fixes* it in one shot across every knowledge/feature/task file. For each frontmatter tag it computes `normalizeTag → resolveAlias`; if that yields a **different tag that is canonical** in the vocabulary it rewrites it (e.g. `search → topic:recall`, `excalidraw → topic:excalidraw` once you've added that alias, `Architecture → architecture`). It is **safe by construction**: already-canonical tags are never touched (so `decisions` is not churned to `decision`), and orphan tags with no alias/canonical target are left untouched and reported as *"needs a vocab decision"* — resolve those first with `taxonomy add`/`taxonomy alias`, then re-run. The workflow is **alias-then-fix**: `taxonomy alias <orphan> <canonical>` teaches the mapping once, `audit --fix` applies it everywhere. Preview with `--fix --dry-run` (writes nothing), apply with `--fix`, automate with `--fix --json`. Idempotent — a second run is a no-op.
+
 ---
 
 ## Excalidraw boards (diagrams)

package/skill/references/sleep.md

@@ -8,21 +8,21 @@ Sleep debt accumulates automatically via hooks (per Write/Edit tool use). Hooks
 
 | Debt | Level | Per-change score | Required behavior |
 |------|-------|------------------|-------------------|
-| 0–3 | Alert | 1–3 changes → +1 | No action |
-| 4–6 | Drowsy | 4–8 changes → +2 | After completing a task: **inform user + offer** consolidation |
-| 7–9 | Sleepy | 9+ changes → +3 | At session start: **inform user + recommend** consolidation before new work |
-| 10+ | Must sleep | — | **Consolidate immediately**, before or right after the current task |
+| 0–7 | Alert | 1–3 changes → +1 | No action |
+| 8–13 | Drowsy | 4–8 changes → +2 | After completing a task: **inform user + offer** consolidation |
+| 14–19 | Sleepy | 9+ changes → +3 | At session start: **inform user + recommend** consolidation before new work |
+| 20+ | Must sleep | — | **Consolidate immediately**, before or right after the current task |
 
-Also triggers an advisory: a **★★★ bookmark** exists (regardless of debt), or **3+ sessions** since last sleep.
+Also triggers an advisory: a **★★★ bookmark** exists (regardless of debt), or **5+ sessions** since last sleep.
 
-Injected directives (SessionStart + every user message via UserPromptSubmit when debt ≥4):
-- Debt ≥10 → "CONSOLIDATION REQUIRED"
-- Debt ≥7 → "CONSOLIDATION RECOMMENDED"
-- Debt ≥4 → offer after the current task
+Injected directives (SessionStart + every user message via UserPromptSubmit when debt ≥8):
+- Debt ≥20 → "CONSOLIDATION REQUIRED"
+- Debt ≥14 → "CONSOLIDATION RECOMMENDED"
+- Debt ≥8 → offer after the current task
 
-**MANDATORY post-task check:** after any task/major implementation, if debt ≥4 tell the user: *"Sleep debt is [N]. I can consolidate now to preserve this work. Want me to run it?"* Never silently finish.
-**Auto-sleep (act without asking):** task completed with debt ≥7; major implementation finished with debt ≥4.
-**Ask first:** debt 4–6 after a task; accumulated small changes; user wrapping up.
+**MANDATORY post-task check:** after any task/major implementation, if debt ≥8 tell the user: *"Sleep debt is [N]. I can consolidate now to preserve this work. Want me to run it?"* Never silently finish.
+**Auto-sleep (act without asking):** task completed with debt ≥14; major implementation finished with debt ≥8.
+**Ask first:** debt 8–13 after a task; accumulated small changes; user wrapping up.
 
 For non-file-change work (architecture discussion, a decision with no edits): `dreamcontext sleep add <score> "<reason>"`.
 

package/skill-deep-research/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: dreamcontext-deep-research
+description: >
+  Load when a question needs synthesis across a LARGE or MULTI-PROJECT dreamcontext corpus —
+  more than `dreamcontext-explore` can answer in a single fast pass — or the user invokes
+  `/dreamcontext-deep-research`. Triggers: "deep research the brain", "research this across my
+  projects", "synthesize what we know about X across everything", "deep dive across the
+  connected vaults", "explore is too shallow for this", "pull together everything on X and
+  cite it", "cross-project / cross-corpus question", or any "tons of data, federated/tagged
+  vault" question where one explore agent and one answer under-serves. This is the heavy,
+  iterative, sub-agent-driven counterpart to `dreamcontext-explore`: it fans out searchers over
+  the whole curated corpus (knowledge + features + tasks + memory + CHANGELOG) AND connected
+  peer vaults, adversarially verifies the load-bearing claims, and returns a SYNTHESIZED, CITED
+  report — not raw hits.
+user-invocable: true
+alwaysApply: false
+tags: [deep-research, recall, synthesis, federation, cross-project, orchestration, sub-agents, dreamcontext]
+---
+
+# Deep Research — iterative, sub-agent-driven corpus synthesis
+
+You are the **orchestrator**. Like `curator`, `initializer`, `multi-review`, and `council`,
+**you do not do the bulk of the searching yourself** — you decompose the question, fan out
+`dreamcontext-explore` searchers in parallel, read their cited findings, loop to close gaps,
+adversarially verify the claims that matter, and then **you** write the synthesized report. Your
+value is the decomposition, the gap loop, the verification gate, and the final synthesis — not
+running every `recall` and `grep` by hand.
+
+**Why this exists, vs `dreamcontext-explore`.** Explore is tuned for **speed and a single
+answer**: one Haiku agent, a tight tool-call budget, recall-then-grep, return the best hit. That
+is the right tool for "where is X?" / "how does Y work?" on one project. It **under-serves** the
+question that needs *synthesis across many files and many projects*: "what have we decided about
+recall across all my vaults?", "reconcile everything we know about federation", "pull the whole
+history of how the sleep cycle evolved and cite it". For those, a single fast pass returns a
+fragment and stops. Deep research is the escalation: **iterative fan-out → verify → synthesize a
+cited answer**.
+
+| | `dreamcontext-explore` | `dreamcontext-deep-research` (this) |
+|---|---|---|
+| Shape | one sub-agent, one pass | main agent orchestrates many searchers + verifiers, looped |
+| Budget | tight (1–20 tool calls) | scaled to the corpus; multiple waves |
+| Scope | one project, narrow | whole corpus + **connected peer vaults** |
+| Output | the best hit, fast | a **synthesized, cited** report reconciling sources |
+| Verify | none | adversarial pass on load-bearing claims |
+| Use when | "where / how is X?" | "synthesize / reconcile / research X across everything" |
+
+**It is read-only.** Deep research never mutates the corpus. It may *recommend* capturing a
+finding (a knowledge file, a feedback item) at the end — but only with the user's say-so, via the
+normal CLI. It is not a writer.
+
+**Recall is the engine; the corpus index + peer connections are the substrate.** Every wave starts
+from `dreamcontext memory recall` (BM25 + Haiku intent extraction over the curated corpus), which
+already spans readable peers and namespaces cross-vault hits `<vault>::<type>/<slug>`. You are not
+grepping a blind filesystem — you are mining a pre-indexed, cross-project brain.
+
+## When to invoke
+
+- `/dreamcontext-deep-research` (primary entry).
+- A `dreamcontext-explore` pass came back thin, fragmented, or "found a piece but not the whole
+  picture", and the real question spans many files.
+- The question is explicitly **cross-project / federated**: "across my vaults", "everything we
+  know about X", "reconcile what project A and project B decided".
+- "Synthesize", "reconcile", "pull together and cite", "deep dive", "research" over the brain.
+
+**Scale the machinery to the corpus.** A small single-project brain rarely needs this — say so and
+just run one `dreamcontext-explore`. Reserve the full fan-out for a genuinely large or multi-project
+tagged corpus where one agent and one answer leave the question half-answered.
+
+## Commitment ritual (do this FIRST)
+
+1. **Announce**: tell the user you're running deep research — that it fans out read-only searchers
+   across the whole corpus and any connected peer vaults, verifies the key claims, and ends in a
+   cited synthesis. Confirm the question and its scope (which vaults, which time range if any).
+2. **TodoWrite** the phases (1–6) so the gates are visible. A phase isn't done until its gate passes.
+3. **Sharpen the question.** If it's underspecified ("research recall"), narrow it with the user
+   first (recall *precision*? recall *architecture*? across *which* projects?) — a vague question
+   fans out into vague reports. One or two clarifying questions beat a 10-agent wild goose chase.
+
+## The flow (the main agent runs this directly — sub-agents can't nest)
+
+In this harness a sub-agent cannot dispatch sub-agents, so **you** own the loop and the fan-out —
+exactly like the sleep cycle. `dreamcontext-explore` is your searcher *and* your verifier; you are
+the planner and the synthesizer.
+
+### Phase 1 — Scope & seed (recall-driven)
+
+- Establish the corpus surface: read the **Connected projects** section of the snapshot, or run
+  `dreamcontext connections list` / `dreamcontext vaults list`. Decide the span:
+  - current vault only → recall as-is (already spans eligible peers by default),
+  - specific peers → `--vault <name>` (repeatable),
+  - everything readable → `--connected` (out/both peers) or `--all-vaults`.
+- **Seed with recall, in JSON, scoped by type:**
+  ```bash
+  dreamcontext memory recall "<facet>" --json --top 15 --types knowledge,feature,task,memory,changelog --connected
+  ```
+  Run it for **2–4 different phrasings/facets** of the question — recall is cheap (<100ms, zero
+  token overhead) and different keywords surface different docs. Collect the union of hits.
+- **Decompose** the question into 3–6 sub-questions / facets / per-project slices. This decomposition
+  is the fan-out plan. Write it into the Todo.
+
+### Phase 2 — Fan-out search (parallel `dreamcontext-explore`)
+
+- Dispatch **one `dreamcontext-explore` per sub-question / corpus slice / project, in parallel**
+  (one message, multiple `Agent` calls). Each searcher gets:
+  - its narrow sub-question,
+  - the seed hits relevant to it (file paths / `<vault>::<slug>` from Phase 1 — so it doesn't
+    re-discover them),
+  - an explicit instruction: **return findings WITH citations** (absolute path or
+    `<vault>::<type>/<slug>`), and flag anything that looks contradictory or stale.
+- Searchers are read-only and recall-first by design — that's the whole point of using them. Scope a
+  searcher to a peer when a specific sibling project owns that slice (it can `recall --vault`,
+  `snapshot --vault`, or read the peer's files directly).
+
+### Phase 3 — Gap loop (loop-until-dry)
+
+- Read every searcher's report. Build a running map: **claim → source(s)**.
+- Identify **gaps** (a facet nobody answered), **contradictions** (two sources disagree), and
+  **dangling references** (a doc cites another you haven't read). Dispatch a **second wave** of
+  `dreamcontext-explore` aimed only at those.
+- Stop when a wave returns nothing materially new (two dry waves) or the picture is complete enough
+  to answer. **Log what you chose not to chase** — silent truncation reads as "covered everything".
+
+### Phase 4 — Adversarial verification (the gate)
+
+- For each **load-bearing claim** (the ones the answer actually rests on), dispatch a
+  `dreamcontext-explore` **verifier** whose job is to *check the claim against its cited source* —
+  open the file, confirm the source says what the claim says, and look for a more recent doc that
+  supersedes it. Default to **"unverified"** when the source doesn't actually support the claim.
+- Drop or downgrade claims that don't survive. A plausible-but-uncited assertion does not enter the
+  report. This is what separates deep research from a confident hallucination.
+
+### Phase 5 — Synthesize (you write this — not a sub-agent)
+
+- **You** write the report from the verified claim→source map. It must be a *synthesis*, not a
+  concatenation of searcher outputs:
+  - **Answer** — the reconciled conclusion, organized by the question's structure.
+  - **Every claim carries a citation** — absolute path or `<vault>::<type>/<slug>`. No citation ⇒
+    it doesn't go in (or it's explicitly marked as inference).
+  - **Cross-project provenance** — when projects agree, say so; when they diverge, surface the
+    divergence with both sources rather than silently picking one.
+  - **Contradictions & open questions** — name them; don't paper over them.
+  - **Confidence** — note where evidence is thin or a source looked stale.
+
+### Phase 6 — Persist (optional, only on consent)
+
+- If durable findings emerged ("we actually decided X across A and B" / "these three docs are
+  near-duplicates"), **offer** to capture them — a `dreamcontext knowledge create`, or a
+  `dreamcontext feedback` if deep research exposed a recall/structure gap. Never auto-write; the
+  user confirms. Deep research is a reader.
+
+## Output contract
+
+A **synthesized, cited report** — never a raw hit dump. The minimum bar:
+- Citations are **mandatory** for every load-bearing claim (path or `<vault>::<type>/<slug>`).
+- Cross-vault hits are first-class, not noise — provenance is the point on a multi-project corpus.
+- Contradictions and gaps are surfaced, not hidden.
+- Any coverage you deliberately capped is stated.
+
+## Boundaries
+
+- **Read-only.** No writes except the optional, consent-gated Phase 6 capture via the normal CLI.
+- **Reuse `dreamcontext-explore`.** Don't reinvent a searcher — it's the tested, recall-accelerated,
+  read-only explorer. This skill is the *orchestration* around it.
+- **Stay in the decisions/knowledge lane.** For raw code *structure* ("who calls this function?")
+  the code-graph lane (graphify) owns it — deep research synthesizes curated decisions/knowledge, it
+  is not an AST indexer.
+- **Scale to the corpus.** Don't fan out 10 agents at a 12-file single-project brain. Match the
+  machinery to the data.
+
+## Relationship to the rest of dreamcontext
+
+- **vs `dreamcontext-explore`** — explore is the fast single-pass searcher; this is the iterative
+  multi-agent synthesizer that *uses* explore. Escalate from explore → deep-research when one pass
+  and one answer leave a cross-corpus question half-answered.
+- **vs `sleep`** — sleep *writes* (consolidates experience into memory); deep research *reads*
+  (synthesizes existing memory into an answer). Same fan-out shape, opposite direction.
+- **vs `curator`** — curator refactors the corpus's *shape*; deep research mines its *content*.
+- **vs the generic `deep-research` web skill** — that one researches the open web; this one researches
+  *your brain* (the curated corpus + connected vaults). Same harness shape, different substrate.

package/dist/dashboard/assets/channel-Cm_3yJBQ.js

@@ -1 +0,0 @@
-import{aq as o,ar as n}from"./index-BvNbWm56.js";const t=(r,a)=>o.lang.round(n.parse(r)[a]);export{t as c};

package/dist/dashboard/assets/classDiagram-6PBFFD2Q-CN3Z7CiL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-_7FEisTX.js";import{_ as i}from"./index-BvNbWm56.js";import"./chunk-FMBD7UC4-PlFeuiZ_.js";import"./chunk-YZCP3GAM-DGLXUzMF.js";import"./chunk-55IACEB6-Cz4CusRM.js";import"./chunk-EDXVE4YY-C5yb7Q9H.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/dashboard/assets/classDiagram-v2-HSJHXN6E-CN3Z7CiL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-_7FEisTX.js";import{_ as i}from"./index-BvNbWm56.js";import"./chunk-FMBD7UC4-PlFeuiZ_.js";import"./chunk-YZCP3GAM-DGLXUzMF.js";import"./chunk-55IACEB6-Cz4CusRM.js";import"./chunk-EDXVE4YY-C5yb7Q9H.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/dashboard/assets/clone-Cq5lwLPz.js

@@ -1 +0,0 @@
-import{b as r}from"./graph-Dm-hvy_w.js";var e=4;function a(o){return r(o,e)}export{a as c};