e3d-pilot 0.1.0 → 0.1.1

package/README.md

@@ -2,11 +2,11 @@
 
 **Multi-model AI problem solving: independent answers → critique → convergence → human decision → execution → review → provenance.**
 
-![e3d-debate: independent AI models answer a question, critique each other across rounds, converge on a synthesis with consensus and named dissent, then hand off to a human decision, execution, and provenance](docs/images/debate-convergence.svg)
+![e3d-debate: independent AI models answer a question, critique each other across rounds, converge on a synthesis with consensus and named dissent, then hand off to a human decision, execution, and provenance](https://raw.githubusercontent.com/spacepacket1/e3d-pilot/main/docs/images/debate-convergence.svg)
 
 e3d-pilot is an open-source system for getting multiple AI models to work on the same problem instead of trusting a single model's answer — from a one-off question to a fully executed, human-gated software change.
 
-It starts simply. Ask several configured models (Claude, Codex, Grok, Devin, or others you wire in) the same question. Let them answer independently, see and critique each other's positions, revise, expose real dissent, and converge on the strongest answer. That's `bin/e3d-debate` — a standalone tool, no repo or pipeline required.
+It starts simply. Ask several configured models (Claude, Codex, Grok, Devin, or others you wire in) the same question. Let them answer independently, see and critique each other's positions, revise, expose real dissent, and converge on the strongest answer. That's `bin/e3d-debate` — a standalone tool, no repo or pipeline required. It's also available inside your editor as an MCP server: [use it from GitHub Copilot, Claude Code, or Cursor](#use-e3d-pilot-from-github-copilot-claude-code-and-cursor-mcp) with one `npx` line.
 
 Then e3d-pilot takes the same instinct further, into real software work: `discover → ideate → approve → draft → negotiate → execute → review → publish → outcome`. Every step is preserved in an append-only ledger, so the system (or a human, or a fresh AI session) can later reconstruct where an idea came from, which models or people influenced it, what it produced, and what happened afterward.
 
@@ -70,13 +70,34 @@ demand instead — a real, named disagreement the tool didn't paper over.
 
 You don't need the rest of e3d-pilot to use `e3d-debate` on its own — see [e3d-debate](#e3d-debate-experimental) below for the full flag reference. Keep reading for the part that takes a debate's answer all the way to a shipped, reviewed, provenance-tracked change.
 
-## Use e3d-debate from GitHub Copilot (MCP)
+## Use e3d-pilot from GitHub Copilot, Claude Code, and Cursor (MCP)
 
-`bin/e3d-mcp` is a zero-dependency [Model Context Protocol](https://modelcontextprotocol.io) server, so Copilot agent mode in VS Code (and any other MCP client: Claude Code, Cursor, ...) can ask for a multi-model second opinion mid-task.
+`e3d-mcp` is a zero-dependency [Model Context Protocol](https://modelcontextprotocol.io) server. It lets an AI coding assistant ask for a multi-model second opinion mid-task, instead of committing to the first answer one model gives it. It's published on npm as [`e3d-pilot`](https://www.npmjs.com/package/e3d-pilot) and listed in the official MCP registry as `io.github.spacepacket1/e3d-pilot`.
 
-Tools: `e3d_debate` (answer + consensus + named dissent + transcript), `e3d_list_providers`, and read-only `e3d_provenance_trace` / `e3d_ideas_list` ("why does this change exist?").
+| Tool | What it does |
+| --- | --- |
+| `e3d_debate` | Several independent models answer and a synthesizer returns a decisive answer, a consensus level (`full` / `majority` / `split`), any named dissent, and each model's final position, as both readable text and structured data (`dissent.present`, `dissent.summary`, `positions`). `mode: "quick"` (default) is one round and takes seconds; `mode: "thorough"` adds a critique round where models rebut each other. The full transcript is opt-in (`include_transcript`). |
+| `e3d_list_providers` | Shows which model providers are available on this machine. A debate needs at least two. |
+| `e3d_provenance_trace` | Read-only: traces why a change exists, from its origin through debates, approvals, execution, review, and outcome. |
+| `e3d_ideas_list` | Read-only: lists the ideas e3d-pilot tracks in a repo, to find an id for the trace. |
+
+A real result in `quick` mode (11 seconds, two models), from asking whether a small CLI should default to a flat JSON file or SQLite:
+
+```text
+FINAL ANSWER: Default to a flat JSON file for a small CLI. It has no dependencies, is
+human-readable and diffable, and is easy to hand-edit and debug. Write it atomically
+(temp file, then rename). Move to SQLite once you need indexed queries, concurrent
+writers, or data beyond a few MB.
+CONSENSUS: split
+DISSENT: Codex prefers SQLite as the default for any persistent mutable state because
+it gives transactions, concurrency safety, and schema evolution at low cost.
+```
+
+The disagreement is the point: you get the answer and the strongest case against it, instead of one model's confident guess.
+
+### Install
 
-**Install (VS Code / Copilot agent mode):** [one-click install](https://insiders.vscode.dev/redirect/mcp/install?name=e3d-pilot&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22-p%22%2C%22e3d-pilot%22%2C%22e3d-mcp%22%5D%7D), or add this to `.vscode/mcp.json`:
+**VS Code (GitHub Copilot agent mode):** [one-click install](https://insiders.vscode.dev/redirect/mcp/install?name=e3d-pilot&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22-p%22%2C%22e3d-pilot%22%2C%22e3d-mcp%22%5D%7D), or add this to `.vscode/mcp.json`:
 
 ```json
 {
@@ -86,14 +107,37 @@ Tools: `e3d_debate` (answer + consensus + named dissent + transcript), `e3d_list
 }
 ```
 
-Prerequisites: Node 18+, `jq`, bash 4+ (macOS: `brew install bash jq`), and at least two model CLIs logged in (e.g. `claude` and `codex`). Check them all with `npx -y -p e3d-pilot e3d-mcp --doctor`. From a clone, `bin/e3d-mcp --print-config --local` prints a config pointing at your checkout.
+**Claude Code:**
+
+```bash
+claude mcp add e3d-pilot -- npx -y -p e3d-pilot e3d-mcp
+```
+
+**Cursor** (`~/.cursor/mcp.json`) and other clients that use the `mcpServers` shape:
+
+```json
+{ "mcpServers": { "e3d-pilot": { "command": "npx", "args": ["-y", "-p", "e3d-pilot", "e3d-mcp"] } } }
+```
+
+Any MCP client that can launch a stdio server should work; the shapes above are each client's standard format.
+
+**Prerequisites:** Node 18+, `jq`, bash 4+ (macOS ships 3.2: `brew install bash jq`), and at least two model CLIs logged in (e.g. `claude` and `codex`). Check them all at once:
+
+```bash
+npx -y -p e3d-pilot e3d-mcp --doctor
+```
+
+`--doctor` reports what's missing and how to fix it. It does not need the full pipeline's `e3d-code` executor (it only notes whether that is installed). From a clone, `bin/e3d-mcp --print-config --local` prints a config that points at your checkout.
 
-Then, in Copilot agent mode: *"Before you pick a storage layer, run e3d_debate on SQLite vs flat JSON for this CLI."* To make Copilot do that unprompted for contestable design choices, copy [examples/copilot-instructions.md](examples/copilot-instructions.md) into `.github/copilot-instructions.md` or `AGENTS.md`.
+### Using it
 
-Notes:
-- Debates are slow (minutes) and spend **your** model credits. The server caps rounds/providers/concurrency: `E3D_MCP_MAX_ROUNDS` (3), `E3D_MCP_MAX_PROVIDERS` (4), `E3D_MCP_MAX_CONCURRENT` (2), `E3D_MCP_TIMEOUT_SEC` (900).
-- It uses whatever provider CLIs/keys are in the server's environment (`claude`, `codex`, ... see `e3d-pilot providers list`). Needs at least two available.
-- The Copilot *coding agent* runs on GitHub-hosted runners, where those provider CLIs are not installed; use the local (stdio) setup above for now.
+In Copilot agent mode (or any client), ask: *"Before you pick a storage layer, run e3d_debate on SQLite vs flat JSON for this CLI."* To make the assistant do this unprompted for contestable design choices, copy [examples/copilot-instructions.md](examples/copilot-instructions.md) into `.github/copilot-instructions.md` or `AGENTS.md`. Don't use it for lookups or questions with an obvious answer; it is slow and costs money.
+
+### Cost and limits
+
+- `quick` debates take seconds to a minute and `thorough` ones a few minutes; both spend **your** model credits. The server caps `e3d_debate` with `E3D_MCP_MAX_ROUNDS` (3), `E3D_MCP_MAX_PROVIDERS` (4), `E3D_MCP_MAX_CONCURRENT` (2), and `E3D_MCP_TIMEOUT_SEC` (900).
+- It uses whatever provider CLIs and keys are in the server's environment (see `e3d-pilot providers list`).
+- The Copilot *coding agent* runs on GitHub-hosted runners, where those provider CLIs aren't installed. Use the local (stdio) setup above for now.
 - The server never writes to a repo. Recording a verdict into provenance is still `e3d-debate --repo --idea`.
 
 ## Why we built this
@@ -209,11 +253,18 @@ Start from [`examples/sample-fleet-config-with-ops.json`](examples/sample-fleet-
 Install Bash, Git, `jq`, and `curl`; the full pipeline's execute stage also needs [`e3d-code`](https://github.com/spacepacket1/e3d-code) (formerly `spec2code`; the debate and MCP tools do not). Install and authenticate whichever model CLIs and forge CLI your configuration uses (`claude`, `codex`, `devin`, a local OpenAI-compatible endpoint, and/or `grok` for `grok-build`). Add this repository's `bin` directory to `PATH`:
 
 ```bash
+# From npm (also installs e3d-code, the execute-stage dependency, when it can):
+npm install -g e3d-pilot
+e3d-pilot --help
+
+# Or from a clone:
 git clone https://github.com/spacepacket1/e3d-pilot.git
 export PATH="$PWD/e3d-pilot/bin:$PATH"
 e3d-pilot --help
 ```
 
+The npm package provides three commands: `e3d-pilot`, `e3d-debate`, and `e3d-mcp`.
+
 Node.js is only needed for the optional `e3d-pilot web` dashboard (see [Web UI](#web-ui-optional) below) — every other command needs only Bash, Git, `jq`, and `curl`.
 
 ## Configure a repository
@@ -578,6 +629,8 @@ Both `E3D_PILOT_WEB_AUTH_USER` and `E3D_PILOT_WEB_AUTH_PASS` are required; there
 
 ## e3d-debate (experimental)
 
+> Want this inside your editor? `e3d-debate` is also exposed as an [MCP tool](#use-e3d-pilot-from-github-copilot-claude-code-and-cursor-mcp) for Copilot, Claude Code, and Cursor.
+
 `bin/e3d-debate` is a separate, standalone script — not wired into `bin/e3d-pilot`'s subcommand tree or `config.schema.json`, the same way `bin/e3d-backend-benchmark` and `bin/e3d-grok-workers` already aren't — for the "ask several models a question and see whether they actually agree" loop, applied to any question rather than repo work specifically. It reuses the same `lib/providers/<name>` adapters and the `lib/negotiate/convergence` primitive that discover/ideate/negotiate/review already depend on. "Experimental" here means still standalone, not wired into the pipeline proper — not unused or untested: `tests/phase34.sh` covers the provenance-linking flags below, and it has already been the deciding mechanism behind several real architecture and product-direction calls for this project, not just a demo.
 
 ```bash

package/bin/e3d-mcp

@@ -22,7 +22,7 @@ import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const SERVER_INFO = { name: 'e3d-pilot', version: '0.1.0' };
+const SERVER_INFO = { name: 'e3d-pilot', version: '0.1.1' };
 const SUPPORTED_PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05'];
 
 const envInt = (name, dflt) => {
@@ -63,26 +63,79 @@ async function configuredProviders() {
 
 const NAME_RE = /^[a-z0-9][a-z0-9_-]*$/;
 
+// quick = one round of independent answers + one synthesis call (fast, no cross-critique);
+// thorough = the debate as originally shipped (2 rounds, models see and rebut each other).
+const MODES = { quick: { rounds: 1, maxWords: 80 }, thorough: { rounds: 2, maxWords: 200 } };
+
+// e3d-debate prints "FINAL ANSWER: ...\nCONSENSUS: ...\nDISSENT: ..." -- turn that into fields.
+function parseVerdict(out) {
+  const raw = out.match(/FINAL ANSWER:[\s\S]*$/)?.[0]?.trim();
+  if (!raw) return null;
+  const m = raw.match(/^FINAL ANSWER:\s*([\s\S]*?)\s*\n\s*CONSENSUS:\s*([^\n]*)\n\s*DISSENT:\s*([\s\S]*)$/);
+  if (!m) return { final_answer: raw.replace(/^FINAL ANSWER:\s*/, ''), consensus: 'unknown', dissent: { present: null, summary: 'Verdict could not be parsed; read the answer text in full.' } };
+  const consensus = ['full', 'majority', 'split'].find((c) => m[2].toLowerCase().includes(c)) ?? 'unknown';
+  const dissentText = m[3].trim();
+  const none = /^["'`]*none[."'`]*$/i.test(dissentText);
+  return { final_answer: m[1].trim(), consensus, dissent: { present: !none, summary: none ? 'none' : dissentText } };
+}
+
+// Each model's answer in the last round, from transcript.md ("## Round N -- provider").
+function parsePositions(transcript) {
+  const sections = transcript.split(/\n(?=## )/).map((c) => c.match(/^## Round (\d+) -- (\S+)\n\n([\s\S]*)$/)).filter(Boolean)
+    .map((m) => ({ round: Number(m[1]), provider: m[2], body: m[3].trim() }));
+  const last = Math.max(0, ...sections.map((x) => x.round));
+  return {
+    roundsRan: last,
+    positions: sections.filter((x) => x.round === last).map((x) => ({
+      provider: x.provider,
+      text: x.body.replace(/\n*status: (approved|revise)\s*$/i, '').replace(/\n*POSITION:[^\n]*$/, '').trim(),
+    })),
+  };
+}
+
+function renderDebate(d) {
+  const label = d.consensus === 'full' ? 'FULL CONSENSUS' : d.consensus === 'majority' ? 'MAJORITY (some dissent)' : d.consensus === 'split' ? 'SPLIT' : 'CONSENSUS UNKNOWN';
+  const lines = [
+    `# Debate verdict: ${label}`,
+    `_${d.providers.join(', ')} | ${d.mode} mode | ${d.rounds_ran} round${d.rounds_ran === 1 ? '' : 's'}_`,
+    '', `**Answer:** ${d.final_answer}`, '',
+  ];
+  if (d.dissent.present === false) lines.push('**Dissent:** none', '');
+  else lines.push(`**Dissent (report this to the user, do not drop it when summarizing):** ${d.dissent.summary}`, '');
+  if (d.positions.length) {
+    lines.push('**Each model\'s final position:**');
+    for (const p of d.positions) lines.push('', `**${p.provider}:**`, ...p.text.split('\n').map((l) => `> ${l}`));
+  }
+  if (d.transcript) lines.push('', '<details><summary>Full transcript</summary>', '', d.transcript, '', '</details>');
+  return lines.join('\n');
+}
+
 async function toolDebate(args, progress) {
   const question = typeof args.question === 'string' ? args.question.trim() : '';
   if (!question) return text('error: `question` is required', true);
   if (question.length > LIMITS.questionChars) return text(`error: question exceeds ${LIMITS.questionChars} characters`, true);
 
-  const rounds = args.rounds ?? 2;
+  const mode = args.mode ?? 'quick';
+  if (!MODES[mode]) return text('error: mode must be "quick" or "thorough"', true);
+  const rounds = args.rounds ?? MODES[mode].rounds;
   if (!Number.isInteger(rounds) || rounds < 1 || rounds > LIMITS.rounds) return text(`error: rounds must be an integer 1..${LIMITS.rounds}`, true);
-  const maxWords = args.max_words ?? 200;
+  const maxWords = args.max_words ?? MODES[mode].maxWords;
   if (!Number.isInteger(maxWords) || maxWords < 20 || maxWords > LIMITS.maxWords) return text(`error: max_words must be an integer 20..${LIMITS.maxWords}`, true);
+  if (args.include_transcript !== undefined && typeof args.include_transcript !== 'boolean') return text('error: include_transcript must be a boolean', true);
 
-  const known = await configuredProviders();
+  // E3D_MCP_DEBATE_BIN swaps in another debate executable (used by tests); provider checks are then that binary's job.
+  const debateBin = process.env.E3D_MCP_DEBATE_BIN || join(ROOT, 'bin/e3d-debate');
+  const stubbed = Boolean(process.env.E3D_MCP_DEBATE_BIN);
+  const known = stubbed ? [] : await configuredProviders();
   let providers = args.providers;
   if (providers === undefined) {
-    providers = known.filter((p) => p.available && ['claude', 'codex'].includes(p.name)).map((p) => p.name);
+    providers = stubbed ? ['claude', 'codex'] : known.filter((p) => p.available && ['claude', 'codex'].includes(p.name)).map((p) => p.name);
   }
   if (!Array.isArray(providers) || providers.some((p) => typeof p !== 'string' || !NAME_RE.test(p))) return text('error: providers must be an array of provider names', true);
   providers = [...new Set(providers)];
   if (providers.length < 2) return text('error: need at least 2 available providers to debate (call e3d_list_providers); only found: ' + (providers.join(', ') || 'none'), true);
   if (providers.length > LIMITS.providers) return text(`error: at most ${LIMITS.providers} providers per debate`, true);
-  const unavailable = providers.filter((p) => !known.find((k) => k.name === p && k.available));
+  const unavailable = stubbed ? [] : providers.filter((p) => !known.find((k) => k.name === p && k.available));
   if (unavailable.length) return text(`error: provider(s) not available on this machine: ${unavailable.join(', ')}`, true);
 
   if (activeDebates >= LIMITS.concurrent) return text(`error: ${LIMITS.concurrent} debates already running; retry shortly`, true);
@@ -94,21 +147,23 @@ async function toolDebate(args, progress) {
     const cliArgs = ['--question-file', qfile, '--providers', providers.join(','), '--rounds', String(rounds),
       '--max-words', String(maxWords), '--out-dir', join(dir, 'out')];
     let step = 0;
-    const r = await run(join(ROOT, 'bin/e3d-debate'), cliArgs, {
+    const r = await run(debateBin, cliArgs, {
       timeoutMs: LIMITS.timeoutMs,
       onStderr: (s) => { for (const m of s.matchAll(/^=== (.+?) ===$/gm)) progress?.(++step, m[1]); },
     });
     if (r.timedOut) return text(`error: debate timed out after ${LIMITS.timeoutMs / 1000}s`, true);
-    const verdict = r.out.match(/FINAL ANSWER:[\s\S]*$/)?.[0]?.trim();
+    const verdict = parseVerdict(r.out);
     if (r.code !== 0 || !verdict) return text(`error: debate failed (exit ${r.code})\n${r.err.slice(-1500)}`, true);
 
-    const transcript = { out: await readFile(join(dir, 'out', 'transcript.md'), 'utf8') };
-    const body = [
-      `# Debate verdict (${providers.join(', ')}; up to ${rounds} rounds)`,
-      '', verdict, '',
-      '<details><summary>Full transcript</summary>', '', transcript.out.trim(), '', '</details>',
-    ].join('\n');
-    return text(body);
+    const transcript = await readFile(join(dir, 'out', 'transcript.md'), 'utf8').catch(() => '');
+    const { roundsRan, positions } = parsePositions(transcript);
+    const result = {
+      ...verdict,
+      mode, providers, rounds_requested: rounds, rounds_ran: roundsRan || rounds,
+      positions,
+      ...(args.include_transcript ? { transcript: transcript.trim() } : {}),
+    };
+    return { content: [{ type: 'text', text: renderDebate(result) }], structuredContent: result };
   } finally {
     activeDebates--;
     rm(dir, { recursive: true, force: true }).catch(() => {});
@@ -157,18 +212,39 @@ async function toolIdeasList(args) {
 const TOOLS = [
   {
     name: 'e3d_debate',
-    description: 'Get a multi-model second opinion on a decision or design question. Several independent AI models answer, critique each other across rounds, and converge; returns a decisive final answer, a consensus level (full/majority/split), and any named dissent, plus the full transcript. Use for architectural choices, tradeoffs, and contestable judgment calls -- not for lookups or questions with an obvious answer. Slow (minutes) and spends model credits.',
+    description: 'Get a multi-model second opinion on a decision or design question. Independent AI models answer, and a synthesizer returns a final answer, a consensus level (full/majority/split), and any dissent, plus each model\'s final position. ALWAYS report the dissent and consensus level to the user -- the disagreement is the point; never present a split verdict as settled. Write a self-contained question: the models cannot see your code. mode "quick" (default): one round, usually well under a minute. mode "thorough": models also critique each other, a few minutes. Use for architectural choices, tradeoffs, and contestable judgment calls -- not for lookups or questions with an obvious answer. Spends the user\'s model credits.',
     inputSchema: {
       type: 'object',
       properties: {
         question: { type: 'string', description: 'The decision or question, with enough context for models that cannot see your code.' },
+        mode: { type: 'string', enum: ['quick', 'thorough'], description: 'quick (default): 1 round, short answers, no cross-critique. thorough: 2 rounds where models see and rebut each other.' },
         providers: { type: 'array', items: { type: 'string' }, description: 'Provider names (see e3d_list_providers). Default: claude + codex.' },
-        rounds: { type: 'integer', minimum: 1, maximum: LIMITS.rounds, description: 'Max debate rounds; stops early on convergence. Default 2.' },
-        max_words: { type: 'integer', minimum: 20, maximum: LIMITS.maxWords, description: 'Per-provider per-round answer cap. Default 200.' },
+        rounds: { type: 'integer', minimum: 1, maximum: LIMITS.rounds, description: 'Override the mode\'s round count. Stops early on convergence.' },
+        max_words: { type: 'integer', minimum: 20, maximum: LIMITS.maxWords, description: 'Override the mode\'s per-provider per-round answer cap.' },
+        include_transcript: { type: 'boolean', description: 'Also return the full transcript (large). Default false.' },
       },
       required: ['question'],
       additionalProperties: false,
     },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        final_answer: { type: 'string' },
+        consensus: { type: 'string', enum: ['full', 'majority', 'split', 'unknown'] },
+        dissent: {
+          type: 'object',
+          properties: { present: { type: ['boolean', 'null'] }, summary: { type: 'string', description: '"none" when there is no dissent.' } },
+          required: ['present', 'summary'],
+        },
+        positions: { type: 'array', items: { type: 'object', properties: { provider: { type: 'string' }, text: { type: 'string' } }, required: ['provider', 'text'] } },
+        mode: { type: 'string' },
+        providers: { type: 'array', items: { type: 'string' } },
+        rounds_requested: { type: 'integer' },
+        rounds_ran: { type: 'integer' },
+        transcript: { type: 'string' },
+      },
+      required: ['final_answer', 'consensus', 'dissent', 'positions', 'mode', 'providers', 'rounds_ran'],
+    },
     annotations: { title: 'Multi-model debate', readOnlyHint: true, openWorldHint: true, idempotentHint: false },
   },
   {

package/lib/web/render.js

@@ -71,7 +71,6 @@ export function renderIdeasList(rows, filters, repoAliases) {
     .map(
       (r) => `<tr>
         <td>${escapeHtml(r.repoAlias)}</td>
-        <td><code>${escapeHtml(r.idea_id)}</code></td>
         <td><a href="/ideas/${encodeURIComponent(r.repoAlias)}/${encodeURIComponent(r.idea_id)}">${escapeHtml(r.title)}</a></td>
         <td>${statusBadge(r.status)}</td>
         <td>${escapeHtml(r.scores?.revenue ?? '-')} / ${escapeHtml(r.scores?.attraction ?? '-')} / ${escapeHtml(r.scores?.retention ?? '-')}</td>
@@ -88,8 +87,8 @@ export function renderIdeasList(rows, filters, repoAliases) {
   <button type="submit">Filter</button>
 </form>
 <table>
-  <thead><tr><th>Workspace</th><th>ID</th><th>Title</th><th>Status</th><th>Rev/Attr/Ret</th><th>Effort</th><th>Updated</th></tr></thead>
-  <tbody>${tableRows || '<tr><td colspan="7">No ideas found.</td></tr>'}</tbody>
+  <thead><tr><th>Workspace</th><th>Title</th><th>Status</th><th>Rev/Attr/Ret</th><th>Effort</th><th>Updated</th></tr></thead>
+  <tbody>${tableRows || '<tr><td colspan="6">No ideas found.</td></tr>'}</tbody>
 </table>`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "e3d-pilot",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Multi-model debate and decision provenance for AI coding work. Includes an MCP server (e3d-mcp) for GitHub Copilot, Claude Code, Cursor and other MCP clients.",
   "type": "module",
   "license": "MIT",