@heart-of-gold/toolkit 0.1.32 → 0.1.34

package/.claude-plugin/marketplace.json

@@ -15,19 +15,19 @@
       "name": "deep-thought",
       "source": "./plugins/deep-thought",
       "description": "The Answer Computer — reasoning tools for brainstorming, planning, and deep thinking",
-      "version": "0.2.2"
+      "version": "0.2.4"
     },
     {
       "name": "marvin",
       "source": "./plugins/marvin",
       "description": "The Paranoid Android — quality tools for code review, knowledge compounding, and work execution",
-      "version": "0.3.0"
+      "version": "0.3.4"
     },
     {
       "name": "babel-fish",
       "source": "./plugins/babel-fish",
       "description": "Universal Translator — media generation tools for audio, image, and video content",
-      "version": "0.2.0"
+      "version": "0.2.2"
     },
     {
       "name": "quellis",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heart-of-gold/toolkit",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "description": "Cross-platform installer for Heart of Gold skills — works with Codex, OpenCode, Pi, Claude Code, and more",
   "bin": {
@@ -11,6 +11,7 @@
     "check:security": "python3 scripts/check-security-regressions.py",
     "check:compat": "python3 scripts/check-harness-compatibility.py",
     "test:pi-guided": "node --test tests/pi-guided-workflows.test.mjs",
+    "test:visualize": "node --test tests/visualize-smart-render.test.mjs",
     "prepublishOnly": "npm run check:publish-safety && npm run check:compat"
   },
   "dependencies": {

package/plugins/babel-fish/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-fish",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Universal Translator — media generation tools for audio, image, video, and visualization",
   "author": {
     "name": "ondrej-svec",

package/plugins/babel-fish/skills/visualize/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: visualize
 description: >
-  Render mind maps and tree visualizations from markdown. Prefer terminal output for quick local inspection,
-  and generate shareable HTML when the user wants a browser view and share-html infrastructure is configured.
-  Works on brainstorm docs, plan docs, markdown files, or any structured content. Triggers: visualize,
-  mindmap, mind map, show me the structure, draw a map.
+  Render mind maps and tree visualizations from markdown. Prefer shareable HTML first for brainstorms, plans,
+  architecture docs, and other structured workflow artifacts when share-html infrastructure is configured;
+  otherwise fall back to terminal output for quick local inspection. Works on markdown files or any structured
+  content. Triggers: visualize, mindmap, mind map, show me the structure, draw a map.
 allowed-tools:
   - Read
   - Bash
@@ -21,24 +21,28 @@ Translating structured text into spatial understanding. Because walls of text hi
 - MAY: read files, generate terminal mind maps, generate temporary HTML artifacts, run renderer/share scripts via bash
 - MAY NOT: modify project files, create persistent files outside temp/output artifacts, install unrelated packages
 
-## The Renderer
+## The Renderers
 
-A Node.js script that converts markdown headings into colored, spatial Unicode mind maps.
+Visualization now has two layers:
+- `scripts/smart-render.js` — renders one HTML artifact using the mode the coding agent chose (or a safe fallback)
+- `scripts/render-mindmap/index.js` — specialized mind-map renderer for branchy content
 
-**Location:** `scripts/render-mindmap/index.js` (relative to this skill's directory)
+**Locations:**
+- `scripts/smart-render.js`
+- `scripts/render-mindmap/index.js`
 
-**To find the script path**, locate it by searching for `render-mindmap/index.js`:
+**To find the smart renderer path**, locate it by searching for `smart-render.js`:
 ```bash
 # Option 1: Use CLAUDE_PLUGIN_ROOT if available
-SCRIPT="${CLAUDE_PLUGIN_ROOT}/skills/visualize/scripts/render-mindmap/index.js"
+SCRIPT="${CLAUDE_PLUGIN_ROOT}/skills/visualize/scripts/smart-render.js"
 
 # Option 2: Search for it
-SCRIPT=$(find ~/.claude/plugins -path "*/babel-fish/skills/visualize/scripts/render-mindmap/index.js" 2>/dev/null | head -1)
+SCRIPT=$(find ~/.claude/plugins -path "*/babel-fish/skills/visualize/scripts/smart-render.js" 2>/dev/null | head -1)
 ```
 
-**First run:** If `node_modules/` doesn't exist in the renderer directory, run `npm install` there first:
+**First run:** If `node_modules/` doesn't exist in the mind-map renderer directory, run `npm install` there first:
 ```bash
-RENDER_DIR=$(dirname "$SCRIPT")
+RENDER_DIR=$(dirname "$SCRIPT")/render-mindmap
 if [ ! -d "$RENDER_DIR/node_modules" ]; then
   (cd "$RENDER_DIR" && npm install --silent)
 fi
@@ -47,33 +51,33 @@ fi
 ## Usage
 
 ```bash
-# Render a markdown file in the terminal
-node "$SCRIPT" path/to/file.md
-
-# With options
-node "$SCRIPT" --no-color path/to/file.md    # plain Unicode, no ANSI
-node "$SCRIPT" --width 120 path/to/file.md   # constrain to 120 columns
-node "$SCRIPT" --depth 2 path/to/file.md     # limit tree depth
-node "$SCRIPT" --json path/to/data.json      # JSON tree input
-node "$SCRIPT" --html /tmp/map.html path/to/file.md  # generate HTML mind map
-
-# Pipe markdown
-echo "# Root\n## Branch A\n## Branch B" | node "$SCRIPT"
+# Generate a safe default HTML visualization for a markdown file
+node "$SCRIPT" path/to/file.md --out /tmp/view.html
+
+# Usually the coding agent should choose the mode from context
+node "$SCRIPT" path/to/file.md --mode roadmap --out /tmp/view.html
+node "$SCRIPT" path/to/file.md --mode outline --out /tmp/view.html
+node "$SCRIPT" path/to/file.md --mode architecture --out /tmp/view.html
+node "$SCRIPT" path/to/file.md --mode mindmap --out /tmp/view.html
+
+# Use the specialized mind-map renderer directly when needed
+node "$(dirname "$SCRIPT")/render-mindmap/index.js" --html /tmp/map.html path/to/file.md
 ```
 
 ### Shareable HTML flow
 
-Use the helper script when the user wants a browser URL and the share server is already configured:
+Use the helper script when the user wants a browser URL and the share server is already configured. It now generates one polished HTML artifact first, then publishes it:
 
 ```bash
 bash scripts/render-and-share.sh path/to/file.md
 ```
 
 This script:
-1. generates an HTML mind map via the existing renderer
-2. locates `share-html/scripts/publish.sh`
-3. publishes the artifact to the configured local share server
-4. prints the publish JSON so you can return the URL
+1. generates one HTML artifact via the smart renderer
+2. uses the mode the coding agent chose (or the renderer's safe default)
+3. locates `share-html/scripts/publish.sh`
+4. publishes the artifact to the configured local share server
+5. prints the publish result so you can return the URL
 
 ## Rendering Behavior
 
@@ -88,25 +92,28 @@ This script:
 
 ## Phase 0 — Determine What to Visualize
 
-First decide whether the user wants:
-- a quick terminal view
-- a browser/shareable HTML view
+First decide whether this should be a browser/shareable HTML view or a quick terminal view.
 
-**Prefer browser/shareable HTML when:**
+**Prefer browser/shareable HTML first when:**
+- the source is a brainstorm, plan, architecture doc, or other structured workflow artifact
 - the user asks to open it in a browser
 - the user wants to share the result with another person or device
 - the structure is large enough that browser navigation is more useful than terminal rendering
+- `share-html` is configured
 
 **Prefer terminal rendering when:**
-- the user wants a quick local look
-- the environment is SSH-heavy or browser access is not requested
 - share-html is not configured
+- the user explicitly wants a quick terminal-only look
+- the environment is SSH-heavy and the browser/share path is not requested
 
 When invoked as `/visualize [path]`:
 
 **If a file path is provided:**
 1. Read the file
-2. Render it directly with the mind map renderer
+2. Decide what kind of visual artifact would help most from context
+3. If confidence is high enough, choose the mode and generate/share HTML first
+4. If confidence is not high enough, ask the user which direction would help most
+5. If sharing is unavailable or the user explicitly wants terminal output, fall back appropriately
 
 **If no path is provided:**
 1. Check if there's a recent brainstorm or plan document in the conversation context
@@ -140,27 +147,81 @@ The default mode is **vertical layout** — boxes on main branches, compact leav
 
 ### Path B — Shareable HTML
 
-If the user wants browser viewing or sharing and `share-html` is configured:
+For substantial artifacts, prefer this path first when `share-html` is configured.
+
+The coding agent should choose the mode from context. Toolkit guidance:
+- plans often fit `roadmap` or `outline`
+- architecture docs often fit `architecture` or `outline`
+- concise branchy brainstorms may fit `mindmap`
+- product/UI concepts may fit `mockup`
+- stakeholder-friendly summaries may fit `explainer`
+
+If uncertain, ask the user using the harness's structured choice UI when available; otherwise present concise plain-text options.
+
+### Uncertainty protocol
+
+When the best visualization is not clear, do **not** silently guess if the choice would materially affect usefulness.
+
+Ask **one concise question at a time**:
+- state the decision in plain language
+- offer 2-4 explicit options
+- include a recommended option when you have one
+- keep option labels outcome-focused, not renderer-jargon-first
+
+Good pattern:
+- "Which would help most here?"
+- `Roadmap` — show phases, sequencing, and implementation progress
+- `Outline` — show the document structure clearly
+- `Mind map` — show branching ideas and relationships
+- `Architecture view` — show components, boundaries, and decisions
+
+If the harness supports structured choices, use them.
+If not, use a short plain-text question such as:
+
+```text
+I can visualize this a few different ways. Which would be most useful?
+1. Roadmap — phases and tasks
+2. Outline — document structure
+3. Mind map — branching ideas
+4. Architecture view — components and boundaries
+```
+
+If the user does not care or says "you decide," choose the safest useful mode:
+- default to `outline`
+- use `roadmap` for clearly execution-heavy plans
+- use `architecture` for clearly system-design-heavy docs
+- use `mindmap` only when the artifact is genuinely concise and branchy
 
 1. Verify or assume the input markdown is ready
 2. Run:
    ```bash
-   bash scripts/render-and-share.sh [file]
+   bash scripts/render-and-share.sh --mode <chosen-mode> --url-only [file]
    ```
-3. Read the returned JSON
-4. Return the primary URL to the user (`url` when present, otherwise `viewerUrl`)
-5. Briefly explain what was published
+3. Read the returned URL from stdout
+4. Return that URL to the user as the primary result
+5. Briefly explain what was published and why this mode was chosen
+
+If you need more detail for debugging, you may run the helper without `--url-only` and inspect the returned JSON.
 
 If publishing fails because the share server is not configured, say so clearly and fall back to terminal rendering unless the user wants to stop and run `share-server-setup` first.
 
 **For shell usage** (not through assistant panels): terminal rendering can use ANSI colors, or `--horizontal` for the wide spatial layout.
 
+## Current HTML modes
+
+- `outline` — safe default for dense or unknown structured docs
+- `roadmap` — useful for plans and phased execution views
+- `architecture` — useful for architecture docs and architect outputs
+- `mindmap` — useful for concise branchy artifacts where it truly helps
+- `mockup` — reserved for future product/UI concept views
+- `explainer` — reserved for future stakeholder/narrative views
+
 ## Phase 2 — Offer Next Steps
 
 After rendering or sharing, briefly note:
 - for terminal mode: "Use `--depth N` to see more/less detail"
 - for terminal mode: "Use `--width N` to fit a different terminal size"
-- for shared HTML: return the viewer URL and say whether it is local-only or publicly reachable on the user's tailnet
+- for shared HTML: return the final browser URL as the main result and say whether it is local-only or publicly reachable on the user's tailnet
 - if publishing failed due to missing share infrastructure: suggest `share-server-setup`
 - if the source was a brainstorm/plan/architecture doc, offer to continue the workflow (e.g., proceed to `/plan`, `/work`, or implementation)
 

package/plugins/babel-fish/skills/visualize/scripts/render-and-share.sh

@@ -3,30 +3,36 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 RENDER_DIR="$SCRIPT_DIR/render-mindmap"
-RENDER_SCRIPT="$RENDER_DIR/index.js"
+RENDER_SCRIPT="$SCRIPT_DIR/smart-render.js"
 INPUT_PATH=""
 SLUG=""
 TITLE=""
 ALIAS=""
+MODE="auto"
 KEEP_HTML=0
+URL_ONLY=0
 HTML_OUT=""
 TEMP_DIR=""
 
 usage() {
   cat <<'EOF'
-Usage: render-and-share.sh <markdown-file> [--slug STEM] [--title TITLE] [--alias ALIAS] [--html-out PATH] [--keep-html]
+Usage: render-and-share.sh <markdown-file> [--mode MODE] [--slug STEM] [--title TITLE] [--alias ALIAS] [--html-out PATH] [--keep-html] [--url-only]
 
-Generate an HTML mind map from a markdown file, publish it via share-html, and print the publish JSON.
+Generate a polished HTML visualization from a markdown file, publish it via share-html, and print the publish JSON.
+Use --mode to force a renderer (mindmap, outline, roadmap, architecture, mockup, explainer).
+Use --url-only to print only the final browser URL.
 EOF
 }
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    --mode) MODE="$2"; shift 2 ;;
     --slug) SLUG="$2"; shift 2 ;;
     --title) TITLE="$2"; shift 2 ;;
     --alias) ALIAS="$2"; shift 2 ;;
     --html-out) HTML_OUT="$2"; shift 2 ;;
     --keep-html) KEEP_HTML=1; shift ;;
+    --url-only) URL_ONLY=1; shift ;;
     --help) usage; exit 0 ;;
     --*) echo "Unknown argument: $1" >&2; exit 1 ;;
     *)
@@ -72,7 +78,7 @@ cleanup() {
 }
 trap cleanup EXIT
 
-node "$RENDER_SCRIPT" --html "$HTML_OUT" "$INPUT_PATH" >/dev/null
+node "$RENDER_SCRIPT" "$INPUT_PATH" --mode "$MODE" --out "$HTML_OUT" >/dev/null
 
 find_share_publish_script() {
   local candidates=(
@@ -104,4 +110,17 @@ if [[ -n "$SLUG" ]]; then CMD+=(--slug "$SLUG"); fi
 if [[ -n "$TITLE" ]]; then CMD+=(--title "$TITLE"); fi
 if [[ -n "$ALIAS" ]]; then CMD+=(--alias "$ALIAS"); fi
 
-"${CMD[@]}"
+PUBLISH_JSON="$("${CMD[@]}")"
+
+if [[ "$URL_ONLY" -eq 1 ]]; then
+  python3 - <<'PY' "$PUBLISH_JSON"
+import json, sys
+payload = json.loads(sys.argv[1])
+if not payload.get("ok", True):
+    print(json.dumps(payload))
+    raise SystemExit(1)
+print(payload.get("url") or payload.get("viewerUrl") or "")
+PY
+else
+  printf '%s\n' "$PUBLISH_JSON"
+fi

package/plugins/babel-fish/skills/visualize/scripts/smart-render.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function parseArgs(args) {
+  const opts = { file: null, out: null, mode: 'auto' };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--out' && i + 1 < args.length) opts.out = args[++i];
+    else if (arg === '--mode' && i + 1 < args.length) opts.mode = args[++i];
+    else if (!arg.startsWith('-')) opts.file = arg;
+  }
+  return opts;
+}
+
+function parseDocument(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let i = 0;
+  const frontmatter = {};
+  if (lines[0]?.trim() === '---') {
+    i = 1;
+    for (; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === '---') { i++; break; }
+      const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+      if (match) frontmatter[match[1]] = match[2].replace(/^"|"$/g, '');
+    }
+  }
+
+  const sections = [];
+  let current = null;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      current = { level: heading[1].length, title: heading[2].trim(), lines: [] };
+      sections.push(current);
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  return { frontmatter, sections, raw: markdown };
+}
+
+function collectChecklists(lines) {
+  return lines
+    .map((line) => line.match(/^\s*- \[( |x)\]\s+(.+)$/i))
+    .filter(Boolean)
+    .map((m) => ({ done: m[1].toLowerCase() === 'x', text: m[2].trim() }));
+}
+
+function textFromLines(lines) {
+  return lines.join('\n').trim();
+}
+
+function firstParagraph(lines) {
+  const blocks = textFromLines(lines).split(/\n\s*\n/).map((b) => b.trim()).filter(Boolean);
+  return blocks[0] || '';
+}
+
+function classifyMode(_filePath, _doc, preferredMode) {
+  if (preferredMode && preferredMode !== 'auto') return preferredMode;
+  return 'outline';
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function renderShell({ title, eyebrow, summary, toc, content, badge = '' }) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(title)}</title>
+<style>
+:root {
+  --bg: #0b1020;
+  --panel: rgba(255,255,255,0.06);
+  --panel-strong: rgba(255,255,255,0.1);
+  --text: #eef2ff;
+  --muted: #b8c0d9;
+  --border: rgba(255,255,255,0.12);
+  --accent: #7c9cff;
+  --accent-2: #80e0d0;
+  --success: #86efac;
+  --warn: #fbbf24;
+  --danger: #fca5a5;
+  --shadow: 0 20px 60px rgba(0,0,0,0.35);
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; background: radial-gradient(circle at top, #16213d 0%, var(--bg) 48%); color: var(--text); font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+body { line-height: 1.55; }
+main { max-width: 1440px; margin: 0 auto; padding: 40px 24px 72px; }
+.hero { display: grid; gap: 16px; margin-bottom: 28px; }
+.eyebrow { color: var(--accent-2); text-transform: uppercase; letter-spacing: 0.14em; font-size: 12px; font-weight: 700; }
+.hero h1 { margin: 0; font-size: clamp(32px, 4vw, 56px); line-height: 1.03; }
+.hero p { margin: 0; max-width: 78ch; color: var(--muted); font-size: 17px; }
+.badge { display: inline-flex; align-items: center; gap: 8px; width: fit-content; padding: 8px 12px; border-radius: 999px; background: rgba(124,156,255,0.18); border: 1px solid rgba(124,156,255,0.25); color: #dce5ff; font-size: 13px; }
+.layout { display: grid; grid-template-columns: minmax(220px, 300px) minmax(0, 1fr); gap: 24px; }
+nav { position: sticky; top: 16px; align-self: start; padding: 18px; border-radius: 20px; background: var(--panel); border: 1px solid var(--border); box-shadow: var(--shadow); backdrop-filter: blur(16px); }
+nav h2 { margin: 0 0 10px; font-size: 14px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.1em; }
+nav a { display: block; padding: 10px 12px; margin: 4px 0; color: var(--text); text-decoration: none; border-radius: 12px; }
+nav a:hover { background: rgba(255,255,255,0.05); }
+.section { margin-bottom: 18px; padding: 24px; border-radius: 24px; background: var(--panel); border: 1px solid var(--border); box-shadow: var(--shadow); backdrop-filter: blur(16px); }
+.section h2 { margin: 0 0 14px; font-size: clamp(22px, 2vw, 30px); }
+.section h3 { margin: 20px 0 8px; font-size: 18px; }
+.section p, .section li, .section td, .section th { color: var(--muted); font-size: 15px; }
+.section ul { padding-left: 18px; }
+.grid { display: grid; gap: 16px; }
+.grid.cols-2 { grid-template-columns: repeat(2, minmax(0,1fr)); }
+.card { padding: 18px; border-radius: 18px; background: var(--panel-strong); border: 1px solid var(--border); }
+.card h3, .card h4 { margin-top: 0; }
+.kicker { font-size: 12px; text-transform: uppercase; letter-spacing: 0.1em; color: var(--accent-2); margin-bottom: 8px; }
+.checklist { display: grid; gap: 10px; }
+.item { padding: 14px 16px; border-radius: 16px; background: rgba(255,255,255,0.04); border: 1px solid var(--border); }
+.item.done { border-color: rgba(134,239,172,0.35); }
+.item .status { font-size: 12px; text-transform: uppercase; letter-spacing: 0.08em; margin-bottom: 6px; }
+.item.done .status { color: var(--success); }
+.item.todo .status { color: var(--warn); }
+.meta-grid { display: grid; gap: 12px; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); }
+.meta { padding: 14px 16px; border-radius: 16px; background: rgba(255,255,255,0.04); border: 1px solid var(--border); }
+.meta .label { font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.08em; }
+.meta .value { margin-top: 8px; font-weight: 600; font-size: 15px; color: var(--text); }
+code, pre { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+pre { white-space: pre-wrap; background: rgba(0,0,0,0.24); padding: 16px; border-radius: 16px; border: 1px solid var(--border); }
+@media (max-width: 980px) { .layout { grid-template-columns: 1fr; } nav { position: static; } .grid.cols-2 { grid-template-columns: 1fr; } }
+</style>
+</head>
+<body>
+<main>
+  <section class="hero">
+    <div class="eyebrow">${escapeHtml(eyebrow)}</div>
+    <h1>${escapeHtml(title)}</h1>
+    <p>${escapeHtml(summary || 'Shareable HTML artifact generated by Heart of Gold Visualize.')}</p>
+    ${badge ? `<div class="badge">${escapeHtml(badge)}</div>` : ''}
+  </section>
+  <div class="layout">
+    <nav>
+      <h2>Contents</h2>
+      ${toc}
+    </nav>
+    <section>${content}</section>
+  </div>
+</main>
+</body>
+</html>`;
+}
+
+function renderOutline(doc, title, eyebrow, badge) {
+  const toc = doc.sections.map((s, i) => `<a href="#section-${i}">${escapeHtml(s.title)}</a>`).join('');
+  const content = doc.sections.map((section, i) => {
+    const body = textFromLines(section.lines);
+    const paragraphs = body.split(/\n\s*\n/).map((b) => b.trim()).filter(Boolean).map((b) => {
+      if (b.includes('\n- ') || b.match(/^-/m)) {
+        const items = b.split(/\n/).map((line) => line.match(/^\s*[-*]\s+(.+)$/)?.[1]).filter(Boolean);
+        if (items.length) return `<ul>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join('')}</ul>`;
+      }
+      return `<p>${escapeHtml(b)}</p>`;
+    }).join('');
+    return `<article id="section-${i}" class="section"><h2>${escapeHtml(section.title)}</h2>${paragraphs || '<p>No details captured.</p>'}</article>`;
+  }).join('');
+  return renderShell({ title, eyebrow, summary: firstParagraph(doc.sections[0]?.lines || []), toc, content, badge });
+}
+
+function renderRoadmap(doc, title, badge) {
+  const toc = ['Summary', ...doc.sections.map((s) => s.title)].map((s, i) => `<a href="#section-${i}">${escapeHtml(s)}</a>`).join('');
+  const tasksSection = doc.sections.find((s) => /implementation tasks/i.test(s.title));
+  const tasks = tasksSection ? collectChecklists(tasksSection.lines) : [];
+  const meta = [
+    ['Status', doc.frontmatter.status || 'unknown'],
+    ['Confidence', doc.frontmatter.confidence || 'n/a'],
+    ['Date', doc.frontmatter.date || 'n/a'],
+    ['Type', doc.frontmatter.type || 'plan'],
+  ];
+  let content = `<article id="section-0" class="section"><h2>Summary</h2><div class="meta-grid">${meta.map(([l,v]) => `<div class="meta"><div class="label">${escapeHtml(l)}</div><div class="value">${escapeHtml(v)}</div></div>`).join('')}</div></article>`;
+  if (tasks.length) {
+    content += `<article id="section-1" class="section"><h2>Implementation Tasks</h2><div class="checklist">${tasks.map((t) => `<div class="item ${t.done ? 'done' : 'todo'}"><div class="status">${t.done ? 'Done' : 'Planned'}</div><div>${escapeHtml(t.text)}</div></div>`).join('')}</div></article>`;
+  }
+  const remaining = doc.sections.filter((s) => !/implementation tasks/i.test(s.title));
+  content += remaining.map((section, idx) => {
+    const body = firstParagraph(section.lines);
+    return `<article id="section-${idx + 2}" class="section"><div class="kicker">Plan Section</div><h2>${escapeHtml(section.title)}</h2><p>${escapeHtml(body || 'See source markdown for full details.')}</p></article>`;
+  }).join('');
+  return renderShell({ title, eyebrow: 'Plan Dashboard', summary: firstParagraph(doc.sections[0]?.lines || []), toc, content, badge });
+}
+
+function renderArchitecture(doc, title, badge) {
+  const toc = doc.sections.map((s, i) => `<a href="#section-${i}">${escapeHtml(s.title)}</a>`).join('');
+  const cards = doc.sections.slice(0, 4).map((section) => `<div class="card"><div class="kicker">${escapeHtml(section.title)}</div><p>${escapeHtml(firstParagraph(section.lines) || 'See source markdown for detail.')}</p></div>`).join('');
+  const content = `<article class="section"><h2>Architecture Overview</h2><div class="grid cols-2">${cards}</div></article>` + doc.sections.map((section, i) => `<article id="section-${i}" class="section"><h2>${escapeHtml(section.title)}</h2><p>${escapeHtml(firstParagraph(section.lines) || 'See source markdown for detail.')}</p></article>`).join('');
+  return renderShell({ title, eyebrow: 'Architecture View', summary: firstParagraph(doc.sections[0]?.lines || []), toc, content, badge });
+}
+
+function renderMindmap(filePath, outFile) {
+  const script = join(dirname(new URL(import.meta.url).pathname), 'render-mindmap', 'index.js');
+  execFileSync('node', [script, '--html', outFile, filePath], { stdio: 'ignore' });
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (!opts.file || !opts.out) {
+    console.error('Usage: smart-render.js <file.md> --out <file.html> [--mode auto|mindmap|outline|roadmap|architecture|mockup|explainer]');
+    process.exit(1);
+  }
+  const markdown = readFileSync(opts.file, 'utf8');
+  const doc = parseDocument(markdown);
+  const mode = classifyMode(opts.file, doc, opts.mode);
+  const title = doc.frontmatter.title || doc.sections[0]?.title || basename(opts.file);
+  const badge = opts.mode && opts.mode !== 'auto'
+    ? `Mode: ${mode}`
+    : 'Mode: outline (safe default — agent may override)';
+
+  if (mode === 'mindmap') {
+    renderMindmap(opts.file, opts.out);
+    return;
+  }
+
+  const html = mode === 'roadmap'
+    ? renderRoadmap(doc, title, badge)
+    : mode === 'architecture'
+      ? renderArchitecture(doc, title, badge)
+      : renderOutline(doc, title, 'Structured View', badge);
+  writeFileSync(opts.out, html, 'utf8');
+}
+
+main();

package/plugins/deep-thought/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "deep-thought",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "The Answer Computer — reasoning tools for brainstorming, planning, architecture design, and deep thinking",
   "author": {
     "name": "ondrej-svec",

package/plugins/deep-thought/skills/architect/SKILL.md

@@ -176,12 +176,12 @@ Use **AskUserQuestion** with:
 - header: "Next step"
 - options:
   1. label: "Start implementation (Recommended)", description: "Proceed to scaffold or test writing"
-  2. label: "Visualize / Share", description: "Prefer a shareable HTML view when sharing is configured; otherwise render structure in the terminal"
+  2. label: "Visualize / Share", description: "Generate a shareable HTML view first when sharing is configured; otherwise render structure in the terminal"
   3. label: "Review and refine", description: "Adjust stories or architecture based on feedback"
   4. label: "Done for now", description: "Return later"
 - multiSelect: false
 
-**If user selects "Visualize / Share":** Run `/babel-fish:visualize {stories_path}/{slug}.architecture.md` and prefer the shareable HTML flow when browser viewing or sharing is useful and `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
+**If user selects "Visualize / Share":** Run `/babel-fish:visualize {stories_path}/{slug}.architecture.md` and try the shareable HTML flow first when `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
 
 **If pipeline mode (`$BRAINSTORM_PATH` set):**
 Complete without asking. Output paths for downstream consumers:

package/plugins/deep-thought/skills/brainstorm/SKILL.md

@@ -291,13 +291,13 @@ Ask the user what to do next.
 - Prefer the harness's structured choice UI if available
 - Otherwise present this short plain-text choice list:
   1. **Proceed to /plan** — Turn these decisions into an implementation plan
-  2. **Visualize / Share** — Prefer a shareable HTML mind map when sharing is configured; otherwise render in the terminal
+  2. **Visualize / Share** — Generate a shareable HTML mind map first when sharing is configured; otherwise render in the terminal
   3. **Keep exploring** — More questions or refine decisions before moving on
   4. **Done for now** — Return later; to plan: `/plan {brainstorm-path}`
 
 **If user selects "Proceed to /plan":** Suggest running `/plan {brainstorm-path}`.
 
-**If user selects "Visualize / Share":** Run `/babel-fish:visualize {brainstorm-path}` and prefer the shareable HTML flow when browser viewing or sharing is useful and `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
+**If user selects "Visualize / Share":** Run `/babel-fish:visualize {brainstorm-path}` and try the shareable HTML flow first when `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
 
 **If user selects "Keep exploring":** Return to Phase 3 and continue asking questions one at a time. When satisfied, update the document and return to this handoff.
 

package/plugins/deep-thought/skills/plan/SKILL.md

@@ -283,13 +283,13 @@ Ask the user what to do next.
 - Prefer the harness's structured choice UI if available
 - Otherwise present this short plain-text choice list:
   1. **Start /work (Recommended)** — Begin implementing this plan
-  2. **Visualize / Share** — Prefer a shareable HTML mind map when sharing is configured; otherwise render in the terminal
+  2. **Visualize / Share** — Generate a shareable HTML mind map first when sharing is configured; otherwise render in the terminal
   3. **Review and refine** — Adjust the plan based on feedback
   4. **Done for now** — Return later; to start: `/work {plan-path}`
 
 **If user selects "Start /work":** Suggest running `/work {plan-path}`.
 
-**If user selects "Visualize / Share":** Run `/babel-fish:visualize {plan-path}` and prefer the shareable HTML flow when browser viewing or sharing is useful and `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
+**If user selects "Visualize / Share":** Run `/babel-fish:visualize {plan-path}` and try the shareable HTML flow first when `share-html` is configured. Otherwise render the terminal mind map. After rendering or sharing, return to this handoff with the remaining options.
 
 **If user selects "Review and refine":** Accept feedback, update the plan, then present these options again.
 

package/plugins/guide/scripts/fetch-gmail.sh

@@ -82,15 +82,11 @@ print(fetch_body)
 PY
 }
 
-GMAIL_SETTINGS_RAW=$(read_gmail_settings "$CONFIG_PATH" 2>/dev/null) || GMAIL_SETTINGS_RAW=""
-if [[ -n "$GMAIL_SETTINGS_RAW" ]]; then
-  GMAIL_LABEL=$(echo "$GMAIL_SETTINGS_RAW" | sed -n '1p')
-  MAX_ITEMS=$(echo "$GMAIL_SETTINGS_RAW" | sed -n '2p')
-  GMAIL_LABEL_ID=$(echo "$GMAIL_SETTINGS_RAW" | sed -n '3p')
-  FETCH_BODY=$(echo "$GMAIL_SETTINGS_RAW" | sed -n '4p')
-  GMAIL_LABEL="${GMAIL_LABEL:-Content-Feed}"
-  MAX_ITEMS="${MAX_ITEMS:-20}"
-  FETCH_BODY="${FETCH_BODY:-false}"
+if mapfile -t GMAIL_SETTINGS < <(read_gmail_settings "$CONFIG_PATH" 2>/dev/null); then
+  GMAIL_LABEL="${GMAIL_SETTINGS[0]:-Content-Feed}"
+  MAX_ITEMS="${GMAIL_SETTINGS[1]:-20}"
+  GMAIL_LABEL_ID="${GMAIL_SETTINGS[2]:-}"
+  FETCH_BODY="${GMAIL_SETTINGS[3]:-false}"
 else
   GMAIL_LABEL="Content-Feed"
   MAX_ITEMS="20"
@@ -98,61 +94,14 @@ else
   FETCH_BODY="false"
 fi
 
-# Collect seen Gmail message IDs from previous days to avoid duplicates
-PIPELINE_DIR=$(python3 -c "
-import yaml, sys
-with open(sys.argv[1]) as f:
-    c = yaml.safe_load(f)
-print(c.get('output', {}).get('pipeline_dir', 'content/pipeline'))
-" "$CONFIG_PATH" 2>/dev/null || echo "content/pipeline")
-
-SEEN_IDS=$(python3 -c "
-import json, glob, os, sys
-
-pipeline_dir = sys.argv[1]
-config_path = sys.argv[2]
-
-# Resolve relative pipeline_dir against project root (config's grandparent,
-# since config lives in content/ which is one level below project root)
-if not os.path.isabs(pipeline_dir):
-    config_dir = os.path.dirname(os.path.abspath(config_path))
-    # Walk up until we find .git or use config's parent's parent as fallback
-    project_root = config_dir
-    while project_root != '/':
-        if os.path.isdir(os.path.join(project_root, '.git')):
-            break
-        project_root = os.path.dirname(project_root)
-    pipeline_dir = os.path.join(project_root, pipeline_dir)
-
-seen = set()
-# Check last 7 days of signals files
-for path in sorted(glob.glob(os.path.join(pipeline_dir, '*/signals.json')))[-7:]:
-    try:
-        signals = json.load(open(path))
-        for s in signals:
-            if s.get('source') == 'gmail':
-                mid = s.get('metadata', {}).get('message_id', '')
-                if mid:
-                    seen.add(mid)
-    except (json.JSONDecodeError, KeyError):
-        pass
-# Output as comma-separated IDs
-print(','.join(seen))
-" "$PIPELINE_DIR" "$CONFIG_PATH" 2>/dev/null || echo "")
-
-if [[ -n "$SEEN_IDS" ]]; then
-  SEEN_COUNT=$(echo "$SEEN_IDS" | tr ',' '\n' | wc -l | tr -d ' ')
-  echo "  · $SEEN_COUNT previously seen Gmail message IDs loaded" >&2
-fi
-
 # Fetch emails using gws +triage helper (more reliable than raw API calls —
 # the helper handles auth scopes internally, avoiding insufficientPermissions errors)
 # Fetch recent emails with labels, then filter by label ID in Python
 GWS_ERR=$(mktemp)
 trap "rm -f $GWS_ERR" EXIT
 EMAILS_JSON=$(gws gmail +triage \
-  --query "newer_than:7d" \
-  --max 200 \
+  --query "newer_than:3d" \
+  --max 50 \
   --format json \
   --labels \
   2>"$GWS_ERR") || {
@@ -173,21 +122,17 @@ EMAILS_JSON=$(gws gmail +triage \
 # Determine the scripts directory (where this script lives)
 SCRIPTS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-export _GMAIL_LABEL_ID="$GMAIL_LABEL_ID"
-export _GMAIL_MAX_ITEMS="$MAX_ITEMS"
-export _GMAIL_CONFIG_PATH="$CONFIG_PATH"
-export _GMAIL_SEEN_IDS="$SEEN_IDS"
-
 if [[ "$FETCH_BODY" == "true" ]]; then
   # Deep mode: filter messages first, then pass to fetch-gmail-deep.py for
   # full body fetching, link extraction, and article following
-  echo "$EMAILS_JSON" | python3 -c "
-import json, sys, yaml, os
+  echo "$EMAILS_JSON" | python3 - "$GMAIL_LABEL_ID" "$MAX_ITEMS" "$CONFIG_PATH" <<'PY' 2>/dev/null | python3 "$SCRIPTS_DIR/fetch-gmail-deep.py" || {
+import json
+import sys
+import yaml
 
-label_id = os.environ['_GMAIL_LABEL_ID']
-max_items = int(os.environ['_GMAIL_MAX_ITEMS'])
-config_path = os.environ['_GMAIL_CONFIG_PATH']
-seen_ids = set(os.environ.get('_GMAIL_SEEN_IDS', '').split(',')) - {''}
+label_id = sys.argv[1]
+max_items = int(sys.argv[2])
+config_path = sys.argv[3]
 
 data = json.load(sys.stdin)
 messages = data.get('messages', []) if isinstance(data, dict) else data
@@ -195,12 +140,6 @@ messages = data.get('messages', []) if isinstance(data, dict) else data
 if label_id:
     messages = [m for m in messages if label_id in m.get('labels', [])]
 
-before = len(messages)
-messages = [m for m in messages if m.get('id', '') not in seen_ids]
-skipped = before - len(messages)
-if skipped:
-    print(f'  Dedup: skipped {skipped} already-seen messages', file=sys.stderr)
-
 messages = messages[:max_items]
 
 with open(config_path) as f:
@@ -208,19 +147,19 @@ with open(config_path) as f:
 gmail_config = config.get('sources', {}).get('gmail', {}) or {}
 
 json.dump({'messages': messages, 'config': gmail_config}, sys.stdout)
-" | python3 "$SCRIPTS_DIR/fetch-gmail-deep.py" || {
+PY
     echo "Error: Deep Gmail processing failed" >&2
     exit 1
   }
 else
   # Shallow mode: subject-only signals (original behavior)
-  echo "$EMAILS_JSON" | python3 -c "
-import json, sys, os
+  echo "$EMAILS_JSON" | python3 - "$GMAIL_LABEL_ID" "$MAX_ITEMS" <<'PY' 2>/dev/null || {
+import json
+import sys
 from datetime import datetime, timezone
 
-label_id = os.environ.get('_GMAIL_LABEL_ID', '')
-max_items = int(os.environ.get('_GMAIL_MAX_ITEMS', '20'))
-seen_ids = set(os.environ.get('_GMAIL_SEEN_IDS', '').split(',')) - {''}
+label_id = sys.argv[1]
+max_items = int(sys.argv[2])
 
 data = json.load(sys.stdin)
 messages = data.get('messages', []) if isinstance(data, dict) else data
@@ -228,12 +167,6 @@ messages = data.get('messages', []) if isinstance(data, dict) else data
 if label_id:
     messages = [m for m in messages if label_id in m.get('labels', [])]
 
-before = len(messages)
-messages = [m for m in messages if m.get('id', '') not in seen_ids]
-skipped = before - len(messages)
-if skipped:
-    print(f'  Dedup: skipped {skipped} already-seen messages', file=sys.stderr)
-
 messages = messages[:max_items]
 
 signals = []
@@ -270,7 +203,7 @@ for email in messages:
     })
 
 json.dump(signals, sys.stdout, indent=2)
-" 2>/dev/null || {
+PY
     echo "Error: Failed to parse gws output" >&2
     exit 1
   }

package/plugins/marvin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "marvin",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "The Paranoid Android — quality tools for code review, knowledge compounding, and work execution",
   "author": {
     "name": "ondrej-svec",