create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/lib/update-telemetry.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const SERVER_EVENTS = new Set([
+  'check_started',
+  'check_completed',
+  'check_failed',
+  'update_available',
+  'api_check',
+  'apply_requested',
+  'apply_ignored',
+  'apply_started',
+  'apply_spawn_error',
+]);
+
+const CLIENT_EVENTS = new Set([
+  'ui_prompt_shown',
+  'ui_action',
+]);
+
+const SURFACES = new Set(['banner', 'wizard', 'api', 'startup', 'scheduled', 'manual', 'unknown']);
+const ACTIONS = new Set(['later', 'skip', 'apply', 'apply_started', 'apply_failed', 'already_up_to_date']);
+const RESULTS = new Set(['available', 'up_to_date', 'error', 'started', 'ignored']);
+
+function cleanEnum(value, allowed, fallback = 'unknown') {
+  const normalized = String(value || '').trim().toLowerCase().replace(/[^a-z0-9_-]/g, '_');
+  return allowed.has(normalized) ? normalized : fallback;
+}
+
+function cleanVersion(value) {
+  const raw = String(value || '').trim().replace(/^v/i, '');
+  if (!raw || raw.length > 64) return '';
+  return /^[0-9A-Za-z.+_-]+$/.test(raw) ? raw : '';
+}
+
+function cleanBool(value) {
+  return value === true ? true : value === false ? false : undefined;
+}
+
+function errorKind(error) {
+  const message = String(error?.message || error || '').toLowerCase();
+  if (!message) return 'unknown';
+  if (/timeout|timed out|abort/.test(message)) return 'timeout';
+  if (/network|fetch|enotfound|eai_again|econn|socket/.test(message)) return 'network';
+  if (/npm registry returned 4\d\d/.test(message)) return 'registry_client_error';
+  if (/npm registry returned 5\d\d/.test(message)) return 'registry_server_error';
+  if (/spawn|enoent/.test(message)) return 'spawn_error';
+  return 'error';
+}
+
+function sanitizePayload(details = {}) {
+  const payload = {};
+  const source = cleanEnum(details.source, SURFACES, '');
+  const surface = cleanEnum(details.surface, SURFACES, '');
+  const action = cleanEnum(details.action, ACTIONS, '');
+  const result = cleanEnum(details.result, RESULTS, '');
+  const currentVersion = cleanVersion(details.currentVersion || details.current || details.current_version);
+  const latestVersion = cleanVersion(details.latestVersion || details.latest || details.latest_version);
+  const updateAvailable = cleanBool(details.updateAvailable);
+
+  if (source) payload.source = source;
+  if (surface) payload.surface = surface;
+  if (action) payload.action = action;
+  if (result) payload.result = result;
+  if (currentVersion) payload.current_version = currentVersion;
+  if (latestVersion) payload.latest_version = latestVersion;
+  if (updateAvailable !== undefined) payload.update_available = updateAvailable;
+  if (details.error || details.errorKind) payload.error_kind = details.errorKind || errorKind(details.error);
+
+  return payload;
+}
+
+function trackUpdateTelemetry(telemetry, event, details = {}) {
+  const normalized = cleanEnum(event, new Set([...SERVER_EVENTS, ...CLIENT_EVENTS]), '');
+  if (!normalized) return false;
+  try {
+    telemetry?.track?.(`ctm_update_${normalized}`, sanitizePayload(details));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function clientUpdateTelemetryEvent(body = {}) {
+  const rawEvent = String(body.event || '').trim().toLowerCase();
+  if (rawEvent === 'prompt_shown') {
+    return {
+      event: 'ui_prompt_shown',
+      details: sanitizePayload({
+        surface: body.surface,
+        currentVersion: body.currentVersion,
+        latestVersion: body.latestVersion,
+      }),
+    };
+  }
+  if (rawEvent === 'action') {
+    return {
+      event: 'ui_action',
+      details: sanitizePayload({
+        surface: body.surface,
+        action: body.action,
+        currentVersion: body.currentVersion,
+        latestVersion: body.latestVersion,
+      }),
+    };
+  }
+  return null;
+}
+
+module.exports = {
+  clientUpdateTelemetryEvent,
+  errorKind,
+  sanitizePayload,
+  trackUpdateTelemetry,
+};

package/template/claude-task-manager/lib/walle-ctm-history.js

@@ -12,7 +12,7 @@ function applyWalleToolEvent(toolCalls, event) {
     toolCalls.push({
       name: event.tool || event.name || 'tool',
       summary: event.summary || '',
-      args: event.args || null,
+      args: event.args || event.input || null,
       status: 'working',
       output: '',
     });
@@ -29,6 +29,47 @@ function applyWalleToolEvent(toolCalls, event) {
   return toolCalls;
 }
 
+function extractText(content) {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block && block.type === 'text' && block.text)
+      .map((block) => block.text)
+      .join('\n');
+  }
+  if (typeof content.text === 'string') return content.text;
+  return '';
+}
+
+function messageText(entry) {
+  if (!entry || typeof entry !== 'object') return '';
+  if (entry.message && entry.message.content !== undefined) return extractText(entry.message.content);
+  if (entry.content !== undefined) return extractText(entry.content);
+  return '';
+}
+
+function normalizeToolEvent(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  if (entry.type === 'tool_call' || entry.type === 'tool_result' || entry.type === 'tool_done') {
+    return entry;
+  }
+  if (entry.type !== 'walle_part') return null;
+  const data = entry.data && typeof entry.data === 'object' ? entry.data : {};
+  if (entry.partType !== 'tool_call' && entry.partType !== 'tool_result' && entry.partType !== 'tool_done') return null;
+  return {
+    type: entry.partType,
+    tool: data.tool || data.name || 'tool',
+    name: data.name || data.tool || 'tool',
+    summary: data.summary || '',
+    args: data.args || data.input || null,
+    input: data.input || data.args || null,
+    output: data.output || data.result || '',
+    result: data.result || data.output || '',
+    error: data.error || null,
+  };
+}
+
 function readWalleCtmHistory(filePath) {
   let raw = '';
   try { raw = fs.readFileSync(filePath, 'utf8'); } catch { return []; }
@@ -41,20 +82,21 @@ function readWalleCtmHistory(filePath) {
     if (entry.type === 'user') {
       messages.push({
         role: 'user',
-        content: entry.content || '',
+        content: messageText(entry),
         timestamp: entry.timestamp || 0,
       });
       continue;
     }
-    if (entry.type === 'tool_call' || entry.type === 'tool_result' || entry.type === 'tool_done') {
-      applyWalleToolEvent(pendingToolCalls, entry);
+    const toolEvent = normalizeToolEvent(entry);
+    if (toolEvent) {
+      applyWalleToolEvent(pendingToolCalls, toolEvent);
       continue;
     }
     if (entry.type === 'assistant') {
       messages.push({
         role: 'assistant',
-        content: entry.content || '',
-        model: entry.model || '',
+        content: messageText(entry),
+        model: entry.message?.model || entry.model || entry.modelId || '',
         latency_ms: entry.latencyMs || entry.latency_ms || 0,
         timestamp: entry.timestamp || 0,
         toolCalls: entry.toolCalls || cloneToolCalls(pendingToolCalls),
@@ -68,5 +110,6 @@ function readWalleCtmHistory(filePath) {
 module.exports = {
   applyWalleToolEvent,
   cloneToolCalls,
+  extractText,
   readWalleCtmHistory,
 };

package/template/claude-task-manager/lib/walle-default-model.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { sanitizeSetupProviderType } = require('./setup-provider-config');
+
+function _kv(brain, key) {
+  try {
+    if (brain && typeof brain.getKv === 'function') return brain.getKv(key) || '';
+    if (brain && typeof brain.getDb === 'function') {
+      return brain.getDb().prepare('SELECT value FROM brain_metadata WHERE key = ?').get(key)?.value || '';
+    }
+  } catch (e) {
+    if (process.env.CTM_DEBUG_WALLE_DEFAULTS === '1') {
+      console.warn('[walle-default-model] metadata lookup failed:', e.message);
+    }
+  }
+  return '';
+}
+
+function _providerDefault(provider, providerRegistry) {
+  if (!provider) return '';
+  try {
+    const registry = providerRegistry || require('../../wall-e/llm/registry');
+    if (typeof registry.ensureBootstrapped === 'function') registry.ensureBootstrapped();
+    return registry.getDefaultModel(provider) || '';
+  } catch (e) {
+    if (process.env.CTM_DEBUG_WALLE_DEFAULTS === '1') {
+      console.warn('[walle-default-model] provider default lookup failed:', e.message);
+    }
+    return '';
+  }
+}
+
+function resolveWalleDefaultModelSelection(opts = {}) {
+  const env = opts.env || process.env;
+  const brain = opts.brain || null;
+  const provider = sanitizeSetupProviderType(
+    _kv(brain, 'walle_provider')
+      || env.WALLE_PROVIDER
+      || 'anthropic'
+  ) || 'anthropic';
+  const model = _kv(brain, 'walle_model_' + provider)
+    || _kv(brain, 'walle_model')
+    || env.WALLE_MODEL
+    || _providerDefault(provider, opts.providerRegistry)
+    || '';
+
+  return {
+    model_id: model,
+    model_provider: provider,
+  };
+}
+
+module.exports = {
+  resolveWalleDefaultModelSelection,
+};

package/template/claude-task-manager/lib/walle-mcp-auto-config.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const path = require('path');
+
+let lastEnsureAt = 0;
+
+function isMcpAutoConfigDisabled(env = process.env) {
+  const value = String(env.WALLE_MCP_AUTO_CONFIG || '').toLowerCase();
+  return value === '0' || value === 'false' || value === 'off';
+}
+
+function isMcpCapableAgentCommand(cmd) {
+  const base = path.basename(String(cmd || '')).toLowerCase();
+  return base === 'claude' || base === 'codex';
+}
+
+function loadMcpIntegration() {
+  return require(path.resolve(__dirname, '..', '..', 'wall-e', 'lib', 'mcp-integration'));
+}
+
+function ensureWalleMcpForAgentSession({
+  cmd,
+  wallePort,
+  homeDir,
+  env = process.env,
+  logger = console,
+  now = Date.now(),
+  minIntervalMs = 30000,
+} = {}) {
+  if (!isMcpCapableAgentCommand(cmd)) return { skipped: 'not_mcp_capable_agent' };
+  if (isMcpAutoConfigDisabled(env)) return { skipped: 'disabled' };
+  if (lastEnsureAt && now - lastEnsureAt < minIntervalMs) return { skipped: 'throttled' };
+  lastEnsureAt = now;
+
+  try {
+    const { ensureMcpIntegrations } = loadMcpIntegration();
+    const results = ensureMcpIntegrations(wallePort, { homeDir: homeDir || env.HOME || process.env.HOME });
+    const changed = results.filter(r => r.kind === 'mcp_config' && (r.action === 'added' || r.action === 'updated'));
+    const instructionChanged = results.filter(r => r.kind === 'agent_instructions' && (r.action === 'added' || r.action === 'updated'));
+    const errors = results.filter(r => r.action === 'error');
+    if (changed.length) {
+      logger.log(`[ctm] Auto-configured Wall-E MCP for ${changed.length} AI tool(s) before agent launch`);
+    }
+    if (instructionChanged.length) {
+      logger.log(`[ctm] Updated Wall-E memory-routing instructions for ${instructionChanged.length} AI agent(s) before launch`);
+    }
+    if (errors.length) {
+      logger.warn(`[ctm] Wall-E MCP auto-config skipped ${errors.length} invalid config file(s): ${errors.map(r => r.tool).join(', ')}`);
+    }
+    return { results, changed: changed.length, instructionChanged: instructionChanged.length, errors: errors.length };
+  } catch (err) {
+    logger.warn(`[ctm] Wall-E MCP auto-config failed: ${err.message}`);
+    return { error: err.message };
+  }
+}
+
+function _resetWalleMcpAutoConfigState() {
+  lastEnsureAt = 0;
+}
+
+module.exports = {
+  ensureWalleMcpForAgentSession,
+  isMcpAutoConfigDisabled,
+  isMcpCapableAgentCommand,
+  _resetWalleMcpAutoConfigState,
+};

package/template/claude-task-manager/lib/walle-supervisor.js

@@ -66,6 +66,7 @@ const defaultProcessOps = {
 function createWalleSupervisor({
   ctmDir,
   configDir,
+  ctmPort = process.env.CTM_PORT || 3456,
   wallePort,
   instanceTag,
   walleToken = null,
@@ -124,6 +125,44 @@ function createWalleSupervisor({
     return pidSet;
   }
 
+  function readPidFile() {
+    try {
+      const pid = parseInt(fs.readFileSync(pidFile(), 'utf8').trim(), 10);
+      return pid || null;
+    } catch {
+      return null;
+    }
+  }
+
+  function isAlive(pid) {
+    if (!pid || pid === (processOps.pid || process.pid)) return false;
+    try {
+      processOps.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function writePidFile(pid) {
+    try {
+      fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(pidFile(), String(pid));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function removePidFile() {
+    try {
+      fs.unlinkSync(pidFile());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   async function killAll() {
     const pidSet = await collectManagedPids();
     if (pidSet.size === 0) return waitForPortFree();
@@ -175,6 +214,8 @@ function createWalleSupervisor({
 
     const childEnv = {
       ...process.env,
+      CTM_PORT: String(ctmPort),
+      CTM_API_BASE_URL: `http://127.0.0.1:${ctmPort}`,
       WALL_E_PORT: String(wallePort),
       WALLE_INSTANCE_TAG: instanceTag,
     };
@@ -225,27 +266,53 @@ function createWalleSupervisor({
     return nextChild.pid;
   }
 
-  function getStatus() {
-    let running = false;
-    let pid = null;
-    if (childPid) {
-      try {
-        process.kill(childPid, 0);
-        running = true;
-        pid = childPid;
-      } catch {}
+  async function getStatus() {
+    const savedPid = readPidFile();
+    let stalePid = null;
+
+    if (childPid && isAlive(childPid)) {
+      return {
+        running: true,
+        pid: childPid,
+        pidSource: 'child',
+        stalePid: savedPid && savedPid !== childPid ? savedPid : null,
+        repairedPidFile: savedPid !== childPid ? writePidFile(childPid) : false,
+      };
     }
-    if (!running) {
-      try {
-        const orphanPid = parseInt(fs.readFileSync(pidFile(), 'utf8').trim(), 10);
-        if (orphanPid && orphanPid !== process.pid) {
-          process.kill(orphanPid, 0);
-          running = true;
-          pid = orphanPid;
-        }
-      } catch {}
+
+    if (savedPid && isAlive(savedPid)) {
+      return { running: true, pid: savedPid, pidSource: 'pid_file' };
     }
-    return { running, pid };
+    if (savedPid) stalePid = savedPid;
+
+    const title = processTitle();
+    let discovered = [];
+    try {
+      const results = await Promise.all([
+        processOps.findPidsByExactCommand ? processOps.findPidsByExactCommand(title) : [],
+        processOps.findListeningPidsByExactCommand ? processOps.findListeningPidsByExactCommand(wallePort, title) : [],
+      ]);
+      discovered = [...new Set(results.flat().filter(pid => pid && isAlive(pid)))];
+    } catch {}
+
+    if (discovered.length > 0) {
+      const pid = discovered[0];
+      return {
+        running: true,
+        pid,
+        pidSource: 'discovered',
+        stalePid,
+        repairedPidFile: writePidFile(pid),
+      };
+    }
+
+    return {
+      running: false,
+      pid: null,
+      pidSource: stalePid ? 'stale_pid_file' : 'none',
+      stalePid,
+      removedStalePidFile: stalePid ? removePidFile() : false,
+    };
   }
 
   function apiStop(req, res) {

package/template/claude-task-manager/lib/walle-transcript.js

@@ -15,9 +15,7 @@ function defaultSessionsDir(env = process.env) {
   if (env.WALL_E_DATA_DIR && env.WALL_E_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
     return path.join(env.WALL_E_DATA_DIR, 'sessions');
   }
-  if (env.CTM_DATA_DIR && env.CTM_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
-    return path.join(env.CTM_DATA_DIR, 'sessions');
-  }
+  // CTM_DATA_DIR belongs to the task manager; Wall-E transcripts stay in Wall-E-owned storage.
   return path.join(os.homedir(), '.walle', 'sessions');
 }
 

package/template/claude-task-manager/lib/worktree-cwd.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+function fail(error, status) {
+  return { ok: false, status: status || 400, error };
+}
+
+function gitText(cwd, args) {
+  return execFileSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 5000,
+  }).trim();
+}
+
+function firstWorktreePath(porcelain) {
+  for (const line of String(porcelain || '').split('\n')) {
+    if (line.startsWith('worktree ')) return line.slice('worktree '.length).trim();
+  }
+  return '';
+}
+
+function realpathOrResolve(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch (_) {
+    return path.resolve(p);
+  }
+}
+
+function resolveWorktreeRepoRoot(cwd) {
+  if (typeof cwd !== 'string' || !cwd.trim()) return fail('cwd is required');
+  const raw = cwd.trim();
+  if (raw.includes('~')) {
+    return fail('cwd must be an absolute path with no `~` (the literal-tilde is the source of ghost worktrees).');
+  }
+  if (!path.isAbsolute(raw)) return fail('cwd must be an absolute path');
+
+  let realCwd;
+  try {
+    realCwd = fs.realpathSync(raw);
+  } catch (_) {
+    return fail('cwd does not exist');
+  }
+
+  let stat;
+  try {
+    stat = fs.statSync(realCwd);
+  } catch (_) {
+    return fail('cwd does not exist');
+  }
+  if (!stat.isDirectory()) return fail('cwd must be a directory');
+
+  let topLevel;
+  try {
+    topLevel = gitText(realCwd, ['rev-parse', '--show-toplevel']);
+  } catch (_) {
+    return fail('cwd must be inside a Git work tree');
+  }
+  if (!topLevel) return fail('cwd must be inside a Git work tree');
+
+  let primaryRoot = '';
+  try {
+    primaryRoot = firstWorktreePath(gitText(realCwd, ['worktree', 'list', '--porcelain']));
+  } catch (_) {
+    primaryRoot = '';
+  }
+
+  return {
+    ok: true,
+    cwd: realpathOrResolve(primaryRoot || topLevel),
+    requestedCwd: realCwd,
+  };
+}
+
+module.exports = {
+  resolveWorktreeRepoRoot,
+};

package/template/claude-task-manager/package.json

@@ -22,6 +22,7 @@
     "dev": "node server.js --dev",
     "test": "node --test --test-force-exit \"tests/*.test.js\" \"tests/**/*.test.js\"",
     "test:render": "npx playwright test --config tests/rendering/playwright.config.js --grep-invert 'soak'",
+    "test:session-ux-smoke": "npx playwright test --config tests/rendering/playwright.config.js scenarios/blank-tab-retry-recovery.spec.js scenarios/blank-tab-worker-saturation.spec.js scenarios/codex-panel-restore-gap.spec.js scenarios/codex-clear-scrollback.spec.js scenarios/session-status-typing.spec.js scenarios/session-search-dedupe.spec.js scenarios/walle-session-default-model.spec.js --retries=0",
     "test:render:blank": "npx playwright test --config tests/rendering/playwright.config.js scenarios/blank-tab-real-click.spec.js --retries=0",
     "test:render:blank:native": "CTM_RENDER_NATIVE_GPU=1 npx playwright test --config tests/rendering/playwright.config.js scenarios/blank-tab-real-click.spec.js --headed --retries=0",
     "test:soak": "SOAK_DURATION_MINUTES=5 npx playwright test --config tests/rendering/playwright.config.js --grep 'soak'"

package/template/claude-task-manager/providers/codex-mcp.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// Codex MCP permission form:
+//
+//   Calling wall-e.walle_memory_status({})
+//   Field 1/1 ...
+//   Allow the wall-e MCP server to run tool "walle_memory_status"?
+//   1. Allow
+//   2. Allow for this session
+//   3. Always allow
+//   4. Cancel
+//   enter to submit | esc to cancel
+
+const CALLING_RE = /\bCalling\s+([A-Za-z0-9_.-]+)\.([A-Za-z0-9_.-]+)\s*\(/i;
+const QUESTION_RE = /Allow the ([A-Za-z0-9_.-]+) MCP server to run tool ["']?([A-Za-z0-9_.-]+)["']?\?/i;
+const ANCHOR_RE = /enter to submit\s*\|\s*esc to cancel/i;
+const ALLOW_RE = /^\s*[❯›> ]?\s*1\.\s*Allow\b/i;
+const OPTION_RE = /^\s*[❯›> ]?\s*(\d+)\.\s*(Allow for this session|Always allow|Allow|Cancel)\b/i;
+
+function extractMcpTool(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const q = lines[i].match(QUESTION_RE);
+    if (q) return { server: q[1], tool: q[2], questionIdx: i };
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const c = lines[i].match(CALLING_RE);
+    if (c) return { server: c[1], tool: c[2], questionIdx: -1 };
+  }
+  return null;
+}
+
+function parseOptions(lines) {
+  const out = {
+    allowShortcut: '1',
+    sessionShortcut: null,
+    alwaysShortcut: null,
+  };
+
+  for (const line of lines) {
+    const match = line.match(OPTION_RE);
+    if (!match) continue;
+    const index = match[1];
+    const label = match[2].toLowerCase();
+    if (label === 'allow for this session') out.sessionShortcut = index;
+    else if (label === 'always allow') out.alwaysShortcut = index;
+    else if (label === 'allow') out.allowShortcut = index;
+  }
+  return out;
+}
+
+module.exports = {
+  id: 'codex-mcp',
+  name: 'Codex MCP Permission',
+
+  detect(text) {
+    const lines = String(text || '').split('\n').map(l => l.trim()).filter(Boolean);
+    if (lines.length < 5) return false;
+    if (!lines.slice(-5).some(l => ANCHOR_RE.test(l))) return false;
+    if (!lines.some(l => ALLOW_RE.test(l))) return false;
+    return lines.some(l => QUESTION_RE.test(l)) || lines.some(l => CALLING_RE.test(l));
+  },
+
+  parse(text) {
+    const lines = String(text || '').split('\n').map(l => l.trim()).filter(Boolean);
+    const mcp = extractMcpTool(lines);
+    if (!mcp) return null;
+
+    let allowIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (ALLOW_RE.test(lines[i])) { allowIdx = i; break; }
+    }
+    if (allowIdx < 0) return null;
+
+    const options = parseOptions(lines.slice(allowIdx, allowIdx + 8));
+    const ctxAnchor = mcp.questionIdx >= 0 ? mcp.questionIdx : allowIdx;
+    const ctxStart = Math.max(0, ctxAnchor - 5);
+    const ctxEnd = Math.min(lines.length, allowIdx + 8);
+    const command = `${mcp.server}.${mcp.tool}({})`;
+
+    return {
+      toolName: 'MCP',
+      command: command.slice(0, 2000),
+      warning: '',
+      fullContext: lines.slice(ctxStart, ctxEnd).join('\n').slice(0, 2000),
+      hasAllowAll: !!options.sessionShortcut,
+      approveShortcut: options.allowShortcut,
+      approveAllShortcut: options.sessionShortcut,
+      alwaysAllowShortcut: options.alwaysShortcut,
+      mcpServer: mcp.server,
+      mcpTool: mcp.tool,
+      providerId: 'codex-mcp',
+    };
+  },
+
+  approveKeystroke(ctx) {
+    return ctx.approveAllShortcut || ctx.approveShortcut || '1';
+  },
+
+  approveAllKeystroke(ctx) {
+    return ctx.approveAllShortcut || null;
+  },
+
+  requiresEnter: true,
+};

package/template/claude-task-manager/providers/index.js

@@ -4,6 +4,7 @@
 // Detection order: most distinctive signals first to minimize false positives.
 
 const claudeCode = require('./claude-code');
+const codexMcp = require('./codex-mcp');
 const codex = require('./codex');
 const gemini = require('./gemini');
 const amazonQ = require('./amazon-q');
@@ -19,6 +20,7 @@ const opencode = require('./opencode');
 // Numbered-widget providers (Claude Code, Codex, Cursor, OpenCode, Kimi)
 // run before inline [Y/n] providers (Gemini, Aider, Amazon Q, Cline, Copilot).
 const providers = [
+  codexMcp,
   claudeCode,
   codex,
   cursor,