create-walle 0.9.8 → 0.9.10

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.)
-- **16 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model training, and more
+- **19 Bundled Skills** — Morning briefing, weekly reflection, proactive alerts, Slack monitoring, email sync, calendar integration, coding agent, model training, model pricing sync, and more
 - **Multi-Model** — Works with Claude, GPT, Gemini, and local models via Ollama 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

package/bin/create-walle.js

@@ -13,6 +13,7 @@ const RED = '\x1b[31m';
 const CYAN = '\x1b[36m';
 const RESET = '\x1b[0m';
 
+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');
@@ -70,6 +71,29 @@ ${BOLD}${CYAN}  Wall-E${RESET} — Your personal digital twin
 `);
 }
 
+function printMcpResults(wallePort) {
+  try {
+    const results = injectMcpConfigs(wallePort);
+    const hasAny = results.some(r => r.action !== 'not_installed');
+    if (!hasAny) return;
+
+    console.log(`  ${BOLD}MCP Integrations:${RESET}`);
+    for (const r of results) {
+      if (r.action === 'not_installed') {
+        console.log(`     ${DIM}-  ${r.tool} -- not installed${RESET}`);
+      } else if (r.action === 'already_configured') {
+        console.log(`     ${DIM}=  ${r.tool} -- already configured${RESET}`);
+      } else if (r.action === 'updated') {
+        console.log(`     ${GREEN}~  ${r.tool}${RESET} -- updated port in ${DIM}${r.configPath}${RESET}`);
+      } else {
+        console.log(`     ${GREEN}+  ${r.tool}${RESET} -- added Wall-E to ${DIM}${r.configPath}${RESET}`);
+      }
+    }
+    console.log(`\n  ${DIM}Your AI coding tools can now access Wall-E's memory and knowledge.`);
+    console.log(`  To undo: remove the "wall-e" entry from the config files above.${RESET}\n`);
+  } catch {}
+}
+
 function install(targetDir) {
   // If no target dir given, check for existing install
   if (!targetDir) {
@@ -120,14 +144,20 @@ function install(targetDir) {
   console.log(`  Installing dependencies...\n`);
   npmInstall(targetDir);
 
+  compileHotkeyDaemon(targetDir);
+
   // .env
   const envLines = [
     `# Wall-E configuration — generated ${new Date().toISOString().split('T')[0]}`,
     `# Finish setup at http://localhost:${port}/setup.html`,
     '',
-    `WALLE_OWNER_NAME=${ownerName}`,
+    `WALLE_OWNER_NAME="${ownerName.replace(/"/g, '\\"')}"`,
     '# ANTHROPIC_API_KEY=',
     '',
+    '# AI Provider: anthropic, openai, google, ollama',
+    '# WALLE_PROVIDER=anthropic',
+    '# WALLE_MODEL=',
+    '',
     `CTM_PORT=${port}`,
     `WALL_E_PORT=${wallePort}`,
     '',
@@ -172,6 +202,7 @@ function install(targetDir) {
     npx create-walle status      ${DIM}Check status${RESET}
     npx create-walle logs        ${DIM}View logs${RESET}
 `);
+  printMcpResults(parseInt(wallePort));
 }
 
 function update() {
@@ -218,7 +249,9 @@ function update() {
   console.log(`  Installing dependencies...\n`);
   npmInstall(dir);
 
-  // 6. Start again
+  compileHotkeyDaemon(dir);
+
+  // 7. Start again
   console.log(`\n  Starting Wall-E...`);
   startForegroundOrService(dir, port);
 
@@ -227,6 +260,7 @@ function update() {
 
   ${DIM}Your .env and config were preserved.${RESET}
 `);
+  printMcpResults(parseInt(readWallePort(dir)));
 }
 
 function start() {
@@ -235,6 +269,7 @@ function start() {
   console.log(`\n  Starting Wall-E from ${DIM}${dir}${RESET} on port ${port}...`);
   installService(dir, port);
   console.log(`  ${GREEN}Running!${RESET}  http://localhost:${port}\n`);
+  printMcpResults(parseInt(readWallePort(dir)));
 }
 
 function stop() {
@@ -300,9 +335,8 @@ function stopQuiet(dir, port) {
   while (Date.now() < deadline) {
     try {
       execFileSync('curl', ['-s', '--max-time', '1', `http://localhost:${port}/api/services/status`], { encoding: 'utf8', timeout: 2000 });
-      // Still running — busy-wait briefly
-      const waitUntil = Date.now() + 500;
-      while (Date.now() < waitUntil) { /* spin */ }
+      // Still running — sleep briefly (avoid CPU spin)
+      try { execFileSync('sleep', ['0.5'], { timeout: 2000 }); } catch {}
     } catch {
       break; // Port is free
     }
@@ -339,15 +373,18 @@ function installService(walleDir, port) {
     fs.mkdirSync(plistDir, { recursive: true });
     const plistPath = path.join(plistDir, `${LABEL}.plist`);
 
-    let envDict = `    <key>PATH</key>\n    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>\n`;
-    envDict += `    <key>HOME</key>\n    <string>${process.env.HOME}</string>\n`;
+    const xmlEsc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const nodeBinDir = path.dirname(nodePath);
+    let envDict = `    <key>PATH</key>\n    <string>${xmlEsc(nodeBinDir)}:/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>\n`;
+    envDict += `    <key>HOME</key>\n    <string>${xmlEsc(process.env.HOME)}</string>\n`;
     envDict += `    <key>CTM_PORT</key>\n    <string>${port}</string>\n`;
+    envDict += `    <key>CTM_MANAGED_BY_LAUNCHD</key>\n    <string>1</string>\n`;
     try {
       const envFile = fs.readFileSync(path.join(walleDir, '.env'), 'utf8');
       for (const line of envFile.split('\n')) {
         const m = line.match(/^\s*([^#=\s]+)\s*=\s*(.+?)\s*$/);
         if (m && m[1] !== 'CTM_PORT' && m[1] !== 'PATH' && m[1] !== 'HOME') {
-          envDict += `    <key>${m[1]}</key>\n    <string>${m[2]}</string>\n`;
+          envDict += `    <key>${xmlEsc(m[1])}</key>\n    <string>${xmlEsc(m[2])}</string>\n`;
         }
       }
     } catch {}
@@ -371,11 +408,16 @@ ${envDict}  </dict>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
-  <true/>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${logDir}/walle.log</string>
+  <string>${logDir}/ctm.log</string>
   <key>StandardErrorPath</key>
-  <string>${logDir}/walle.err</string>
+  <string>${logDir}/ctm.err</string>
 </dict>
 </plist>`;
 
@@ -383,10 +425,34 @@ ${envDict}  </dict>
     try { execFileSync('launchctl', ['unload', plistPath], { stdio: 'ignore' }); } catch {}
     execFileSync('launchctl', ['load', plistPath]);
   } else {
-    const child = spawn(process.execPath, ['claude-task-manager/server.js'], {
+    // Linux/other: spawn with a restart-on-crash wrapper shell script
+    const watchdogScript = path.join(walleDir, 'bin', 'watchdog.sh');
+    const watchdogContent = `#!/bin/bash
+# Auto-restart CTM on crash. Clean exit (code 0) stops the watchdog.
+CRASHES=0
+while true; do
+  "${process.execPath}" claude-task-manager/server.js >> "${logDir}/ctm.log" 2>> "${logDir}/ctm.err"
+  EXIT_CODE=$?
+  if [ $EXIT_CODE -eq 0 ]; then
+    echo "[watchdog] Clean exit (code 0), stopping." >> "${logDir}/ctm.log"
+    break
+  fi
+  CRASHES=$((CRASHES + 1))
+  echo "[watchdog] CTM exited with code $EXIT_CODE (crash #$CRASHES), restarting in 5s..." >> "${logDir}/ctm.log"
+  if [ $CRASHES -ge 5 ]; then
+    echo "[watchdog] Too many crashes ($CRASHES), giving up." >> "${logDir}/ctm.log"
+    break
+  fi
+  sleep 5
+done
+`;
+    fs.mkdirSync(path.join(walleDir, 'bin'), { recursive: true });
+    fs.writeFileSync(watchdogScript, watchdogContent, { mode: 0o755 });
+
+    const child = spawn('bash', [watchdogScript], {
       cwd: walleDir,
       detached: true,
-      stdio: ['ignore', fs.openSync(path.join(logDir, 'walle.log'), 'a'), fs.openSync(path.join(logDir, 'walle.err'), 'a')],
+      stdio: 'ignore',
       env: { ...process.env, CTM_PORT: port },
     });
     child.unref();
@@ -474,6 +540,22 @@ function detectTimezone() {
   return 'UTC';
 }
 
+function compileHotkeyDaemon(walleDir) {
+  if (process.platform !== 'darwin') return; // macOS only
+  const swiftSource = path.join(walleDir, 'claude-task-manager', 'bin', 'ctm-hotkey.swift');
+  if (!fs.existsSync(swiftSource)) return;
+  const binary = path.join(process.env.HOME, '.local', 'bin', 'ctm-hotkey');
+  try {
+    fs.mkdirSync(path.dirname(binary), { recursive: true });
+    execFileSync('swiftc', ['-O', '-o', binary, swiftSource, '-framework', 'Cocoa'], { timeout: 120000, stdio: 'pipe' });
+    fs.chmodSync(binary, 0o755);
+    console.log(`  ${GREEN}Compiled hotkey daemon${RESET} ${DIM}(${binary})${RESET}`);
+  } catch {
+    // swiftc not available or compilation failed — non-fatal
+    console.log(`  ${DIM}Skipped hotkey daemon (Swift compiler not available)${RESET}`);
+  }
+}
+
 function copyRecursive(src, dest) {
   const stat = fs.statSync(src);
   if (stat.isDirectory()) {

package/bin/mcp-inject.js

@@ -0,0 +1,60 @@
+'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 action = existing ? 'updated' : 'added';
+    config.mcpServers['wall-e'] = { type: 'http', url: walleUrl };
+
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    results.push({ tool: target.tool, action, configPath });
+  }
+
+  return results;
+}
+
+module.exports = { injectMcpConfigs, MCP_TARGETS };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-walle",
-  "version": "0.9.8",
-  "description": "CTM + Wall-E — AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini & Aider, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
+  "version": "0.9.10",
+  "description": "CTM + Wall-E \u2014 AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini & Aider, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"
   },
@@ -15,5 +15,13 @@
     "prepublishOnly": "bash build.sh"
   },
   "license": "MIT",
-  "keywords": ["ctm", "task-manager", "wall-e", "ai", "digital-twin", "claude", "personal-assistant"]
+  "keywords": [
+    "ctm",
+    "task-manager",
+    "wall-e",
+    "ai",
+    "digital-twin",
+    "claude",
+    "personal-assistant"
+  ]
 }

package/template/CLAUDE.md

@@ -24,6 +24,18 @@ When developing CTM or Wall-E code:
 4. Test ONLY against your dev port, never 3456
 5. Only restart primary when the user explicitly asks — and ask for confirmation first
 
+## Testing
+
+Both projects use Node.js built-in test runner with `--test-force-exit` to prevent hangs:
+- **Wall-E**: `cd wall-e && npm test`
+- **CTM**: `cd claude-task-manager && npm test`
+
+When writing new tests, follow these rules to avoid handle leaks and cross-test contamination:
+- **Never set `process.env` at module top level** — set in `before()`, restore in `after()`
+- **Close every DB connection you open** — store `readDb` handles in module scope, close in `after()`/teardown
+- **Call `brain.closeDb()` before `brain.initDb()`** in tests that reinitialize the brain singleton
+- **Don't change `journal_mode`** on readonly connections (causes SQLITE_BUSY against WAL dbs)
+
 ## Publishing to npm (create-walle)
 
 When publishing with `/publish`:
@@ -32,3 +44,10 @@ When publishing with `/publish`:
 3. Bump version in both `create-walle/package.json` AND root `package.json`
 4. Run `bash build.sh` and verify file count
 5. Ask for confirmation before `npm publish`
+
+## Architecture reference
+
+For Wall-E architecture (loops, brain DB, scheduler, skills, channels, anti-patterns):
+read `wall-e/docs/architecture.md` before making non-trivial changes. The
+"Non-goals" section is a guardrail — coordinate via data, not via
+manager-of-managers.

package/template/bin/dev.sh

@@ -3,50 +3,64 @@
 # Primary instance stays untouched. Ctrl+C to stop.
 #
 # Usage:
-#   bash bin/dev.sh              # Start dev instance (snapshot DBs on first run)
-#   bash bin/dev.sh --refresh    # Re-copy production DBs before starting
-#   bash bin/dev.sh --fresh      # Start with empty DBs
+#   bash bin/dev.sh              # Start dev instance with fresh empty DBs
+#   bash bin/dev.sh --refresh    # Explicitly copy production DBs before starting
+#   bash bin/dev.sh --fresh      # Reset to empty DBs before starting
 
 set -e
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 DEV_DIR="${WALLE_DEV_DIR:-/tmp/walle-dev}"
 DEV_CTM_PORT="${DEV_CTM_PORT:-4000}"
 DEV_WALLE_PORT="${DEV_WALLE_PORT:-4001}"
+DEV_OAUTH_PROXY_PORT="${DEV_OAUTH_PROXY_PORT:-$((DEV_CTM_PORT + 2))}"
 
-# Source production .env to find DB paths
-PROD_CTM_DIR="$HOME/.walle/data"
-PROD_WALLE_DIR="$HOME/.walle/data"
+# Source production .env to find DB paths. DEV_SOURCE_* lets worktrees without
+# their own .env refresh from the primary repo's configured data directory.
+PROD_CTM_DIR="${DEV_SOURCE_CTM_DATA_DIR:-$HOME/.walle/data}"
+PROD_WALLE_DIR="${DEV_SOURCE_WALL_E_DATA_DIR:-$HOME/.walle/data}"
 if [[ -f "$ROOT/.env" ]]; then
   eval "$(grep -E '^(CTM_DATA_DIR|WALL_E_DATA_DIR)=' "$ROOT/.env" 2>/dev/null)" || true
-  [[ -n "$CTM_DATA_DIR" ]] && PROD_CTM_DIR="$CTM_DATA_DIR"
-  [[ -n "$WALL_E_DATA_DIR" ]] && PROD_WALLE_DIR="$WALL_E_DATA_DIR"
+  [[ -z "$DEV_SOURCE_CTM_DATA_DIR" && -n "$CTM_DATA_DIR" ]] && PROD_CTM_DIR="$CTM_DATA_DIR"
+  [[ -z "$DEV_SOURCE_WALL_E_DATA_DIR" && -n "$WALL_E_DATA_DIR" ]] && PROD_WALLE_DIR="$WALL_E_DATA_DIR"
 fi
 
 mkdir -p "$DEV_DIR"
 
+cleanup_processes() {
+  pkill -f "ctm-dev-$DEV_CTM_PORT" 2>/dev/null || true
+  pkill -f "walle-dev-$DEV_CTM_PORT" 2>/dev/null || true
+  lsof -ti ":$DEV_CTM_PORT" -sTCP:LISTEN 2>/dev/null | xargs kill 2>/dev/null || true
+  lsof -ti ":$DEV_WALLE_PORT" -sTCP:LISTEN 2>/dev/null | xargs kill 2>/dev/null || true
+  lsof -ti ":$DEV_OAUTH_PROXY_PORT" -sTCP:LISTEN 2>/dev/null | xargs kill 2>/dev/null || true
+}
+
+cleanup_dev() {
+  cleanup_processes
+  # Remove dev data directory to prevent /tmp bloat (each copy is ~2-6 GB)
+  if [[ "$DEV_DIR" == /tmp/walle-* && -d "$DEV_DIR" ]]; then
+    echo "[dev] Cleaning up $DEV_DIR ..."
+    rm -rf "$DEV_DIR"
+  fi
+}
+
+cleanup_processes
+
 # Handle flags
-if [[ "$1" == "--fresh" ]]; then
+if [[ "$1" == "--fresh" || -z "$1" ]]; then
   echo "[dev] Starting with fresh (empty) databases"
   rm -f "$DEV_DIR"/*.db "$DEV_DIR"/*.db-wal "$DEV_DIR"/*.db-shm
-elif [[ "$1" == "--refresh" || ! -f "$DEV_DIR/task-manager.db" ]]; then
-  echo "[dev] Copying production databases to $DEV_DIR ..."
-  # Copy CTM DB
-  if [[ -f "$PROD_CTM_DIR/task-manager.db" ]]; then
-    cp "$PROD_CTM_DIR/task-manager.db" "$DEV_DIR/task-manager.db"
-    echo "  CTM: $PROD_CTM_DIR/task-manager.db → $DEV_DIR/"
-  fi
-  # Copy Wall-E brain
-  if [[ -f "$PROD_WALLE_DIR/wall-e-brain.db" ]]; then
-    cp "$PROD_WALLE_DIR/wall-e-brain.db" "$DEV_DIR/wall-e-brain.db"
-    echo "  Brain: $PROD_WALLE_DIR/wall-e-brain.db → $DEV_DIR/"
-  fi
-  # Clean WAL files (they're specific to the source process)
+elif [[ "$1" == "--refresh" ]]; then
+  echo "[dev] Snapshotting production databases to $DEV_DIR ..."
+  node "$ROOT/bin/sqlite-snapshot.js" "$PROD_CTM_DIR/task-manager.db" "$DEV_DIR/task-manager.db" "CTM"
+  node "$ROOT/bin/sqlite-snapshot.js" "$PROD_WALLE_DIR/wall-e-brain.db" "$DEV_DIR/wall-e-brain.db" "Brain"
+  # Ensure the dev instance owns its WAL files from first open.
   rm -f "$DEV_DIR"/*.db-wal "$DEV_DIR"/*.db-shm
 fi
 
 echo ""
 echo "  Dev CTM:    http://localhost:$DEV_CTM_PORT"
 echo "  Dev Wall-E: port $DEV_WALLE_PORT"
+echo "  Dev OAuth:  port $DEV_OAUTH_PROXY_PORT"
 echo "  Dev data:   $DEV_DIR"
 echo "  Source:     $ROOT"
 echo ""
@@ -59,14 +73,23 @@ export WALL_E_PORT="$DEV_WALLE_PORT"
 export CTM_DATA_DIR="$DEV_DIR"
 export WALL_E_DATA_DIR="$DEV_DIR"
 export CTM_HOST="127.0.0.1"
+export CTM_INSTANCE_TAG="dev-$DEV_CTM_PORT"
+export OAUTH_PROXY_PORT="$DEV_OAUTH_PROXY_PORT"
 
 # Source the rest of .env (API keys, owner name, etc.)
 if [[ -f "$ROOT/.env" ]]; then
   set -a
-  source <(grep -v '^#' "$ROOT/.env" | grep -vE '^(CTM_PORT|WALL_E_PORT|CTM_DATA_DIR|WALL_E_DATA_DIR|CTM_HOST)=' | grep '=')
+  source <(grep -v '^#' "$ROOT/.env" | grep -vE '^(CTM_PORT|WALL_E_PORT|CTM_DATA_DIR|WALL_E_DATA_DIR|CTM_HOST|CTM_INSTANCE_TAG|OAUTH_PROXY_PORT)=' | grep '=')
   set +a
 fi
 
+trap cleanup_dev EXIT
+
+# Clean up stale dev/e2e data dirs older than 24h (from crashed sessions)
+find /tmp -maxdepth 1 -name "walle-dev-*" -type d -mmin +1440 -exec rm -rf {} + 2>/dev/null || true
+find /tmp -maxdepth 1 -name "walle-e2e-*" -type d -mmin +1440 -exec rm -rf {} + 2>/dev/null || true
+find /tmp -maxdepth 1 -name "ctm-dev-*" -type d -mmin +1440 -exec rm -rf {} + 2>/dev/null || true
+
 # Run in foreground so Ctrl+C stops it cleanly
 cd "$ROOT"
 exec node claude-task-manager/server.js

package/template/bin/install-service.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
-# Install Wall-E as a macOS Launch Agent so it starts automatically on login.
+# Install CTM + Wall-E as a macOS Launch Agent so it starts automatically on login
+# and auto-restarts on crash (but NOT on clean exit).
 # Usage: bash bin/install-service.sh [--uninstall]
 
 set -e
@@ -7,22 +8,40 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 ROOT="$(dirname "$SCRIPT_DIR")"
 LABEL="com.walle.server"
 PLIST="$HOME/Library/LaunchAgents/$LABEL.plist"
-PORT="${CTM_PORT:-4567}"
+PORT="${CTM_PORT:-3456}"
 
 if [[ "$1" == "--uninstall" ]]; then
-  launchctl unload "$PLIST" 2>/dev/null || true
+  launchctl bootout "gui/$(id -u)/$LABEL" 2>/dev/null || \
+    launchctl unload "$PLIST" 2>/dev/null || true
   rm -f "$PLIST"
-  echo "Wall-E service uninstalled."
+  echo "CTM service uninstalled."
   exit 0
 fi
 
-# Source .env to get the port
+# Source .env for port and data dir overrides
+ENV_VARS=""
 if [[ -f "$ROOT/.env" ]]; then
-  export $(grep -v '^#' "$ROOT/.env" | grep '=' | xargs)
-  PORT="${CTM_PORT:-4567}"
+  while IFS='' read -r line || [[ -n "$line" ]]; do
+    [[ -z "$line" || "$line" == \#* ]] && continue
+    key="${line%%=*}"
+    value="${line#*=}"
+    key=$(echo "$key" | xargs)
+    value=$(echo "$value" | xargs | sed 's/^["'"'"']//;s/["'"'"']$//')
+    [[ -z "$key" ]] && continue
+    case "$key" in
+      CTM_PORT) PORT="$value" ;;
+    esac
+    # XML-escape for plist safety
+    esc_key=$(echo "$key" | sed 's/&/\&amp;/g;s/</\&lt;/g;s/>/\&gt;/g')
+    esc_val=$(echo "$value" | sed 's/&/\&amp;/g;s/</\&lt;/g;s/>/\&gt;/g')
+    ENV_VARS="$ENV_VARS
+    <key>$esc_key</key>
+    <string>$esc_val</string>"
+  done < "$ROOT/.env"
 fi
 
 NODE=$(which node)
+NODE_BIN_DIR=$(dirname "$NODE")
 LOG_DIR="$HOME/.walle/logs"
 mkdir -p "$LOG_DIR"
 
@@ -43,30 +62,45 @@ cat > "$PLIST" << EOF
   <key>EnvironmentVariables</key>
   <dict>
     <key>PATH</key>
-    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+    <string>$NODE_BIN_DIR:/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
     <key>HOME</key>
     <string>$HOME</string>
     <key>CTM_PORT</key>
     <string>$PORT</string>
+    <key>CTM_MANAGED_BY_LAUNCHD</key>
+    <string>1</string>$ENV_VARS
   </dict>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
-  <true/>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>$LOG_DIR/walle.log</string>
+  <string>$LOG_DIR/ctm.log</string>
   <key>StandardErrorPath</key>
-  <string>$LOG_DIR/walle.err</string>
+  <string>$LOG_DIR/ctm.err</string>
 </dict>
 </plist>
 EOF
 
-launchctl unload "$PLIST" 2>/dev/null || true
-launchctl load "$PLIST"
+# Load the service (unload first if previously loaded, wait for clean exit)
+launchctl bootout "gui/$(id -u)/$LABEL" 2>/dev/null || \
+  launchctl unload "$PLIST" 2>/dev/null || true
+sleep 1  # Let old process release port before bootstrapping new one
+launchctl bootstrap "gui/$(id -u)" "$PLIST" 2>/dev/null || \
+  launchctl load "$PLIST"
 
-echo "Wall-E installed as a macOS service."
+echo "CTM installed as a macOS Launch Agent."
 echo ""
-echo "  Status:    launchctl list | grep walle"
-echo "  Logs:      tail -f ~/.walle/logs/walle.log"
+echo "  Status:    launchctl list $LABEL"
+echo "  Logs:      tail -f ~/.walle/logs/ctm.log"
+echo "  Errors:    tail -f ~/.walle/logs/ctm.err"
 echo "  Dashboard: http://localhost:$PORT"
 echo "  Uninstall: bash bin/install-service.sh --uninstall"
+echo ""
+echo "  Auto-restarts on crash. Clean exit (SIGTERM/SIGINT) stops the service."
+echo "  To manually stop: launchctl kill SIGTERM gui/$(id -u)/$LABEL"

package/template/bin/setup.js

@@ -7,6 +7,7 @@
 const { execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteFileSync } = require('../claude-task-manager/atomic-write');
 
 const ROOT = path.resolve(__dirname, '..');
 const ENV_PATH = path.join(ROOT, '.env');
@@ -41,7 +42,7 @@ function runIfNeeded() {
     `WALLE_OWNER_NAME=${ownerName}`,
     '# ANTHROPIC_API_KEY=sk-ant-...',
   ];
-  fs.writeFileSync(ENV_PATH, envLines.join('\n') + '\n', { mode: 0o600 });
+  atomicWriteFileSync(ENV_PATH, envLines.join('\n') + '\n', { mode: 0o600 });
 
   // Set in current process
   process.env.WALLE_OWNER_NAME = ownerName;