dreamcontext 0.5.4 → 0.7.0

package/skill/SKILL.md

@@ -87,7 +87,7 @@ All three are auto-loaded every session via the SessionStart hook.
 Every session start injects these automatically (zero tool calls needed):
 
 - **Soul, User, Memory** -- full content
-- **Extended core files index** -- names/types of style guide, tech stack, data structures
+- **Extended core files index** -- names/types of style guide, tech stack, system flow
 - **Active tasks** -- status, priority, last updated (answer "which tasks are active?" directly from this, zero tool calls needed)
 - **Bookmarks** -- tagged important moments from previous sessions, ordered by salience
 - **Contextual reminders** -- matching triggers for active tasks (prospective memory)
@@ -115,7 +115,7 @@ Decide dynamically. Match the task to what you need. Choose the right operation
 | `core/features/<name>.md` | READ | Feature scoping, sprint work, planning, "what's next" questions |
 | `core/3.style_guide_and_branding.md` | READ | UI/UX work, frontend, branding, copy, design tasks |
 | `core/4.tech_stack.md` | READ | Architecture decisions, integrations, dependency questions, infra |
-| `core/data-structures/<product>.md` (or `default.md`) | READ or SEARCH | Database work, API design, schema changes, data modeling |
+| `knowledge/data-structures/<product>.md` (or `default.md`) | READ or SEARCH | Database work, API design, schema changes, data modeling (recall-indexed like all knowledge) |
 | `core/CHANGELOG.json` | SEARCH | Bug investigations, "what changed recently?" |
 | `core/RELEASES.json` | SEARCH | "Which release shipped this?", rollback decisions |
 | `state/<task>.md` | READ | Continuing previous work. Changelog section = where you left off |
@@ -134,17 +134,17 @@ When debugging (e.g., "notifications are broken"):
 
 Some projects are monorepos with multiple products. Init asks "Is this a monorepo with multiple products?" and records the product list in `_dream_context/state/.config.json` under `multiProduct: string[] | false`. When products are configured:
 
-- **Per-product data structures** live at `_dream_context/core/data-structures/<product>.md` (single-product projects use `default.md`).
+- **Per-product data structures** live at `_dream_context/knowledge/data-structures/<product>.md` (single-product projects use `default.md`). They're knowledge files — recall-indexed, staleness-tracked, owned by `sleep-product`. **Body format: a single \`\`\`sql fenced block** with SQL comments (`-- ...`) for documentation — this is what the dashboard highlights. `migrateDataStructures` auto-wraps unfenced bodies; `dreamcontext init` scaffolds the fenced template.
 - **Per-product knowledge** lives at `_dream_context/knowledge/products/<product>.md`. Cross-cutting knowledge still lives at the top-level `knowledge/`.
 - **Tasks** MAY include `product: <name>` in frontmatter. The dashboard / CLI surfaces a product filter when `.config.json` lists products.
 - **Auto-injection — handled by the SessionStart hook.** The hook (`npx dreamcontext hook session-start` → `generateSnapshot()`) resolves the active task (override file `_dream_context/state/.active-task`, or fallback: most recently modified task with status `in_progress`). If that task's frontmatter has `product: <name>` and `<name>` is listed under `multiProduct`, the hook injects the body of `_dream_context/knowledge/products/<name>.md` into the snapshot under an `## Active Product Knowledge: <name>` section (capped at 200 lines, with a "read full" pointer if truncated). You don't need to remember to load it — it's already in your context. Cross-cutting knowledge still lives at the top-level `knowledge/`.
 - **Feature PRDs** MAY include `product: <name>` in frontmatter for product scoping; they still live in the flat `core/features/` directory.
 
-If `multiProduct` is `false` or missing, treat the project as single-product and use `data-structures/default.md` exclusively. The SessionStart hook no-ops the product-knowledge injection in that case.
+If `multiProduct` is `false` or missing, treat the project as single-product and use `knowledge/data-structures/default.md` exclusively. The SessionStart hook no-ops the product-knowledge injection in that case.
 
 ### Extended Core Files (3+)
 
-Beyond the auto-loaded soul/user/memory, projects define additional core files (style guide, tech stack, data structures, and potentially more).
+Beyond the auto-loaded soul/user/memory, projects define additional core files (style guide, tech stack, and potentially more). (Data structures are no longer a core file — they live under `knowledge/data-structures/` as recall-indexed knowledge.)
 
 **Discovery protocol**:
 1. The extended core files index is auto-loaded each session (names and types visible).
@@ -318,7 +318,9 @@ Sleep debt reminders are injected on every user message (via UserPromptSubmit ho
      - user hint mentions knowledge or a feature
    - When unsure, **over-fire** `sleep-product` — it no-ops cheaply.
    - Pass each specialist a small text brief in its prompt: epoch, session IDs, active task slugs, planning version, signals relevant to that specialist, optional user hint. Do **not** include transcript content — specialists call `dreamcontext transcript distill <id>` themselves.
+   - **Consolidation discipline (remind both 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 or a needless sub-task; `sleep-product` keeps similar verticals/brands/topics in the fewest knowledge files, splitting only on a sharp topical boundary that sharpens tags. Duplicate tasks and fragmented near-duplicate knowledge are the top consolidation failure modes — but genuinely separate concerns/topics still get their own task/file.
 5. Wait for all specialist reports. Each returns a short structured report.
+5a. Run `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.
 6. Marketing pass if `_dream_context/marketing/` exists: `dreamcontext mk rem-sleep`.
 7. Council promote check: `dreamcontext council list --unpromoted` — promote if user engaged positively.
 8. `dreamcontext sleep done "<one-paragraph summary stitched from specialist reports>"` — clears pre-epoch state, resets debt.
@@ -364,6 +366,18 @@ Tasks are your **working documents**. All context, decisions, user stories, acce
 dreamcontext tasks list                                                 # List non-completed tasks (or --all for everything)
 Read _dream_context/state/<task>.md                                     # Load full context (Why + Changelog = where you left off)
 
+# Slice the list — filters compose (AND), and stack with --status / --all
+dreamcontext tasks list --version S5                                    # All tasks in version/milestone S5 (no more frontmatter scraping)
+dreamcontext tasks list --tag memoryos --tag backend --status todo      # --tag is repeatable, AND semantics (must have ALL)
+dreamcontext tasks list --any-tag lina --any-tag studio                 # --any-tag is repeatable, OR semantics (at least one)
+dreamcontext tasks list --priority critical                             # critical | high | medium | low
+dreamcontext tasks list --feature recall-engine                         # match related_feature
+dreamcontext tasks list --long                                          # also show version + tags inline
+dreamcontext tasks list --group-by version --all                        # sectioned output with per-group counts (tag|version|priority|status)
+dreamcontext tasks list --tag lina --json                              # scriptable: emit the filtered set as JSON (use this, not awk/grep)
+dreamcontext tasks tags                                                  # distinct tags with counts (--all to include completed)
+#   Filters are case-insensitive; version/priority/feature match exactly; multiple --tag = AND, --any-tag = OR.
+
 # Create (rich task with Why, User Stories, Acceptance Criteria, Constraints, Technical Details, Notes, Changelog)
 dreamcontext tasks create <name> --description "..." --priority medium --why "What this task accomplishes"
 
@@ -449,9 +463,6 @@ dreamcontext memory status
 _dream_context/
 +-- core/
 |   +-- features/<feature>.md         <- Feature PRDs (may include product: <name>)
-|   +-- data-structures/              <- Per-product schemas
-|   |   +-- default.md                <-   single-product fallback
-|   |   +-- <product>.md              <-   one per product if monorepo
 |   +-- 0.soul.md                     <- Identity, principles, rules
 |   +-- 1.user.md                     <- Preferences, project details
 |   +-- 2.memory.md                   <- Decisions + Known Issues (ship narrative moved to CHANGELOG 2026-05-23)
@@ -460,6 +471,9 @@ _dream_context/
 |   +-- 6.system_flow.md
 |   +-- CHANGELOG.json, RELEASES.json
 +-- knowledge/<topic>.md              <- Deep research, resources (global)
+|   +-- data-structures/              <- Per-product schemas (recall-indexed knowledge)
+|   |   +-- default.md                <-   single-product fallback
+|   |   +-- <product>.md              <-   one per product if monorepo
 |   +-- products/<product>.md         <- Per-product knowledge (multi-product)
 +-- state/
 |   +-- <task>.md                     <- Active tasks (frontmatter may include product:)
@@ -474,14 +488,15 @@ All commands prefixed with `dreamcontext`. For reading/searching, use native too
 
 | Command | Description |
 |---------|-------------|
-| `init [--multi-product=a,b,c]` | Initialize `_dream_context/`. Prompts interactively whether the project is a monorepo with multiple products; `--multi-product=a,b,c` skips the prompt and provides kebab-case product names directly. Creates `core/data-structures/<product>.md` per product (or `default.md` for single-product) and seeds `knowledge/products/`. |
+| `init [--multi-product=a,b,c]` | Initialize `_dream_context/`. Prompts interactively whether the project is a monorepo with multiple products; `--multi-product=a,b,c` skips the prompt and provides kebab-case product names directly. Creates `knowledge/data-structures/<product>.md` per product (or `default.md` for single-product) and seeds `knowledge/products/`. |
 | `core changelog add` | Add changelog entry (interactive) |
 | `core releases add [--ver v --summary s --yes] [--status planning]` | Create release (default: released with auto-discovery; --status planning: empty planning version, auto-becomes active) |
 | `core releases active [<version>] [--clear]` | Get/set/clear the active planning version (default for new tasks' `version` field) |
 | `core releases list [-n count]` | List recent releases |
 | `core releases show <version>` | Show release details |
-| `features create <name>` | Create feature PRD |
-| `features insert <name> <section> <content>` | Insert into feature section |
+| `features create <name> [-w why] [-t tags] [-s status] [--related-tasks a,b]` | Create feature PRD; frontmatter set without hand-editing (status: planning\|in_progress\|in_review\|active\|shipped\|deprecated) |
+| `features insert <name> <section> <content>` | Insert into feature section (replaces template placeholders on first write; `user_stories`/`acceptance_criteria` auto-formatted as `- [ ]` items) |
+| `features set <name> <tags\|status\|related_tasks> <value...>` | Set a feature frontmatter field (comma-separated for tags/related_tasks) without hand-editing |
 | `knowledge create <name>` | Create knowledge file |
 | `knowledge index [--tag <tag>]` | Show knowledge index |
 | `knowledge tags` | List standard tags |
@@ -492,7 +507,8 @@ All commands prefixed with `dreamcontext`. For reading/searching, use native too
 | `memory delete <slug> [--force]` | Remove a knowledge entry |
 | `memory list [--types ...]` | List indexable memory corpus by type |
 | `memory status` | Show corpus size broken down by type |
-| `tasks list [-s status] [--all]` | List tasks (default: excludes completed) |
+| `tasks list [-s status] [--all] [--tag t]… [--any-tag t]… [--version id] [--priority p] [--feature slug] [--group-by tag\|version\|priority\|status] [--long] [--json]` | List/filter/group tasks. Default excludes completed. `--tag` repeatable (AND), `--any-tag` repeatable (OR), filters compose; `--json` emits the filtered set; case-insensitive matching |
+| `tasks tags [--all] [--json]` | List distinct task tags with counts (discover before filtering) |
 | `tasks create <name> [-d desc] [-p priority] [-s status] [-t tags] [-w why] [--reach N --impact N --confidence N --effort N]` | Create task (defaults: priority=medium, status=todo). RICE flags optional and additive. |
 | `tasks rice <name> [--reach N] [--impact N] [--confidence N] [--effort N] [--clear]` | Print or update RICE values; no flags prints current values |
 | `tasks insert <name> <section> <content>` | Insert into task section |
@@ -505,6 +521,7 @@ All commands prefixed with `dreamcontext`. For reading/searching, use native too
 | `trigger add "<when>" "<remind>" [-m max_fires] [-s source]` | Create contextual trigger |
 | `trigger list` | Show active triggers |
 | `trigger remove <id>` | Remove a trigger |
+| `reflect [--min-sessions N] [--max N] [--write]` | Detect recurring cross-session terms not yet in knowledge/memory as CANDIDATES; `--write` persists to `state/.reflection.md` |
 | `transcript distill <session_id>` | Extract high-signal content from session transcript |
 | `sleep status` | Show sleep state and history |
 | `sleep add <score> "<desc>"` | Manual debt add |
@@ -523,6 +540,8 @@ All commands prefixed with `dreamcontext`. For reading/searching, use native too
 | `snapshot --tokens` | Estimate snapshot token count |
 | `doctor` | Validate `_dream_context/` structure |
 | `install-skill` | Install skill + hooks |
+| `config show` | Print project config (platforms, packs, native-memory state) |
+| `config native-memory <enable\|disable>` | Toggle Claude's native auto-memory; disabled by default so dreamcontext owns project memory |
 | `upgrade [--check]` | Update the dreamcontext CLI itself to the latest npm release |
 
 Feature insert sections: `changelog`, `notes`, `technical_details`, `constraints`, `user_stories`, `acceptance_criteria`, `why`

package/skill-packs/catalog.json

@@ -352,6 +352,50 @@
         "security"
       ],
       "alwaysApply": false
+    },
+    {
+      "name": "excalidraw",
+      "file": "excalidraw/SKILL.md",
+      "description": "Generate or extend Obsidian Excalidraw (.excalidraw.md) boards — lay out images/screenshots, text, shapes, arrows, frames, lanes and grids — by writing a small JSON spec and running a deterministic script that emits valid plugin markup (near-zero tokens, always renders). Embeds local images via the plugin's sha1 wikilink trick (no base64). Triggers: 'draw this in excalidraw', 'make an excalidraw board', 'excalidraw diagram', 'funnel map board', 'embed screenshots into excalidraw', 'excalidraw çiz', 'excalidraw board oluştur'.",
+      "tags": [
+        "excalidraw",
+        "obsidian",
+        "diagram",
+        "board",
+        "visualization",
+        "screenshots",
+        "funnel-map",
+        "drawing"
+      ],
+      "alwaysApply": false,
+      "bundleDir": true
+    },
+    {
+      "name": "video-watching",
+      "file": "video-watching/SKILL.md",
+      "description": "Load when the user hands over a video file/link or asks to watch/analyze a video, extract a transcript, or 'bu videoda ne var'. Turns a video into a time-mapped transcript with on-screen visuals (slides, UI, charts, text) described inline, then reasons about it. Triggers: 'watch this video', 'videoyu izle/analiz et', 'transkript çıkar', 'video transcript'.",
+      "tags": [
+        "video",
+        "transcript",
+        "whisper",
+        "ffmpeg",
+        "frames",
+        "ocr",
+        "marketing-teardown",
+        "media"
+      ],
+      "alwaysApply": false,
+      "bundleDir": true,
+      "requiresBinaries": [
+        "whisper-cpp",
+        "ffmpeg",
+        "yt-dlp (remote links only)"
+      ],
+      "crossPackDeps": [
+        "growth (marketing-video teardown handoff)",
+        "meta-marketing (ad-creative teardown handoff)",
+        "design/onboarding-design (app-demo / FTE reconstruction handoff)"
+      ]
     }
   ],
   "agents": [

package/skill-packs/excalidraw/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: excalidraw
+description: >-
+  Generate or extend Obsidian Excalidraw (.excalidraw.md) boards in this vault — lay out
+  images/screenshots, text labels, shapes, arrows, frames, lanes and grids — by writing a small
+  JSON spec and letting a deterministic script emit valid plugin markup (so it costs ~no tokens and
+  always renders). Embeds local images via the plugin's sha1 wikilink trick (no base64). Triggers:
+  '/excalidraw', 'draw this in excalidraw', 'make an excalidraw board', 'excalidraw diagram',
+  'funnel map board', 'embed screenshots into excalidraw', 'add images to an excalidraw file',
+  'excalidraw çiz', 'excalidraw board oluştur', 'ekran görüntülerini excalidraw a ekle'.
+---
+
+# Excalidraw board generator (Obsidian)
+
+Write `.excalidraw.md` files that render natively in this vault's Obsidian Excalidraw plugin.
+**Do not hand-author the scene JSON.** Build a small spec and run the generator — it produces the
+frontmatter, `## Text Elements`, `## Embedded Files`, and the `%% ## Drawing … %%` JSON, with
+correct sha1 image links, fractional z-indices, and deterministic seeds (clean git diffs).
+
+## The one trick that makes images work
+An image element references `fileId` = **sha1 of the image file**. The `## Embedded Files` section
+maps `<sha1>: [[image.png]]`. The plugin resolves the picture from the vault via that wikilink —
+**no base64 needed.** The generator computes the sha1 and writes both sides for you.
+
+## Usage
+
+### CLI (most common)
+```bash
+node .claude/skills/excalidraw/scripts/build_excalidraw.js <spec.json> [--out <path.excalidraw.md>]
+```
+Write a spec JSON, then run it. The script prints `elements/images/texts` counts on success.
+
+### JS API (for pipelines that generate many boards)
+```js
+const path = require('path');
+// skill lives at <project>/.claude/skills/excalidraw/ — adjust leading ../ count to match your script's depth from project root
+const { buildExcalidraw, lane, grid } = require(path.resolve(__dirname, '../.claude/skills/excalidraw/scripts/build_excalidraw.js'));
+buildExcalidraw({ out: path.resolve(__dirname, '../boards/Board.excalidraw.md'), elements: [ ...lane({ title, images, x, y, thumbW }) ] });
+```
+
+## File layout
+
+### Single board (default)
+Keep the spec next to the generated board but clearly separated:
+```
+boards/
+├── MyBoard.excalidraw.md      ← generated deliverable; do not hand-edit
+└── _spec/
+    └── MyBoard.json           ← source of truth; edit this, then regenerate
+```
+The `.excalidraw.md` is **disposable** — it is fully derived from the spec. If the two ever
+disagree, the spec wins. Commit both (the board for Obsidian/GitHub preview, the spec for
+reproducibility), but only edit the spec.
+
+### Multi-board pipeline
+When a single generator produces several boards, isolate it in a `pipeline/` folder so the
+deliverable boards stay at the top of the project and are easy to open in Obsidian:
+```
+boards/
+├── Overview.excalidraw.md     ← generated
+├── Funnel.excalidraw.md       ← generated
+├── Pricing.excalidraw.md      ← generated
+└── pipeline/
+    ├── generate.js            ← single regen entrypoint: `node pipeline/generate.js`
+    ├── shared-style.js        ← shared palette / helpers
+    └── spec/
+        ├── Overview.json      ← source spec for Overview board
+        ├── Funnel.json        ← source spec for Funnel board
+        └── Pricing.json       ← source spec for Pricing board
+```
+- **Generated files** (`*.excalidraw.md`) live one level above `pipeline/` — open them in Obsidian without navigating into a sub-folder.
+- **Source specs** live in `pipeline/spec/` — one JSON per board.
+- **Single entrypoint**: `node pipeline/generate.js` rebuilds every board. No per-board manual commands.
+
+### Many boards from shared data (recipe)
+Use this pattern when multiple boards pull from the same data set (e.g. one board per product, per region, or per funnel step):
+
+```js
+// pipeline/generate.js  (lives at boards/pipeline/generate.js)
+const path = require('path');
+const ROOT  = path.resolve(__dirname, '..');          // boards/ directory
+// ../../ = project root (boards/ → project/); adjust if boards/ is nested deeper
+const { buildExcalidraw, lane } = require(path.resolve(__dirname, '../../.claude/skills/excalidraw/scripts/build_excalidraw.js'));
+const style  = require(path.resolve(__dirname, 'shared-style.js'));
+const items  = require(path.resolve(__dirname, 'spec/items.json'));  // shared data
+
+for (const item of items) {
+  const elements = style.buildItemBoard(item);        // per-item spec logic
+  buildExcalidraw({
+    out: path.resolve(ROOT, `${item.slug}.excalidraw.md`),
+    elements,
+  });
+  console.log('wrote', item.slug);
+}
+```
+
+```js
+// pipeline/shared-style.js  (lives at boards/pipeline/shared-style.js)
+const path = require('path');
+// ../../ = project root (boards/ → project/); adjust if boards/ is nested deeper
+const { card, connector, sectionTitle } = require(path.resolve(__dirname, '../../.claude/skills/excalidraw/scripts/lib/style.js'));
+
+exports.buildItemBoard = (item) => [
+  sectionTitle({ x: 0, y: 0, text: item.name, fontSize: 40 }),
+  // … common layout using item fields
+];
+```
+
+Key conventions:
+- `ROOT = path.resolve(__dirname, '..')` pins paths relative to the generator file, not the working directory. The generator works correctly wherever it is invoked from.
+- Each item produces exactly one board; the mapping is `items.json → <slug>.excalidraw.md`.
+- `shared-style.js` owns the layout logic — boards stay visually consistent; change the style once, regenerate all.
+- Add a `package.json` script or `Makefile` alias so the command is always `npm run boards` (or similar) and never has to be rediscovered.
+
+## Spec schema
+```jsonc
+{
+  "out": "./boards/Board.excalidraw.md",    // prefer __dirname-relative in JS generators; relative to cwd for CLI
+  "vaultRoot": "/abs/vault",                  // optional; auto-detected by walking up to `.obsidian`
+  "attachDir": "Attachments",                 // external images get copied here (relative to board dir)
+  "wikilinkMode": "basename",                 // "basename" (default) or "path" (vault-relative)
+  "background": "#ffffff",
+  "elements": [ /* ElementSpec… */ ]
+}
+```
+
+**Paths in generators**: always use `path.resolve(__dirname, ...)` for `out` and image `path` fields — never
+hardcode absolute paths. This keeps the generator portable: move the folder and it still runs.
+
+### Element types
+- `text`     — `{ x, y, text, fontSize?, color?, width?, align?, fontFamily? }` (fontFamily 1=hand, 2=normal, 3=code). **Set `width` for any caption/label that must stay inside a column or card** → the text WRAPS to that width (autoResize off) and its height is computed from the wrapped line count. Omit `width` only for short single-line text you want sized to content (it renders on one line and will overlap neighbours if long).
+- `image`    — `{ x, y, path, width? , height? }` — give ONE of width/height; the other is derived from aspect. `path` is an absolute file path.
+- `rectangle`/`ellipse`/`diamond` — `{ x, y, width, height, strokeColor?, backgroundColor?, fillStyle?(solid|hachure|cross-hatch), strokeWidth?, roundness?(true=rounded) }`
+- `line`/`arrow` — `{ points: [[x1,y1],[x2,y2],…], strokeColor?, strokeWidth?, endArrow?, startArrow? }` (coords are absolute; arrows default to an end arrowhead)
+- `frame`    — `{ x, y, width, height, name }`
+
+### Layout helpers (JS API) — dimension-aware, never gap/overlap
+Both read each image's real pixel size at layout time, so every caption **hugs its own image's bottom**
+(no fixed-aspect guess → no big gap under a short screenshot, no overlap under a tall one). They return
+an `ElementSpec[]` you spread with `...`, and that array also carries `.height`, `.width`, and **`.nextY`**
+so you can stack lanes/grids/sections without doing height math by hand.
+- `lane({ title, images:[{path, caption}], x, y, thumbW, gap, captionSize, captionGap })` → titled horizontal
+  strip; caption wraps to `thumbW` under each thumb. Ideal for **funnel step maps** (one lane per funnel).
+- `grid({ images:[{path, caption}], x, y, cols, thumbW, gapX, gapY, captionSize })` → wrapping grid; each
+  row sizes to its tallest image, each caption hugs its image.
+- `thumbHeight(path, thumbW)` → the on-board height a thumbnail of width `thumbW` will get (exported for
+  custom layouts that need to place captions/rows themselves).
+```js
+const a = lane({ title:'Pilates', images, x:60, y:120, thumbW:150 });
+const b = lane({ title:'Fasting', images2, x:60, y:a.nextY, thumbW:150 }); // stacks under `a`, no overlap
+buildExcalidraw({ out, elements:[ ...a, ...b ] });
+```
+House-style `card()` labels are also vertically centered correctly even when the label **wraps** to the card width.
+
+## House style (`scripts/lib/style.js`) — learned from the vault's presentation boards
+Match the team's look by default. The builder now defaults text to **Excalifont (fontFamily 5)**.
+`style.js` exports the palette + ready-made builders so boards look hand-drawn and consistent:
+
+- **`PALETTE`** (semantic, = Excalidraw's native swatches): `green` benefit/go · `red` pain/risk ·
+  `blue` system/flow · `purple` core service · `yellow` processing · `mint` result · `gray` muted.
+  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).
+- **`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.
+- **`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}`.
+- **`hub({cx,cy,label,spokes})`** → central node + satellites with arrows (the "Layer + APIs" pattern).
+- **`bullets({x,y,items})`** → one left-aligned bulleted text block (their spec-list pattern).
+- Edge helpers `center/rightOf/leftOf/topOf/bottomOf(x,y,w,h)` to wire connectors to card edges.
+
+Compose these into a `buildExcalidraw({ out, elements })` call. Runnable example: `examples/style_board.js`.
+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.
+
+## 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
+  (e.g. `bm-pilates-2707-step-03.png`) or use `"wikilinkMode": "path"`.
+- Images must live inside the vault. External paths are auto-copied into `attachDir`.
+- Output is uncompressed JSON inside `%% … %%`. The plugin reads it; on its first save it may
+  re-compress — that's expected and harmless.
+- Re-running with the same `out` + same spec yields a byte-stable file (seeds are derived from the
+  output path), so boards diff cleanly in git.
+- **Self-contained / portable.** No `npm install` — `build_excalidraw.js` uses only Node builtins +
+  the vendored `scripts/lib/*` (fractional-indexing, imagesize, style). Copy `.claude/skills/excalidraw/`
+  into any project and it works. `vaultRoot` auto-detects `.obsidian`; with none it falls back to the
+  board's own folder, so the `.excalidraw.md` is still written (it just renders inside Obsidian).
+
+## Verify
+Run the bundled examples from the skill folder (they use skill-relative paths + a bundled `sample.png`,
+so they work in any project):
+```bash
+cd .claude/skills/excalidraw
+node scripts/build_excalidraw.js examples/hello.spec.json   # spec-driven: text/shapes/image → examples/Hello Excalidraw.excalidraw.md
+node examples/style_board.js                                # JS API: card/connector/lane house style → examples/Style Demo.excalidraw.md
+```
+Then open the resulting board in Obsidian (Excalidraw view) to confirm it renders.
+
+See `reference/format.md` for the exact `.excalidraw.md` anatomy reverse-engineered from this vault.

package/skill-packs/excalidraw/examples/hello.spec.json

@@ -0,0 +1,14 @@
+{
+  "out": "examples/Hello Excalidraw.excalidraw.md",
+  "background": "#ffffff",
+  "elements": [
+    { "type": "text", "x": 0, "y": -70, "text": "excalidraw skill — portable smoke test", "fontSize": 28, "color": "#1971c2" },
+    { "type": "text", "x": 0, "y": -28, "text": "Give a text a width and it wraps to that width (no overlap). The image embeds via sha1 wikilink — no base64. Only skill-relative paths, so this runs in any project.", "fontSize": 15, "color": "#868e96", "width": 540 },
+    { "type": "rectangle", "x": 0, "y": 40, "width": 260, "height": 140, "strokeColor": "#1e1e1e", "backgroundColor": "#a5d8ff", "fillStyle": "solid", "strokeWidth": 2, "roundness": true },
+    { "type": "text", "x": 24, "y": 96, "text": "rounded rect\n+ fill", "fontSize": 20, "color": "#1e1e1e" },
+    { "type": "ellipse", "x": 340, "y": 40, "width": 160, "height": 140, "strokeColor": "#2f9e44", "backgroundColor": "#b2f2bb", "fillStyle": "hachure" },
+    { "type": "arrow", "points": [[260, 110], [340, 110]], "strokeColor": "#e8590c", "strokeWidth": 3 },
+    { "type": "text", "x": 0, "y": 220, "text": "embedded image (resolved from vault by sha1 wikilink):", "fontSize": 16, "color": "#555", "width": 420 },
+    { "type": "image", "x": 0, "y": 250, "path": "examples/sample.png", "width": 320 }
+  ]
+}

package/skill-packs/excalidraw/examples/style_board.js

@@ -0,0 +1,31 @@
+// style_board.js — house-style demo. Run from anywhere:  node examples/style_board.js
+// Shows card/connector/sectionTitle + the dimension-aware lane() (captions hug images, .nextY stacks).
+const path = require('path');
+const { buildExcalidraw, lane } = require(path.join(__dirname, '..', 'scripts', 'build_excalidraw.js'));
+const { card, connector, sectionTitle, rightOf, leftOf, bottomOf, topOf } = require(path.join(__dirname, '..', 'scripts', 'lib', 'style.js'));
+
+const SAMPLE = path.join(__dirname, 'sample.png');
+const els = [];
+const P = (...a) => els.push(...a.flat());
+
+// --- flow row with labeled connectors (color nodes by role) ---
+P(sectionTitle({ x: 0, y: 0, text: 'House style', fontSize: 40 }));
+const A = { x: 0, y: 90, w: 220, h: 84 }, B = { x: 360, y: 90, w: 220, h: 84 }, C = { x: 720, y: 90, w: 220, h: 84 };
+P(card({ ...A, text: 'input', color: 'blue' }));
+P(card({ ...B, text: 'core service', color: 'purple' }));
+P(card({ ...C, text: 'result', color: 'mint' }));
+P(connector({ from: rightOf(A.x, A.y, A.w, A.h), to: leftOf(B.x, B.y, B.w, B.h), label: 'request' }));
+P(connector({ from: rightOf(B.x, B.y, B.w, B.h), to: leftOf(C.x, C.y, C.w, C.h), label: 'response' }));
+
+// --- a dimension-aware lane: captions hug each image, .nextY gives the next free row ---
+const imgs = [
+  { path: SAMPLE, caption: 'lane() reads the real image size, so this caption hugs the bottom and wraps to the thumb width — no gap, no overlap.' },
+  { path: SAMPLE, caption: 'second thumb' },
+  { path: SAMPLE, caption: 'third thumb' },
+];
+const strip = lane({ title: 'lane()  — funnel-step style strip', images: imgs, x: 0, y: 220, thumbW: 200 });
+P(strip);
+P(sectionTitle({ x: 0, y: strip.nextY, text: 'stacked below via strip.nextY', fontSize: 22, color: '#868e96' }));
+
+buildExcalidraw({ out: path.join(__dirname, 'Style Demo.excalidraw.md'), elements: els, background: '#fbfbfb' });
+console.log('style demo →', path.join(__dirname, 'Style Demo.excalidraw.md'));

package/skill-packs/excalidraw/package.json

@@ -0,0 +1,5 @@
+{
+  "type": "commonjs",
+  "private": true,
+  "description": "Scopes the excalidraw skill's vendored scripts to CommonJS so `require()` works even when the host project sets \"type\": \"module\". No dependencies — scripts use only Node builtins + vendored lib/."
+}

package/skill-packs/excalidraw/reference/format.md

@@ -0,0 +1,93 @@
+# Obsidian `.excalidraw.md` format (reverse-engineered from this vault)
+
+Source files inspected: `lina/excalidraw/Lina Web Funnel.excalidraw.md` (decompressed),
+`Lina Web Funnel Benchmark.excalidraw.md`. Plugin: `zsviczian/obsidian-excalidraw-plugin`.
+
+## File anatomy
+```
+---
+
+excalidraw-plugin: parsed
+tags: [excalidraw]
+
+---
+==⚠  Switch to EXCALIDRAW VIEW … ⚠== …saving hint…
+
+
+# Excalidraw Data
+
+## Text Elements
+<text content> ^<elementId>      ← one block per text element, blank line between
+
+## Embedded Files
+<sha1>: [[image filename.png]]    ← maps fileId → vault image, blank line between
+
+%%
+## Drawing
+```json
+{ "type":"excalidraw", "version":2, "source":"…", "elements":[…], "appState":{…}, "files":{} }
+```
+%%
+```
+- `## Drawing` may be ` ```compressed-json ` (LZString.compressToBase64) **or** ` ```json `
+  (uncompressed). The plugin reads both. We emit uncompressed JSON — readable, no deps.
+- The whole drawing block is wrapped in `%% … %%` (Obsidian comment) so it hides in reading view.
+- `## Text Elements` and `## Embedded Files` sit **before** the `%%`.
+
+## Image embedding (the key mechanism)
+- An image element is `{"type":"image", "fileId":"<sha1>", …, "scale":[1,1], "status":"pending", "crop":null}`.
+- `fileId` is the **sha1 of the image file's bytes**.
+- The `## Embedded Files` line `<sha1>: [[file.png]]` is what the plugin uses to load the picture
+  from the vault. **The scene `files` object can be empty (`{}`)** — no base64 dataURL required.
+- `crop` is optional (only when the user cropped). `null` shows the whole image.
+
+## Ground-truth image element (decompressed from the vault)
+```json
+{
+  "id":"GtJwnnEj","type":"image","x":-147.3,"y":-290.5,"width":118.8,"height":469,
+  "angle":0,"strokeColor":"transparent","backgroundColor":"transparent","fillStyle":"solid",
+  "strokeWidth":2,"strokeStyle":"solid","roughness":1,"opacity":100,"groupIds":[],"frameId":null,
+  "index":"a0","roundness":null,"seed":2054545386,"version":188,"versionNonce":1261541290,
+  "isDeleted":false,"boundElements":[],"updated":1779266944741,"link":null,"locked":false,
+  "status":"pending","fileId":"3eaa974da433f70ba06cb3fb2587b486d6143d32","scale":[1,1],
+  "crop":{ "x":713.7,"y":0,"width":871.3,"height":3440,"naturalWidth":2283,"naturalHeight":3440 },
+  "hasTextLink":false
+}
+```
+…and its `## Embedded Files` line:
+```
+3eaa974da433f70ba06cb3fb2587b486d6143d32: [[Pasted Image 20260515130812_941.png]]
+```
+
+## z-order: fractional indices
+- Every element has a string `index` (`"a0"`, `"a1"`, …) — fractional indexing, compared
+  lexicographically. We generate them with the vendored `fractional-indexing` lib
+  (`generateNKeysBetween(null,null,N)`), which matches the vault output exactly.
+- Excalidraw's `restore()` (run by the plugin on load) repairs invalid/missing indices, but we emit
+  valid ascending ones anyway.
+
+## appState
+Minimal is fine: `{"gridSize":null,"gridStep":5,"gridModeEnabled":false,"viewBackgroundColor":"#ffffff"}`.
+
+## House style (measured from MemoryOS High Level / Personalization Module / Research)
+The vault's presentation boards share one fingerprint — `scripts/lib/style.js` encodes it:
+- **Font:** Excalifont, `fontFamily: 5`, for ~100% of text. Sizes form a scale: ~16 labels, ~20 body,
+  ~28 sub-headers, ~44–50 section titles (scaled up on large zoomed-out canvases).
+- **Fills:** `fillStyle: "solid"` exclusively (never hachure). **Every rectangle is rounded.**
+- **Ink:** `strokeColor: "#1e1e1e"`, `strokeWidth: 2` dominant (1 for fine/secondary).
+- **Semantic palette** (Excalidraw native swatches): green `#b2f2bb`/`#2f9e44` (benefit/go),
+  red `#ffc9c9`/`#e03131` (pain/risk), blue `#a5d8ff`/`#1971c2` (system/flow), purple `#d0bfff`/`#6741d9`
+  (core service), yellow `#ffec99`/`#f08c00` (processing), mint `#96f2d7`/`#0c8599` (result),
+  pale variants `#ebfbee`/`#e7f5ff`/`#f3f0ff` for backdrops.
+- **Patterns:** rounded-card (rect + centered label, grouped) · color nodes by role · ellipse = actor,
+  diamond = decision, container-rect groups sub-states · arrows almost always single end-arrowhead,
+  labeled inline ("req", "msg+ctx") · side-annotation arrows to spec notes · big plain section titles
+  ("Configuration", "Flow") · benefit/risk **card columns** · hub-and-spoke concept maps · bulleted
+  spec lists as one text block. Heavy use of embedded screenshots in research murals (huge canvases,
+  29+ groups) — exactly the funnel-map use case.
+
+## Tooling note
+The `yctimlin/mcp_excalidraw` MCP server was evaluated and rejected for this vault: it needs a
+running localhost canvas server and exports excalidraw.com JSON / PNG / share-URLs — it does **not**
+write Obsidian `.excalidraw.md` with the `## Embedded Files` wikilink section. Hand-generating the
+file (this skill) is the correct, dependency-light path for bulk-embedding local screenshots.