opencandle 0.10.0 → 0.11.1

package/gui/server/projector.ts

@@ -2,6 +2,7 @@ import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 
 export interface DashboardState {
+  knownSymbols: string[];
   watchlist: Array<{
     symbol: string;
     quote: Record<string, unknown> | null;
@@ -26,6 +27,16 @@ export interface DashboardState {
     softGaps: Array<{ provider: string; lastSeen: string }>;
     hardSkips: Array<{ provider: string; lastSeen: string }>;
   };
+  lastTurn?: {
+    routeKind: string;
+    workflow?: string;
+    symbols: string[];
+    slotSources: Record<string, number>;
+    priorTurnCount: number;
+    savedStateIncluded?: boolean;
+    attachmentCount?: number;
+    validation?: { passed: boolean; mismatchCount: number };
+  };
 }
 
 const DIRECT_TOOL_GAP_PROVIDERS: Record<string, string> = {
@@ -41,6 +52,7 @@ const DIRECT_TOOL_GAP_PROVIDERS: Record<string, string> = {
 
 export function createEmptyDashboardState(): DashboardState {
   return {
+    knownSymbols: [],
     watchlist: [],
     activeAnalyses: [],
     recentResearch: [],
@@ -48,12 +60,26 @@ export function createEmptyDashboardState(): DashboardState {
   };
 }
 
-export function projectDashboard(entries: SessionEntry[], sessionId = "local"): DashboardState {
+export function projectDashboard(
+  entries: SessionEntry[],
+  sessionId = "local",
+  savedSymbols: string[] = [],
+): DashboardState {
   const state = createEmptyDashboardState();
+  let pendingAttachmentCount: number | undefined;
+  let pendingAttachmentUserSeen = false;
 
   for (const entry of entries) {
     if (entry.type === "message") {
       projectMessage(state, entry.message as Message, entry.timestamp, sessionId);
+      const message = entry.message as Message;
+      if (pendingAttachmentCount !== undefined) {
+        if (message.role === "user") pendingAttachmentUserSeen = true;
+        else if (pendingAttachmentUserSeen) {
+          pendingAttachmentCount = undefined;
+          pendingAttachmentUserSeen = false;
+        }
+      }
       continue;
     }
 
@@ -73,6 +99,54 @@ export function projectDashboard(entries: SessionEntry[], sessionId = "local"):
       continue;
     }
 
+    if (entry.type === "custom" && entry.customType === "opencandle-user-input") {
+      const attachments = asArray(asRecord(entry.data).attachments);
+      pendingAttachmentCount = attachments.length > 0 ? attachments.length : undefined;
+      pendingAttachmentUserSeen = false;
+      if (state.lastTurn) {
+        if (pendingAttachmentCount !== undefined)
+          state.lastTurn.attachmentCount = pendingAttachmentCount;
+        else delete state.lastTurn.attachmentCount;
+      }
+      continue;
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-route-context") {
+      state.lastTurn = projectRouteContext(entry.data, pendingAttachmentCount);
+      addKnownSymbols(state, asArray(asRecord(asRecord(entry.data).entities).symbols));
+      pendingAttachmentCount = undefined;
+      pendingAttachmentUserSeen = false;
+      continue;
+    }
+
+    if (pendingAttachmentUserSeen) {
+      pendingAttachmentCount = undefined;
+      pendingAttachmentUserSeen = false;
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-validation") {
+      if (state.lastTurn) {
+        const data = asRecord(entry.data);
+        state.lastTurn.validation = {
+          passed: Boolean(data.passed),
+          mismatchCount: asArray(data.mismatches).length,
+        };
+      }
+      continue;
+    }
+
+    if (entry.type === "custom" && entry.customType === "opencandle-analyst-step") {
+      // debate_* stages share this entry type but are not analysts.
+      const stage = stringValue(asRecord(entry.data).stage) ?? "";
+      const active = state.activeAnalyses[state.activeAnalyses.length - 1];
+      if (active && stage.startsWith("analyst_")) {
+        const nextDone = active.analystsDone + 1;
+        active.analystsDone =
+          active.analystsTotal > 0 ? Math.min(nextDone, active.analystsTotal) : nextDone;
+      }
+      continue;
+    }
+
     if (entry.type === "custom" && entry.customType === "opencandle-turn-gap") {
       // The accumulator writes a single combined annotation string with one
       // [OPENCANDLE_SKIPPED ... provider=X ...] tag per fallback provider.
@@ -105,9 +179,40 @@ export function projectDashboard(entries: SessionEntry[], sessionId = "local"):
     }
   }
 
+  addKnownSymbols(state, savedSymbols);
   return state;
 }
 
+function projectRouteContext(
+  data: unknown,
+  attachmentCount: number | undefined,
+): DashboardState["lastTurn"] {
+  const record = asRecord(data);
+  const entities = asRecord(record.entities);
+  const routeKind = stringValue(record.routeKind) ?? "unknown";
+  const workflow = stringValue(record.workflow);
+  const slots = asRecord(record.slots);
+  const slotSources: Record<string, number> = {};
+  for (const slot of Object.values(slots)) {
+    const source = stringValue(asRecord(slot).source);
+    if (!source) continue;
+    slotSources[source] = (slotSources[source] ?? 0) + 1;
+  }
+  const symbols = stringArray(entities.symbols);
+  const priorTurnCount = asArray(record.priorTurns).length;
+  return {
+    routeKind,
+    ...(workflow ? { workflow } : {}),
+    symbols,
+    slotSources,
+    priorTurnCount,
+    ...(typeof record.savedStateIncluded === "boolean"
+      ? { savedStateIncluded: record.savedStateIncluded }
+      : {}),
+    ...(attachmentCount !== undefined ? { attachmentCount } : {}),
+  };
+}
+
 function projectMessage(
   state: DashboardState,
   message: Message,
@@ -185,10 +290,13 @@ function projectQuote(
 ): void {
   const symbol = symbolHint ?? inferSymbolFromContent(content);
   if (!symbol) return;
+  const normalizedSymbol = normalizeSymbol(symbol);
+  if (!normalizedSymbol) return;
+  addKnownSymbols(state, [normalizedSymbol]);
 
-  const existing = state.watchlist.find((row) => row.symbol === symbol);
+  const existing = state.watchlist.find((row) => row.symbol === normalizedSymbol);
   const row = {
-    symbol,
+    symbol: normalizedSymbol,
     quote: Object.keys(details).length > 0 ? details : null,
     pinned: existing?.pinned ?? false,
     lastSeen: timestamp,
@@ -240,6 +348,21 @@ function inferSymbolFromContent(content: ToolResultMessage["content"]): string |
   return match?.[1];
 }
 
+function addKnownSymbols(state: DashboardState, values: unknown[]): void {
+  for (const value of values) {
+    const symbol = normalizeSymbol(value);
+    if (!symbol || state.knownSymbols.includes(symbol)) continue;
+    if (state.knownSymbols.length >= 100) return;
+    state.knownSymbols.push(symbol);
+  }
+}
+
+function normalizeSymbol(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toUpperCase();
+  return normalized ? normalized : null;
+}
+
 function asRecord(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -258,6 +381,12 @@ function firstString(value: unknown): string | undefined {
   return Array.isArray(value) ? value.find((item) => typeof item === "string") : undefined;
 }
 
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string")
+    : [];
+}
+
 function numberValue(value: unknown): number | undefined {
   return typeof value === "number" ? value : undefined;
 }

package/gui/server/server.ts

@@ -25,6 +25,7 @@ import {
 import { createInitialGuiSessionManager } from "./gui-session-manager.js";
 import { createHttpRequestHandler, resolveSessionManagerById } from "./http-routes.js";
 import { createToolInvokeController } from "./invoke-tool.js";
+import { createLocalSessionCoordinator } from "./local-session-coordinator.js";
 import { buildMarketStateQuoteSnapshot } from "./market-state-api.js";
 import { createModelSetupController } from "./model-setup.js";
 import { isTrustedPrivateApiRequest } from "./private-api-access.js";
@@ -33,6 +34,7 @@ import { createSessionActionsController } from "./session-actions.js";
 import { createGracefulShutdown } from "./shutdown.js";
 import {
   acquireWriterLock,
+  migrateWriterLockScope,
   refreshWriterLock,
   releaseWriterLock,
   writerLockScopeForSession,
@@ -49,6 +51,8 @@ const automationHeartbeatMs = normalizeAutomationHeartbeatMs(
 );
 const allowRemotePrivateApi = process.env.OPENCANDLE_GUI_ALLOW_REMOTE_PRIVATE_API === "1";
 const privateApiSessionToken = randomBytes(32).toString("base64url");
+const localCoordinatorSecret = randomBytes(32).toString("base64url");
+const localCoordinatorEndpoint = `http://${coordinatorEndpointHost(host)}:${port}`;
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const webDist = resolve(__dirname, "../web/dist");
 
@@ -60,8 +64,12 @@ const initialSessionManager = createInitialGuiSessionManager(cwd);
 let sessionManager = initialSessionManager;
 const sessionDir = sessionManager.getSessionDir();
 const initialWriterLockScope = writerLockScopeForSession(sessionManager);
-const lockResult = await acquireWriterLock(initialWriterLockScope, "gui");
+const lockResult = await acquireWriterLock(initialWriterLockScope, "gui", {
+  coordinatorEndpoint: localCoordinatorEndpoint,
+  coordinatorSecret: localCoordinatorSecret,
+});
 let activeWriterLockScope = initialWriterLockScope;
+let currentWriterLockLost = false;
 let wsHub: WsHub;
 let quotePoller: BackgroundQuotePoller;
 const askUserBridge = createAskUserBridge({
@@ -91,8 +99,28 @@ const runtime = await createAgentSessionRuntime(
   { cwd, agentDir, sessionManager },
 );
 let session = runtime.session;
-const heartbeat = setInterval(() => refreshWriterLock(activeWriterLockScope), 5000);
+function syncCurrentWriterLockScope(): void {
+  if (currentWriterLockLost) throw new Error("OpenCandle is reconnecting to this session.");
+  if (lockResult.role !== "writer") return;
+  const nextScope = writerLockScopeForSession(sessionManager);
+  if (nextScope === activeWriterLockScope) return;
+  if (migrateWriterLockScope(activeWriterLockScope, nextScope)) {
+    activeWriterLockScope = nextScope;
+  } else {
+    currentWriterLockLost = true;
+    throw new Error("OpenCandle is reconnecting to this session.");
+  }
+}
+const heartbeat = setInterval(() => {
+  try {
+    syncCurrentWriterLockScope();
+    refreshWriterLock(activeWriterLockScope);
+  } catch {
+    clearInterval(heartbeat);
+  }
+}, 5000);
 const backgroundQuoteRefreshes = new BackgroundQuoteRefreshes();
+const localSessionCoordinator = createLocalSessionCoordinator();
 const quoteSnapshotStore = new QuoteSnapshotStore(() => buildMarketStateQuoteSnapshot());
 quotePoller = createBackgroundQuotePoller({
   getClientCount: () => wsHub.getClientCount(),
@@ -121,6 +149,10 @@ const toolInvokeController = createToolInvokeController({
   onMarketStateChanged: () => quoteSnapshotStore.invalidate(),
   askUserHandler: askUserBridge.ask,
   askUserHandlerForSessionId: (sessionId) => askUserBridge.askForSession(sessionId),
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
+  localSessionCoordinator,
+  syncWriterLockScope: syncCurrentWriterLockScope,
   resolveSessionManager: (sessionId) =>
     resolveSessionManagerById(
       { cwd, sessionDir, getSessionManager: () => sessionManager },
@@ -139,6 +171,7 @@ const sessionActionsController = createSessionActionsController({
   sendBoot: (client) => wsHub.sendBoot(client),
   broadcastState: () => wsHub.broadcastState(),
   broadcastSessions: () => wsHub.broadcastSessions(),
+  localSessionCoordinator,
 });
 wsHub = createWsHub({
   role: lockResult.role,
@@ -163,11 +196,12 @@ let unsubscribeSession = wsHub.subscribeToSessionEvents();
 runtime.setRebindSession(async (nextSession) => {
   const nextWriterLockScope = writerLockScopeForSession(nextSession.sessionManager);
   if (lockResult.role === "writer" && nextWriterLockScope !== activeWriterLockScope) {
-    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui");
+    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui", {
+      coordinatorEndpoint: localCoordinatorEndpoint,
+      coordinatorSecret: localCoordinatorSecret,
+    });
     if (nextLockResult.role !== "writer") {
-      throw new Error(
-        `Session is currently being written by ${nextLockResult.lock.processKind} (pid ${nextLockResult.lock.pid}).`,
-      );
+      throw new Error("OpenCandle is reconnecting to this session.");
     }
     releaseWriterLock(activeWriterLockScope);
     activeWriterLockScope = nextWriterLockScope;
@@ -187,7 +221,10 @@ const httpRequestHandler = createHttpRequestHandler({
   agentDir,
   sessionDir,
   privateApiSessionToken,
+  localCoordinatorEndpoint,
+  localCoordinatorSecret,
   allowRemotePrivateApi,
+  syncCurrentWriterLockScope,
   getSession: () => session,
   getSessionManager: () => sessionManager,
   createSessionForManager: async (targetSessionManager) =>
@@ -203,7 +240,9 @@ const httpRequestHandler = createHttpRequestHandler({
   wsHub,
   modelSetupController,
   sessionActionsController,
+  toolInvokeController,
   quoteSnapshotStore,
+  localSessionCoordinator,
 });
 
 const server = createServer((req, res) => {
@@ -240,5 +279,11 @@ const shutdown = createGracefulShutdown({
   exit: (code) => process.exit(code),
 });
 
+function coordinatorEndpointHost(bindHost: string): string {
+  if (bindHost === "0.0.0.0") return "127.0.0.1";
+  if (bindHost === "::") return "[::1]";
+  return bindHost.includes(":") && !bindHost.startsWith("[") ? `[${bindHost}]` : bindHost;
+}
+
 process.once("SIGINT", shutdown);
 process.once("SIGTERM", shutdown);

package/gui/server/session-actions.ts

@@ -1,5 +1,10 @@
 import { unlink } from "node:fs/promises";
 import { type AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
+import type {
+  LocalSessionCoordinator,
+  SessionActionEnvelope,
+  SessionActionSource,
+} from "./local-session-coordinator.js";
 import type { ModelSetupState } from "./model-setup.js";
 import { type PromptObservation, selectReplayPrompt } from "./prompt-observation.js";
 import {
@@ -7,6 +12,7 @@ import {
   waitForResolvedToolCalls,
   waitForSessionTurnSettlement,
 } from "./session-entry-wait.js";
+import { readWriterLock, writerLockScopeForSession } from "./writer-lock.js";
 
 interface AskUserBridge {
   answer(id: string, answer: string): boolean;
@@ -23,9 +29,8 @@ interface SessionActionClient {
 }
 
 export interface SessionActionsController {
-  handlePrompt(prompt: string): Promise<void>;
-  handleAskUserAnswer(id: string, value: unknown): Promise<void>;
-  handleAskUserCancel(id: string): Promise<void>;
+  handleAskUserAnswer(id: string, value: unknown, action?: SessionActionMeta): Promise<void>;
+  handleAskUserCancel(id: string, action?: SessionActionMeta): Promise<void>;
   handleNewSession(): Promise<void>;
   handleOpenSession(path: string): Promise<void>;
   handleRenameSession(path: string, name: string): Promise<void>;
@@ -44,9 +49,17 @@ export interface SessionActionsControllerOptions {
   sendBoot: (client: SessionActionClient) => void;
   broadcastState: () => void;
   broadcastSessions: () => void;
+  localSessionCoordinator?: LocalSessionCoordinator;
   now?: () => number;
 }
 
+export interface SessionActionMeta {
+  sessionId?: string;
+  actionId?: string;
+  source?: SessionActionSource;
+  allowProxy?: boolean;
+}
+
 export function createSessionActionsController({
   role,
   cwd,
@@ -59,48 +72,37 @@ export function createSessionActionsController({
   sendBoot,
   broadcastState,
   broadcastSessions,
+  localSessionCoordinator,
   now = Date.now,
 }: SessionActionsControllerOptions): SessionActionsController {
   function ensureWriter(): void {
     if (role !== "writer") throw new Error("Read-only follower mode");
   }
 
-  async function handlePrompt(prompt: string): Promise<void> {
-    ensureWriter();
-
-    const modelSetup = getModelSetupState();
-    const sessionManager = getSessionManager();
-    const trimmedPrompt = prompt.trim();
-    if (!trimmedPrompt.startsWith("/") && modelSetup.requirement !== "ready") {
-      sessionManager.appendMessage({ role: "user", content: prompt, timestamp: now() });
-      broadcastState();
-      const message =
-        modelSetup.requirement === "select_model"
-          ? "Choose an available model before chat can run. OpenCandle found configured credentials but no active model."
-          : "Connect an AI model before chat can run. Paste a Google Gemini, OpenAI, or Anthropic API key in the setup panel.";
-      sessionManager.appendCustomMessageEntry("opencandle-model-setup", message, true, {
-        source: "gui",
-        requirement: modelSetup.requirement,
-      });
-      broadcastState();
-      return;
-    }
-
-    const beforeIds = new Set(sessionManager.getEntries().map((entry) => entry.id));
-    await promptAndSettle(getSession(), prompt, beforeIds);
-    broadcastState();
-  }
-
-  async function handleAskUserAnswer(id: string, value: unknown): Promise<void> {
-    ensureWriter();
+  async function handleAskUserAnswer(
+    id: string,
+    value: unknown,
+    action?: SessionActionMeta,
+  ): Promise<void> {
     const answer = String(value ?? "").trim();
     if (!answer) throw new Error("Answer cannot be empty");
-    if (!askUserBridge.answer(id, answer)) throw new Error("Unknown or resolved question");
+    if (shouldProxyAskUserAction(action)) {
+      if (await proxyAskUserAction("ask_user.answer", { id, answer }, action)) return;
+      throw new Error("OpenCandle is reconnecting to this session.");
+    }
+    await runCoordinatedSessionAction("ask_user.answer", { id, answer }, action, async () => {
+      if (!askUserBridge.answer(id, answer)) throw new Error("Unknown or resolved question");
+    });
   }
 
-  async function handleAskUserCancel(id: string): Promise<void> {
-    ensureWriter();
-    if (!askUserBridge.cancel(id)) throw new Error("Unknown or resolved question");
+  async function handleAskUserCancel(id: string, action?: SessionActionMeta): Promise<void> {
+    if (shouldProxyAskUserAction(action)) {
+      if (await proxyAskUserAction("ask_user.cancel", { id }, action)) return;
+      throw new Error("OpenCandle is reconnecting to this session.");
+    }
+    await runCoordinatedSessionAction("ask_user.cancel", { id }, action, async () => {
+      if (!askUserBridge.cancel(id)) throw new Error("Unknown or resolved question");
+    });
   }
 
   async function handleNewSession(): Promise<void> {
@@ -143,7 +145,6 @@ export function createSessionActionsController({
   }
 
   return {
-    handlePrompt,
     handleAskUserAnswer,
     handleAskUserCancel,
     handleNewSession,
@@ -151,6 +152,88 @@ export function createSessionActionsController({
     handleRenameSession,
     handleDeleteSession,
   };
+
+  async function runCoordinatedSessionAction(
+    actionType: SessionActionEnvelope["actionType"],
+    payload: Record<string, unknown>,
+    action: SessionActionMeta | undefined,
+    handler: () => Promise<void> | void,
+  ): Promise<void> {
+    if (!localSessionCoordinator || !action?.actionId) {
+      await handler();
+      return;
+    }
+    const sessionId = action.sessionId?.trim();
+    if (!sessionId) throw new Error("sessionId is required");
+    const result = await localSessionCoordinator.runSessionAction(
+      {
+        sessionId,
+        actionId: action.actionId,
+        actionType,
+        payload,
+        source: action.source ?? "gui",
+      },
+      async () => {
+        await handler();
+        return { accepted: true };
+      },
+    );
+    if (!result.ok) throw new Error(result.message);
+  }
+
+  async function proxyAskUserAction(
+    actionType: "ask_user.answer" | "ask_user.cancel",
+    payload: Record<string, unknown>,
+    action: SessionActionMeta | undefined,
+  ): Promise<boolean> {
+    if (action?.allowProxy === false) return false;
+    const sessionManager = await resolveActionSessionManager(action);
+    const lock = readWriterLock(writerLockScopeForSession(sessionManager));
+    if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret || lock.pid === process.pid) {
+      return false;
+    }
+    if (lock.processKind === "tui") return false;
+    const endpoint = new URL("/api/local-coordinator/ask-user", lock.coordinatorEndpoint);
+    let response: Response;
+    try {
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-opencandle-coordinator-secret": lock.coordinatorSecret,
+        },
+        body: JSON.stringify({
+          sessionId: action?.sessionId,
+          actionId: action?.actionId || "",
+          actionType,
+          payload,
+        }),
+      });
+    } catch {
+      return false;
+    }
+    if (response.ok) return true;
+    const body = (await response.json().catch(() => ({}))) as { error?: string };
+    throw new Error(body.error || "OpenCandle is reconnecting to this session.");
+  }
+
+  function shouldProxyAskUserAction(action: SessionActionMeta | undefined): boolean {
+    if (role !== "writer") return true;
+    const targetSessionId = action?.sessionId?.trim();
+    return Boolean(targetSessionId && targetSessionId !== getSessionManager().getSessionId());
+  }
+
+  async function resolveActionSessionManager(
+    action: SessionActionMeta | undefined,
+  ): Promise<SessionManager> {
+    const current = getSessionManager();
+    const targetSessionId = action?.sessionId?.trim();
+    if (!targetSessionId || targetSessionId === current.getSessionId()) return current;
+    const sessions = await SessionManager.list(cwd, sessionDir);
+    const match = sessions.find((candidate) => candidate.id === targetSessionId);
+    if (!match) throw new Error("Unknown saved session");
+    return SessionManager.open(match.path, sessionDir, cwd);
+  }
 }
 
 export async function promptAndSettle(
@@ -158,12 +241,10 @@ export async function promptAndSettle(
   prompt: string,
   beforeIds: Set<string>,
   observation?: PromptObservation,
+  options?: { images?: Array<{ type: "image"; data: string; mimeType: string }> },
 ): Promise<void> {
-  await runSession.prompt(prompt);
-  await waitForSessionTurnSettlement(() => ({
-    isStreaming: runSession.isStreaming,
-    pendingMessageCount: runSession.pendingMessageCount,
-  }));
+  await runSession.prompt(prompt, options);
+  await settleWithEventProgress(runSession);
   await waitForNewEntryId(
     () => runSession.sessionManager.getEntries().map((entry) => entry.id),
     beforeIds,
@@ -172,6 +253,27 @@ export async function promptAndSettle(
   await replayObservedWorkflowPromptIfNeeded(runSession, prompt, observation);
 }
 
+/**
+ * Settle wait fed by a session-event counter: a single long model generation
+ * keeps isStreaming/pendingMessageCount frozen for its whole duration, and
+ * without an activity signal the stall detector killed healthy long turns.
+ */
+async function settleWithEventProgress(runSession: AgentSession): Promise<void> {
+  let progressToken = 0;
+  const unsubscribe = runSession.subscribe(() => {
+    progressToken += 1;
+  });
+  try {
+    await waitForSessionTurnSettlement(() => ({
+      isStreaming: runSession.isStreaming,
+      pendingMessageCount: runSession.pendingMessageCount,
+      progressToken,
+    }));
+  } finally {
+    unsubscribe();
+  }
+}
+
 export async function replayObservedWorkflowPromptIfNeeded(
   runSession: AgentSession,
   originalPrompt: string,
@@ -181,14 +283,13 @@ export async function replayObservedWorkflowPromptIfNeeded(
   const replayPrompt = selectReplayPrompt(observation, originalPrompt);
   if (!replayPrompt) return;
 
+  // V1 attachment replay is text-only: the recorded expanded prompt is
+  // re-sent, but image bytes are not replayed.
   await runSession.prompt(replayPrompt, {
     expandPromptTemplates: false,
     source: "extension",
   });
-  await waitForSessionTurnSettlement(() => ({
-    isStreaming: runSession.isStreaming,
-    pendingMessageCount: runSession.pendingMessageCount,
-  }));
+  await settleWithEventProgress(runSession);
   await waitForResolvedToolCalls(() => runSession.sessionManager.getEntries());
 }
 

package/gui/server/session-entry-wait.ts

@@ -12,6 +12,12 @@ export interface WaitForSessionTurnSettlementOptions extends WaitForEntryCountOp
 export interface SessionRunStatus {
   isStreaming: boolean;
   pendingMessageCount: number;
+  /**
+   * Monotonic activity signal (e.g. a session-event counter). A single long
+   * model generation keeps isStreaming/pendingMessageCount frozen for its
+   * whole duration; this token is what distinguishes it from a hung run.
+   */
+  progressToken?: number;
 }
 
 export interface UnresolvedToolCall {
@@ -60,15 +66,29 @@ export async function waitForSessionTurnSettlement(
   const timeoutMs = options.timeoutMs ?? 120_000;
   const intervalMs = options.intervalMs ?? 25;
   const idleGraceMs = options.idleGraceMs ?? 250;
-  const deadline = Date.now() + timeoutMs;
+  // timeoutMs bounds STALL, not total runtime: a live workflow run (e.g.
+  // /analyze) stays active for minutes while its status keeps changing, and
+  // capping total runtime failed those runs mid-workflow with
+  // "Timed out waiting for the session turn to settle". A hung session stops
+  // changing status entirely, which is what the deadline must catch.
+  let lastProgressAt = Date.now();
+  let lastSignature: string | undefined;
   let idleSince: number | undefined;
 
-  while (Date.now() < deadline) {
+  while (true) {
     const status = getStatus();
+    const signature = `${status.isStreaming}:${status.pendingMessageCount}:${status.progressToken ?? 0}`;
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      lastProgressAt = Date.now();
+    }
     const active = status.isStreaming || status.pendingMessageCount > 0;
 
     if (active) {
       idleSince = undefined;
+      if (Date.now() - lastProgressAt >= timeoutMs) {
+        throw new Error("Timed out waiting for the session turn to settle");
+      }
       await delay(intervalMs);
       continue;
     }
@@ -80,7 +100,6 @@ export async function waitForSessionTurnSettlement(
 
     await delay(intervalMs);
   }
-  throw new Error("Timed out waiting for the session turn to settle");
 }
 
 export function findUnresolvedToolCalls(entries: SessionEntry[]): UnresolvedToolCall[] {

package/gui/server/tool-metadata.ts

@@ -75,12 +75,14 @@ function serializeProvider(provider: ProviderDescriptor, onboardingState: Onboar
   };
 
   if (isApiKeyProvider(provider)) {
+    // Never serialize the credential value: this payload reaches the browser DOM.
     const credential = getCredential(provider.id);
     const source = credential.source;
     return {
       ...common,
       source,
-      apiKey: credential.value,
+      configured: source !== "absent",
+      maskedKeyHint: credential.value ? `…${credential.value.slice(-4)}` : undefined,
       status: source,
       signupUrl: provider.signupUrl,
       freeTier: provider.freeTier,