dreamcontext 0.10.0 → 0.10.5

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}

package/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/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/dist/dashboard/assets/channel-44TauaoC.js

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

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

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-BYd5xUfH.js";import{_ as i}from"./index-CC4bLFLV.js";import"./chunk-FMBD7UC4-LC1eQ6Bn.js";import"./chunk-YZCP3GAM-CrKe7Bc4.js";import"./chunk-55IACEB6-BRmdVuF4.js";import"./chunk-EDXVE4YY-B-pwoibO.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-DvAbYAqz.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-BYd5xUfH.js";import{_ as i}from"./index-CC4bLFLV.js";import"./chunk-FMBD7UC4-LC1eQ6Bn.js";import"./chunk-YZCP3GAM-CrKe7Bc4.js";import"./chunk-55IACEB6-BRmdVuF4.js";import"./chunk-EDXVE4YY-B-pwoibO.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-C56fm_aT.js

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