claude-remote 0.6.0 → 0.6.1

package/lib/logger.js

@@ -1,48 +1,81 @@
-'use strict';
-
-const fs = require('fs');
-const { WebSocket } = require('ws');
-const crypto = require('crypto');
-const { state, LOG_FILE, EVENT_BUFFER_MAX } = require('./state');
-const APPROVAL_MODE_ORDER = { default: 0, partial: 1, all: 2 };
-
-// --- Logging → file only (never pollute the terminal) ---
-fs.writeFileSync(LOG_FILE, `--- Bridge started ${new Date().toISOString()} ---\n`);
-
-function log(msg) {
-  const line = `[${new Date().toISOString()}] ${msg}\n`;
-  fs.appendFileSync(LOG_FILE, line);
-}
-
-function wsLabel(ws) {
-  const clientId = ws && ws._clientInstanceId ? ` client=${ws._clientInstanceId}` : '';
-  return `ws#${ws && ws._bridgeId ? ws._bridgeId : '?'}${clientId}`;
-}
-
-function isAuthenticatedClient(ws) {
-  return !!ws && ws.readyState === WebSocket.OPEN && !!ws._authenticated;
-}
-
-function normalizeApprovalMode(mode) {
-  const normalized = String(mode || '').toLowerCase();
-  return Object.prototype.hasOwnProperty.call(APPROVAL_MODE_ORDER, normalized) ? normalized : 'default';
-}
-
-function computeConnectedHighestApprovalMode() {
-  if (!state.wss) return 'default';
-  let best = 'default';
-  let bestScore = APPROVAL_MODE_ORDER.default;
-  for (const ws of state.wss.clients) {
-    if (!isAuthenticatedClient(ws)) continue;
-    const mode = normalizeApprovalMode(ws._approvalMode);
-    const score = APPROVAL_MODE_ORDER[mode];
-    if (score > bestScore) {
-      best = mode;
-      bestScore = score;
-    }
-  }
-  return best;
-}
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { WebSocket } = require('ws');
+const crypto = require('crypto');
+const { state, LOG_FILE, EVENT_BUFFER_MAX } = require('./state');
+const APPROVAL_MODE_ORDER = { default: 0, partial: 1, all: 2 };
+
+// --- Logging → file only (never pollute the terminal) ---
+let loggerFilePath = LOG_FILE;
+let loggerInitialized = false;
+let loggerEnabled = false;
+
+function initLogger({ filePath = LOG_FILE, reset = true } = {}) {
+  loggerFilePath = filePath;
+  loggerInitialized = true;
+  try {
+    fs.mkdirSync(path.dirname(loggerFilePath), { recursive: true });
+    const header = `--- Bridge started ${new Date().toISOString()} ---\n`;
+    if (reset) {
+      fs.writeFileSync(loggerFilePath, header);
+    } else {
+      fs.appendFileSync(loggerFilePath, header);
+    }
+    loggerEnabled = true;
+  } catch {
+    loggerEnabled = false;
+  }
+  return loggerEnabled;
+}
+
+function ensureLoggerReady() {
+  if (loggerInitialized) return loggerEnabled;
+  return initLogger({ filePath: loggerFilePath, reset: false });
+}
+
+function log(msg) {
+  if (!ensureLoggerReady()) return false;
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  try {
+    fs.appendFileSync(loggerFilePath, line);
+    return true;
+  } catch {
+    loggerEnabled = false;
+    return false;
+  }
+}
+
+function wsLabel(ws) {
+  const clientId = ws && ws._clientInstanceId ? ` client=${ws._clientInstanceId}` : '';
+  return `ws#${ws && ws._bridgeId ? ws._bridgeId : '?'}${clientId}`;
+}
+
+function isAuthenticatedClient(ws) {
+  return !!ws && ws.readyState === WebSocket.OPEN && !!ws._authenticated;
+}
+
+function normalizeApprovalMode(mode) {
+  const normalized = String(mode || '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(APPROVAL_MODE_ORDER, normalized) ? normalized : 'default';
+}
+
+function computeConnectedHighestApprovalMode() {
+  if (!state.wss) return 'default';
+  let best = 'default';
+  let bestScore = APPROVAL_MODE_ORDER.default;
+  for (const ws of state.wss.clients) {
+    if (!isAuthenticatedClient(ws)) continue;
+    const mode = normalizeApprovalMode(ws._approvalMode);
+    const score = APPROVAL_MODE_ORDER[mode];
+    if (score > bestScore) {
+      best = mode;
+      bestScore = score;
+    }
+  }
+  return best;
+}
 
 function sendWs(ws, msg, context = '') {
   if (!ws || ws.readyState !== WebSocket.OPEN) return false;
@@ -59,8 +92,8 @@ function sendWs(ws, msg, context = '') {
   return true;
 }
 
-function broadcast(msg) {
-  if (!state.wss) return;
+function broadcast(msg) {
+  if (!state.wss) return;
   const raw = JSON.stringify(msg);
   const recipients = [];
   for (const ws of state.wss.clients) {
@@ -71,62 +104,62 @@ function broadcast(msg) {
   }
   if (msg.type === 'status' || msg.type === 'transcript_ready' || msg.type === 'turn_state') {
     log(`Broadcast ${msg.type} -> ${recipients.length} client(s)${recipients.length ? ` [${recipients.join(', ')}]` : ''}`);
-  }
-}
-
-function autoResolveAllPendingApprovals(reason = '') {
-  if (state.pendingApprovals.size === 0) return;
-  for (const [id, approval] of state.pendingApprovals) {
-    clearTimeout(approval.timer);
-    approval.res.writeHead(200, { 'Content-Type': 'application/json' });
-    approval.res.end(JSON.stringify({ decision: 'allow' }));
-    log(`Permission #${id}: auto-allowed (${reason || 'effective mode switched to all'})`);
-  }
-  state.pendingApprovals.clear();
-  broadcast({ type: 'clear_permissions' });
-}
-
-function recomputeEffectiveApprovalMode(reason = '') {
-  const connectedHighest = computeConnectedHighestApprovalMode();
-  const connectedScore = APPROVAL_MODE_ORDER[connectedHighest];
-  const turnFloor = normalizeApprovalMode(state.turnApprovalFloorMode);
-  const turnFloorScore = APPROVAL_MODE_ORDER[turnFloor];
-  const floorActive = state.turnState.phase === 'running' && !!state.turnApprovalFloorMode;
-  const nextMode = (floorActive && turnFloorScore > connectedScore) ? turnFloor : connectedHighest;
-  if (state.approvalMode === nextMode) return nextMode;
-
-  const prevMode = state.approvalMode;
-  state.approvalMode = nextMode;
-  log(`Approval mode effective: ${prevMode} -> ${nextMode}${reason ? ` (${reason})` : ''} connected=${connectedHighest} turnFloor=${floorActive ? turnFloor : 'none'} phase=${state.turnState.phase}`);
-  if (nextMode === 'all' && prevMode !== 'all') {
-    autoResolveAllPendingApprovals(reason || 'effective mode switched to all');
-  }
-  return nextMode;
-}
-
-function setClientApprovalMode(ws, mode, reason = '') {
-  if (!ws) return state.approvalMode;
-  const normalized = normalizeApprovalMode(mode);
-  ws._approvalMode = normalized;
-  log(`Approval mode reported by ${wsLabel(ws)}: ${normalized}${reason ? ` (${reason})` : ''}`);
-  return recomputeEffectiveApprovalMode(`client mode update ${wsLabel(ws)}`);
-}
-
-function setTurnApprovalFloorMode(mode, reason = '') {
-  const normalized = normalizeApprovalMode(mode);
-  const prev = state.turnApprovalFloorMode || 'none';
-  state.turnApprovalFloorMode = normalized;
-  log(`Turn approval floor set: ${prev} -> ${normalized}${reason ? ` (${reason})` : ''}`);
-  return normalized;
-}
-
-function clearTurnApprovalFloorMode(reason = '') {
-  if (!state.turnApprovalFloorMode) return state.approvalMode;
-  const prev = state.turnApprovalFloorMode;
-  state.turnApprovalFloorMode = '';
-  log(`Turn approval floor cleared: ${prev}${reason ? ` (${reason})` : ''}`);
-  return recomputeEffectiveApprovalMode(`turn floor cleared${reason ? `: ${reason}` : ''}`);
-}
+  }
+}
+
+function autoResolveAllPendingApprovals(reason = '') {
+  if (state.pendingApprovals.size === 0) return;
+  for (const [id, approval] of state.pendingApprovals) {
+    clearTimeout(approval.timer);
+    approval.res.writeHead(200, { 'Content-Type': 'application/json' });
+    approval.res.end(JSON.stringify({ decision: 'allow' }));
+    log(`Permission #${id}: auto-allowed (${reason || 'effective mode switched to all'})`);
+  }
+  state.pendingApprovals.clear();
+  broadcast({ type: 'clear_permissions' });
+}
+
+function recomputeEffectiveApprovalMode(reason = '') {
+  const connectedHighest = computeConnectedHighestApprovalMode();
+  const connectedScore = APPROVAL_MODE_ORDER[connectedHighest];
+  const turnFloor = normalizeApprovalMode(state.turnApprovalFloorMode);
+  const turnFloorScore = APPROVAL_MODE_ORDER[turnFloor];
+  const floorActive = state.turnState.phase === 'running' && !!state.turnApprovalFloorMode;
+  const nextMode = (floorActive && turnFloorScore > connectedScore) ? turnFloor : connectedHighest;
+  if (state.approvalMode === nextMode) return nextMode;
+
+  const prevMode = state.approvalMode;
+  state.approvalMode = nextMode;
+  log(`Approval mode effective: ${prevMode} -> ${nextMode}${reason ? ` (${reason})` : ''} connected=${connectedHighest} turnFloor=${floorActive ? turnFloor : 'none'} phase=${state.turnState.phase}`);
+  if (nextMode === 'all' && prevMode !== 'all') {
+    autoResolveAllPendingApprovals(reason || 'effective mode switched to all');
+  }
+  return nextMode;
+}
+
+function setClientApprovalMode(ws, mode, reason = '') {
+  if (!ws) return state.approvalMode;
+  const normalized = normalizeApprovalMode(mode);
+  ws._approvalMode = normalized;
+  log(`Approval mode reported by ${wsLabel(ws)}: ${normalized}${reason ? ` (${reason})` : ''}`);
+  return recomputeEffectiveApprovalMode(`client mode update ${wsLabel(ws)}`);
+}
+
+function setTurnApprovalFloorMode(mode, reason = '') {
+  const normalized = normalizeApprovalMode(mode);
+  const prev = state.turnApprovalFloorMode || 'none';
+  state.turnApprovalFloorMode = normalized;
+  log(`Turn approval floor set: ${prev} -> ${normalized}${reason ? ` (${reason})` : ''}`);
+  return normalized;
+}
+
+function clearTurnApprovalFloorMode(reason = '') {
+  if (!state.turnApprovalFloorMode) return state.approvalMode;
+  const prev = state.turnApprovalFloorMode;
+  state.turnApprovalFloorMode = '';
+  log(`Turn approval floor cleared: ${prev}${reason ? ` (${reason})` : ''}`);
+  return recomputeEffectiveApprovalMode(`turn floor cleared${reason ? `: ${reason}` : ''}`);
+}
 
 function latestEventSeq() {
   return state.eventBuffer.length > 0 ? state.eventBuffer[state.eventBuffer.length - 1].seq : 0;
@@ -147,34 +180,34 @@ function sendTurnState(ws, context = '') {
   return sendWs(ws, getTurnStatePayload(), context);
 }
 
-function setTurnState(phase, { sessionId = state.currentSessionId, reason = '', force = false } = {}) {
-  const normalizedPhase = phase === 'running' ? 'running' : 'idle';
-  const normalizedSessionId = sessionId || null;
+function setTurnState(phase, { sessionId = state.currentSessionId, reason = '', force = false } = {}) {
+  const normalizedPhase = phase === 'running' ? 'running' : 'idle';
+  const normalizedSessionId = sessionId || null;
   const changed = force ||
     state.turnState.phase !== normalizedPhase ||
     state.turnState.sessionId !== normalizedSessionId;
 
   if (!changed) return false;
 
-  state.turnState = {
-    phase: normalizedPhase,
-    sessionId: normalizedSessionId,
-    version: ++state.turnStateVersion,
-    updatedAt: Date.now(),
-    reason,
-  };
-
-  const modeReason = reason || `turn_state:${normalizedPhase}`;
-  if (normalizedPhase !== 'running' && state.turnApprovalFloorMode) {
-    clearTurnApprovalFloorMode(modeReason);
-  } else {
-    recomputeEffectiveApprovalMode(modeReason);
-  }
-
-  log(`Turn state -> phase=${state.turnState.phase} session=${state.turnState.sessionId ?? 'null'} version=${state.turnState.version}${reason ? ` reason=${reason}` : ''}`);
-  broadcast(getTurnStatePayload());
-  return true;
-}
+  state.turnState = {
+    phase: normalizedPhase,
+    sessionId: normalizedSessionId,
+    version: ++state.turnStateVersion,
+    updatedAt: Date.now(),
+    reason,
+  };
+
+  const modeReason = reason || `turn_state:${normalizedPhase}`;
+  if (normalizedPhase !== 'running' && state.turnApprovalFloorMode) {
+    clearTurnApprovalFloorMode(modeReason);
+  } else {
+    recomputeEffectiveApprovalMode(modeReason);
+  }
+
+  log(`Turn state -> phase=${state.turnState.phase} session=${state.turnState.sessionId ?? 'null'} version=${state.turnState.version}${reason ? ` reason=${reason}` : ''}`);
+  broadcast(getTurnStatePayload());
+  return true;
+}
 
 function emitInterrupt(source) {
   const interruptEvent = {
@@ -197,20 +230,21 @@ function formatTtyInputChunk(chunk) {
   return `len=${buf.length} hex=${buf.toString('hex')} base64=${buf.toString('base64')} utf8=${JSON.stringify(buf.toString('utf8'))}`;
 }
 
-module.exports = {
-  log,
-  wsLabel,
-  isAuthenticatedClient,
+module.exports = {
+  initLogger,
+  log,
+  wsLabel,
+  isAuthenticatedClient,
   sendWs,
   broadcast,
   latestEventSeq,
   getTurnStatePayload,
-  sendTurnState,
-  setTurnState,
-  recomputeEffectiveApprovalMode,
-  setClientApprovalMode,
-  setTurnApprovalFloorMode,
-  clearTurnApprovalFloorMode,
-  emitInterrupt,
-  formatTtyInputChunk,
-};
+  sendTurnState,
+  setTurnState,
+  recomputeEffectiveApprovalMode,
+  setClientApprovalMode,
+  setTurnApprovalFloorMode,
+  clearTurnApprovalFloorMode,
+  emitInterrupt,
+  formatTtyInputChunk,
+};

package/lib/state.js

@@ -76,12 +76,13 @@ const state = {
   wss: null,
   nextWsId: 0,
 
-  // Permission approval
-  approvalSeq: 0,
-  pendingApprovals: new Map(),
-  pendingImageUploads: new Map(),
-  approvalMode: 'default',
-  turnApprovalFloorMode: '',
+  // Permission approval
+  approvalSeq: 0,
+  pendingApprovals: new Map(),
+  pendingImageUploads: new Map(),
+  pendingQuestionSubmissions: new Set(),
+  approvalMode: 'default',
+  turnApprovalFloorMode: '',
 
   // TTY forwarders
   ttyInputForwarderAttached: false,

package/lib/ws-server.js

@@ -13,19 +13,19 @@ const {
   LEGACY_REPLAY_DELAY_MS,
   isTTY,
 } = require('./state');
-const {
-  log,
-  broadcast,
-  wsLabel,
-  sendWs,
-  sendTurnState,
-  setTurnState,
-  recomputeEffectiveApprovalMode,
-  setClientApprovalMode,
-  setTurnApprovalFloorMode,
-  latestEventSeq,
-  emitInterrupt,
-} = require('./logger');
+const {
+  log,
+  broadcast,
+  wsLabel,
+  sendWs,
+  sendTurnState,
+  setTurnState,
+  recomputeEffectiveApprovalMode,
+  setClientApprovalMode,
+  setTurnApprovalFloorMode,
+  latestEventSeq,
+  emitInterrupt,
+} = require('./logger');
 const {
   extractSlashCommand,
   markExpectingSwitch,
@@ -34,17 +34,23 @@ const {
   getDirectoryRoots,
   assertDirectoryPath,
 } = require('./transcript');
-const {
-  cleanupImageUpload,
-  cleanupClientUploads,
-  sendUploadStatus,
-  handlePreparedImageUpload,
-  handleImageUpload,
-  createTempImageFile,
-} = require('./image-upload');
-const { restartClaude } = require('./pty-manager');
-
-function sendReplay(ws, lastSeq = null) {
+const {
+  cleanupImageUpload,
+  cleanupClientUploads,
+  sendUploadStatus,
+  handlePreparedImageUpload,
+  handleImageUpload,
+  createTempImageFile,
+} = require('./image-upload');
+const {
+  claimAskUserQuestionSubmissionLock,
+  releaseAskUserQuestionSubmissionLock,
+  buildAskUserQuestionPtyOperations,
+  executePtyOperations,
+} = require('./interactive-questions');
+const { restartClaude } = require('./pty-manager');
+
+function sendReplay(ws, lastSeq = null) {
   const normalizedLastSeq = Number.isInteger(lastSeq) && lastSeq >= 0 ? lastSeq : null;
   const replayFrom = normalizedLastSeq == null ? 0 : normalizedLastSeq;
   const records = replayFrom > 0
@@ -101,11 +107,11 @@ function setupWebSocketServer(server) {
   const wss = new WebSocketServer({ server });
   state.wss = wss;
 
-  wss.on('connection', (ws, req) => {
+  wss.on('connection', (ws, req) => {
     ws._bridgeId = ++state.nextWsId;
     ws._clientInstanceId = '';
-    ws._authenticated = state.AUTH_DISABLED;
-    ws._approvalMode = 'default';
+    ws._authenticated = state.AUTH_DISABLED;
+    ws._approvalMode = 'default';
     ws._authTimer = null;
     log(`WS connected: ${wsLabel(ws)} remote=${req.socket.remoteAddress || '?'} ua=${JSON.stringify(req.headers['user-agent'] || '')} authRequired=${!state.AUTH_DISABLED}`);
 
@@ -226,10 +232,40 @@ function setupWebSocketServer(server) {
           log(`Foreground probe ack -> ${wsLabel(ws)} probeId=${probeId || 'none'} session=${state.currentSessionId ?? 'null'} lastSeq=${latestEventSeq()}`);
           break;
         }
-        case 'input':
-          if (state.claudeProc) state.claudeProc.write(msg.data);
-          break;
-        case 'interrupt': {
+        case 'input':
+          if (state.claudeProc) state.claudeProc.write(msg.data);
+          break;
+        case 'answer_questions': {
+          const submissionKey = claimAskUserQuestionSubmissionLock(
+            state.pendingQuestionSubmissions,
+            msg,
+            wsLabel(ws),
+          );
+          if (!submissionKey) {
+            log(`AskUserQuestion duplicate submit ignored from ${wsLabel(ws)} toolUseId=${msg.toolUseId || 'unknown'}`);
+            break;
+          }
+          try {
+            if (!state.claudeProc) {
+              throw new Error('Claude is not running');
+            }
+            const operations = buildAskUserQuestionPtyOperations(msg);
+            log(`AskUserQuestion submit from ${wsLabel(ws)} toolUseId=${msg.toolUseId || 'unknown'} questions=${Array.isArray(msg.questions) ? msg.questions.length : 0}`);
+            await executePtyOperations(state.claudeProc, operations);
+          } catch (err) {
+            const error = err && err.message ? err.message : 'Failed to submit answers';
+            log(`AskUserQuestion submit error from ${wsLabel(ws)} toolUseId=${msg.toolUseId || 'unknown'}: ${error}`);
+            sendWs(ws, {
+              type: 'question_submission_error',
+              toolUseId: typeof msg.toolUseId === 'string' ? msg.toolUseId : '',
+              error,
+            }, 'answer_questions_error');
+          } finally {
+            releaseAskUserQuestionSubmissionLock(state.pendingQuestionSubmissions, submissionKey);
+          }
+          break;
+        }
+        case 'interrupt': {
           if (!state.claudeProc || state.turnState.phase !== 'running') break;
           log(`Interrupt from ${wsLabel(ws)} — sending Ctrl+C to PTY`);
           state.claudeProc.write('\x03');
@@ -239,23 +275,23 @@ function setupWebSocketServer(server) {
         case 'expect_clear':
           markExpectingSwitch();
           break;
-        case 'chat':
-          if (state.claudeProc) {
-            const text = msg.text;
-            log(`Chat input → PTY: "${text.substring(0, 80)}"`);
-            const slashCommand = extractSlashCommand(text);
-            if (slashCommand === '/clear') {
-              markExpectingSwitch();
-            }
-            if (!slashCommand) {
-              if (state.turnState.phase !== 'running') {
-                setTurnApprovalFloorMode(ws._approvalMode || 'default', `chat by ${wsLabel(ws)}`);
-              }
-              setTurnState('running', { reason: 'chat' });
-            }
-            state.claudeProc.write(text);
-            setTimeout(() => {
-              if (state.claudeProc) state.claudeProc.write('\r');
+        case 'chat':
+          if (state.claudeProc) {
+            const text = msg.text;
+            log(`Chat input → PTY: "${text.substring(0, 80)}"`);
+            const slashCommand = extractSlashCommand(text);
+            if (slashCommand === '/clear') {
+              markExpectingSwitch();
+            }
+            if (!slashCommand) {
+              if (state.turnState.phase !== 'running') {
+                setTurnApprovalFloorMode(ws._approvalMode || 'default', `chat by ${wsLabel(ws)}`);
+              }
+              setTurnState('running', { reason: 'chat' });
+            }
+            state.claudeProc.write(text);
+            setTimeout(() => {
+              if (state.claudeProc) state.claudeProc.write('\r');
             }, 150);
           }
           break;
@@ -264,29 +300,29 @@ function setupWebSocketServer(server) {
             state.claudeProc.resize(msg.cols, msg.rows);
           }
           break;
-        case 'permission_response': {
-          const approval = state.pendingApprovals.get(msg.id);
-          if (approval) {
-            clearTimeout(approval.timer);
-            state.pendingApprovals.delete(msg.id);
+        case 'permission_response': {
+          const approval = state.pendingApprovals.get(msg.id);
+          if (approval) {
+            clearTimeout(approval.timer);
+            state.pendingApprovals.delete(msg.id);
             approval.res.writeHead(200, { 'Content-Type': 'application/json' });
             approval.res.end(JSON.stringify({
               decision: msg.decision,
               reason: msg.reason || '',
-            }));
-            log(`Permission #${msg.id}: ${msg.decision}`);
-            broadcast({
-              type: 'permission_resolved',
-              id: msg.id,
-              decision: msg.decision,
-            });
-          }
-          break;
-        }
-        case 'set_approval_mode': {
-          setClientApprovalMode(ws, msg.mode);
-          break;
-        }
+            }));
+            log(`Permission #${msg.id}: ${msg.decision}`);
+            broadcast({
+              type: 'permission_resolved',
+              id: msg.id,
+              decision: msg.decision,
+            });
+          }
+          break;
+        }
+        case 'set_approval_mode': {
+          setClientApprovalMode(ws, msg.mode);
+          break;
+        }
         case 'image_upload_init': {
           const uploadId = String(msg.uploadId || '');
           if (!uploadId) {
@@ -388,7 +424,7 @@ function setupWebSocketServer(server) {
           sendUploadStatus(ws, uploadId, 'aborted');
           break;
         }
-        case 'image_submit': {
+        case 'image_submit': {
           const uploadId = String(msg.uploadId || '');
           const upload = state.pendingImageUploads.get(uploadId);
           if (!upload || !upload.tmpFile) {
@@ -396,33 +432,33 @@ function setupWebSocketServer(server) {
             break;
           }
           try {
-            await handlePreparedImageUpload({
-              tmpFile: upload.tmpFile,
+            await handlePreparedImageUpload({
+              tmpFile: upload.tmpFile,
               mediaType: upload.mediaType,
               text: msg.text || '',
               logLabel: upload.name || uploadId,
               onCleanup: () => cleanupImageUpload(uploadId),
-            });
-            upload.submitted = true;
-            upload.updatedAt = Date.now();
-            if (state.turnState.phase !== 'running') {
-              setTurnApprovalFloorMode(ws._approvalMode || 'default', `image_submit by ${wsLabel(ws)}`);
-            }
-            setTurnState('running', { reason: 'image_submit' });
-            sendUploadStatus(ws, uploadId, 'submitted');
-          } catch (err) {
-            sendUploadStatus(ws, uploadId, 'error', { message: err.message });
-            cleanupImageUpload(uploadId);
-          }
-          break;
-        }
-        case 'image_upload': {
-          if (state.turnState.phase !== 'running') {
-            setTurnApprovalFloorMode(ws._approvalMode || 'default', `legacy image_upload by ${wsLabel(ws)}`);
+            });
+            upload.submitted = true;
+            upload.updatedAt = Date.now();
+            if (state.turnState.phase !== 'running') {
+              setTurnApprovalFloorMode(ws._approvalMode || 'default', `image_submit by ${wsLabel(ws)}`);
+            }
+            setTurnState('running', { reason: 'image_submit' });
+            sendUploadStatus(ws, uploadId, 'submitted');
+          } catch (err) {
+            sendUploadStatus(ws, uploadId, 'error', { message: err.message });
+            cleanupImageUpload(uploadId);
           }
-          handleImageUpload(msg);
           break;
         }
+        case 'image_upload': {
+          if (state.turnState.phase !== 'running') {
+            setTurnApprovalFloorMode(ws._approvalMode || 'default', `legacy image_upload by ${wsLabel(ws)}`);
+          }
+          handleImageUpload(msg);
+          break;
+        }
         case 'list_sessions': {
           try {
             const sessions = scanSessions(state.CWD, 20);
@@ -475,7 +511,7 @@ function setupWebSocketServer(server) {
       }
     });
 
-    ws.on('close', () => {
+    ws.on('close', () => {
       if (ws._authTimer) {
         clearTimeout(ws._authTimer);
         ws._authTimer = null;
@@ -483,12 +519,12 @@ function setupWebSocketServer(server) {
       if (ws._legacyReplayTimer) {
         clearTimeout(ws._legacyReplayTimer);
         ws._legacyReplayTimer = null;
-      }
-      log(`WS closed: ${wsLabel(ws)}`);
-      cleanupClientUploads(ws);
-      recomputeEffectiveApprovalMode(`client disconnected ${wsLabel(ws)}`);
-    });
-  });
-}
+      }
+      log(`WS closed: ${wsLabel(ws)}`);
+      cleanupClientUploads(ws);
+      recomputeEffectiveApprovalMode(`client disconnected ${wsLabel(ws)}`);
+    });
+  });
+}
 
 module.exports = { setupWebSocketServer };