opencandle 0.11.0 → 0.11.1

package/gui/server/market-state-api.ts

@@ -1,4 +1,5 @@
 import type Database from "better-sqlite3";
+import { buildFreshnessStamp } from "../../src/infra/freshness.js";
 import { isZeroFilledQuote, searchYahooInstruments } from "../../src/market-state/resolve.js";
 import { MarketStateService } from "../../src/market-state/service.js";
 import { initDefaultDatabase } from "../../src/memory/sqlite.js";
@@ -37,12 +38,12 @@ export interface MarketStateQuoteSnapshot {
     instrumentId: number;
     symbol: string;
     status: "ok" | "unavailable";
-    currentPrice?: number;
+    currentPrice?: number | null;
     changePercent?: number;
-    marketValue?: number;
+    marketValue?: number | null;
     totalCost: number;
-    pnl?: number;
-    pnlPercent?: number;
+    pnl?: number | null;
+    pnlPercent?: number | null;
     allocationPercent?: number;
     currency: string;
     includedInTotals: boolean;
@@ -60,6 +61,30 @@ export interface MarketStateQuoteSnapshot {
   };
 }
 
+interface SavedSymbolsMemoOptions {
+  ttlMs?: number;
+  now?: () => number;
+}
+
+export function createSavedSymbolsMemo(
+  load: () => string[],
+  options: SavedSymbolsMemoOptions = {},
+): () => string[] {
+  const ttlMs = options.ttlMs ?? 30_000;
+  const now = options.now ?? Date.now;
+  let cachedAt = 0;
+  let cached: string[] | null = null;
+  return () => {
+    const current = now();
+    if (cached && current - cachedAt < ttlMs) return cached;
+    cached = load();
+    cachedAt = current;
+    return cached;
+  };
+}
+
+export const getSavedMarketStateSymbols = createSavedSymbolsMemo(loadSavedMarketStateSymbols);
+
 export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSnapshot {
   const ownedDb = db ?? initDefaultDatabase();
   const service = new MarketStateService(ownedDb);
@@ -88,6 +113,30 @@ export function buildMarketStateSnapshot(db?: Database.Database): MarketStateSna
   }
 }
 
+function loadSavedMarketStateSymbols(): string[] {
+  const db = initDefaultDatabase();
+  const service = new MarketStateService(db);
+  try {
+    const symbols = [
+      ...service.listWatchlistItems().map((item) => item.symbol),
+      ...service.listPortfolioLots().map((lot) => lot.symbol),
+    ];
+    return normalizeSymbols(symbols);
+  } finally {
+    db.close();
+  }
+}
+
+function normalizeSymbols(symbols: string[]): string[] {
+  const normalized: string[] = [];
+  for (const symbol of symbols) {
+    const next = symbol.trim().toUpperCase();
+    if (!next || normalized.includes(next)) continue;
+    normalized.push(next);
+  }
+  return normalized;
+}
+
 export async function buildMarketStateQuoteSnapshot(
   db?: Database.Database,
 ): Promise<MarketStateQuoteSnapshot> {
@@ -262,11 +311,20 @@ async function fetchQuoteSnapshot(symbol: string): Promise<
   if (isZeroFilledQuote(result.data)) {
     return { status: "unavailable", reason: "Yahoo returned no valid market data." };
   }
+  const freshness = buildFreshnessStamp({
+    asOf: result.data.asOf,
+    cached: result.cached,
+    stale: result.stale,
+    cachedAt: result.timestamp,
+  });
+  if (freshness.isStaleForSession) {
+    return { status: "unavailable", reason: "provider returned stale market data" };
+  }
   return {
     status: "ok",
     price: result.data.price,
     changePercent: result.data.changePercent,
-    fetchedAt: result.timestamp,
+    fetchedAt: freshness.providerDataAt ?? result.timestamp,
     stale: result.stale,
     currency: result.data.currency ?? null,
   };

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/session-actions.ts

@@ -29,7 +29,6 @@ interface SessionActionClient {
 }
 
 export interface SessionActionsController {
-  handlePrompt(prompt: string): Promise<void>;
   handleAskUserAnswer(id: string, value: unknown, action?: SessionActionMeta): Promise<void>;
   handleAskUserCancel(id: string, action?: SessionActionMeta): Promise<void>;
   handleNewSession(): Promise<void>;
@@ -80,32 +79,6 @@ export function createSessionActionsController({
     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,
@@ -172,7 +145,6 @@ export function createSessionActionsController({
   }
 
   return {
-    handlePrompt,
     handleAskUserAnswer,
     handleAskUserCancel,
     handleNewSession,
@@ -191,7 +163,8 @@ export function createSessionActionsController({
       await handler();
       return;
     }
-    const sessionId = action.sessionId?.trim() || getSessionManager().getSessionId();
+    const sessionId = action.sessionId?.trim();
+    if (!sessionId) throw new Error("sessionId is required");
     const result = await localSessionCoordinator.runSessionAction(
       {
         sessionId,
@@ -230,7 +203,7 @@ export function createSessionActionsController({
           "x-opencandle-coordinator-secret": lock.coordinatorSecret,
         },
         body: JSON.stringify({
-          sessionId: action?.sessionId || sessionManager.getSessionId(),
+          sessionId: action?.sessionId,
           actionId: action?.actionId || "",
           actionType,
           payload,
@@ -258,7 +231,8 @@ export function createSessionActionsController({
     if (!targetSessionId || targetSessionId === current.getSessionId()) return current;
     const sessions = await SessionManager.list(cwd, sessionDir);
     const match = sessions.find((candidate) => candidate.id === targetSessionId);
-    return match ? SessionManager.open(match.path, sessionDir, cwd) : current;
+    if (!match) throw new Error("Unknown saved session");
+    return SessionManager.open(match.path, sessionDir, cwd);
   }
 }
 
@@ -267,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,
@@ -281,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,
@@ -290,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/ws-hub.ts

@@ -16,6 +16,7 @@ import type { ChatEvent } from "../shared/chat-events.js";
 import type { BackgroundQuoteRefreshes } from "./background-quotes.js";
 import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
 import type { ToolInvokeController } from "./invoke-tool.js";
+import { getSavedMarketStateSymbols } from "./market-state-api.js";
 import type { ModelSetupController } from "./model-setup.js";
 import { projectDashboard } from "./projector.js";
 import type { SessionActionsController } from "./session-actions.js";
@@ -109,8 +110,11 @@ export function createWsHub({
     try {
       switch (data.type) {
         case "chat.prompt":
-          await sessionActionsController.handlePrompt(String(data.prompt ?? ""));
-          break;
+          // Legacy implicit-active-session mutation; parity with the HTTP
+          // route's 410. Chat runs go through the session-addressed API.
+          throw new Error(
+            "Legacy active-session chat prompts are no longer supported. Use the session-addressed chat-run API.",
+          );
         case "ask_user.answer":
           await sessionActionsController.handleAskUserAnswer(String(data.id ?? ""), data.answer, {
             actionId: String(data.actionId ?? ""),
@@ -281,7 +285,11 @@ export function createWsHub({
     const entries = sessionManager.getEntries();
     return {
       sessionId,
-      state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId),
+      state: projectDashboard(
+        backgroundQuoteRefreshes.withEntries(entries),
+        sessionId,
+        getSavedMarketStateSymbols(),
+      ),
       entries,
       events: currentChatEvents(entries),
       // Ownership can change mid-run (e.g. a TUI takes over the session), so
@@ -295,7 +303,11 @@ export function createWsHub({
     const entries = sessionManager.getEntries();
     return {
       sessionId,
-      state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId),
+      state: projectDashboard(
+        backgroundQuoteRefreshes.withEntries(entries),
+        sessionId,
+        getSavedMarketStateSymbols(),
+      ),
       entries,
       events: sessionEntriesToChatEvents(entries, {
         sessionId,

package/gui/shared/chat-events.ts

@@ -12,12 +12,19 @@ export interface MessageToolContent {
 
 export interface MessageImageContent {
   type: "image";
-  url: string;
+  url?: string;
+  data?: string;
+  mimeType?: string;
   alt?: string;
 }
 
 export type MessageContent = MessageTextContent | MessageToolContent | MessageImageContent;
 
+export interface MessageAttachmentChip {
+  kind: string;
+  label: string;
+}
+
 export interface ToolOutput {
   content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
   details?: unknown;
@@ -63,6 +70,7 @@ export type ChatEvent =
       type: "message.completed";
       messageId: string;
       content: MessageContent[];
+      attachments?: MessageAttachmentChip[];
       runId?: string;
     } & ChatEventBase)
   | ({
@@ -98,6 +106,7 @@ export interface RenderMessage {
   status: "streaming" | "completed";
   content: MessageContent[];
   text: string;
+  attachments?: MessageAttachmentChip[];
   customType?: string;
 }
 

package/gui/shared/event-reducer.ts

@@ -66,6 +66,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
       message.status = "completed";
       message.content = event.content;
       message.text = contentText(event.content);
+      message.attachments = event.attachments;
       break;
     }