create-walle 0.9.12 → 0.9.14

package/README.md

@@ -23,7 +23,7 @@ An always-on AI agent that learns from your Slack, email, calendar, and coding s
 - **Second Brain** — Automatically ingests your digital life into a searchable memory store with full-text search, knowledge extraction, and pattern detection
 - **Proactive Intelligence** — Surfaces time-sensitive items, suggests actions, and delivers morning briefings and weekly reflections without being asked
 - **Chat with Tools** — Talk to Wall-E in the browser — it can search your memories, look up people, run skills, and call external tools via MCP (Slack, Glean, etc.)
-- **19 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model training, model pricing sync, and more
+- **20 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, memory search, model training, model pricing sync, and more
 - **Multi-Model** — Works with Claude, GPT, Gemini, DeepSeek, and local models via Ollama, LM Studio, or MLX with smart routing
 - **Skill Management GUI** — Search, filter, create, edit, and monitor skills from the browser with rich cards, config forms, execution history, export/import, and pre-flight validation
 - **Multi-Device** — Share your brain across machines via Dropbox or iCloud
@@ -49,6 +49,11 @@ npx create-walle uninstall       # Remove the auto-start service
 npx create-walle -v              # Show version
 ```
 
+Install, update, and start verify Node-native modules such as `better-sqlite3`
+against the exact Node.js binary Wall-E will use. If you switch Node versions,
+Wall-E automatically runs the needed `npm rebuild` before starting so CTM does
+not crash with a `NODE_MODULE_VERSION` mismatch.
+
 ## Setup
 
 On first launch, the browser setup page guides you through:

package/bin/create-walle.js

@@ -17,37 +17,50 @@ const { injectMcpConfigs } = require('./mcp-inject');
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
 const LABEL = 'com.walle.server';
 const INSTALL_PATH_FILE = path.join(process.env.HOME, '.walle', 'install-path');
+const MANAGED_PACKAGE_DIRS = ['claude-task-manager', 'wall-e'];
+const NATIVE_DEPENDENCIES = new Set([
+  'better-sqlite3',
+  'node-pty',
+  'sqlite-vec',
+  'tree-sitter-bash',
+]);
 
 // Files to preserve during update (user config, not code)
 const PRESERVE_ON_UPDATE = ['.env', 'wall-e/wall-e-config.json'];
 
 // ── CLI Router ──
 
-const command = process.argv[2] || '';
-
-if (command === 'install') {
-  install(process.argv[3]);
-} else if (command === 'update' || command === 'upgrade') {
-  update();
-} else if (command === 'start') {
-  start();
-} else if (command === 'stop') {
-  stop();
-} else if (command === 'status') {
-  status();
-} else if (command === 'logs') {
-  logs();
-} else if (command === 'uninstall') {
-  uninstall();
-} else if (command === '--help' || command === '-h' || command === 'help') {
-  usage();
-} else if (command === '--version' || command === '-v') {
-  const pkg = require('../package.json');
-  console.log(pkg.version);
-} else if (command && !command.startsWith('-')) {
-  install(command);
-} else {
-  usage();
+if (require.main === module) {
+  main(process.argv.slice(2));
+}
+
+function main(argv = []) {
+  const command = argv[0] || '';
+
+  if (command === 'install') {
+    install(argv[1]);
+  } else if (command === 'update' || command === 'upgrade') {
+    update();
+  } else if (command === 'start') {
+    start();
+  } else if (command === 'stop') {
+    stop();
+  } else if (command === 'status') {
+    status();
+  } else if (command === 'logs') {
+    logs();
+  } else if (command === 'uninstall') {
+    uninstall();
+  } else if (command === '--help' || command === '-h' || command === 'help') {
+    usage();
+  } else if (command === '--version' || command === '-v') {
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+  } else if (command && !command.startsWith('-')) {
+    install(command);
+  } else {
+    usage();
+  }
 }
 
 // ── Commands ──
@@ -267,6 +280,15 @@ function start() {
   const dir = findWalleDir();
   const port = readPort(dir);
   console.log(`\n  Starting Wall-E from ${DIM}${dir}${RESET} on port ${port}...`);
+  try {
+    repairNativeDependencies(dir, { phase: 'start' });
+  } catch (err) {
+    console.error(`\n  ${RED}Native module repair failed.${RESET}`);
+    console.error(`  ${DIM}${err.message}${RESET}`);
+    console.error(`  Try: ${BOLD}cd ${dir}/claude-task-manager && npm rebuild better-sqlite3 node-pty${RESET}`);
+    console.error(`       ${BOLD}cd ${dir}/wall-e && npm rebuild better-sqlite3 sqlite-vec tree-sitter-bash${RESET}\n`);
+    process.exit(1);
+  }
   installService(dir, port);
   console.log(`  ${GREEN}Running!${RESET}  http://localhost:${port}\n`);
   printMcpResults(parseInt(readWallePort(dir)));
@@ -326,7 +348,7 @@ function stopQuiet(dir, port) {
   const wallePort = dir ? readWallePort(dir) : String(parseInt(port) + 1);
   for (const p of [port, wallePort]) {
     try {
-      const pids = execFileSync('lsof', ['-ti', ':' + p], { encoding: 'utf8', timeout: 3000 }).trim().split('\n').filter(Boolean);
+      const pids = execFileSync('lsof', ['-ti', '-sTCP:LISTEN', ':' + p], { encoding: 'utf8', timeout: 3000 }).trim().split('\n').filter(Boolean);
       for (const pid of pids) { try { process.kill(parseInt(pid), 'SIGTERM'); } catch {} }
     } catch {}
   }
@@ -464,14 +486,146 @@ done
 
 function npmInstall(dir) {
   try {
-    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(dir, 'claude-task-manager'), stdio: 'inherit' });
-    execFileSync('npm', ['install', '--loglevel=warn'], { cwd: path.join(dir, 'wall-e'), stdio: 'inherit' });
-  } catch {
-    console.error(`\n  ${RED}npm install failed.${RESET} Try manually:\n    cd ${dir}/claude-task-manager && npm install\n    cd ${dir}/wall-e && npm install\n`);
+    for (const relDir of MANAGED_PACKAGE_DIRS) {
+      runNpm(path.join(dir, relDir), ['install', '--loglevel=warn']);
+    }
+    repairNativeDependencies(dir, { phase: 'install' });
+  } catch (err) {
+    console.error(`\n  ${RED}npm install failed.${RESET}`);
+    if (err && err.message) console.error(`  ${DIM}${err.message}${RESET}`);
+    console.error(`  Try manually with the same Node version used by Wall-E:\n    cd ${dir}/claude-task-manager && npm install && npm rebuild better-sqlite3 node-pty\n    cd ${dir}/wall-e && npm install && npm rebuild better-sqlite3 sqlite-vec tree-sitter-bash\n`);
     process.exit(1);
   }
 }
 
+function repairNativeDependencies(walleDir, {
+  phase = 'install',
+  checkDependency = checkNativeDependency,
+  runNpmCommand = runNpm,
+  log = console.log,
+} = {}) {
+  const repairs = [];
+  for (const relDir of MANAGED_PACKAGE_DIRS) {
+    const packageDir = path.join(walleDir, relDir);
+    const deps = nativeDependenciesForPackage(packageDir);
+    if (!deps.length) continue;
+
+    const failed = [];
+    for (const dep of deps) {
+      const check = checkDependency(packageDir, dep);
+      if (!check.ok) failed.push(dep);
+    }
+    if (!failed.length) continue;
+
+    log(`  ${YELLOW}Rebuilding native modules for ${relDir}${RESET} ${DIM}(Node ${process.version}, ABI ${process.versions.modules})${RESET}`);
+    runNpmCommand(packageDir, ['rebuild', ...failed, '--loglevel=warn']);
+
+    const stillBroken = [];
+    for (const dep of failed) {
+      const check = checkDependency(packageDir, dep);
+      if (!check.ok) stillBroken.push(`${dep}: ${firstLine(check.error)}`);
+    }
+    if (stillBroken.length) {
+      throw new Error(`Native module repair failed in ${relDir} after ${phase}: ${stillBroken.join('; ')}`);
+    }
+    repairs.push(`${relDir}: ${failed.join(', ')}`);
+  }
+
+  if (repairs.length) {
+    log(`  ${GREEN}Native modules rebuilt successfully${RESET} ${DIM}(${repairs.join('; ')})${RESET}`);
+  }
+  return repairs;
+}
+
+function nativeDependenciesForPackage(packageDir) {
+  const pkgPath = path.join(packageDir, 'package.json');
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return [];
+  }
+  const declared = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.optionalDependencies || {}),
+  };
+  return Object.keys(declared).filter((name) => NATIVE_DEPENDENCIES.has(name));
+}
+
+function checkNativeDependency(packageDir, dependency) {
+  try {
+    execFileSync(process.execPath, ['-e', `require(${JSON.stringify(dependency)})`], {
+      cwd: packageDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 15000,
+      env: npmChildEnv(),
+    });
+    return { ok: true };
+  } catch (err) {
+    const error = [err && err.message, err && err.stdout, err && err.stderr].filter(Boolean).join('\n');
+    return { ok: false, error };
+  }
+}
+
+function runNpm(cwd, args) {
+  const runner = resolveNpmRunner();
+  if (runner.type === 'node-cli') {
+    execFileSync(process.execPath, [runner.path, ...args], {
+      cwd,
+      stdio: 'inherit',
+      env: npmChildEnv(),
+    });
+    return;
+  }
+  execFileSync('npm', args, {
+    cwd,
+    stdio: 'inherit',
+    env: npmChildEnv(),
+  });
+}
+
+function resolveNpmRunner(env = process.env, execPath = process.execPath) {
+  const envPath = normalizeNpmExecPath(env.npm_execpath);
+  if (envPath && fs.existsSync(envPath)) return { type: 'node-cli', path: envPath };
+
+  for (const candidate of npmCliCandidates(execPath)) {
+    if (fs.existsSync(candidate)) return { type: 'node-cli', path: candidate };
+  }
+  return { type: 'bin', path: 'npm' };
+}
+
+function normalizeNpmExecPath(value) {
+  if (!value) return null;
+  const resolved = path.resolve(value);
+  if (path.basename(resolved) === 'npx-cli.js') {
+    return path.join(path.dirname(resolved), 'npm-cli.js');
+  }
+  return resolved;
+}
+
+function npmCliCandidates(execPath = process.execPath) {
+  const binDir = path.dirname(execPath);
+  return [
+    path.join(binDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(binDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(binDir, '..', 'libexec', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ].map((candidate) => path.resolve(candidate));
+}
+
+function npmChildEnv() {
+  const nodeDir = path.dirname(process.execPath);
+  return {
+    ...process.env,
+    PATH: [nodeDir, process.env.PATH || ''].filter(Boolean).join(path.delimiter),
+    npm_config_update_notifier: 'false',
+  };
+}
+
+function firstLine(value) {
+  return String(value || '').split(/\r?\n/).find(Boolean) || 'unknown error';
+}
+
 function stampVersion(dir) {
   try {
     const ver = require('../package.json').version;
@@ -568,3 +722,14 @@ function copyRecursive(src, dest) {
     fs.copyFileSync(src, dest);
   }
 }
+
+module.exports = {
+  checkNativeDependency,
+  firstLine,
+  main,
+  nativeDependenciesForPackage,
+  normalizeNpmExecPath,
+  npmCliCandidates,
+  repairNativeDependencies,
+  resolveNpmRunner,
+};

package/bin/mcp-inject.js

@@ -1,60 +1,25 @@
 'use strict';
-const fs = require('fs');
-const path = require('path');
-
-const MCP_TARGETS = [
-  { tool: 'Claude Code', configPath: '.claude/mcp.json', detectDir: '.claude' },
-  { tool: 'Cursor', configPath: '.cursor/mcp.json', detectDir: '.cursor' },
-  { tool: 'Windsurf', configPath: '.codeium/windsurf/mcp_config.json', detectDir: '.codeium/windsurf' },
-  { tool: 'Claude Desktop', configPath: 'Library/Application Support/Claude/claude_desktop_config.json', detectDir: 'Library/Application Support/Claude' },
-];
-
-/**
- * Inject Wall-E MCP server config into detected AI tool config files.
- * @param {number} wallePort - The Wall-E HTTP port
- * @param {string} [homeDir] - Home directory override for testing
- * @returns {Array<{tool: string, action: string, configPath?: string}>}
- */
-function injectMcpConfigs(wallePort, homeDir) {
-  const home = homeDir || process.env.HOME;
-  const walleUrl = `http://localhost:${wallePort}/mcp`;
-  const results = [];
-
-  for (const target of MCP_TARGETS) {
-    const detectPath = path.join(home, target.detectDir);
-    const configPath = path.join(home, target.configPath);
-
-    if (!fs.existsSync(detectPath)) {
-      results.push({ tool: target.tool, action: 'not_installed' });
-      continue;
-    }
 
-    let config = {};
-    if (fs.existsSync(configPath)) {
-      try {
-        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      } catch {
-        config = {};
-      }
-    }
-
-    if (!config.mcpServers) config.mcpServers = {};
-
-    const existing = config.mcpServers['wall-e'];
-    if (existing && existing.url === walleUrl) {
-      results.push({ tool: target.tool, action: 'already_configured', configPath });
-      continue;
-    }
+const path = require('path');
 
-    const action = existing ? 'updated' : 'added';
-    config.mcpServers['wall-e'] = { type: 'http', url: walleUrl };
+const runtimePath = path.join(__dirname, '..', 'template', 'wall-e', 'lib', 'mcp-integration');
+let runtime = null;
 
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    results.push({ tool: target.tool, action, configPath });
+function loadRuntime() {
+  if (runtime) return runtime;
+  try {
+    runtime = require(runtimePath);
+  } catch {
+    runtime = require('../../wall-e/lib/mcp-integration');
   }
-
-  return results;
+  return runtime;
 }
 
-module.exports = { injectMcpConfigs, MCP_TARGETS };
+module.exports = {
+  get MCP_TARGETS() { return loadRuntime().MCP_TARGETS; },
+  detectMcpIntegrations: (...args) => loadRuntime().detectMcpIntegrations(...args),
+  ensureMcpIntegrations: (...args) => loadRuntime().ensureMcpIntegrations(...args),
+  injectMcpConfigs: (...args) => loadRuntime().injectMcpConfigs(...args),
+  testWallEMcpEndpoint: (...args) => loadRuntime().testWallEMcpEndpoint(...args),
+  wallEMcpUrl: (...args) => loadRuntime().wallEMcpUrl(...args),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-walle",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "CTM + Wall-E \u2014 AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini, Aider, OpenCode, and more, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"
@@ -12,6 +12,8 @@
   ],
   "scripts": {
     "build": "bash build.sh",
+    "test": "node --test tests/*.test.js",
+    "test:npx-e2e": "CREATE_WALLE_NPX_E2E=1 node --test tests/npx-install-update.e2e.test.js",
     "prepublishOnly": "bash build.sh"
   },
   "license": "MIT",

package/template/claude-task-manager/approval-agent.js

@@ -356,6 +356,13 @@ function reviewWithHeuristics(context) {
   const tool = (context.toolName || '').replace(/^[⏺●\s]+/, '').toLowerCase();
   const warning = (context.warning || '').toLowerCase();
 
+  if (/^mcp\b/.test(tool)
+      && /\bwall-e\.walle_memory_status\b|\bwall-e\b[\s\S]*\bwalle_memory_status\b/.test(cmd)) {
+    return { decision: 'approve', reasoning: 'Read-only Wall-E memory status MCP call (heuristic)', riskLevel: 'low',
+      ruleLabel: 'Wall-E memory status', rulePattern: 'wall-e.*walle_memory_status',
+      ruleDescription: 'Read Wall-E MCP memory status' };
+  }
+
   // Low-risk tools — auto-approve immediately (before high-risk content check,
   // because Edit/Write diffs may contain code with "drop table" or "rm -rf" as
   // string literals — those are code content, not dangerous operations).

package/template/claude-task-manager/docs/session-standup-command-center-design.md

@@ -0,0 +1,242 @@
+# Session Standup Command Center Design
+
+## Problem
+
+CTM already supports many long-lived sessions, but the operator cost rises when
+multiple agents are active at once. Each terminal has its own context, and a new
+session does not inherit the hard-won context from an existing one. Reusing
+sessions is therefore necessary, but reuse creates a second problem: the user
+must remember what every session is doing, whether it is blocked, and what the
+next useful instruction should be.
+
+The Standup Command Center is a central dashboard for that operating loop. It is
+not a replacement for session terminals. It is a "manager view" over existing
+sessions that answers:
+
+- What is every active session doing?
+- Which sessions need the user's attention?
+- Which sessions are ready to review or finish?
+- What should the user do next for each session?
+- How can the user quickly deep dive and issue instructions without losing the
+  fleet-level view?
+
+## Research Signals
+
+Open-source projects validate the need for a control-plane style UI, but CTM
+should borrow the operating patterns rather than replatforming the runtime.
+
+- Mission Control positions itself as an open-source dashboard for agent fleets,
+  tasks, costs, workflows, logs, memory, alerts, and quality gates:
+  https://github.com/builderz-labs/mission-control
+- AutoGen Studio shows that multi-agent debugging benefits from explicit
+  sessions, observable messages, metrics, and reusable agent components, but it
+  is framed as a prototyping UI rather than a production app:
+  https://autogenhub.github.io/autogen/blog/2023/12/01/AutoGenStudio/
+- OpenHands exposes a local GUI, REST API, CLI-compatible coding-agent workflow,
+  and cloud/enterprise surfaces for scaling coding agents:
+  https://github.com/OpenHands/OpenHands
+- LangGraph's product framing emphasizes human-in-the-loop checks, persistent
+  memory, and streaming as first-class agent UX primitives:
+  https://www.langchain.com/langgraph
+
+The design conclusion for CTM: do not add a manager-of-managers orchestration
+runtime. CTM already has terminals, stream capture, recent-session history,
+worktree state, approval detection, and review panels. The right abstraction is
+a reusable dashboard projection over those signals, with deterministic manager
+recommendations first and optional LLM annotations later.
+
+## Existing CTM Substrate
+
+The feature should reuse these existing surfaces:
+
+- `lib/session-stream.js`: summary, intent, progress, last prompt, stream status.
+- `lib/status-hooks.js`: idle, busy, and waiting-input state transitions.
+- `server.js` session payloads: active sessions, provider, cwd, branch, modified
+  time, capabilities, and worktree status.
+- `/api/recent-sessions`: historical sessions and project filtering.
+- `/api/stream/status` and `/api/sessions/:id/summary`: stream health and
+  per-session summary.
+- Review tab and session deep links: structured transcript and review flows.
+
+## UX Model
+
+The first screen in CTM Sessions should become the operator dashboard when no
+terminal is selected. The dashboard is dense, operational, and scannable. It is
+closer to a standup board than a marketing landing page.
+
+Primary regions:
+
+1. Fleet header
+   - Total active sessions.
+   - Counts by lane.
+   - Last refresh time.
+   - Refresh action.
+   - New Session action.
+
+2. Attention ribbon
+   - Highest priority sessions needing input or approval.
+   - Shows only the action needed and evidence.
+   - Lets the user open the session directly.
+
+3. Lanes
+   - Needs User: approvals, questions, waiting input, or explicit blockers.
+   - Ready Review: worktree changes, completed work, or reviewable artifacts.
+   - Running: active output or recent work.
+   - Continue Later: idle, stale, or context-preserving sessions.
+
+4. Session card
+   - Title and agent/provider.
+   - State badge and age.
+   - Intent: one-line goal.
+   - Progress: one-line latest progress.
+   - Manager recommendation: what the user should do next.
+   - Evidence chips: waiting input, branch, worktree, last prompt, last activity.
+   - Actions: Open, Review when supported, and Send Instruction when a terminal
+     target is available.
+
+5. Deep dive behavior
+   - Open keeps the user's mental model simple: jump into the session terminal.
+   - Review opens the transcript/review panel when the agent supports it.
+   - Send Instruction targets the existing prompt/queue mechanism in a later
+     phase; the first implementation can focus the session and preserve the
+     command center as the resume surface.
+
+## Manager Recommendation Taxonomy
+
+Recommendations must be conservative and explainable. They should be derived
+from existing signals and include evidence. They should never claim certainty
+from weak heuristics.
+
+Recommended action kinds:
+
+- `approval_needed`: approve, deny, or answer a tool prompt.
+- `needs_input`: user instruction appears required.
+- `review`: inspect completed work or worktree changes.
+- `watch`: session is running; no action needed right now.
+- `resume`: session is idle but can continue with more instruction.
+- `investigate`: session appears failed or blocked.
+- `archive`: work appears complete and inactive.
+
+Lane priority:
+
+1. Failed or blocked signals.
+2. Waiting input or approval.
+3. Reviewable worktree/session output.
+4. Running or recently active sessions.
+5. Idle or stale sessions.
+
+Each recommendation includes:
+
+- `lane`: where it appears on the board.
+- `actionKind`: stable machine-readable action.
+- `actionLabel`: short CTA text.
+- `recommendation`: short human-readable manager note.
+- `confidence`: `high`, `medium`, or `low`.
+- `evidence`: short strings tied to concrete signals.
+
+## API Contract
+
+Add `GET /api/sessions/standup`.
+
+Response shape:
+
+```json
+{
+  "generatedAt": "2026-04-30T12:00:00.000Z",
+  "counts": {
+    "total": 3,
+    "needs_user": 1,
+    "ready_review": 1,
+    "running": 1,
+    "continue_later": 0
+  },
+  "lanes": [
+    {
+      "id": "needs_user",
+      "title": "Needs User",
+      "sessions": []
+    }
+  ],
+  "sessions": [
+    {
+      "id": "ctm-session-id",
+      "agentSessionId": "agent-session-id",
+      "title": "Fix build failure",
+      "agent": "codex",
+      "provider": "openai",
+      "cwd": "/repo",
+      "branch": "fix-build",
+      "status": "waiting_input",
+      "lane": "needs_user",
+      "actionKind": "approval_needed",
+      "actionLabel": "Respond",
+      "recommendation": "Approval or input is waiting in the terminal.",
+      "confidence": "high",
+      "evidence": ["waiting_input", "last activity 2m ago"],
+      "intent": "Fix build failure",
+      "progress": "Waiting for command approval",
+      "lastActivity": "2026-04-30T11:58:00.000Z",
+      "worktree": {
+        "branch": "fix-build",
+        "dirtyFiles": 2,
+        "unmergedCommits": 1
+      },
+      "capabilities": {
+        "review": true,
+        "resume": true
+      }
+    }
+  ]
+}
+```
+
+The endpoint should be pure projection logic over active sessions first. Recent
+sessions can be added as a later extension once the active-session dashboard is
+stable.
+
+## Implementation Phases
+
+Phase 1: Design document
+
+- Commit this design.
+
+Phase 2: Backend projection
+
+- Add a pure `lib/session-standup.js` module.
+- Classify sessions into lanes and recommendations.
+- Add unit tests for the classifier and snapshot builder.
+- Add `GET /api/sessions/standup`.
+
+Phase 3: Dashboard UI
+
+- Replace the empty Sessions welcome panel with the Standup Command Center.
+- Fetch `/api/sessions/standup`.
+- Render fleet header, attention ribbon, lanes, cards, and actions.
+- Keep the UI within the existing CTM visual language: compact, dark,
+  terminal-adjacent, and operational.
+
+Phase 4: Verification and polish
+
+- Run focused unit tests.
+- Run an isolated CTM dev server on random ports, never the primary 3456/3457.
+- Curl the new API.
+- Drive the dashboard in a real browser and confirm it renders without layout
+  overlap or blank states.
+
+Future phase: Manager annotations
+
+- Add optional LLM-generated manager notes only after deterministic
+  recommendations are useful.
+- Store annotation provenance and age.
+- Do not let the LLM issue autonomous cross-session commands; it can propose
+  actions, not execute them.
+
+## Open Questions
+
+- Should historical/recent sessions appear on the same board or in a secondary
+  "Resume Later" view?
+- Should Send Instruction fan out to multiple sessions, or should the first
+  version stay one-session-at-a-time?
+- Should manager annotations be cached per session turn, per stream summary, or
+  per dashboard refresh?
+