dreamcontext 0.10.2 → 0.10.6

package/dist/skill-packs/excalidraw/SKILL.md

@@ -161,9 +161,17 @@ Match the team's look by default. The builder now defaults text to **Excalifont
   Each is `{ fill, stroke }`. `INK` = `#1e1e1e` (the default 2px card outline). Fills are **solid**,
   rects are **always rounded**.
 - **`card({x,y,w,h,text,color,fontSize})`** → rounded filled rect + centered label, grouped (move as one).
+  The label **cannot overflow**: it is hard-wrapped to the card width and the font auto-shrinks (down to
+  `minFont`, default 9px) until it also fits the height. Optional `{ minFont, padX, padY }`. If even the
+  floor font won't fit, it still draws but logs a `[excalidraw]` warning — that's your cue to enlarge the
+  card or shorten the text.
 - **`node(...)`** → smaller card for flow steps.
 - **`sectionTitle({x,y,text,fontSize})`** → big plain header (no box), like "Configuration" / "Flow".
-- **`connector({from,to,label,double,dashed})`** → labeled arrow between two points.
+- **`connector({from,to,label,double,dashed,via,elbow})`** → labeled arrow between two points. Route it
+  AROUND intervening boxes instead of through them: `elbow:'hv'` (horizontal then vertical) / `elbow:'vh'`
+  (vertical then horizontal) bends it once at a right angle, or `via:[[x,y],…]` threads explicit waypoints.
+- **`fitText({text,w,h,fontSize,minFont})`** → the wrap+shrink primitive `card()` uses; call it directly to
+  pre-size a box to its label (returns `{ text, fontSize, lineCount, fits }`).
 - **`annotate({from,to,text})`** → short arrow to a side-spec note (the "90sec / deepseek…" pattern).
 - **`column({x,y,items,color})`** → vertical stack of cards (benefit/risk lists). `items` may be
   strings or `{text,color}`.
@@ -175,6 +183,16 @@ Compose these into a `buildExcalidraw({ out, elements })` call. Runnable example
 Conventions: color nodes by ROLE, label every arrow, put specs in side-annotations, use big plain
 section titles to break the board into "slides", keep one idea per card.
 
+### Layout rules that keep boards clean
+- **Size boxes for their text.** A card guarantees the label stays *inside*, but it does so by shrinking
+  the font — a long label in a small box ends up tiny. Give wide/long labels a wider `w` (or more `h`),
+  or split the idea across two cards. Watch for `[excalidraw]` fit warnings on the console.
+- **Fan out through a margin bus, never as a diagonal star.** A hub wired straight to a vertical stack of
+  boxes draws diagonals that cut across the boxes in between. Instead, route the trunk into an empty
+  margin beside the stack, run one vertical "bus" line down that margin, then a short horizontal stub from
+  the bus into each box. With `connector()`: send the trunk `elbow:'hv'` into the bus x, then one
+  `elbow:'hv'` stub per branch (or `via:[[busX, branchY]]`). No arrow crosses a box it isn't pointing at.
+
 ## Rules & gotchas
 - **Unique image filenames.** Obsidian resolves `[[name.png]]` by basename; if two different files
   share a name anywhere in the vault the link is ambiguous. Name screenshots uniquely

package/dist/skill-packs/excalidraw/scripts/build_excalidraw.js

@@ -55,30 +55,44 @@ function findVaultRoot(startDir) {
 }
 
 // ---------- text sizing ----------
+// Excalifont glyph advance (multiples of fontSize): latin ~0.58, emoji/arrows/CJK/combining ~1.05.
+// A flat factor under-counted wide glyphs, so emoji labels measured narrow and overflowed their box.
+// This mirrors glyphW() in scripts/lib/style.js so card() pre-wrapping and on-board height agree.
+function isWideGlyph(code) {
+  return (
+    (code >= 0x1100 && code <= 0x115f) || (code >= 0x2190 && code <= 0x21ff) ||
+    (code >= 0x2300 && code <= 0x23ff) || (code >= 0x25a0 && code <= 0x27bf) ||
+    (code >= 0x2b00 && code <= 0x2bff) || (code >= 0x2e80 && code <= 0x9fff) ||
+    (code >= 0xac00 && code <= 0xd7a3) || (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe30 && code <= 0xfe4f) || (code >= 0xff00 && code <= 0xff60) ||
+    (code >= 0x1f000 && code <= 0x1faff) || (code >= 0x1f1e6 && code <= 0x1f1ff)
+  );
+}
+function glyphW(ch, fontSize) { return fontSize * (isWideGlyph(ch.codePointAt(0)) ? 1.05 : 0.58); }
+function measureText(s, fontSize) { let w = 0; for (const ch of String(s)) w += glyphW(ch, fontSize); return w; }
+
 // When a fixedWidth is given the text element is treated as WRAPPING (autoResize off downstream),
 // so height must reflect word-wrapped line count — otherwise long captions render as one wide line
 // and overlap their neighbours. Honors explicit \n and greedily wraps each logical line to width.
 function sizeText(text, fontSize, fixedWidth) {
   const rawLines = String(text).split('\n');
   if (fixedWidth != null) {
-    const charW = fontSize * 0.52;                       // approx Excalifont glyph advance
-    const perLine = Math.max(1, Math.floor(fixedWidth / charW));
     let totalLines = 0;
     for (const ln of rawLines) {
       const words = ln.split(/\s+/).filter(Boolean);
       if (!words.length) { totalLines += 1; continue; }
-      let cur = 0, lc = 1;
+      let cur = '', lc = 1;
       for (const w of words) {
-        const add = (cur ? 1 : 0) + w.length;
-        if (cur + add > perLine && cur > 0) { lc++; cur = w.length; }
-        else cur += add;
+        if (!cur) { cur = w; continue; }
+        if (measureText(cur + ' ' + w, fontSize) > fixedWidth) { lc++; cur = w; }
+        else cur += ' ' + w;
       }
       totalLines += lc;
     }
     return { width: fixedWidth, height: Math.max(Math.round(fontSize * 1.25), Math.round(totalLines * fontSize * 1.25)) };
   }
-  const maxLen = rawLines.reduce((m, l) => Math.max(m, l.length), 0);
-  return { width: Math.max(10, Math.round(maxLen * fontSize * 0.6)), height: Math.round(rawLines.length * fontSize * 1.25) };
+  const maxW = rawLines.reduce((m, l) => Math.max(m, measureText(l, fontSize)), 0);
+  return { width: Math.max(10, Math.round(maxW)), height: Math.round(rawLines.length * fontSize * 1.25) };
 }
 
 // ---------- element factory ----------
@@ -119,6 +133,31 @@ function buildExcalidraw(spec) {
   const wikilinkMode = spec.wikilinkMode || 'basename';
   const background = spec.background || '#ffffff';
 
+  // Pre-flight: every referenced image MUST exist on disk before we write the
+  // board. A missing asset would otherwise be emitted as a dangling `## Embedded
+  // Files` wikilink (`<sha1>: [[missing.png]]`) that can never resolve in any
+  // renderer — the board ships with blank images. Collect ALL missing paths and
+  // fail once with the full list (and the board path), so the author fixes every
+  // gap in a single pass instead of discovering them one throw at a time.
+  const missingImages = [];
+  for (const e of (spec.elements || [])) {
+    if (e && e.type === 'image' && e.path) {
+      // A missing file OR a non-file (directory / broken symlink) is unusable —
+      // statSync throws for a broken link / absent path, so default to missing.
+      let isFile = false;
+      try { isFile = fs.statSync(path.resolve(e.path)).isFile(); } catch { isFile = false; }
+      if (!isFile) missingImages.push(e.path);
+    }
+  }
+  if (missingImages.length) {
+    throw new Error(
+      `build_excalidraw: ${missingImages.length} referenced image(s) missing or not a file — ` +
+      `refusing to write a board with dangling embeds:\n  ` +
+      missingImages.join('\n  ') +
+      `\n(board: ${outPath})`,
+    );
+  }
+
   const rng = mulberry32(strHash(path.resolve(outPath)));
   const elements = [];
   const textEntries = [];          // {text, id}

package/dist/skill-packs/excalidraw/scripts/lib/style.js

@@ -23,30 +23,112 @@ function pal(c) { return PALETTE[c] || { fill: c, stroke: INK }; }
 let _gc = 0;
 const newGroup = (hint) => `g${++_gc}-${hint || ''}`;
 const lines = (t) => String(t).split('\n').length;
-// word-wrapped line count at a given width — keeps card labels vertically centered when they wrap
-function wrapLineCount(text, fontSize, width) {
-  const perLine = Math.max(1, Math.floor(width / (fontSize * 0.52)));
+
+// --- text fitting --------------------------------------------------------
+// Excalifont glyph advance, in multiples of fontSize. Latin is ~0.58; emoji, arrows, CJK and
+// combining marks render roughly square (~1.05) — the old flat 0.52 under-counted them, so wide
+// labels measured narrow and spilled out of their card. Mirrored in build_excalidraw.js sizeText().
+function isWideGlyph(code) {
+  return (
+    (code >= 0x1100 && code <= 0x115f) || // Hangul Jamo
+    (code >= 0x2190 && code <= 0x21ff) || // arrows
+    (code >= 0x2300 && code <= 0x23ff) || // misc technical (⏰ ⏳ …)
+    (code >= 0x25a0 && code <= 0x27bf) || // geometric shapes, misc symbols, dingbats (✅ ★ …)
+    (code >= 0x2b00 && code <= 0x2bff) || // extra arrows / symbols
+    (code >= 0x2e80 && code <= 0x9fff) || // CJK radicals … unified ideographs
+    (code >= 0xac00 && code <= 0xd7a3) || // Hangul syllables
+    (code >= 0xf900 && code <= 0xfaff) || // CJK compatibility ideographs
+    (code >= 0xfe30 && code <= 0xfe4f) || // CJK compatibility forms
+    (code >= 0xff00 && code <= 0xff60) || // fullwidth forms
+    (code >= 0x1f000 && code <= 0x1faff) || // emoji & pictographs
+    (code >= 0x1f1e6 && code <= 0x1f1ff)    // regional indicators (flags)
+  );
+}
+function glyphW(ch, fontSize) { return fontSize * (isWideGlyph(ch.codePointAt(0)) ? 1.05 : 0.58); }
+function measureText(s, fontSize) { let w = 0; for (const ch of String(s)) w += glyphW(ch, fontSize); return w; }
+
+// Greedy word-wrap to a pixel width, honoring existing \n and HARD-breaking any single word that is
+// itself wider than the box (e.g. a long URL). Returns the text WITH the newlines baked in — the
+// Obsidian plugin keeps them instead of re-flowing the label into one over-wide centered line.
+function wrapToWidth(text, fontSize, width) {
+  const out = [];
+  for (const logical of String(text).split('\n')) {
+    const words = logical.split(/\s+/).filter(Boolean);
+    if (!words.length) { out.push(''); continue; }
+    let cur = '';
+    for (let word of words) {
+      while (measureText(word, fontSize) > width) {
+        let acc = '';
+        for (const ch of word) {
+          if (acc && measureText(acc + ch, fontSize) > width) break;
+          acc += ch;
+        }
+        if (cur) { out.push(cur); cur = ''; }
+        out.push(acc);
+        word = word.slice(acc.length);
+        if (!word) break;
+      }
+      if (!word) continue;
+      const candidate = cur ? cur + ' ' + word : word;
+      if (cur && measureText(candidate, fontSize) > width) { out.push(cur); cur = word; }
+      else cur = candidate;
+    }
+    if (cur) out.push(cur);
+  }
+  return out.join('\n');
+}
+
+const _warned = new Set();
+function warnFit(msg) { if (!_warned.has(msg)) { _warned.add(msg); try { console.warn('[excalidraw] ' + msg); } catch (e) {} } }
+
+// Wrap `text` to the card's inner width, then shrink the font (down to minFont) until the wrapped
+// label also fits the card height. Returns { text (with baked-in newlines), fontSize, lineCount, fits }.
+function fitText(o) {
+  const { text = '', w = 260, h = 92, fontSize = 20, minFont = 9, lineHeight = 1.25, padX = 10, padY = 8 } = o;
+  const innerW = Math.max(1, w - 2 * padX);
+  const innerH = Math.max(1, h - 2 * padY);
+  let fs = Math.max(minFont, Math.round(fontSize));
+  let wrapped = wrapToWidth(text, fs, innerW);
+  let lineCount = wrapped.split('\n').length;
+  while (fs > minFont && lineCount * fs * lineHeight > innerH) {
+    fs -= 1;
+    wrapped = wrapToWidth(text, fs, innerW);
+    lineCount = wrapped.split('\n').length;
+  }
+  return { text: wrapped, fontSize: fs, lineCount, fits: lineCount * fs * lineHeight <= innerH };
+}
+
+// arc-length midpoint of a polyline — keeps a connector label on the line even when it elbows
+function polyMid(pts) {
+  if (!pts || pts.length < 2) return (pts && pts[0]) || [0, 0];
+  const seg = [];
   let total = 0;
-  for (const ln of String(text).split('\n')) {
-    const words = ln.split(/\s+/).filter(Boolean);
-    if (!words.length) { total += 1; continue; }
-    let cur = 0, lc = 1;
-    for (const w of words) { const add = (cur ? 1 : 0) + w.length; if (cur + add > perLine && cur > 0) { lc++; cur = w.length; } else cur += add; }
-    total += lc;
+  for (let i = 1; i < pts.length; i++) { const l = Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]); seg.push(l); total += l; }
+  let half = total / 2;
+  for (let i = 1; i < pts.length; i++) {
+    if (half <= seg[i - 1] || i === pts.length - 1) {
+      const t = seg[i - 1] ? half / seg[i - 1] : 0;
+      return [pts[i - 1][0] + (pts[i][0] - pts[i - 1][0]) * t, pts[i - 1][1] + (pts[i][1] - pts[i - 1][1]) * t];
+    }
+    half -= seg[i - 1];
   }
-  return total;
+  return pts[0];
 }
 
-// rounded card: filled rect + centered label, grouped so they move together
+// rounded card: filled rect + centered label, grouped so they move together. The label is
+// hard-wrapped to the card width and the font auto-shrinks (to `minFont`) until it also fits the
+// height, so text can never spill outside the box. Warns if even the floor font won't fit.
 function card(o) {
-  const { x, y, w = 260, h = 92, text = '', color = 'blue', fontSize = 20, stroke = INK, strokeWidth = 2, textColor = INK, roundness = true } = o;
+  const { x, y, w = 260, h = 92, text = '', color = 'blue', fontSize = 20, stroke = INK, strokeWidth = 2, textColor = INK, roundness = true, minFont = 9, padX = 10, padY = 8 } = o;
   const group = o.group || newGroup('card');
   const p = pal(color);
-  const textH = wrapLineCount(text, fontSize, w) * fontSize * 1.25;
-  const ty = y + Math.max(6, (h - textH) / 2);
+  const fit = fitText({ text, w, h, fontSize, minFont, padX, padY });
+  if (!fit.fits) warnFit(`label ${JSON.stringify(String(text).slice(0, 32))} won't fit a ${w}×${h} card even at ${minFont}px — enlarge the card or shorten the text.`);
+  const textH = fit.lineCount * fit.fontSize * 1.25;
+  const ty = y + Math.max(padY, (h - textH) / 2);
   return [
     { type: 'rectangle', x, y, width: w, height: h, strokeColor: stroke, backgroundColor: p.fill, fillStyle: 'solid', strokeWidth, roundness, group },
-    { type: 'text', x, y: ty, text, fontSize, color: textColor, width: w, align: 'center', fontFamily: 5, group },
+    { type: 'text', x, y: ty, text: fit.text, fontSize: fit.fontSize, color: textColor, width: w, align: 'center', fontFamily: 5, group },
   ];
 }
 // small node (flow step) — card with tighter defaults
@@ -58,13 +140,21 @@ function sectionTitle(o) {
   return [{ type: 'text', x, y, text, fontSize, color, fontFamily: 5, width: Math.max(200, String(text).length * fontSize * 0.6) }];
 }
 
-// labeled connector arrow between two points (centers of cards, etc.)
+// labeled connector arrow between two points (centers of cards, etc.).
+// Routing: pass `via:[[x,y],…]` for explicit waypoints, or `elbow:'hv'|'vh'` for an auto right-angle
+// bend ('hv' = horizontal then vertical, 'vh' = vertical then horizontal). Use these to route a link
+// AROUND intervening boxes instead of cutting a diagonal straight through them.
 function connector(o) {
-  const { from, to, label, double = false, strokeColor = INK, strokeWidth = 2, dashed = false, labelColor = '#495057', fontSize = 16 } = o;
-  const out = [{ type: 'arrow', points: [from, to], strokeColor, strokeWidth, strokeStyle: dashed ? 'dashed' : 'solid', endArrow: 'arrow', startArrow: double ? 'arrow' : null }];
+  const { from, to, label, double = false, strokeColor = INK, strokeWidth = 2, dashed = false, labelColor = '#495057', fontSize = 16, via = null, elbow = null } = o;
+  let pts;
+  if (via && via.length) pts = [from, ...via, to];
+  else if (elbow === 'hv') pts = [from, [to[0], from[1]], to];
+  else if (elbow === 'vh') pts = [from, [from[0], to[1]], to];
+  else pts = [from, to];
+  const out = [{ type: 'arrow', points: pts, strokeColor, strokeWidth, strokeStyle: dashed ? 'dashed' : 'solid', endArrow: 'arrow', startArrow: double ? 'arrow' : null }];
   if (label) {
-    const mx = (from[0] + to[0]) / 2, my = (from[1] + to[1]) / 2;
-    const w = Math.max(40, String(label).length * fontSize * 0.62);
+    const [mx, my] = polyMid(pts);
+    const w = Math.max(40, measureText(String(label), fontSize) + fontSize);
     out.push({ type: 'text', x: mx - w / 2, y: my - fontSize - 4, text: label, fontSize, color: labelColor, width: w, align: 'center', fontFamily: 5 });
   }
   return out;
@@ -127,4 +217,4 @@ const leftOf = (x, y, w, h) => [x, y + h / 2];
 const bottomOf = (x, y, w, h) => [x + w / 2, y + h];
 const topOf = (x, y, w, h) => [x + w / 2, y];
 
-module.exports = { INK, PALETTE, pal, card, node, sectionTitle, connector, annotate, column, hub, bullets, center, rightOf, leftOf, bottomOf, topOf };
+module.exports = { INK, PALETTE, pal, card, node, sectionTitle, connector, annotate, column, hub, bullets, fitText, measureText, center, rightOf, leftOf, bottomOf, topOf };

package/dist/skill-packs/goal-skill/SKILL.md

@@ -122,6 +122,12 @@ dreamcontext tasks status <slug> in_progress "plan validated; implementing"
 
 If `<slug>` already exists, de-collide (append a short suffix) rather than clobbering.
 
+If the project has **roadmap objectives** (`_dream_context/core/objectives/` non-empty — they appear
+in your snapshot), link the task to the objective(s) this goal serves: `tasks create --objectives a,b`
+(or `dreamcontext tasks objectives <slug> a,b` after). One goal often serves several objectives —
+that's expected. If unsure which, ask the user in Phase 0; never leave an obviously-serving task
+unlinked, and never overwrite an existing non-empty `objectives:` list.
+
 If the project declares **custom task fields** (`_dream_context/overrides/task.md`), `tasks create`
 hard-fails (exit 1) on an unset `required` field — set each with `--field key=value` on create. For
 any field marked `ask: true`, ask the user for the value back in Phase 0 (it's a human judgment) rather

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dreamcontext",
-  "version": "0.10.2",
+  "version": "0.10.6",
   "description": "dreamcontext — the persistent brain for your AI agents. Remembers what you built, knows how your project works.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -76,6 +76,7 @@ dreamcontext is **more than memory files**. Every capability below is real and s
 |---|---|---|
 | **Structured memory** | soul/user/memory + knowledge + tasks, auto-loaded each session | this file |
 | **Tasks** | Working documents with changelog, RICE, status lifecycle, start/due date ranges, resolved assignees, and project-declared custom fields (`overrides/task.md`) | [tasks-and-features.md](references/tasks-and-features.md) |
+| **Roadmap / Objectives** | PO-authored OKR board: objectives in `core/objectives/`, many-to-many task links (`objectives:` frontmatter), dependency DAG with full forecast cascade, target vs forecast slip detection, `dreamcontext roadmap` (+ `--json`) | [tasks-and-features.md](references/tasks-and-features.md) |
 | **Features (PRDs)** | Retrospective product docs, updated only during sleep | [tasks-and-features.md](references/tasks-and-features.md) |
 | **Knowledge** | Tagged deep docs, pinning, staleness, Excalidraw diagrams | [knowledge-and-recall.md](references/knowledge-and-recall.md) |
 | **Memory recall** | Haiku/BM25 search over the whole corpus; auto-injected on prompts | [knowledge-and-recall.md](references/knowledge-and-recall.md) |
@@ -105,7 +106,8 @@ The SessionStart hook injects this automatically every session — answer from i
 
 - **Soul, User, Memory** — full content (`core/0.soul.md`, `1.user.md`, `2.memory.md`)
 - **Extended core files index** — names/types of style guide, tech stack, system flow
-- **Active tasks** — status, priority, last updated (answer "which tasks are active?" from this)
+- **Active tasks** — status, priority, last updated, and the objectives each serves (answer "which tasks are active?" from this)
+- **Objectives (roadmap)** — active + recently-finished objectives with progress %, target vs forecast, and slip flags. **Weigh decisions against these outcomes** — they are WHAT the project is driving toward
 - **Bookmarks** — tagged important moments from prior sessions, by salience
 - **Contextual reminders** — triggers matching active tasks (prospective memory)
 - **Sleep state** — current debt level, sessions since last sleep, history
@@ -256,8 +258,9 @@ A ★★★ bookmark or 5+ sessions since last sleep also triggers an advisory.
 3. Build a brief inline (cheap CLI): read `state/.sleep.json`, `git status --short`, `git log` since last sleep, `dreamcontext core releases active`.
 4. Dispatch specialists **in parallel** (one message, multiple Agent calls): always `sleep-tasks` + `sleep-state`; fire `sleep-product` when knowledge/features/research signals warrant (over-fire — it no-ops cheaply); fire `sleep-migration` only if `dreamcontext migrations pending` has output.
 5. Wait for reports, then `dreamcontext reflect` (promote only genuinely load-bearing terms).
-6. `dreamcontext sleep done "<one-paragraph summary>"` — clears pre-epoch state, resets debt.
-7. Report the consolidated summary to the user.
+6. If `_dream_context/core/objectives/` is non-empty, run `dreamcontext roadmap` — a cheap deterministic call that refreshes the auto-generated board (`knowledge/roadmap/board.md`) from the reconciled tasks. Surface any 🔴 SLIPPING objectives in your summary.
+7. `dreamcontext sleep done "<one-paragraph summary>"` — clears pre-epoch state, resets debt.
+8. Report the consolidated summary to the user.
 
 For non-file-change work (decisions, architecture talk): `dreamcontext sleep add <score> "<reason>"`.
 
@@ -282,6 +285,8 @@ Status: `todo → in_progress → in_review → completed`. Sections: `why`, `us
 
 **Custom fields (if this project declares them).** When `_dream_context/overrides/task.md` exists, every task carries project-defined custom fields. Their **values are surfaced to you inline** — in the snapshot's Active Tasks block and in `dreamcontext tasks list --long` — so you can see them without opening the file; unset **required** fields show as `⚠ UNSET (required)`. When you create or reconcile a task, **set every declared field** (`dreamcontext tasks field <slug> <key> <value>` or `tasks create --field key=value`). **REQUIRED fields are mandatory — never create or complete a task with a required field left empty.** Fields marked **[ASK THE USER]** (`ask: true`) capture a human judgment (e.g. a time estimate) — **ask the user for the value when creating the task instead of guessing it.** The full schema + sync behavior → [tasks-and-features.md](references/tasks-and-features.md).
 
+**Objectives (roadmap links).** When the project has objectives (`core/objectives/` non-empty — they're in your snapshot), every task should declare which it serves: `objectives: [slug-a, slug-b]` in frontmatter (many-to-many — one task often lifts several outcomes). Set at creation (`tasks create --objectives a,b`) or later (`dreamcontext tasks objectives <task> a,b`). **Propose objective links for tasks you create; never overwrite a non-empty `objectives:` list — an existing value is a PO decision that sticks.** The field is local-only (never synced to a cloud backend). Rollups, forecasts, and slip detection are computed — `dreamcontext roadmap` / `--json`. Full model → [tasks-and-features.md](references/tasks-and-features.md).
+
 **RICE, due dates, tags/people, the Workflow flowchart, versioning, and multi-product** → [tasks-and-features.md](references/tasks-and-features.md).
 **Syncing tasks to a cloud backend (ClickUp _or_ GitHub — one at a time)** → [integrations.md](references/integrations.md).
 

package/skill/references/cli-reference.md

@@ -34,12 +34,13 @@ Every command and flag, grouped. All commands are prefixed with `dreamcontext`.
 
 | Command | Description |
 |---|---|
-| `tasks list` | List/filter/group tasks (excludes completed by default). Flags: `-s/--status`, `-a/--all`, `--tag <t>` (repeatable, AND), `--any-tag <t>` (repeatable, OR), `--version <id>`, `--priority <level>`, `--feature <slug>`, `-g/--group-by tag\|version\|priority\|status`, `--long`, `--tags`, `--json`. Filters compose (AND), case-insensitive. |
+| `tasks list` | List/filter/group tasks (excludes completed by default). Flags: `-s/--status`, `-a/--all`, `--tag <t>` (repeatable, AND), `--any-tag <t>` (repeatable, OR), `--version <id>`, `--priority <level>`, `--feature <slug>`, `--objective <slug>`, `-g/--group-by tag\|version\|priority\|status`, `--long`, `--tags`, `--json`. Filters compose (AND), case-insensitive. |
 | `tasks tags` | Distinct task tags with counts. `-a/--all`, `--json`. |
-| `tasks create <name>` | Create a task. Flags: `-d/--description`, `-p/--priority critical\|high\|medium\|low`, `-u/--urgency …`, `-s/--status`, `-t/--tags <csv>`, `-w/--why`, `-v/--version`, `--person <name>`, `--reach <1-10>`, `--impact <1-5>`, `--confidence 25\|50\|75\|100`, `--effort <weeks>`, `--start YYYY-MM-DD`, `--due YYYY-MM-DD`, `--field <key=value>` (repeatable; sets declared custom fields), `--allow-missing-required` (create a draft even when a required custom field is unset). **Fails** if a required custom field is unset and `--allow-missing-required` is not given. |
+| `tasks create <name>` | Create a task. Flags: `-d/--description`, `-p/--priority critical\|high\|medium\|low`, `-u/--urgency …`, `-s/--status`, `-t/--tags <csv>`, `-w/--why`, `-v/--version`, `--person <name>`, `--reach <1-10>`, `--impact <1-5>`, `--confidence 25\|50\|75\|100`, `--effort <weeks>`, `--start YYYY-MM-DD`, `--due YYYY-MM-DD`, `--objectives <csv>` (roadmap objective slugs this task serves; slugs must exist), `--field <key=value>` (repeatable; sets declared custom fields), `--allow-missing-required` (create a draft even when a required custom field is unset). **Fails** if a required custom field is unset and `--allow-missing-required` is not given. |
 | `tasks rice <name>` | Print or update RICE values. `--reach`/`--impact`/`--confidence`/`--effort`, `--clear`. |
 | `tasks start <name> <YYYY-MM-DD\|clear>` | Set or clear a planned start date (range start). Must be ≤ the due date; setting it removes the `backlog` tag. |
 | `tasks due <name> <YYYY-MM-DD\|clear>` | Set or clear a due/end date (range end). |
+| `tasks objectives <name> [slugs\|clear]` | Print, set (comma-separated, validated against `core/objectives/`), or clear the roadmap objectives a task serves. LOCAL-ONLY — never synced to a cloud backend. |
 | `tasks tag <name> <tags...>` | Add (or `--remove`) tags. `person:<slug>` assigns a person. |
 | `tasks field <name> <key> [value\|clear]` | Set or clear a user-defined custom field declared in `overrides/task.md` (synced to ClickUp/GitHub). Validates select options + number types. |
 | `tasks insert <name> <section> <content...>` | Insert into a section: `why`, `user_stories`, `acceptance_criteria`, `constraints`, `technical_details`, `notes`, `changelog`. |
@@ -58,6 +59,23 @@ Sections for `tasks insert`: `why`, `user_stories`, `acceptance_criteria`, `cons
 
 ---
 
+## Roadmap (objectives — the OKR board)
+
+| Command | Description |
+|---|---|
+| `roadmap` | Render the objective board (rollups, target vs forecast, slip flags) and regenerate `knowledge/roadmap/board.md`. `--json` emits the typed RoadmapModel instead (no writes). |
+| `roadmap objective create <slug>` | Create `core/objectives/<slug>.md`. `--title <str>` (required), `--target YYYY-MM-DD`, `--depends-on <csv>`, `--feature <prd-slug>`, `--why <text>`. |
+| `roadmap objective list` | All objectives with progress %, status, forecast. `--json`. |
+| `roadmap objective show <slug>` | One objective: member tasks, direct dependents, and the transitive "if this slips, so do" set. `--json`. |
+| `roadmap objective edit <slug>` | `--title`, `--target <date\|clear>`, `--feature <slug\|clear>`, `--status not_started\|active\|review\|done\|clear` (manual PO override; `clear` returns to computed). |
+| `roadmap objective delete <slug>` | Delete; other objectives' `depends_on` are healed automatically. `--yes`. |
+| `roadmap objective depend <A> <B>` | A depends on B — **rejected at write time** if it would create a circular dependency. |
+| `roadmap objective undepend <A> <B>` | Remove the dependency edge. |
+
+Task-side linkage: `tasks create --objectives a,b` · `tasks objectives <task> a,b|clear` · `tasks list --objective <slug>`. Objectives are recallable: `memory recall "<query>" --types objective`.
+
+---
+
 ## Features
 
 | Command | Description |

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

@@ -67,6 +67,7 @@ dreamcontext memory recall "how did we decide on the sleep fan-out"
 dreamcontext memory recall "auth flow" --types knowledge,feature
 dreamcontext memory recall "deprecated" --types changelog        # ship history
 dreamcontext memory recall "rate limit" --types task             # in-flight work
+dreamcontext memory recall "retention goal" --types objective    # roadmap objectives (OKR outcomes)
 
 # Tune result count / machine-readable output
 dreamcontext memory recall "rice prioritization" --top 3 --json

package/skill/references/sleep.md

@@ -52,10 +52,11 @@ For non-file-change work (architecture discussion, a decision with no edits): `d
    - Pass each specialist a small text brief: epoch, session IDs, active task slugs, planning version, the signals relevant to it, optional user hint. Do **not** paste transcript content — specialists call `dreamcontext transcript distill <id>` themselves.
 5. **Wait for all reports** (each returns a short structured report).
 6. **`dreamcontext reflect`** — each candidate is a term seen across multiple sessions not yet in soul/user/memory/knowledge. Promote into `2.memory.md` or a knowledge file ONLY if genuinely load-bearing; most are noise — discard. Never auto-promote.
-7. **Marketing pass** if `_dream_context/marketing/` exists: `dreamcontext mk rem-sleep`.
-8. **Council promote check:** `dreamcontext council list --unpromoted` — promote if the user engaged positively.
-9. **`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.)
-10. **Report** the consolidated summary to the user.
+7. **Roadmap refresh** if `_dream_context/core/objectives/` is non-empty: run `dreamcontext roadmap` — a cheap deterministic call that recomputes rollups/forecasts from the reconciled tasks and rewrites the auto-generated `knowledge/roadmap/board.md`. Surface any 🔴 SLIPPING objectives (and objectives whose member tasks are now all complete — suggest the PO confirm them done) in your summary. Sleep never edits objective files themselves — they are PO-authored.
+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.)
+11. **Report** the consolidated summary to the user.
 
 ---
 
@@ -63,7 +64,7 @@ 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). |
+| `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). |
 | `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 `core/features/*.md`, processes staleness flags, maintains the knowledge index + taxonomy. |
 | `sleep-migration` | Structure only | Moves/renames folders, normalizes frontmatter, wraps fences. Never alters body prose. |

package/skill/references/tasks-and-features.md

@@ -100,6 +100,42 @@ dreamcontext tasks tag <name> person:ada --remove  # unassign
 
 ---
 
+## Objectives — the OKR roadmap (task ↔ objective, many-to-many)
+
+Objectives are **PO-authored outcomes** ("increase retention 20%", "ship v0.2.3", "launch mobile") stored one file each in `_dream_context/core/objectives/<slug>.md` — first-class, durable, recallable (`memory recall --types objective`), independent of any task. The roadmap is NOT a derived shadow of tasks and NOT a list of releases: the PO owns the structure; computation is the assist layer (rollups, forecast, slip detection).
+
+**The load-bearing relationship:** a task declares the objectives it serves via `objectives: [a, b]` frontmatter — **many-to-many** (one shipped task often lifts revenue AND retention). The reverse direction (objective → member tasks, objective → dependents) is always **computed**, never stored — so the two sides cannot drift.
+
+```bash
+dreamcontext roadmap                                  # text board + regenerate knowledge/roadmap/board.md
+dreamcontext roadmap --json                           # the typed RoadmapModel (query surface; no writes)
+dreamcontext roadmap objective create <slug> --title "..." [--target YYYY-MM-DD] [--depends-on a,b] [--feature <prd-slug>] [--why "..."]
+dreamcontext roadmap objective list|show <slug>       # show = members + dependents + "if this slips, so do: …"
+dreamcontext roadmap objective edit <slug> [--title] [--target <date>|clear] [--status not_started|active|review|done|clear] [--feature <slug>|clear]
+dreamcontext roadmap objective depend <A> <B>         # A depends on B — REJECTED at write time if it would create a cycle
+dreamcontext roadmap objective undepend <A> <B>
+dreamcontext roadmap objective delete <slug> --yes    # also heals other objectives' depends_on
+dreamcontext tasks create <name> --objectives a,b     # link at creation (slugs must exist)
+dreamcontext tasks objectives <task> a,b|clear        # set/clear on an existing task
+dreamcontext tasks list --objective <slug>            # all tasks serving an objective
+```
+
+**The computed model** (per objective, from `roadmap --json`):
+- **Progress** = completed ÷ total member tasks (each objective counts over its OWN member set — a shared task contributes to each independently).
+- **Rollup status** (real enum): all `completed`→`done` 🟢 · any `in_progress`→`active` 🔵 · any `in_review`→`review` 🟡 · else `not_started` ⚪. A manual `--status` override wins (`status_source: override`).
+- **Forecast cascade — full transitive DAG:** `forecast_start = max(earliest member start, max(forecast_end of dependencies))`; `forecast_end = max(latest member due, forecast_start)`. A slip anywhere propagates to ALL transitive dependents (diamond shapes included).
+- **Null rule:** no dated member tasks → `forecast = null` ("unforecastable") and it imposes NO constraint on dependents.
+- **Slipping** 🔴 = `forecast_end > target_date` (the PO's committed date). This is the live on-track signal — surfaced in the snapshot and the board.
+
+**Rules for agents:**
+1. **Propose, never overwrite.** Suggest `objectives:` for tasks you create or find unlabeled; an existing non-empty list is a PO decision — never change it unless the user asks.
+2. **Local-only field.** `objectives` is never pushed/pulled by cloud sync backends. Do not try to map it to remote labels.
+3. **Objectives are orthogonal to versions/cycles.** `version` = WHEN (the time-box); `objectives` = WHAT outcomes it serves. Both live on the task independently.
+4. **`knowledge/roadmap/board.md` is auto-generated** — regenerate with `dreamcontext roadmap`, never hand-edit it. Objective files themselves are PO-authored prose — edit `## Why`/`## Notes` freely, but rollups/members are computed and don't belong in them.
+5. A feature PRD *may* back an objective via the objective's `feature:` field — a convenience link, not a requirement.
+
+---
+
 ## The Workflow flowchart (keep it in sync)
 
 Every task file has a `## Workflow` mermaid block near the top: one node per acceptance criterion, grouped under milestone subgraphs, with status classes `done` / `active` / `todo` / `blocked`. It is the load-bearing summary of the task — drift makes future sessions misread progress.
@@ -130,6 +166,7 @@ related_feature: null     # feature slug for cross-link
 product: null             # multi-product scoping (optional)
 start_date: null          # YYYY-MM-DD or null — planned start (range start)
 due_date: null            # YYYY-MM-DD or null — due / planned end (range end)
+objectives: []            # roadmap objective slugs this task serves (many-to-many, LOCAL-ONLY — never synced)
 rice: { reach: 5, impact: 3, confidence: 75, effort: 2, score: 5.625 }
 custom_fields: {}         # project-declared fields (only when overrides/task.md exists)
 ---

package/skill-packs/excalidraw/SKILL.md

@@ -161,9 +161,17 @@ Match the team's look by default. The builder now defaults text to **Excalifont
   Each is `{ fill, stroke }`. `INK` = `#1e1e1e` (the default 2px card outline). Fills are **solid**,
   rects are **always rounded**.
 - **`card({x,y,w,h,text,color,fontSize})`** → rounded filled rect + centered label, grouped (move as one).
+  The label **cannot overflow**: it is hard-wrapped to the card width and the font auto-shrinks (down to
+  `minFont`, default 9px) until it also fits the height. Optional `{ minFont, padX, padY }`. If even the
+  floor font won't fit, it still draws but logs a `[excalidraw]` warning — that's your cue to enlarge the
+  card or shorten the text.
 - **`node(...)`** → smaller card for flow steps.
 - **`sectionTitle({x,y,text,fontSize})`** → big plain header (no box), like "Configuration" / "Flow".
-- **`connector({from,to,label,double,dashed})`** → labeled arrow between two points.
+- **`connector({from,to,label,double,dashed,via,elbow})`** → labeled arrow between two points. Route it
+  AROUND intervening boxes instead of through them: `elbow:'hv'` (horizontal then vertical) / `elbow:'vh'`
+  (vertical then horizontal) bends it once at a right angle, or `via:[[x,y],…]` threads explicit waypoints.
+- **`fitText({text,w,h,fontSize,minFont})`** → the wrap+shrink primitive `card()` uses; call it directly to
+  pre-size a box to its label (returns `{ text, fontSize, lineCount, fits }`).
 - **`annotate({from,to,text})`** → short arrow to a side-spec note (the "90sec / deepseek…" pattern).
 - **`column({x,y,items,color})`** → vertical stack of cards (benefit/risk lists). `items` may be
   strings or `{text,color}`.
@@ -175,6 +183,16 @@ Compose these into a `buildExcalidraw({ out, elements })` call. Runnable example
 Conventions: color nodes by ROLE, label every arrow, put specs in side-annotations, use big plain
 section titles to break the board into "slides", keep one idea per card.
 
+### Layout rules that keep boards clean
+- **Size boxes for their text.** A card guarantees the label stays *inside*, but it does so by shrinking
+  the font — a long label in a small box ends up tiny. Give wide/long labels a wider `w` (or more `h`),
+  or split the idea across two cards. Watch for `[excalidraw]` fit warnings on the console.
+- **Fan out through a margin bus, never as a diagonal star.** A hub wired straight to a vertical stack of
+  boxes draws diagonals that cut across the boxes in between. Instead, route the trunk into an empty
+  margin beside the stack, run one vertical "bus" line down that margin, then a short horizontal stub from
+  the bus into each box. With `connector()`: send the trunk `elbow:'hv'` into the bus x, then one
+  `elbow:'hv'` stub per branch (or `via:[[busX, branchY]]`). No arrow crosses a box it isn't pointing at.
+
 ## Rules & gotchas
 - **Unique image filenames.** Obsidian resolves `[[name.png]]` by basename; if two different files
   share a name anywhere in the vault the link is ambiguous. Name screenshots uniquely

package/skill-packs/excalidraw/scripts/build_excalidraw.js

@@ -55,30 +55,44 @@ function findVaultRoot(startDir) {
 }
 
 // ---------- text sizing ----------
+// Excalifont glyph advance (multiples of fontSize): latin ~0.58, emoji/arrows/CJK/combining ~1.05.
+// A flat factor under-counted wide glyphs, so emoji labels measured narrow and overflowed their box.
+// This mirrors glyphW() in scripts/lib/style.js so card() pre-wrapping and on-board height agree.
+function isWideGlyph(code) {
+  return (
+    (code >= 0x1100 && code <= 0x115f) || (code >= 0x2190 && code <= 0x21ff) ||
+    (code >= 0x2300 && code <= 0x23ff) || (code >= 0x25a0 && code <= 0x27bf) ||
+    (code >= 0x2b00 && code <= 0x2bff) || (code >= 0x2e80 && code <= 0x9fff) ||
+    (code >= 0xac00 && code <= 0xd7a3) || (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe30 && code <= 0xfe4f) || (code >= 0xff00 && code <= 0xff60) ||
+    (code >= 0x1f000 && code <= 0x1faff) || (code >= 0x1f1e6 && code <= 0x1f1ff)
+  );
+}
+function glyphW(ch, fontSize) { return fontSize * (isWideGlyph(ch.codePointAt(0)) ? 1.05 : 0.58); }
+function measureText(s, fontSize) { let w = 0; for (const ch of String(s)) w += glyphW(ch, fontSize); return w; }
+
 // When a fixedWidth is given the text element is treated as WRAPPING (autoResize off downstream),
 // so height must reflect word-wrapped line count — otherwise long captions render as one wide line
 // and overlap their neighbours. Honors explicit \n and greedily wraps each logical line to width.
 function sizeText(text, fontSize, fixedWidth) {
   const rawLines = String(text).split('\n');
   if (fixedWidth != null) {
-    const charW = fontSize * 0.52;                       // approx Excalifont glyph advance
-    const perLine = Math.max(1, Math.floor(fixedWidth / charW));
     let totalLines = 0;
     for (const ln of rawLines) {
       const words = ln.split(/\s+/).filter(Boolean);
       if (!words.length) { totalLines += 1; continue; }
-      let cur = 0, lc = 1;
+      let cur = '', lc = 1;
       for (const w of words) {
-        const add = (cur ? 1 : 0) + w.length;
-        if (cur + add > perLine && cur > 0) { lc++; cur = w.length; }
-        else cur += add;
+        if (!cur) { cur = w; continue; }
+        if (measureText(cur + ' ' + w, fontSize) > fixedWidth) { lc++; cur = w; }
+        else cur += ' ' + w;
       }
       totalLines += lc;
     }
     return { width: fixedWidth, height: Math.max(Math.round(fontSize * 1.25), Math.round(totalLines * fontSize * 1.25)) };
   }
-  const maxLen = rawLines.reduce((m, l) => Math.max(m, l.length), 0);
-  return { width: Math.max(10, Math.round(maxLen * fontSize * 0.6)), height: Math.round(rawLines.length * fontSize * 1.25) };
+  const maxW = rawLines.reduce((m, l) => Math.max(m, measureText(l, fontSize)), 0);
+  return { width: Math.max(10, Math.round(maxW)), height: Math.round(rawLines.length * fontSize * 1.25) };
 }
 
 // ---------- element factory ----------
@@ -119,6 +133,31 @@ function buildExcalidraw(spec) {
   const wikilinkMode = spec.wikilinkMode || 'basename';
   const background = spec.background || '#ffffff';
 
+  // Pre-flight: every referenced image MUST exist on disk before we write the
+  // board. A missing asset would otherwise be emitted as a dangling `## Embedded
+  // Files` wikilink (`<sha1>: [[missing.png]]`) that can never resolve in any
+  // renderer — the board ships with blank images. Collect ALL missing paths and
+  // fail once with the full list (and the board path), so the author fixes every
+  // gap in a single pass instead of discovering them one throw at a time.
+  const missingImages = [];
+  for (const e of (spec.elements || [])) {
+    if (e && e.type === 'image' && e.path) {
+      // A missing file OR a non-file (directory / broken symlink) is unusable —
+      // statSync throws for a broken link / absent path, so default to missing.
+      let isFile = false;
+      try { isFile = fs.statSync(path.resolve(e.path)).isFile(); } catch { isFile = false; }
+      if (!isFile) missingImages.push(e.path);
+    }
+  }
+  if (missingImages.length) {
+    throw new Error(
+      `build_excalidraw: ${missingImages.length} referenced image(s) missing or not a file — ` +
+      `refusing to write a board with dangling embeds:\n  ` +
+      missingImages.join('\n  ') +
+      `\n(board: ${outPath})`,
+    );
+  }
+
   const rng = mulberry32(strHash(path.resolve(outPath)));
   const elements = [];
   const textEntries = [];          // {text, id}