npm - dreamcontext - Versions diffs - 0.17.1 → 0.18.0 - Mend

dreamcontext 0.17.1 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (181) hide show

package/dist/skill-packs/goal-skill/assets/goal-skill-demo.cjs ADDED Viewed

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// Dummy goal-skill run: drives the live state file through every phase so the
+// viewer (localhost:4747) can be watched end-to-end. No real agents are spawned.
+//   node .claude/goal-skill-demo.cjs
+const fs = require('fs');
+const path = require('path');
+const FILE = path.join(process.cwd(), '_dream_context', 'tmp', '.goal-skill-live.json');
+fs.mkdirSync(path.dirname(FILE), { recursive: true });
+const started = new Date().toISOString();
+const F = (s) => ({ s });
+// [seconds-to-hold, phase, iters, impl]
+const BEATS = [
+  [8,  'plan',       { plan: 1 },                                    null],
+  [8,  'review',     { plan: 1, review: 1 },                         null],
+  [7,  'plan',       { plan: 2, review: 1 },                         null],
+  [7,  'review',     { plan: 2, review: 2 },                         null],
+  [6,  'plan',       { plan: 3, review: 2 },                         null],
+  [6,  'review',     { plan: 3, review: 3 },                         null],
+  [5,  'task',       { plan: 3, review: 3 },                         null],
+  [8,  'impl',       { plan: 3, review: 3 }, { wave: 1, waves: 3, forks: [F('run'), F('run'), F('run')] }],
+  [5,  'impl',       { plan: 3, review: 3 }, { wave: 1, waves: 3, forks: [F('done'), F('run'), F('run')] }],
+  [8,  'impl',       { plan: 3, review: 3 }, { wave: 2, waves: 3, forks: [F('done'), F('done'), F('done'), F('run'), F('run')] }],
+  [6,  'impl',       { plan: 3, review: 3 }, { wave: 2, waves: 3, forks: [F('done'), F('done'), F('done'), F('run'), F('fail')] }],
+  [6,  'impl',       { plan: 3, review: 3 }, { wave: 2, waves: 3, forks: [F('done'), F('done'), F('done'), F('done'), F('run')] }],
+  [8,  'impl',       { plan: 3, review: 3 }, { wave: 3, waves: 3, forks: [F('done'), F('done'), F('done'), F('done'), F('done'), F('run')] }],
+  [7,  'codereview', { plan: 3, review: 3, codereview: 1 }, { wave: 3, waves: 3, forks: Array(6).fill(F('done')) }],
+  [6,  'impl',       { plan: 3, review: 3, codereview: 2 }, { wave: 3, waves: 3, forks: [...Array(5).fill(F('done')), F('run')] }],
+  [6,  'codereview', { plan: 3, review: 3, codereview: 2 }, { wave: 3, waves: 3, forks: Array(6).fill(F('done')) }],
+  [7,  'validate',   { plan: 3, review: 3, codereview: 2, validate: 1 }, { wave: 3, waves: 3, forks: Array(6).fill(F('done')) }],
+  [90, 'done',       { plan: 3, review: 3, codereview: 2, validate: 1 }, { wave: 3, waves: 3, forks: Array(6).fill(F('done')) }],
+];
+let i = 0;
+function step() {
+  if (i >= BEATS.length) {
+    fs.rmSync(FILE, { force: true });
+    console.log('demo finished — state cleared');
+    return;
+  }
+  const [hold, phase, iters, impl] = BEATS[i];
+  const st = { goal: 'demo-dummy-goal', started, updated: new Date().toISOString(), phase, iters };
+  // Scope the demo run to the launching session (if any) — same contract as a real run.
+  if (process.env.CLAUDE_CODE_SESSION_ID) st.session = process.env.CLAUDE_CODE_SESSION_ID;
+  if (impl) st.impl = impl;
+  fs.writeFileSync(FILE, JSON.stringify(st));
+  console.log(`beat ${i + 1}/${BEATS.length}: ${phase}` + (impl ? ` wave ${impl.wave}/${impl.waves}` : ''));
+  i++;
+  setTimeout(step, hold * 1000);
+}
+step();

package/dist/skill-packs/goal-skill/assets/goal-skill-viewer.cjs ADDED Viewed

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// Live Excalidraw-style viewer for a goal-skill v2 run.
+// Serves a hand-drawn animated graph of _dream_context/tmp/.goal-skill-live.json
+// (the same state file the app's live panel reads — single writer: the orchestrator).
+//   node .claude/goal-skill-viewer.cjs [port]     default port 4747
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const PORT = Number(process.argv[2]) || 4747;
+const STATE = path.join(process.cwd(), '_dream_context', 'tmp', '.goal-skill-live.json');
+const HTML = `<!doctype html><html><head><meta charset="utf-8"><title>goal-skill live</title>
+<style>
+  :root { color-scheme: dark; }
+  body { margin:0; background:#121217; color:#e8e8ec; font-family:'Chalkboard SE','Comic Sans MS','Segoe Print',cursive;
+         display:flex; flex-direction:column; align-items:center; min-height:100vh; }
+  header { display:flex; gap:14px; align-items:baseline; padding:18px 0 0; }
+  header .mark { color:#b197fc; font-size:22px; font-weight:700; }
+  header .goal { color:#aaa; font-size:17px; }
+  header .clock { color:#666; font-size:15px; }
+  #wrap { width:min(96vw,1400px); }
+  svg { width:100%; height:auto; }
+  .node rect { stroke-width:2.4px; }
+  .node text { font-family:inherit; font-size:17px; font-weight:700; }
+  .node .sub { font-size:12.5px; font-weight:400; }
+  .pending rect { fill:#1d1d24; stroke:#4a4a55; stroke-dasharray:7 5; }
+  .pending text { fill:#666; }
+  .done rect { fill:#b2f2bb; stroke:#2f9e44; }
+  .done text { fill:#0b2e13; }
+  .active text { fill:#101014; }
+  .active rect { animation:pulse 1.4s ease-in-out infinite; }
+  @keyframes pulse { 0%,100%{ filter:drop-shadow(0 0 3px var(--glow,#4dabf7)); }
+                     50%{ filter:drop-shadow(0 0 16px var(--glow,#4dabf7)); } }
+  .arrow { stroke:#8a8a95; stroke-width:2.2; fill:none; marker-end:url(#arr); }
+  .arrow.dim { stroke:#3a3a44; }
+  .loop { stroke-width:2; fill:none; stroke-dasharray:8 6; marker-end:url(#arr); opacity:.35; }
+  .loop.hot { opacity:1; animation:flow 1s linear infinite; }
+  @keyframes flow { to { stroke-dashoffset:-14; } }
+  .heat { font-size:19px; font-weight:800; }
+  .sat { stroke:#101014; stroke-width:1.4; }
+  .sat.run { animation:blink 1s ease-in-out infinite; }
+  @keyframes blink { 50%{ opacity:.35; } }
+  .wave { fill:#66d9e8; font-size:14px; }
+  #idle { color:#555; font-size:18px; margin-top:8px; display:none; }
+  .rough { filter:url(#rough); }
+  #donebanner { fill:#2f9e44; font-size:30px; font-weight:800; display:none; }
+</style></head><body>
+<header><span class="mark">&#9068; goal-skill live</span><span class="goal" id="goal"></span><span class="clock" id="clock"></span></header>
+<div id="idle">no active goal-skill run &mdash; waiting&hellip;</div>
+<div id="wrap"><svg viewBox="0 0 1400 430">
+<defs>
+  <marker id="arr" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7.5" markerHeight="7.5" orient="auto-start-reverse">
+    <path d="M0,0 L10,5 L0,10 z" fill="#8a8a95"/></marker>
+  <filter id="rough"><feTurbulence type="fractalNoise" baseFrequency="0.035" numOctaves="2" seed="7" result="n"/>
+    <feDisplacementMap in="SourceGraphic" in2="n" scale="2.6"/></filter>
+</defs>
+<g class="rough" id="scene"></g>
+</svg></div>
+<script>
+const PAL = { blue:['#a5d8ff','#1971c2'], yellow:['#ffec99','#f08c00'], mint:['#96f2d7','#087f5b'] };
+const NODES = [
+  { id:'plan',       label:'PLAN',      sub:'planner fork',    color:'blue',   x:40   },
+  { id:'review',     label:'REVIEW',    sub:'clean judges',    color:'yellow', x:262  },
+  { id:'task',       label:'TASK DOC',  sub:'map + registry',  color:'mint',   x:484  },
+  { id:'impl',       label:'IMPL',      sub:'wave forks',      color:'blue',   x:706  },
+  { id:'codereview', label:'CODE-REV',  sub:'clean',           color:'yellow', x:928  },
+  { id:'validate',   label:'VALIDATE',  sub:'evidence',        color:'yellow', x:1150 },
+];
+const NY=180, NW=170, NH=74;
+const svgNS='http://www.w3.org/2000/svg';
+const scene=document.getElementById('scene');
+function el(t,a){const e=document.createElementNS(svgNS,t);for(const k in a)e.setAttribute(k,a[k]);return e;}
+// static skeleton
+NODES.forEach((n,i)=>{
+  const g=el('g',{class:'node pending',id:'n-'+n.id});
+  g.appendChild(el('rect',{x:n.x,y:NY,width:NW,height:NH,rx:14}));
+  const t=el('text',{x:n.x+NW/2,y:NY+32,'text-anchor':'middle'}); t.id='t-'+n.id; g.appendChild(t);
+  const s=el('text',{x:n.x+NW/2,y:NY+54,'text-anchor':'middle',class:'sub'}); s.id='s-'+n.id; s.textContent=n.sub; g.appendChild(s);
+  scene.appendChild(g);
+  if(i<NODES.length-1) scene.appendChild(el('path',{class:'arrow dim',id:'a-'+i,
+    d:'M'+(n.x+NW+4)+','+(NY+NH/2)+' L'+(NODES[i+1].x-8)+','+(NY+NH/2)}));
+});
+// loop arcs: review->plan (top), codereview->impl & validate->impl (bottom)
+function arc(id,x1,x2,y,cy){ scene.appendChild(el('path',{class:'loop',id,stroke:'#ffd43b',
+  d:'M'+x1+','+y+' Q'+((x1+x2)/2)+','+cy+' '+x2+','+y})); }
+arc('l-review', NODES[1].x+60, NODES[0].x+110, NY-6, NY-120);
+arc('l-codereview', NODES[4].x+60, NODES[3].x+120, NY+NH+6, NY+NH+96);
+arc('l-validate', NODES[5].x+60, NODES[3].x+50,  NY+NH+6, NY+NH+150);
+// arc → which iter count it visualizes: the review→plan arc glows with PLAN's revision rounds
+const heats={review:['l-review','plan',(NODES[0].x+110+NODES[1].x+60)/2,NY-70],
+             codereview:['l-codereview','codereview',(NODES[3].x+120+NODES[4].x+60)/2,NY+NH+64],
+             validate:['l-validate','validate',(NODES[3].x+50+NODES[5].x+60)/2,NY+NH+118]};
+for(const k in heats){const h=el('text',{x:heats[k][2],y:heats[k][3],'text-anchor':'middle',class:'heat'});h.id='h-'+k;scene.appendChild(h);}
+const satg=el('g',{id:'sats'}); scene.appendChild(satg);
+const doneT=el('text',{x:NODES[5].x+NW/2,y:NY-40,'text-anchor':'middle',id:'donebanner'}); doneT.textContent='\\u2714 DONE'; scene.appendChild(doneT);
+const ORDER=NODES.map(n=>n.id);
+function heatColor(n){ return n>=4?'#ff6b6b':n===3?'#ffa94d':'#ffd43b'; }
+function render(st){
+  const idle=document.getElementById('idle');
+  if(!st){ idle.style.display='block'; document.getElementById('goal').textContent='';
+    document.getElementById('clock').textContent='';
+    NODES.forEach(n=>{document.getElementById('n-'+n.id).setAttribute('class','node pending');
+      document.getElementById('t-'+n.id).textContent=n.label;});
+    doneT.style.display='none'; satg.innerHTML=''; waveT.textContent='';
+    for(const k in heats){document.getElementById('h-'+k).textContent='';
+      document.getElementById(heats[k][0]).setAttribute('class','loop');}
+    return; }
+  idle.style.display='none';
+  document.getElementById('goal').textContent=st.goal||'';
+  const mins=st.started?Math.max(0,Math.round((Date.now()-Date.parse(st.started))/60000)):null;
+  document.getElementById('clock').textContent=(mins!=null?mins+' min':'');
+  const cur=st.phase==='done'?ORDER.length:Math.max(0,ORDER.indexOf(st.phase));
+  NODES.forEach((n,i)=>{
+    const g=document.getElementById('n-'+n.id), t=document.getElementById('t-'+n.id);
+    const it=(st.iters||{})[n.id]||0;
+    if(st.phase==='done'||i<cur){ g.setAttribute('class','node done'); t.textContent='\\u2714 '+n.label; }
+    else if(i===cur){ g.setAttribute('class','node active');
+      const [f,s]=PAL[n.color]; const r=g.querySelector('rect');
+      r.style.fill=f; r.style.stroke=s; g.style.setProperty('--glow',s); t.textContent='\\u25B6 '+n.label; }
+    else { g.setAttribute('class','node pending'); const r=g.querySelector('rect');
+      r.style.fill=''; r.style.stroke=''; t.textContent=n.label; }
+    if(it>1){ const ts=document.createElementNS(svgNS,'tspan');
+      ts.textContent=' \\u00D7'+it; ts.style.fill=heatColor(it); t.appendChild(ts); }
+    if(i<NODES.length-1) document.getElementById('a-'+i).setAttribute('class','arrow'+(i<cur?'':' dim'));
+  });
+  for(const k in heats){
+    const n=(st.iters||{})[k]||0; const h=document.getElementById('h-'+k); const l=document.getElementById(heats[k][0]);
+    if(n>=2){ h.textContent='\\u00D7'+n; h.style.fill=heatColor(n); l.setAttribute('class','loop hot'); l.style.stroke=heatColor(n); }
+    else { h.textContent=''; l.setAttribute('class','loop'); l.style.stroke='#ffd43b'; }
+  }
+  satg.innerHTML='';
+  const forks=(st.impl&&st.impl.forks)||[];
+  const cx=NODES[3].x+NW/2, cy=NY+NH/2, RX=112, RY=62;
+  forks.forEach((f,i)=>{
+    const a=-Math.PI/2+i*(2*Math.PI/Math.max(forks.length,1));
+    const col=f.s==='done'?'#69db7c':f.s==='run'?'#ffd43b':f.s==='fail'?'#ff6b6b':'#555';
+    satg.appendChild(el('circle',{cx:cx+RX*Math.cos(a),cy:cy+RY*Math.sin(a),r:9,fill:col,
+      class:'sat'+(f.s==='run'?' run':'')}));
+  });
+  document.getElementById('s-impl').textContent=(st.impl&&st.impl.waves)
+    ?('wave '+(st.impl.wave||1)+' / '+st.impl.waves):'wave forks';
+  doneT.style.display=st.phase==='done'?'block':'none';
+}
+async function tick(){ try{ const r=await fetch('/state',{cache:'no-store'});
+    render(r.ok?await r.json():null); }catch(e){ render(null); } }
+tick(); setInterval(tick,800);
+</script></body></html>`;
+const server = http.createServer((req, res) => {
+  if (req.url.startsWith('/state')) {
+    try {
+      const raw = fs.readFileSync(STATE, 'utf8');
+      const st = JSON.parse(raw);
+      const upd = Date.parse(st.updated || st.started || 0);
+      if (!upd || Date.now() - upd > 3 * 3600 * 1000) throw new Error('stale');
+      res.writeHead(200, { 'content-type': 'application/json' });
+      return res.end(raw);
+    } catch {
+      res.writeHead(404); return res.end();
+    }
+  }
+  res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+  res.end(HTML);
+});
+server.on('error', (e) => {
+  if (e.code === 'EADDRINUSE') {
+    console.error('port ' + PORT + ' is already in use — a viewer is probably running: http://localhost:' + PORT);
+    process.exit(1);
+  }
+  throw e;
+});
+server.listen(PORT, '127.0.0.1', () => {
+  const url = 'http://localhost:' + PORT;
+  console.log('goal-skill live viewer: ' + url);
+  if (process.platform === 'darwin' && !process.env.NO_OPEN) exec('open ' + url);
+});

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "dreamcontext",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "dreamcontext — the persistent brain for your AI agents. Remembers what you built, knows how your project works.",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
     "skill-curator",
     "skill-deep-research",
     "skill-sync",
+    "skill-task-manager",
     "skill-packs",
     "agents",
     "README.md",

package/skill/references/integrations.md CHANGED Viewed

@@ -55,6 +55,8 @@ dreamcontext config task-backend local
 dreamcontext tasks sync [push|pull|both]   # default: both; no-op on the local backend
 dreamcontext tasks sync --hook             # best-effort mode for git hooks (never fails, exit 0)
 dreamcontext tasks sync --json             # machine-readable sync report
+dreamcontext tasks sync pull --reconcile   # heal assignees + version that sit BELOW the watermark
+dreamcontext tasks sync --refresh-meta     # force-refresh cached statuses/members/fields (skip the hourly throttle)
 dreamcontext tasks members [--json]        # people with access to the remote list (assignee candidates)
 dreamcontext tasks provision               # create recommended + override-declared custom fields (reuses existing ones by name)
 dreamcontext tasks sync-hooks install|uninstall   # manage the git sync triggers
@@ -66,6 +68,58 @@ dreamcontext config show        # shows task backend, ClickUp token presence (ma
 ```
 The mirror, sync ledger, and conflict files are derived and gitignored — never commit them, never hand-edit them.
+#### Gotchas (#184 — learned the hard way)
+**Prefer one list per project — but a shared list is now survivable (#177).** A ClickUp
+list shared by two dreamcontext projects pulls the other's tasks into your brain. A
+foreign `completed` task then reads as proof that THIS project has the capability when
+the work actually landed in a sibling repo — a sleep specialist once read one and
+concluded "already done", nearly dropping a whole work group. Three layers now guard
+against it:
+- **Provenance stamp.** Every pushed row is stamped with an invisible `dcproject:<id>`
+  tag identifying the owning project. On pull, a row whose stamp names *another* project
+  is recorded with a `source_project:` frontmatter field and shown `⚠ FOREIGN` in the
+  SessionStart snapshot and `⚠ foreign:<id>` in `tasks list`, so it is visibly foreign.
+  The id is derived from `projectId` in `.config.json`, else the first `linkedRepos` URL,
+  else the project folder name; unstamped rows (created in the ClickUp UI, or pushed
+  before this shipped) are always treated as native, so there are no false positives.
+- **Scope filter.** Set `clickup.scope: "project"` in `.config.json` to *skip importing*
+  foreign rows entirely (unstamped rows are still pulled — we never silently drop a row
+  we can't prove is foreign). Default `"all"` keeps every row (marked, not dropped).
+- **`dreamcontext doctor`** warns when two registered projects point at the same list.
+The fix is still ideally one list per project; the above makes a shared list safe when
+that isn't possible.
+**Set the list's statuses in the ClickUp UI BEFORE the first sync to a new list.**
+ClickUp API v2 cannot write folder/list statuses (`PUT /folder/{id}` with
+`override_statuses` returns `override_statuses:false`), so dreamcontext cannot create
+them for you. If a dreamcontext status (`todo`/`in_progress`/`in_review`) has no name
+match on the list, the push omits the field and ClickUp stamps the list's first open
+status — every task landing in e.g. `backlog`. The sync warns when this is about to
+happen; heal it by adding the status in the UI, then:
+```bash
+dreamcontext tasks sync --refresh-meta   # bypass the hourly meta cache
+```
+**Changing the sync target invalidates the cached list meta automatically.** The
+cached statuses/members/field-defs and the pull watermark are stamped with the list
+they describe, so repointing `clickup-list` — via `--migrate`, `--keep`, the dashboard,
+or a hand-edited config — drops them and re-reads the new list in full. You should
+never need to hand-edit `state/.tasks-sync.json`; if you think you do, that is a bug.
+**ClickUp lowercases tag names**, and `version` rides the tags as `version:<v>`. A
+sprint pushed as `S5 (Jul 13 - Jul 17)` comes back as `s5 (jul 13 - jul 17)`. The pull
+restores the canonical spelling by folding against `RELEASES.json` + the active
+sprint, so register a sprint before syncing tasks into it — an *unregistered* version
+cannot be canonicalized and will not match a sprint bucket on the board. A version tag
+added in ClickUp after import lands below the sync watermark and needs:
+```bash
+dreamcontext tasks sync pull --reconcile   # heals assignees + version below the watermark
+dreamcontext tasks version <task> "S5 (Jul 13 - Jul 17)"   # or set it directly
+```
 ### GitHub Issues
 The same backend interface, talking **plain GitHub Issues over REST** (no GraphQL). Tasks map ~1:1 onto issues — the **issue body is the task markdown** — and the four-state status is carried by issue `state`/`state_reason` plus `dc:*` labels.

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

@@ -41,6 +41,8 @@ dreamcontext knowledge move <slug> <folder>   # knowledge/<slug>.md → knowledg
 It moves the file **and** rewrites every inbound `[[wikilink]]` in one atomic step (target token only; `|alias` and `#anchor` are preserved), keeps the file first-class in index/recall/snapshot/dashboard, and migrates its `knowledge_access` decay key. Folder names are free-form — nothing is reserved; nested folders are allowed; path traversal and clobbering an existing destination are rejected. Context grouping is normally done by `sleep-product` during consolidation — its "Organize" pass groups files that share a clear topic and calls this same command. During active work, just create knowledge with `dreamcontext knowledge create` and let sleep organize, or run `knowledge move` yourself — but never `mv` + hand-edit links by hand. When creating a brand-new doc you may place it directly in its context folder.
+**Moving a whole board directory.** The **same command** relocates an Excalidraw board's `<title>/` wrapper folder as one unit — pass the **directory** slug instead of a file slug (`dreamcontext knowledge move diagrams/recall system` → `knowledge/system/recall/`). When `<slug>` resolves to a directory (and no `<slug>.md` exists) that contains a `*.excalidraw.md`, the command carries the board **and its dark tooling siblings** (`.board.cjs`, spec `.json`, helper `.md`) together, rewrites the path-based inbound `[[wikilinks]]` for every indexed `.md` inside (board + any co-located teardown), and migrates each file's decay key — so a board is never split from its generator across two folders. This is the sanctioned way to conform a legacy `knowledge/diagrams/<title>/` board (or any already-foldered board) to the **board-inside-its-context-folder** convention; you no longer need `mv`. A directory with no board inside is rejected (move plain knowledge with a file slug); so are traversal, self-nesting, and clobbering an existing destination.
 ---
 ## Memory functions — what they are and how to use them
@@ -167,4 +169,4 @@ Rules:
 Decision rule: *"Will a future session need this? → its context folder under `knowledge/`. Throwaway? → `inbox/` or `workspace/`."*
-> **Legacy note:** older projects kept all boards under a single top-level `knowledge/diagrams/` tree, and `dreamcontext migrations apply-diagrams` still maintains flat boards there (folds them into per-title folders + rewrites `[[wikilinks]]` atomically — never hand-edit links). That layout still indexes and renders, but new boards should go in their **context folder**, and `sleep-product` keeps the store organized over time.
+> **Legacy note:** older projects kept all boards under a single top-level `knowledge/diagrams/` tree. `dreamcontext migrations apply-diagrams` still *folds flat boards there into per-title folders* (in place, rewriting `[[wikilinks]]` atomically — never hand-edit links). To then **relocate a foldered board into its real context folder** — e.g. `knowledge/diagrams/recall/` → `knowledge/system/recall/` — run `dreamcontext knowledge move diagrams/recall system` (directory move; see "Moving a whole board directory" above), which carries the board + its tooling siblings as one unit. That legacy layout still indexes and renders, but new boards should go in their **context folder**, and `sleep-product` keeps the store organized over time.

package/skill/references/sleep.md CHANGED Viewed

@@ -56,8 +56,8 @@ For non-file-change work (architecture discussion, a decision with no edits): `d
    **Insight-fed objectives:** if `_dream_context/lab/insights/` is non-empty, also run `dreamcontext lab list` — an objective fed by a bound insight (`binding.objective` in the manifest) has a *measured* KR `current` owned by `lab sync`; no specialist hand-writes it. Surface any bound insight whose cache is stale or errored ("KR for `<objective>` is fed by insight `<slug>`, last synced `<date>` — suggest `dreamcontext lab sync <slug>`"). **Sleep NEVER runs `lab sync`** — credentials, latency, non-determinism; refreshing is always an explicit user/agent action outside sleep.
 8. **Marketing pass** if `_dream_context/marketing/` exists: `dreamcontext mk rem-sleep`.
 9. **Council promote check:** `dreamcontext council list --unpromoted` — promote if the user engaged positively.
-10. **`dreamcontext sleep done "<one-paragraph summary stitched from specialist reports>"`** — clears pre-epoch state, resets debt, writes a history entry. (If a remote backend — ClickUp or GitHub — is active and any task pushes failed, this auto-retries once, then errors loudly with the failed slugs.) **Brain sync also fires here:** if a shared brain repo is active (`brainRepo.autoSync`), `sleep done` runs a foreground `brain sync` (fetch→merge→commit→push). Sync failure never fails sleep — but on a prose conflict it pauses with `awaiting-agent` and prints the `/dream-sync` prompt; run that skill, then `brain sync --continue`. Full model → [brain-sync.md](brain-sync.md).
-11. **Report** the consolidated summary to the user.
+10. **`dreamcontext sleep done "<summary>" [--flag <key>::<label>[::<task-slug>]]...`** — clears pre-epoch state, resets debt, writes a history entry. Before running it, collect every recidivism flag the specialists reported (sleep-state's Recidivism flags block, sleep-tasks' grooming (e)) and pass each as its own `--flag` — repeatable, ONE `--flag` per flag, never comma-separated (e.g. `--flag recurring-task:fix-x::"fix-x recurred"::fix-x --flag ceiling-blocked:2.memory.md::"blocked again"`). At 3 consecutive cycles on the same `key`, `sleep done` itself surfaces an escalation ask and bumps the linked task's priority — you relay what specialists reported, you don't compute the streak. (If a remote backend — ClickUp or GitHub — is active and any task pushes failed, this auto-retries once, then errors loudly with the failed slugs.) **Brain sync also fires here:** if a shared brain repo is active (`brainRepo.autoSync`), `sleep done` runs a foreground `brain sync` (fetch→merge→commit→push). Sync failure never fails sleep — but on a prose conflict it pauses with `awaiting-agent` and prints the `/dream-sync` prompt; run that skill, then `brain sync --continue`. Full model → [brain-sync.md](brain-sync.md).
+11. **Report** the consolidated summary to the user — include the semantic dedup digest line `sleep done` printed (`Semantic dedup since epoch: X merge / Y review / Z create (N decisions).`, when non-zero) and any recidivism escalation asks or curator-task creation it surfaced.
 ---
@@ -66,8 +66,8 @@ For non-file-change work (architecture discussion, a decision with no edits): `d
 | Specialist | Owns | Notes |
 |---|---|---|
 | `sleep-tasks` | Task files (`state/*.md`) | Reconciles task bodies to truth, bumps statuses, creates tasks for untracked work, attaches to the planning version, sets the start/due range, and keeps declared custom fields current (never fabricating `ask` fields in the no-user sleep context). When objectives exist, proposes `objectives:` links for tasks with an EMPTY/absent list (multiple slugs when a task serves several outcomes) — **never overwrites a non-empty list** (that's a PO decision). May refresh a KR's observed `current` via `roadmap objective metric` — EXCEPT objectives fed by a bound Lab insight (measured by `lab sync`; hands-off, staleness surfaced instead). |
-| `sleep-state` | Core identity (soul, user, memory, core 3–6), CHANGELOG, RELEASES | Records patterns/decisions/preferences, writes a changelog entry per meaningful change since the epoch, surfaces release readiness, enforces anti-bloat ceilings, flags stale knowledge for `sleep-product`. |
-| `sleep-product` | Knowledge files + feature PRDs | Creates/reconciles `knowledge/*.md` and `knowledge/features/*.md` (typed knowledge, `type: feature`), processes staleness flags, maintains the knowledge index + taxonomy. |
+| `sleep-state` | Core identity (soul, user, memory, core 3–6), CHANGELOG, RELEASES | Records patterns/decisions/preferences, writes a changelog entry per meaningful change since the epoch, surfaces release readiness, enforces anti-bloat ceilings, flags stale knowledge for `sleep-product`. Rare standing exception: when a ceiling and a genuinely-warranted promotion collide, may archive the oldest blocked Decision to `knowledge/archive/<core>-<period>.md` (archive-before-delete: write, verify, then replace). Reports recurring problems as recidivism flags (see step 10). |
+| `sleep-product` | Knowledge files + feature PRDs | Creates/reconciles `knowledge/*.md` and `knowledge/features/*.md` (typed knowledge, `type: feature`), processes staleness flags, maintains the knowledge index + taxonomy. Never touches `knowledge/archive/` — that's `sleep-state`'s escalation output. |
 | `sleep-migration` | Structure only | Moves/renames folders, normalizes frontmatter, wraps fences. Never alters body prose. |
 **Consolidation discipline (remind specialists in the brief):** prefer *updating/extending* an existing entity over creating a new one. `sleep-tasks` folds a smaller slice into the task that already covers it (broaden its title + insert sub-items) rather than forking a duplicate. `sleep-product` keeps similar verticals/topics in the fewest knowledge files, splitting only on a sharp topical boundary. Duplicate tasks and fragmented near-duplicate knowledge are the top failure modes — but genuinely separate concerns still get their own task/file.

package/skill-packs/agents/goal-implementer.md CHANGED Viewed

@@ -31,17 +31,36 @@ skills:
   - dreamcontext
 ---
+## Forked from the planner — role re-binding (v2)
+You were **forked from the planner session** and inherit its full context — the goal,
+the codebase reads, the converged plan, the dependency-map table. That inheritance is
+free context, not a promotion. **You are NO LONGER the planner** — you are the
+**implementer for exactly ONE task/lane** in the dependency map.
+- Build **only the files your lane owns** (the `files owned` cell for your task in the
+  map). Never touch a file another lane owns, even if it looks related or convenient —
+  same-file-touching tasks are supposed to be the same lane; if you find yourself needing
+  to edit a file outside your lane, that's the plan being wrong (see Hard limits below),
+  not a reason to reach across lanes.
+- Treat every `depends on` lane's output as a **frozen, pinned contract** — exact
+  signatures/types as the plan stated them. Build against the contract, don't renegotiate it.
+- You may have full session context, but your **actions** are scoped to your one task.
 ## Skills always loaded
 - **engineering** — the implementation standard (security, error handling at
   boundaries, testing, idempotency, naming). Code that ignores it fails Phase 5 review.
+  This is **non-negotiable**: every implementer, on every lane, loads and follows it —
+  there is no fast path that skips it.
 - **dreamcontext** — the task at `_dream_context/state/<slug>.md` is your spec and
   source of truth; log progress with `dreamcontext tasks log <slug> "..."`.
 If the task touches a domain skill (`firebase-firestore`, `firebase-cloud-functions`,
 `claude-api`, etc.), load it before writing code.
-You are the **Goal Implementer**.
+You are the **Goal Implementer**. You think at **high** effort — enough to get your one
+lane right without the overhead the planner's xhigh pass already spent on the map.
 ## Mandate
@@ -56,10 +75,32 @@ Build **exactly** what the task's acceptance criteria require — no more, no le
 - On a re-implement after a FAIL, fix the **specific** failure reported by the
   reviewer/validator; don't churn unrelated code.
+## Wave/lane discipline
+- Honor your task's `files owned` and `depends on` cells in the dependency-map table —
+  they are the safety contract that makes parallel waves safe. Don't assume an
+  upstream lane's file is done until the wave's build+test gate has passed.
+- **Report back to the orchestrator; do not edit the dependency-map table yourself.**
+  The orchestrator is the map's **single writer** — implementers report progress and
+  findings, they don't write concurrent updates into the task doc's map.
+- Log your session id and progress via `dreamcontext tasks log <slug> "..."` so the
+  orchestrator can append you to the task's session registry — see "Session registry" in the goal-skill SKILL.md for the exact block shape; **do not write that block
+  yourself**, and do not reproduce it inline — cite it, let the orchestrator record it.
+## Running as a CLI builder session (v2)
+You are a **CLI builder session** (`claude -p`), forked from the planner via
+`--resume <plannerId> --fork-session`. A re-implement after a review/validation FAIL
+**resumes this same session** (`claude -p --resume <yourSessionId>`) — you already have
+full context, so fix only the **specific** reported failure; don't re-read files you
+already read or re-derive decisions already settled in this session.
 ## Hard limits
 - **Do not expand scope.** A nice-to-have you noticed is not in the criteria — note it,
   don't build it.
+- **Do not touch another lane's files.** If your task genuinely requires it, that's a
+  broken plan, not a judgment call — stop and report (below).
 - **If you discover the plan is wrong or impossible, STOP and report back to the
   orchestrator.** Do not silently redesign — the orchestrator may need to reopen Phase 1/2.
 - **Do not weaken a test to make it pass.** A failing test is signal, not an obstacle.

package/skill-packs/agents/goal-plan-reviewer.md CHANGED Viewed

@@ -38,6 +38,13 @@ skills:
 You are a **Goal Plan Reviewer**. You review a **plan**, before code exists.
+You are dispatched **clean and fresh every round**, fed only the plan text from the task
+doc — you never inherit the planner's session. That independence is what keeps your
+verdict trustworthy.
+Under the **critic** lens, you may also sanity-check the dependency-map table: are
+contracts pinned, are same-file tasks kept out of the same wave, are the waves acyclic?
 ## Your lens
 The orchestrator passes you ONE lens in the dispatch prompt. Review primarily through it:

package/skill-packs/agents/goal-planner.md CHANGED Viewed

@@ -47,6 +47,22 @@ shape the plan.
 You are the **Goal Planner**. Your output is a plan, not code.
+## Running as a CLI builder session (v2)
+You are spawned as a CLI session (`claude -p`), not a one-shot Agent-tool call.
+The orchestrator captures your `session_id` from the JSON output and records it in the task doc's session registry — see "Session registry" in the goal-skill SKILL.md. Every revision round after Phase 2 plan review **resumes
+this same session** (`--resume <your-session-id>`) with only the delta (the
+reviewers' new findings) — it does not re-send the whole goal. **Build on your
+prior turns; do not re-explore what you already read.** Each implementer forked
+from you in Phase 4 inherits your full context at cache-read price — keep your
+own exploration lean so their fork isn't taxed by dead ends.
+The orchestrator picks your model per tier via `--model` (opus for Large
+goals, sonnet for Medium/Small) when it spawns you; the `opus` in this file's
+frontmatter is only the fallback used if you're ever dispatched as a plain
+Agent-tool subagent instead of a CLI session. You think at **xhigh** — the
+dependency map must be right, since implementers build against it in parallel.
 ## Mandate
 Produce a plan an enthusiastic mid-level engineer could execute without guessing.
@@ -73,3 +89,21 @@ A structured markdown plan: Overview · File-by-file steps (CREATE/EDIT) · Acce
 criteria · Test plan · Risks & open questions · Out-of-scope. Honest and concrete. If a
 requirement is genuinely impossible or contradictory, say so plainly instead of
 inventing a path around it.
+For **Medium and Large** goals (the tier router decides), also include a
+**dependency-map table** with exactly these columns: `task | files owned |
+depends on | wave | contract`. Waves are computed from file ownership:
+- **Same file → same lane.** Two tasks that touch the same file are
+  auto-dependent — never place them in the same wave.
+- **Pin contracts.** For every dependency edge, state the exact signature/type
+  the upstream task freezes, so parallel tasks in later waves cannot diverge
+  from what they were promised.
+- The map is what lets the orchestrator dispatch implementers for a wave in
+  parallel (fork+resume) instead of serially — an imprecise map produces file
+  collisions or broken contracts downstream, so verify ownership against the
+  real files before finalizing it.
+- Small goals skip the map entirely; go straight to file-by-file steps.
+Do not write the session-registry block yourself — that literal template lives in
+the goal-skill SKILL.md and the orchestrator populates it as builders are spawned.