create-walle 0.9.19 → 0.9.21

package/template/claude-task-manager/server.js

@@ -221,6 +221,7 @@ const {
   buildPendingExternalActionNotExecutedReply,
   extractLatestPendingExternalActions,
   externalActionCompletionClaim,
+  hasBlockedExternalActionGatewayToolResult,
   hasExecutedExternalActionToolResult,
 } = require('./lib/walle-external-actions');
 const { persistWalleSessionConversation } = require('./lib/walle-session-cache');
@@ -506,6 +507,15 @@ function _isBusyStatusPtyChunk(session, data) {
   return !!detector.isBusyStatusChunk(filtered);
 }
 
+function _hasBufferedBusyStatusPtyEvidence(session, data) {
+  const providerId = session?._providerId || _providerIdFromCmd(session?.cmd || '');
+  const detector = getStateDetector(providerId);
+  if (typeof detector.textHasCodexBusyStatus !== 'function') return false;
+  const buffer = String(session?._busyStatusEvidenceBuffer || '') + String(data || '');
+  if (session) session._busyStatusEvidenceBuffer = buffer.slice(-512);
+  return !!detector.textHasCodexBusyStatus(buffer);
+}
+
 // Tab activation/resize can trigger delayed TUI repaint frames. Those frames
 // should redraw the terminal, but they must not manufacture fresh activity.
 const CTM_UI_REFRESH_ACTIVITY_SUPPRESS_MS = 7000;
@@ -2747,6 +2757,7 @@ function _sendRemoteJson(res, status, payload) {
 }
 
 const REMOTE_TERMINAL_SUBMIT_DELAY_MS = 100;
+const REMOTE_TERMINAL_BUSY_STATUS_TTL_MS = 90 * 1000;
 
 function _remoteTerminalSubmissionText(text) {
   const normalized = String(text || '').replace(/\r\n?/g, '\n');
@@ -2754,32 +2765,120 @@ function _remoteTerminalSubmissionText(text) {
 }
 
 async function _sendRemoteTerminalSubmission(req, sessionId, text) {
+  const initialSession = sessions.get(sessionId);
+  const blocker = _remoteTerminalSubmissionBlocker(sessionId, initialSession);
+  if (blocker) {
+    recordSessionDiagnostic(sessionId, 'remote-terminal-submit-blocked', blocker);
+    try {
+      telemetry.track('remote_terminal_submit_blocked', {
+        session_id: String(sessionId || '').slice(0, 8),
+        error: blocker.error || 'blocked',
+        reason: blocker.reason || '',
+      });
+    } catch {}
+    return blocker;
+  }
+  initialSession._remoteTerminalSubmissionInFlight = true;
   const data = _remoteTerminalSubmissionText(text);
-  handleInput({ auth: req.ctmAuth }, { id: sessionId, data });
-  recordSessionDiagnostic(sessionId, 'remote-terminal-submit-text', {
-    chars: data.length,
-    enterDelayMs: REMOTE_TERMINAL_SUBMIT_DELAY_MS,
-  });
-  await new Promise((resolve) => setTimeout(resolve, REMOTE_TERMINAL_SUBMIT_DELAY_MS));
-  const session = sessions.get(sessionId);
+  try {
+    handleInput({ auth: req.ctmAuth }, { id: sessionId, data });
+    recordSessionDiagnostic(sessionId, 'remote-terminal-submit-text', {
+      chars: data.length,
+      enterDelayMs: REMOTE_TERMINAL_SUBMIT_DELAY_MS,
+    });
+    await new Promise((resolve) => setTimeout(resolve, REMOTE_TERMINAL_SUBMIT_DELAY_MS));
+    const session = sessions.get(sessionId);
+    if (!_isLiveTerminalSession(session)) {
+      recordSessionDiagnostic(sessionId, 'remote-terminal-submit-enter-skipped', { reason: 'session_not_live' });
+      return {
+        ok: false,
+        error: 'session_not_live',
+        message: 'The text reached the terminal, but the session stopped before CTM could press Enter.',
+      };
+    }
+    // Keep terminal submit as its own input frame. Codex/Claude-style TUIs run
+    // real line editors; CTM's local queue/review flows already use this same
+    // text-then-Enter contract so the editor can first commit the pasted text.
+    handleInput({ auth: req.ctmAuth }, { id: sessionId, data: '\r' });
+    recordSessionDiagnostic(sessionId, 'remote-terminal-submit-enter', { enterDelayMs: REMOTE_TERMINAL_SUBMIT_DELAY_MS });
+    return { ok: true, delivered: true, submitted: true };
+  } finally {
+    const latest = sessions.get(sessionId);
+    if (latest) latest._remoteTerminalSubmissionInFlight = false;
+  }
+}
+
+function _isLiveTerminalSession(session) {
+  return !!(session && session.ptyProcess && session.status !== 'exited' && session.status !== 'closed');
+}
+
+function _remoteTerminalAgentType(session) {
+  if (!session || session.type === 'walle') return '';
+  return normalizeAgentType(session.agentType || session._providerId || '') ||
+    detectAgentType(session.cmd || '') ||
+    _providerIdFromCmd(session.cmd || '') ||
+    'shell';
+}
+
+function _remoteTerminalRequiresReadyPrompt(session) {
+  return new Set(['claude', 'claude-code', 'codex', 'opencode', 'gemini', 'gemini-cli']).has(_remoteTerminalAgentType(session));
+}
+
+function _remoteTerminalSubmissionBlocker(sessionId, session, now = Date.now()) {
   if (!_isLiveTerminalSession(session)) {
-    recordSessionDiagnostic(sessionId, 'remote-terminal-submit-enter-skipped', { reason: 'session_not_live' });
     return {
       ok: false,
       error: 'session_not_live',
-      message: 'The text reached the terminal, but the session stopped before CTM could press Enter.',
+      message: 'This session is not accepting terminal input.',
     };
   }
-  // Keep terminal submit as its own input frame. Codex/Claude-style TUIs run
-  // real line editors; CTM's local queue/review flows already use this same
-  // text-then-Enter contract so the editor can first commit the pasted text.
-  handleInput({ auth: req.ctmAuth }, { id: sessionId, data: '\r' });
-  recordSessionDiagnostic(sessionId, 'remote-terminal-submit-enter', { enterDelayMs: REMOTE_TERMINAL_SUBMIT_DELAY_MS });
-  return { ok: true, delivered: true, submitted: true };
-}
+  if (session._remoteTerminalSubmissionInFlight) {
+    return {
+      ok: false,
+      error: 'session_input_in_flight',
+      message: 'Another phone reply is already being delivered to this session.',
+    };
+  }
+  if (!_remoteTerminalRequiresReadyPrompt(session)) return null;
 
-function _isLiveTerminalSession(session) {
-  return !!(session && session.ptyProcess && session.status !== 'exited' && session.status !== 'closed');
+  const waiting = _isServerWaitingForInput(sessionId, session, now);
+  const waitingReason = _standupWaitingReason(sessionId, session);
+  if (waiting && _standupIsBlockingWaitingReason(waitingReason)) {
+    return {
+      ok: false,
+      error: 'session_waiting_for_approval',
+      reason: waitingReason,
+      message: 'This session is waiting for an approval or choice. Respond to that prompt before sending a new message.',
+    };
+  }
+  if (waiting) return null;
+
+  let busState = '';
+  try {
+    busState = statusHooks._bus && typeof statusHooks._bus.getState === 'function'
+      ? statusHooks._bus.getState(sessionId)
+      : '';
+  } catch {}
+  if (busState === 'busy') {
+    return {
+      ok: false,
+      error: 'session_busy',
+      reason: 'status_bus_busy',
+      message: 'The agent is still working. CTM kept this phone reply queued instead of typing into a busy terminal.',
+    };
+  }
+
+  const busyAt = Number(session._lastBusyStatusAt || 0);
+  if (busyAt && (now - busyAt) < REMOTE_TERMINAL_BUSY_STATUS_TTL_MS) {
+    return {
+      ok: false,
+      error: 'session_busy',
+      reason: 'terminal_busy_status',
+      busyAgeMs: now - busyAt,
+      message: 'The terminal still shows the agent working. CTM kept this phone reply queued instead of typing into a busy terminal.',
+    };
+  }
+  return null;
 }
 
 function _remoteHostedPairingReady(status) {
@@ -2999,15 +3098,46 @@ async function handleRemoteApi(req, res, url) {
             if (session.type !== 'walle') return { ok: false, error: 'not_walle_session' };
             if (!text.trim()) return { ok: false, error: 'message_required' };
             const attachments = Array.isArray(body.attachments) ? body.attachments : [];
+            const explicitModel = body.model_id || body.model || '';
+            const explicitProvider = body.model_provider || body.provider || '';
             await handleWalleMessage({ auth: req.ctmAuth }, {
               id: sessionId,
               text,
               attachments,
               echoUser: true,
               displayText: text,
+              model: explicitModel || session.model_id || '',
+              provider: explicitProvider || session.model_provider || '',
+              model_registry_id: body.model_registry_id || body.modelRegistryId || session.model_registry_id || '',
+              modelPinned: body.modelPinned === true || body.model_pinned === true || !!explicitModel || !!session.model_pinned,
+              allowProviderFallback: explicitModel ? false : !session.model_pinned,
             });
             return { ok: true, delivered: true };
           },
+          setWalleModel: async (sessionId, body = {}) => {
+            const session = sessions.get(sessionId);
+            if (!session) return { ok: false, error: 'session_not_found' };
+            if (session.type !== 'walle') return { ok: false, error: 'not_walle_session' };
+            const pref = _persistWalleSessionModelPreference(session, {
+              model_id: body.model_id || body.model || '',
+              model_provider: body.model_provider || body.provider || '',
+              model_registry_id: body.model_registry_id || body.modelRegistryId || '',
+              model_provider_id: body.model_provider_id || body.provider_id || '',
+              scope: body.scope || 'session',
+              source: 'phone',
+              pinned: body.pinned !== false,
+            });
+            return {
+              ok: true,
+              delivered: true,
+              model_id: session.model_id || null,
+              model_provider: session.model_provider || null,
+              model_registry_id: session.model_registry_id || '',
+              model_provider_id: session.model_provider_id || '',
+              model_pinned: !!session.model_pinned,
+              cleared: !pref,
+            };
+          },
         },
       });
       _sendRemoteJson(res, result.ok ? 200 : 400, result);
@@ -11846,6 +11976,24 @@ if (ws.readyState === 1) ws.send(JSON.stringify(_streamEventWsPayload(_ctmIdForS
         if (msg.id && msg.model_id) {
           const session = sessions.get(msg.id);
           if (session) {
+            if (session.type === 'walle') {
+              try {
+                _persistWalleSessionModelPreference(session, {
+                  ...msg,
+                  source: msg.source || 'user',
+                  pinned: msg.pinned !== false,
+                });
+              } catch (e) {
+                if (ws.readyState === 1) {
+                  ws.send(JSON.stringify({
+                    type: 'toast',
+                    level: 'error',
+                    message: `Could not save Wall-E model preference: ${e.message}`,
+                  }));
+                }
+              }
+              return;
+            }
             session.model_id = msg.model_id;
             session.model_provider = msg.model_provider || null;
             // Persist so preference survives restart
@@ -11999,8 +12147,8 @@ async function dispatchQueuedWalleMessage(sessionId, text, options = {}) {
     source: 'queue',
     model: session.model_id || '',
     provider: session.model_provider || '',
-    modelPinned: false,
-    allowProviderFallback: true,
+    modelPinned: !!session.model_pinned,
+    allowProviderFallback: !session.model_pinned,
   });
 }
 
@@ -12554,6 +12702,8 @@ function checkIdleNotify(sessionId, session, data) {
               session._waitingForInputAt = waitingAt;
               session._lastNonResolvingWaitingInputAt = 0;
               session._lastWaitingResolveInputAt = 0;
+              session._lastBusyStatusAt = 0;
+              session._lastBusyStatusSource = reason ? `waiting:${reason}` : 'waiting';
               _markTerminalLifecycleChanged(session, `waiting-for-input:${reason}`);
             }
             // Provider hooks are useful, but a visible prompt is stronger evidence
@@ -13197,15 +13347,32 @@ function handleCreate(ws, msg) {
   if (agentType === 'walle') {
     // Override auto-generated shell label if user didn't provide one
     if (!msg.label) label = 'Wall-E session';
+    let model_registry_id = msg.model_registry_id || msg.modelRegistryId || '';
+    let model_provider_id = msg.model_provider_id || msg.provider_id || '';
+    let model_pinned = false;
+    try {
+      const pref = dbModule.getSessionModelPreference?.(id);
+      if (pref?.model_id) {
+        model_id = pref.model_id;
+        model_provider = pref.provider_type || model_provider || null;
+        model_registry_id = pref.registry_id || model_registry_id || '';
+        model_provider_id = pref.provider_id || model_provider_id || '';
+        model_pinned = pref.pinned !== false;
+      }
+    } catch (e) {
+      console.error('[walle-session] model preference restore error:', e.message);
+    }
     if (!model_id) {
       const defaults = resolveWalleDefaultModelSelection({ brain: getWalleBrain(), env: process.env });
       model_id = defaults.model_id || null;
       model_provider = defaults.model_provider || null;
+      model_pinned = false;
     }
     const agentMode = msg.agentMode || msg.agent_mode || 'coding';
     const agentKind = msg.agentKind || msg.agent_kind || (agentMode === 'coding' ? 'walle-coding' : 'walle-chat');
     const taskType = msg.taskType || msg.task_type || (agentMode === 'coding' ? 'coding' : 'chat');
     const chatSessionId = msg.chatSessionId || `walle-${id}`;
+    const initialMessage = String(msg.initialMessage || msg.initial_message || '').trim();
     const jsonlPath = _walleTranscriptPathForSession(id, chatSessionId);
     const createResult = walleTranscript.createSession(jsonlPath, {
       reset: !msg._isRestore,
@@ -13231,6 +13398,9 @@ function handleCreate(ws, msg) {
       chatSessionId, jsonlPath,
       abortController: null,
       model_id: model_id || null, model_provider: model_provider || null,
+      model_registry_id: model_registry_id || '',
+      model_provider_id: model_provider_id || '',
+      model_pinned,
       _walleLastTranscriptUuid: createResult?.uuid || walleTranscript.readLastUuid(jsonlPath) || null,
     };
     sessions.set(id, session);
@@ -13269,9 +13439,35 @@ function handleCreate(ws, msg) {
         sessionType: 'walle',
         model_id: session.model_id || null,
         model_provider: session.model_provider || null,
+        model_registry_id: session.model_registry_id || '',
+        model_provider_id: session.model_provider_id || '',
+        model_pinned: !!session.model_pinned,
       }));
     }
     broadcastSessionList(true);
+    if (initialMessage) {
+      setImmediate(() => {
+        handleWalleMessage(ws, {
+          type: 'walle-message',
+          id,
+          text: initialMessage,
+          echoUser: true,
+          source: 'new-session',
+          agentMode,
+          agentKind,
+          taskType,
+        }).catch((e) => {
+          console.error('[walle-session] initial prompt failed:', e.message);
+          if (ws && ws.readyState === 1) {
+            ws.send(JSON.stringify({
+              type: 'walle-error',
+              id,
+              error: e.message || 'Wall-E initial prompt failed',
+            }));
+          }
+        });
+      });
+    }
     return;
   }
 
@@ -14245,8 +14441,13 @@ function handleCreate(ws, msg) {
     const activeChunk = _isActivePtyChunk(session, data);
     const statusOnlyChunk = _isStatusOnlyPtyChunk(session, data);
     const busyStatusChunk = _isBusyStatusPtyChunk(session, data);
+    const busyStatusEvidenceChunk = busyStatusChunk || _hasBufferedBusyStatusPtyEvidence(session, data);
     const waitingForInput = _isServerWaitingForInput(id, session);
     const suppressedUiRefreshChunk = _suppressCtmUiRefreshActivity(session, statusOnlyChunk);
+    if (busyStatusEvidenceChunk) {
+      session._lastBusyStatusAt = Date.now();
+      session._lastBusyStatusSource = suppressedUiRefreshChunk ? 'pty-ui-refresh' : 'pty';
+    }
     const activityChunk = activeChunk && !suppressedUiRefreshChunk && !(statusOnlyChunk && waitingForInput && !busyStatusChunk);
     if (busyStatusChunk && waitingForInput && !suppressedUiRefreshChunk) _markServerSessionResumedFromPty(id, session, 'codex-working-status');
     if (activityChunk) {
@@ -14968,8 +15169,13 @@ function apiAttachSession(req, res) {
         const activeChunk = _isActivePtyChunk(session, data);
         const statusOnlyChunk = _isStatusOnlyPtyChunk(session, data);
         const busyStatusChunk = _isBusyStatusPtyChunk(session, data);
+        const busyStatusEvidenceChunk = busyStatusChunk || _hasBufferedBusyStatusPtyEvidence(session, data);
         const waitingForInput = _isServerWaitingForInput(tabId, session);
         const suppressedUiRefreshChunk = _suppressCtmUiRefreshActivity(session, statusOnlyChunk);
+        if (busyStatusEvidenceChunk) {
+          session._lastBusyStatusAt = Date.now();
+          session._lastBusyStatusSource = suppressedUiRefreshChunk ? 'attached-pty-ui-refresh' : 'attached-pty';
+        }
         const activityChunk = activeChunk && !suppressedUiRefreshChunk && !(statusOnlyChunk && waitingForInput && !busyStatusChunk);
         if (busyStatusChunk && waitingForInput && !suppressedUiRefreshChunk) _markServerSessionResumedFromPty(tabId, session, 'codex-working-status');
         if (activityChunk) {
@@ -15856,6 +16062,144 @@ function normalizeWalleClientModelSelection({ model, provider, session }) {
   return { model: selectedModel, provider: selectedProvider, note };
 }
 
+function _applyWalleSessionModelPreference(session, pref) {
+  if (!session || !pref || !pref.model_id) return false;
+  session.model_id = pref.model_id;
+  session.model_provider = pref.provider_type || session.model_provider || null;
+  session.model_registry_id = pref.registry_id || '';
+  session.model_provider_id = pref.provider_id || '';
+  session.model_pinned = pref.pinned !== false;
+  return true;
+}
+
+function _walleModelPayload(session, extra = {}) {
+  return {
+    type: 'walle-model',
+    id: session.id,
+    model_id: session.model_id || null,
+    model_provider: session.model_provider || null,
+    model_registry_id: session.model_registry_id || '',
+    model_provider_id: session.model_provider_id || '',
+    model_pinned: !!session.model_pinned,
+    ...extra,
+  };
+}
+
+function _broadcastWalleModel(session, extra = {}) {
+  if (!session || !session.clients) return;
+  const payload = JSON.stringify(_walleModelPayload(session, extra));
+  for (const client of session.clients) {
+    if (client.readyState === 1) client.send(payload);
+  }
+}
+
+function _hydrateWalleSessionModelPreference(session, { broadcast = false } = {}) {
+  if (!session || session.type !== 'walle') return null;
+  let pref = null;
+  try {
+    pref = dbModule.getSessionModelPreference?.(session.id) || null;
+  } catch (e) {
+    console.error('[walle-session] model preference read error:', e.message);
+    return null;
+  }
+  if (!_applyWalleSessionModelPreference(session, pref)) return null;
+  if (broadcast) _broadcastWalleModel(session, { model_source: 'session-preference' });
+  return pref;
+}
+
+function _persistWalleSessionModelPreference(session, msg = {}) {
+  if (!session || session.type !== 'walle') return null;
+  const rawModel = msg.model_id || msg.model || '';
+  const rawProvider = msg.model_provider || msg.provider || '';
+  if (!rawModel) {
+    try { dbModule.clearSessionModelPreference?.(session.id); } catch (e) { console.error('[walle-session] model preference clear error:', e.message); }
+    session.model_id = null;
+    session.model_provider = null;
+    session.model_registry_id = '';
+    session.model_provider_id = '';
+    session.model_pinned = false;
+    try { dbModule.addStartupTask(session.id, session.label, '', [], session.cwd, null, 'walle', session.chatSessionId); } catch (e) { console.error('[ctm] addStartupTask (walle model clear) error:', e.message); }
+    _broadcastWalleModel(session, { model_source: 'session-preference-cleared' });
+    broadcastSessionList(true);
+    return null;
+  }
+
+  const selection = normalizeWalleClientModelSelection({
+    model: rawModel,
+    provider: rawProvider,
+    session,
+  });
+  if (selection.note.normalized) {
+    recordSessionDiagnostic(session.id, 'walle-model-preference-normalized', selection.note);
+    console.warn('[walle-session] normalized session model preference:', selection.note);
+  }
+
+  const modelId = selection.model;
+  const providerType = selection.provider || rawProvider || '';
+  if (!providerType) {
+    recordSessionDiagnostic(session.id, 'walle-model-preference-provider-missing', {
+      model_id: modelId,
+      registry_id: msg.model_registry_id || msg.modelRegistryId || '',
+      source: msg.source || 'model-change',
+    });
+  }
+
+  let pref = null;
+  try {
+    pref = dbModule.upsertSessionModelPreference?.({
+      ctmSessionId: session.id,
+      agentType: 'walle',
+      providerType,
+      providerId: msg.provider_id || msg.model_provider_id || '',
+      modelId,
+      registryId: msg.model_registry_id || msg.modelRegistryId || '',
+      scope: msg.scope || 'session',
+      source: msg.source || 'user',
+      pinned: msg.pinned !== false,
+    }) || null;
+  } catch (e) {
+    console.error('[walle-session] model preference persist error:', e.message);
+    recordSessionDiagnostic(session.id, 'walle-model-preference-persist-failed', {
+      error: e.message,
+      model_id: modelId,
+      provider_type: providerType,
+    });
+    throw e;
+  }
+
+  _applyWalleSessionModelPreference(session, pref);
+  try {
+    dbModule.addStartupTask(session.id, session.label, '', [], session.cwd, session.model_id, 'walle', session.chatSessionId);
+  } catch (e) {
+    console.error('[ctm] addStartupTask (walle model preference) error:', e.message);
+  }
+  try {
+    dbModule.upsertSession(session.id, {
+      agentSessionId: session.chatSessionId,
+      provider: 'walle',
+      cwd: session.cwd || '',
+      projectPath: session.cwd || '',
+      title: session.label || '',
+      jsonlPath: session.jsonlPath || '',
+      model: session.model_id || '',
+      hostname: HOSTNAME,
+    });
+  } catch (e) {
+    console.error('[walle-session] model preference index update error:', e.message);
+  }
+  try {
+    telemetry.track('walle_session_model_changed', {
+      session_id: String(session.id || '').slice(0, 8),
+      provider_type: session.model_provider || '',
+      model_id: session.model_id || '',
+      source: msg.source || 'user',
+    });
+  } catch {}
+  _broadcastWalleModel(session, { model_source: 'session-preference' });
+  broadcastSessionList(true);
+  return pref;
+}
+
 async function handleWalleMessage(ws, msg) {
   const session = sessions.get(msg.id);
   if (!session || session.type !== 'walle') return;
@@ -15873,27 +16217,24 @@ async function handleWalleMessage(ws, msg) {
     return;
   }
   session._walleCancelRequested = false;
+  if (!session.model_id) {
+    _hydrateWalleSessionModelPreference(session, { broadcast: true });
+  }
   if (!session.model_id) {
     const defaults = resolveWalleDefaultModelSelection({ brain: getWalleBrain(), env: process.env });
     if (defaults.model_id) {
       session.model_id = defaults.model_id;
       session.model_provider = defaults.model_provider || session.model_provider || null;
+      session.model_pinned = false;
       try {
         dbModule.addStartupTask(session.id, session.label, '', [], session.cwd, session.model_id, 'walle', session.chatSessionId);
       } catch (e) {
         console.error('[ctm] addStartupTask (walle default model) error:', e.message);
       }
-      broadcastToSession({
-        type: 'walle-model',
-        id: session.id,
-        model_id: session.model_id,
-        model_provider: session.model_provider,
-      });
+      broadcastToSession(_walleModelPayload(session, { model_source: 'global-default' }));
       broadcastSessionList(true);
     }
   }
-  const legacyExplicitModel = !!(msg.model && msg.model !== session.model_id);
-  const modelPinned = msg.modelPinned === true || msg.modelExplicit === true || legacyExplicitModel;
   const selection = normalizeWalleClientModelSelection({
     model: msg.model,
     provider: msg.provider,
@@ -15901,6 +16242,9 @@ async function handleWalleMessage(ws, msg) {
   });
   const selectedModel = selection.model;
   const selectedProvider = selection.provider;
+  const legacyExplicitModel = !!(msg.model && selectedModel !== session.model_id);
+  const sessionPinnedModel = !!session.model_pinned && !!session.model_id && selectedModel === session.model_id;
+  const modelPinned = msg.modelPinned === true || msg.modelExplicit === true || legacyExplicitModel || sessionPinnedModel;
   if (selection.note.normalized) {
     recordSessionDiagnostic(session.id, 'walle-model-selection-normalized', selection.note);
     console.warn('[walle-session] normalized client model selection:', selection.note);
@@ -16111,9 +16455,9 @@ async function handleWalleMessage(ws, msg) {
     }
     if (!result) throw new Error('Wall-E chat ended without a final response');
     if (session._walleCancelRequested) throw _createWalleCancelledError();
-    if (pendingExternalActions.length
-      && externalActionApprovals.length === 0
+    if (externalActionApprovals.length === 0
       && externalActionCompletionClaim(result.reply)
+      && (pendingExternalActions.length || hasBlockedExternalActionGatewayToolResult(turnToolCalls))
       && !hasExecutedExternalActionToolResult(turnToolCalls)) {
       result = {
         ...result,
@@ -16433,6 +16777,9 @@ function _sessionPayload(s) {
     fileSize: fileInfo.fileSize || 0,
     model_id: walleModel?.model_id || s.model_id,
     model_provider: walleModel?.model_provider || s.model_provider,
+    model_registry_id: s.model_registry_id || '',
+    model_provider_id: s.model_provider_id || '',
+    model_pinned: !!s.model_pinned,
     walle_model_id: walleModel?.model_id || null,
     walle_model_provider: walleModel?.model_provider || null,
     runtime_model_id: walleOwned ? (s.model_id || null) : null,

package/template/claude-task-manager/workers/state-detectors/codex.js

@@ -41,12 +41,26 @@ function isCodexStatusRedraw(data) {
   return (
     stripped.length <= 160 &&
     (CODEX_STATUS_FRAGMENT_RE.test(stripped) ||
-      CODEX_BUSY_STATUS_LINE_RE.test(stripped) ||
-      CODEX_BUSY_COMPACT_STATUS_LINE_RE.test(stripped.replace(/^[\s•◦·∙●○]+\s*/, ''))) &&
+      textHasCodexBusyStatus(stripped)) &&
     isCursorAddressedRedraw(data)
   );
 }
 
+function normalizeCodexStatusLine(text) {
+  return String(text || '').replace(/^[\s•◦·∙●○]+/u, '').trim();
+}
+
+function isCodexBusyStatusLine(text) {
+  const compact = normalizeCodexStatusLine(text);
+  return CODEX_BUSY_STATUS_LINE_RE.test(compact) ||
+    CODEX_BUSY_COMPACT_STATUS_LINE_RE.test(compact);
+}
+
+function textHasCodexBusyStatus(text) {
+  const clean = stripAnsi(text).replace(/\r/g, '\n');
+  return clean.split('\n').some((line) => isCodexBusyStatusLine(line));
+}
+
 module.exports = {
   ...baseDetector,
   id: 'codex',
@@ -68,7 +82,8 @@ module.exports = {
     return isCodexStatusRedraw(data);
   },
   isBusyStatusChunk(data) {
-    return isCodexStatusRedraw(data) && hasCodexBusyStatusFragment(stripAnsi(data).trim());
+    return isCodexStatusRedraw(data) && textHasCodexBusyStatus(data);
   },
   hasCodexBusyStatusFragment,
+  textHasCodexBusyStatus,
 };

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "walle",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "private": true,
   "description": "Wall-E — your personal digital twin",
   "scripts": {