create-walle 0.9.17 → 0.9.19

package/README.md

@@ -1,6 +1,6 @@
 # create-walle
 
-Set up **CTM + Wall-E** in one command — a browser-based dashboard for AI coding agents paired with a personal AI agent that builds a searchable second brain from your work life.
+Set up **CTM + Wall-E** in one command — a browser-based command center for AI coding agents, remote phone access, review workflows, and a personal AI agent that builds a searchable second brain from your work life.
 
 ## What You Get
 
@@ -12,7 +12,8 @@ A web dashboard for running and managing AI coding sessions across multiple prov
 - **Prompt Editor** — Save, version, and organize prompts with folders, tags, chains, templates, and AI search
 - **Task Queue** — Queue prompts for sequential execution with auto-advance when the agent finishes, or step through manually
 - **Approval Workflows** — Auto-approve tool-use requests based on learned rules; uncertain cases escalate to you
-- **Code Review** — View git diffs from any project, staged or unstaged, with line-level detail
+- **Remote Phone Access** — Pair your phone with a QR code and use a mobile CTM UI over Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote
+- **Code & Doc Review** — Review git diffs and Markdown docs side by side, add anchored comments, and send feedback into an agent session or queue
 - **Model Registry** — Manage providers (Anthropic, OpenAI, Google, DeepSeek, Ollama, LM Studio, MLX, and CLI subscription providers), compare pricing, switch models per session
 - **Session Insights** — Analyze patterns across sessions to optimize prompts and workflows
 
@@ -23,7 +24,7 @@ An always-on AI agent that learns from your Slack, email, calendar, and coding s
 - **Second Brain** — Automatically ingests your digital life and coding sessions 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 memories, recall prior coding sessions, look up people, run skills, and call external tools via MCP
-- **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
+- **21 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
@@ -34,7 +35,7 @@ An always-on AI agent that learns from your Slack, email, calendar, and coding s
 npx create-walle install ./walle
 ```
 
-This copies the project, installs dependencies, auto-detects your name and timezone, and starts the server. Open **http://localhost:3456** to finish setup in the browser.
+This copies the project, installs dependencies, auto-detects your name and timezone, and starts the server. Open **http://localhost:3456** to finish setup in the browser, then pair your phone from Setup if you want remote access.
 
 ## Commands
 
@@ -61,6 +62,7 @@ On first launch, the browser setup page guides you through:
 1. **Owner name** — auto-detected from `git config`
 2. **API key** — enter manually, or click "Auto-detect" to find it from your shell environment, Claude Code OAuth, or corporate devbox
 3. **Integrations** — connect Slack (OAuth), email and calendar auto-detected on macOS
+4. **Remote phone access** — optional QR pairing with Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote
 
 ## Custom Port
 
@@ -76,7 +78,7 @@ Everything runs locally. CTM serves the dashboard, Wall-E runs as a background a
 
 | Component | Default Port | What it does |
 |-----------|-------------|--------------|
-| CTM | 3456 | Dashboard, multi-agent terminal, prompt editor, queue, model registry, code review |
+| CTM | 3456 | Dashboard, multi-agent terminal, prompt editor, queue, model registry, code/doc review, remote phone UI |
 | Wall-E | 3457 | AI agent, brain database, skills engine, multi-model chat API |
 
 ## Links

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-walle",
-  "version": "0.9.17",
-  "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.",
+  "version": "0.9.19",
+  "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, remote phone access, code/doc review, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"
   },

package/template/README.md

@@ -2,20 +2,21 @@
 
 **Wall-E** is your personal digital twin — an AI agent that learns from your Slack, email, and calendar to build a searchable second brain, answer questions in your voice, and automate daily workflows.
 
-**CTM** (Claude Task Manager) is an agent task manager and terminal multiplexer — a web dashboard for running Claude Code sessions, managing prompts, reviewing code, and controlling Wall-E.
+**CTM** (Coding Task Manager) is an agent task manager and terminal multiplexer — a web dashboard for running Claude Code, Codex, Gemini, Aider, OpenCode, Cursor Agent, and other AI coding sessions, plus prompts, code review, phone access, and Wall-E control.
 
-Together they give you a local-first AI command center: a browser-based workspace where you manage Claude Code sessions, chat with an AI that knows your work context, and automate the repetitive parts of your day.
+Together they give you a local-first AI command center: a browser-based workspace where you manage AI coding sessions, chat with an AI that knows your work context, respond from your phone, and automate the repetitive parts of your day.
 
 ## What You Get
 
 ### CTM — Agent Task Manager
-- **Terminal multiplexer** — run multiple Claude Code sessions side-by-side in browser tabs, with session history, search, and replay
+- **Terminal multiplexer** — run multiple AI coding agents side-by-side in browser tabs, with session history, search, and replay
 - **Prompt library** — rich-text editor with versioning, folders, tags, and one-click send to any active session
 - **Prompt queue** — batch multiple prompts and send them sequentially to a session with idle detection
 - **Shadow Approver** — learns your permission patterns and auto-approves safe operations across sessions
 - **Code review** — AI-assisted diff review across projects with inline comments
-- **Session insights** — AI analysis of your Claude Code usage with actionable recommendations
-- **Permission manager** — fine-grained control over what Claude Code can do automatically, with risk tiers and rule consolidation
+- **Phone access** — pair a phone with a QR code and use the mobile CTM UI through Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote
+- **Session insights** — AI analysis of your coding-agent usage with actionable recommendations
+- **Permission manager** — fine-grained control over what coding agents can do automatically, with risk tiers and rule consolidation
 
 ### Wall-E — Personal AI Agent
 - **Second brain** — ingests Slack messages, calendar events, and sent emails into a local SQLite database with full-text search
@@ -54,12 +55,10 @@ CTM (port 3456)                    Wall-E Daemon
 ## Quickstart
 
 ```bash
-npx create-walle my-agent
-cd my-agent
-node claude-task-manager/server.js
+npx create-walle install ./walle
 ```
 
-Open **http://localhost:3456** — the setup page walks you through adding your API key and connecting integrations. Your name and timezone are auto-detected.
+Open **http://localhost:3456** — the setup page walks you through adding your API key, connecting integrations, and pairing your phone if you want mobile access. Your name and timezone are auto-detected.
 
 Or clone manually:
 
@@ -75,7 +74,7 @@ The first run auto-creates `.env`, `wall-e-config.json`, and `~/.walle/data/`. F
 ## Dashboard Features
 
 ### Sessions
-Terminal multiplexer for Claude Code — create, monitor, and manage multiple sessions from a single browser tab. Features include:
+Terminal multiplexer for AI coding agents — create, monitor, and manage multiple sessions from a single browser tab. Features include:
 - Live terminal output via WebSocket (xterm.js)
 - Session search and AI-powered search across all session history
 - AI auto-titling for sessions
@@ -84,7 +83,7 @@ Terminal multiplexer for Claude Code — create, monitor, and manage multiple se
 - Session replay and review
 
 ### Prompts
-Rich-text prompt editor with a full formatting toolbar. Organize prompts into folders, tag them, track usage across sessions, and send to any active Claude Code session with one click.
+Rich-text prompt editor with a full formatting toolbar. Organize prompts into folders, tag them, track usage across sessions, and send to any active coding-agent session with one click.
 - **Composite prompts** — parent prompt with sub-prompts that compose into a single message
 - **Prompt queue** — batch multiple prompts, send sequentially with idle detection between items
 - **Power tools** — chains (multi-step sequences), templates, pattern detection, harvest (extract prompts from session history), and AI copilot suggestions
@@ -101,8 +100,11 @@ Chat directly with Wall-E from the dashboard. Wall-E has access to your full bra
 
 Sub-tabs: Chat, Tasks (background task manager), Skills (view and run), Brain (knowledge graph), Actions, Timeline, Questions, Status.
 
+### Phone Access
+Pair a phone from Setup and open the mobile CTM UI at `/m/`. CTM supports Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, and Walle Remote paths so you can monitor sessions and respond while away from the desktop browser.
+
 ### Shadow Approver
-Learns your permission patterns from Claude Code sessions and auto-approves safe operations. Features:
+Learns your permission patterns from coding-agent sessions and auto-approves safe operations. Features:
 - Pattern learning from your approval history
 - AI-driven approval decisions with confidence scoring
 - Domain-specific trust tiers (Observe, Draft, Guarded, Autonomous)
@@ -114,10 +116,10 @@ AI-assisted code review across projects:
 - Inline diff viewer
 - Multi-project support
 - AI review comments with confidence levels
-- Send review to a Claude Code session for implementation
+- Send review to a coding-agent session for implementation
 
 ### Session Insights
-AI analysis of your Claude Code usage patterns:
+AI analysis of your coding-agent usage patterns:
 - Workflow recommendations (automate repetitive tasks)
 - Prompt effectiveness analysis
 - Skill gap detection
@@ -125,7 +127,7 @@ AI analysis of your Claude Code usage patterns:
 - Session statistics
 
 ### Permission Manager
-Fine-grained control over what Claude Code can do automatically:
+Fine-grained control over what coding agents can do automatically:
 - Search and filter across all rules
 - Risk-based categorization (LOW, MEDIUM, HIGH)
 - Per-project or global scope
@@ -239,7 +241,7 @@ CTM runs on port 3456. Key endpoints:
 | GET | `/api/wall-e/tasks` | List background tasks |
 | POST | `/api/wall-e/chat` | Chat with Wall-E (supports SSE streaming) |
 | GET | `/api/prompts` | List prompts |
-| GET | `/api/recent-sessions` | List recent Claude Code sessions |
+| GET | `/api/recent-sessions` | List recent coding-agent sessions |
 
 ## Tech Stack
 

package/template/bin/ctm-dev-cleanup.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+const DEFAULT_MAX_AGE_MIN = 24 * 60;
+const PROTECTED_PORTS = new Set([3456, 3457]);
+
+function parseArgs(argv) {
+  const opts = {
+    kill: false,
+    stale: false,
+    maxAgeMin: DEFAULT_MAX_AGE_MIN,
+    port: null,
+    wallePort: null,
+    json: false,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--kill') opts.kill = true;
+    else if (arg === '--stale') opts.stale = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--max-age-min') opts.maxAgeMin = Number(argv[++i] || DEFAULT_MAX_AGE_MIN);
+    else if (arg === '--port') opts.port = Number(argv[++i] || 0) || null;
+    else if (arg === '--wall-e-port') opts.wallePort = Number(argv[++i] || 0) || null;
+    else if (arg === '--help' || arg === '-h') opts.help = true;
+  }
+  return opts;
+}
+
+function parseElapsedToSeconds(value) {
+  const text = String(value || '').trim();
+  if (!text) return 0;
+  const daySplit = text.split('-');
+  let days = 0;
+  let rest = text;
+  if (daySplit.length === 2) {
+    days = Number(daySplit[0]) || 0;
+    rest = daySplit[1];
+  }
+  const parts = rest.split(':').map(n => Number(n) || 0);
+  if (parts.length === 3) return days * 86400 + parts[0] * 3600 + parts[1] * 60 + parts[2];
+  if (parts.length === 2) return days * 86400 + parts[0] * 60 + parts[1];
+  return days * 86400 + (parts[0] || 0);
+}
+
+function findExecutable(candidates) {
+  for (const file of candidates) {
+    try {
+      execFileSync(file, ['-v'], { stdio: 'ignore', timeout: 1000 });
+      return file;
+    } catch {}
+  }
+  return candidates[0];
+}
+
+function runText(file, args, timeout = 3000) {
+  try {
+    return execFileSync(file, args, { encoding: 'utf8', timeout, maxBuffer: 8 * 1024 * 1024 });
+  } catch {
+    return '';
+  }
+}
+
+function listProcesses() {
+  const output = runText('ps', ['-A', '-o', 'pid=,ppid=,etime=,pcpu=,command=']);
+  const rows = [];
+  for (const line of output.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(\S+)\s+([0-9.]+)\s+(.+)$/);
+    if (!match) continue;
+    rows.push({
+      pid: Number(match[1]),
+      ppid: Number(match[2]),
+      etime: match[3],
+      ageSeconds: parseElapsedToSeconds(match[3]),
+      cpu: Number(match[4]) || 0,
+      command: match[5].trim(),
+    });
+  }
+  return rows;
+}
+
+function lsofBinary() {
+  return findExecutable(['lsof', '/usr/sbin/lsof', '/usr/bin/lsof']);
+}
+
+function pidsListeningOnPort(port, lsof = lsofBinary()) {
+  if (!port || PROTECTED_PORTS.has(Number(port))) return [];
+  const output = runText(lsof, [`-tiTCP:${port}`, '-sTCP:LISTEN', '-nP']);
+  return [...new Set(output.split(/\s+/).map(n => Number(n)).filter(Number.isInteger))];
+}
+
+function processDetails(pid, lsof = lsofBinary()) {
+  const output = runText(lsof, ['-Pan', '-p', String(pid)], 2000);
+  const ports = [];
+  const paths = [];
+  for (const line of output.split(/\r?\n/)) {
+    const portMatch = line.match(/TCP\s+\S+:(\d+)\s+\(LISTEN\)/);
+    if (portMatch) ports.push(Number(portMatch[1]));
+    const pathMatch = line.match(/\s(\/(?:private\/)?tmp\/(?:walle|ctm)-[^ ]+)/);
+    if (pathMatch) paths.push(pathMatch[1]);
+  }
+  return { ports: [...new Set(ports)], paths: [...new Set(paths)] };
+}
+
+function isProtectedProcess(proc, details = {}) {
+  if (/^(ctm|walle)-primary\b/.test(proc.command)) return true;
+  return (details.ports || []).some(port => PROTECTED_PORTS.has(Number(port)));
+}
+
+function titleKind(command) {
+  if (/^ctm-dev-\d+\b/.test(command)) return 'ctm-dev';
+  if (/^walle-dev-\d+\b/.test(command)) return 'walle-dev';
+  if (/^ctm-(?:badge-test|render-test|e2e|test)(?:[-\w]*)?\b/.test(command)) return 'ctm-test';
+  if (/^walle-(?:staging|render-test|e2e|test)(?:[-\w]*)?\b/.test(command)) return 'walle-test';
+  return null;
+}
+
+function commandMatchesExactPort(command, port, wallePort) {
+  if (PROTECTED_PORTS.has(Number(port)) || PROTECTED_PORTS.has(Number(wallePort))) return false;
+  if (port && (command === `ctm-dev-${port}` || command === `walle-dev-${port}`)) return true;
+  if (wallePort && command === `walle-dev-${Number(wallePort) - 1}`) return true;
+  return false;
+}
+
+function tempBacked(details) {
+  return (details.paths || []).some(p =>
+    /\/(?:private\/)?tmp\/(?:walle-dev|walle-staging|walle-e2e|ctm-dev|ctm-worktree|ctm-render-test|ctm-e2e)(?:[-/]|$)/.test(p)
+  );
+}
+
+function collectTargets(procs, opts, detailsByPid = new Map()) {
+  const maxAgeSeconds = Math.max(0, Number(opts.maxAgeMin || DEFAULT_MAX_AGE_MIN)) * 60;
+  const exactPortPids = new Set([
+    ...pidsListeningOnPort(opts.port).filter(pid => Number.isInteger(pid)),
+    ...pidsListeningOnPort(opts.wallePort).filter(pid => Number.isInteger(pid)),
+  ]);
+
+  const targets = [];
+  const kept = [];
+
+  for (const proc of procs) {
+    const kind = titleKind(proc.command);
+    const maybeExact = exactPortPids.has(proc.pid) || commandMatchesExactPort(proc.command, opts.port, opts.wallePort);
+    if (!kind && !maybeExact) continue;
+
+    const details = detailsByPid.get(proc.pid) || processDetails(proc.pid);
+    detailsByPid.set(proc.pid, details);
+
+    if (isProtectedProcess(proc, details)) {
+      kept.push({ ...proc, reason: 'protected primary CTM/Wall-E' });
+      continue;
+    }
+
+    if (maybeExact) {
+      targets.push({ ...proc, reason: 'matching requested dev port', details });
+      continue;
+    }
+
+    if (!opts.stale) {
+      kept.push({ ...proc, reason: `${kind} candidate; stale sweep disabled`, details });
+      continue;
+    }
+
+    const oldEnough = proc.ageSeconds >= maxAgeSeconds;
+    const orphaned = proc.ppid === 1 && tempBacked(details);
+    if (oldEnough || orphaned) {
+      targets.push({
+        ...proc,
+        reason: oldEnough ? `stale ${kind} older than ${opts.maxAgeMin}m` : `orphaned temp-backed ${kind}`,
+        details,
+      });
+    } else {
+      kept.push({ ...proc, reason: `${kind} below stale threshold`, details });
+    }
+  }
+
+  return { targets, kept };
+}
+
+function killTargets(targets) {
+  const killedByPid = new Map();
+  for (const proc of targets) {
+    try {
+      process.kill(proc.pid, 'SIGTERM');
+      killedByPid.set(proc.pid, { ...proc, signal: 'SIGTERM' });
+    } catch {}
+  }
+  const deadline = Date.now() + 1500;
+  while (Date.now() < deadline) {
+    const alive = targets.filter(proc => {
+      try { process.kill(proc.pid, 0); return true; } catch { return false; }
+    });
+    if (alive.length === 0) return [...killedByPid.values()];
+  }
+  for (const proc of targets) {
+    try {
+      process.kill(proc.pid, 0);
+      process.kill(proc.pid, 'SIGKILL');
+      const previous = killedByPid.get(proc.pid);
+      killedByPid.set(proc.pid, { ...(previous || proc), signal: previous ? 'SIGTERM+SIGKILL' : 'SIGKILL' });
+    } catch {}
+  }
+  return [...killedByPid.values()];
+}
+
+function formatReport(result, opts) {
+  if (opts.json) return JSON.stringify(result, null, 2);
+  const action = opts.kill ? 'Cleaned' : 'Would clean';
+  const lines = [`${action} ${result.killed.length || result.targets.length} CTM/Wall-E dev process(es); kept ${result.kept.length}.`];
+  const visibleTargets = opts.kill ? result.killed : result.targets;
+  if (visibleTargets.length > 0) {
+    lines.push('');
+    lines.push(opts.kill ? 'Killed:' : 'Targets:');
+    for (const p of visibleTargets) {
+      const ports = p.details && p.details.ports && p.details.ports.length ? ` ports=${p.details.ports.join(',')}` : '';
+      lines.push(`  PID ${p.pid} ${p.command} (${p.cpu}% CPU, age ${p.etime}) - ${p.reason}${ports}`);
+    }
+  }
+  if (result.kept.length > 0) {
+    lines.push('');
+    lines.push('Kept:');
+    for (const p of result.kept) {
+      lines.push(`  PID ${p.pid} ${p.command} - ${p.reason}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function main(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv);
+  if (opts.help) {
+    console.log([
+      'Usage: node bin/ctm-dev-cleanup.js [--kill] [--stale] [--max-age-min N] [--port N --wall-e-port N] [--json]',
+      '',
+      'Dry-runs by default. Never targets ctm-primary/walle-primary or ports 3456/3457.',
+    ].join('\n'));
+    return 0;
+  }
+  const detailsByPid = new Map();
+  const { targets, kept } = collectTargets(listProcesses(), opts, detailsByPid);
+  const killed = opts.kill ? killTargets(targets) : [];
+  const result = { targets, killed, kept };
+  console.log(formatReport(result, opts));
+  return 0;
+}
+
+if (require.main === module) {
+  process.exitCode = main();
+}
+
+module.exports = {
+  collectTargets,
+  commandMatchesExactPort,
+  formatReport,
+  isProtectedProcess,
+  killTargets,
+  parseArgs,
+  parseElapsedToSeconds,
+  tempBacked,
+  titleKind,
+};

package/template/bin/dev.sh

@@ -27,6 +27,15 @@ fi
 mkdir -p "$DEV_DIR"
 
 cleanup_processes() {
+  local stale_args=()
+  if [[ "${1:-}" == "--stale" ]]; then
+    stale_args=(--stale --max-age-min "${CTM_DEV_STALE_MAX_MIN:-1440}")
+  fi
+  node "$ROOT/bin/ctm-dev-cleanup.js" \
+    --kill \
+    --port "$DEV_CTM_PORT" \
+    --wall-e-port "$DEV_WALLE_PORT" \
+    "${stale_args[@]}" >/dev/null 2>&1 || true
   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
@@ -35,6 +44,10 @@ cleanup_processes() {
 }
 
 cleanup_dev() {
+  node "$ROOT/bin/ctm-dev-cleanup.js" \
+    --kill \
+    --port "$DEV_CTM_PORT" \
+    --wall-e-port "$DEV_WALLE_PORT" >/dev/null 2>&1 || true
   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
@@ -43,7 +56,7 @@ cleanup_dev() {
   fi
 }
 
-cleanup_processes
+cleanup_processes --stale
 
 # Handle flags
 if [[ "$1" == "--fresh" || -z "$1" ]]; then
@@ -81,14 +94,39 @@ export WALL_E_SESSIONS_DIR="$DEV_DIR/sessions"
 export CTM_HOST="127.0.0.1"
 export CTM_INSTANCE_TAG="dev-$DEV_CTM_PORT"
 export OAUTH_PROXY_PORT="$DEV_OAUTH_PROXY_PORT"
+export CTM_TLS_CERT=""
+export CTM_TLS_KEY=""
+# Dev instances must not rewrite user-level Codex/Claude MCP config to their
+# temporary Wall-E port. Set WALLE_MCP_AUTO_CONFIG=1 to opt in deliberately.
+export WALLE_MCP_AUTO_CONFIG="${WALLE_MCP_AUTO_CONFIG:-0}"
 
 # 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|WALLE_SESSIONS_DIR|WALL_E_SESSIONS_DIR|CTM_HOST|CTM_INSTANCE_TAG|OAUTH_PROXY_PORT)=' | grep '=')
+  source <(grep -v '^#' "$ROOT/.env" | grep -vE '^(CTM_PORT|WALL_E_PORT|CTM_DATA_DIR|WALL_E_DATA_DIR|WALLE_SESSIONS_DIR|WALL_E_SESSIONS_DIR|CTM_HOST|CTM_INSTANCE_TAG|OAUTH_PROXY_PORT|CTM_TLS_CERT|CTM_TLS_KEY|CTM_API_BASE_URL|CTM_SESSION_MEMORY_API_BASE_URL|WALLE_MCP_AUTO_CONFIG|CTM_SKIP_DOTENV)=' | grep '=')
   set +a
 fi
 
+# Reassert the dev isolation boundary after loading production credentials.
+# Some user .env files contain TLS/public-host settings for the primary CTM;
+# the dev instance must stay loopback HTTP so Wall-E's internal CTM API probe,
+# browser tests, and curl checks hit the isolated data dir instead.
+export CTM_PORT="$DEV_CTM_PORT"
+export WALL_E_PORT="$DEV_WALLE_PORT"
+export CTM_DATA_DIR="$DEV_DIR"
+export WALL_E_DATA_DIR="$DEV_DIR"
+export WALLE_SESSIONS_DIR="$DEV_DIR/sessions"
+export WALL_E_SESSIONS_DIR="$DEV_DIR/sessions"
+export CTM_HOST="127.0.0.1"
+export CTM_INSTANCE_TAG="dev-$DEV_CTM_PORT"
+export OAUTH_PROXY_PORT="$DEV_OAUTH_PROXY_PORT"
+export CTM_TLS_CERT=""
+export CTM_TLS_KEY=""
+export CTM_API_BASE_URL="http://127.0.0.1:$DEV_CTM_PORT"
+export CTM_SESSION_MEMORY_API_BASE_URL="http://127.0.0.1:$DEV_CTM_PORT"
+export WALLE_MCP_AUTO_CONFIG="${WALLE_MCP_AUTO_CONFIG:-0}"
+export CTM_SKIP_DOTENV="1"
+
 trap cleanup_dev EXIT
 
 # Clean up stale dev/e2e data dirs older than 24h (from crashed sessions)