gloomberb 0.16.4 → 0.16.5

package/src/plugins/builtin/chart-composer/use-series-catalog.ts

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import {
   buildTickerSearchCandidates,
   searchTickerCandidates,
@@ -6,6 +6,8 @@ import {
 import { useOptionalAppSelector } from "../../../state/app/context";
 import type { TickerRecord } from "../../../types/ticker";
 import { searchChartSeriesCapabilities } from "../../../capabilities";
+import { SERIES_CATALOG_CAPABILITY_ID } from "../../../series/capability";
+import type { SeriesCatalogEntry } from "../../../series/types";
 import { getSharedRegistry } from "../../registry";
 import {
   analyzeSeriesSearchQuery,
@@ -17,6 +19,9 @@ import {
 
 const EMPTY_TICKERS: ReadonlyMap<string, TickerRecord> = new Map();
 const EMPTY_RECENT: readonly string[] = [];
+const EMPTY_PLUGINS: readonly string[] = [];
+const EMPTY_ENTRIES: readonly SeriesCatalogEntry[] = [];
+const NO_SUBSCRIPTION = () => () => {};
 const MAX_SERIES_SUGGESTIONS = 8;
 const DEFAULT_CATALOG_INSTRUMENTS: readonly SeriesCatalogInstrument[] = [
   { symbol: "AAPL", exchange: "NASDAQ", name: "Apple Inc." },
@@ -72,6 +77,56 @@ function candidateToInstrument(candidate: {
   };
 }
 
+/**
+ * Every registered series of the plugins that are switched on. On the
+ * desktop, series only the Bun process has (files in the profile's series
+ * folder) are asked for once and listed after the rest; elsewhere, sources
+ * that change while the app runs catch up when the catalog opens.
+ */
+export function useRegisteredSeries(): readonly SeriesCatalogEntry[] {
+  const registry = getSharedRegistry();
+  const series = registry?.series;
+  const version = useSyncExternalStore(
+    series ? series.subscribe.bind(series) : NO_SUBSCRIPTION,
+    () => series?.getVersion() ?? 0,
+    () => 0,
+  );
+  const disabledPlugins = useOptionalAppSelector((state) => state.config.disabledPlugins, EMPTY_PLUGINS);
+  const [remote, setRemote] = useState<readonly SeriesCatalogEntry[] | null>(null);
+
+  useEffect(() => {
+    if (!registry || !series) return;
+    if (!registry.usesRemoteCapabilities) {
+      void series.refresh();
+      return;
+    }
+    let cancelled = false;
+    void registry.invokeCapability<{ entries: SeriesCatalogEntry[] }>(SERIES_CATALOG_CAPABILITY_ID, "list", {})
+      .then((result) => {
+        if (!cancelled && Array.isArray(result?.entries)) setRemote(result.entries);
+      })
+      .catch(() => {
+        // The view's own series still list; only the Bun process's extras are missing.
+      });
+    return () => { cancelled = true; };
+  }, [registry, series]);
+
+  return useMemo(() => {
+    const local = series?.catalog() ?? EMPTY_ENTRIES;
+    let entries = local;
+    if (remote?.length) {
+      const known = new Set(local.map((entry) => entry.id));
+      const extra = remote.filter((entry) => !known.has(entry.id));
+      if (extra.length) entries = [...local, ...extra];
+    }
+    if (disabledPlugins.length === 0) return entries;
+    const disabled = new Set(disabledPlugins);
+    return entries.some((entry) => disabled.has(entry.pluginId))
+      ? entries.filter((entry) => !disabled.has(entry.pluginId))
+      : entries;
+  }, [disabledPlugins, remote, series, version]);
+}
+
 export function useCatalogUniverse(query: string): {
   instruments: SeriesCatalogInstrument[];
   loading: boolean;
@@ -193,6 +248,7 @@ export function useSeriesCatalogSuggestions({
   enabled: boolean;
 }): SeriesCatalogSearchResult {
   const tickers = useOptionalAppSelector((state) => state.tickers, EMPTY_TICKERS);
+  const registered = useRegisteredSeries();
   const analysis = useMemo(() => analyzeSeriesSearchQuery(query), [query]);
   const [providerSearch, setProviderSearch] = useState<{
     query: string;
@@ -298,11 +354,11 @@ export function useSeriesCatalogSuggestions({
   // and they arrive well before plugin catalogs (which can take seconds), so
   // late plugin results append below instead of pushing the list around.
   const suggestions = useMemo(() => {
-    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments);
+    const builtIn = buildSeriesCatalogSuggestions(query, defaultInstrument, instruments, MAX_SERIES_SUGGESTIONS, registered);
     const provider = providerSearch.query === query.trim() ? providerSearch.suggestions : [];
     return [...builtIn, ...provider.filter((entry) => !builtIn.some((candidate) => candidate.id === entry.id))]
       .slice(0, MAX_SERIES_SUGGESTIONS);
-  }, [defaultInstrument, instruments, providerSearch, query]);
+  }, [defaultInstrument, instruments, providerSearch, query, registered]);
 
   return {
     suggestions,

package/src/plugins/builtin/chart-composer/user-series.ts

@@ -0,0 +1,84 @@
+import { getCurrentPluginTarget } from "../../current-target";
+import { getSharedRegistry } from "../../registry";
+import { listSeriesFiles, seriesFromFile } from "../../../series/files";
+import type { SeriesDefinition } from "../../../series/types";
+import type { GloomPluginContext } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
+
+interface RegisteredFile {
+  mtimeMs: number;
+  dispose: () => void;
+}
+
+/**
+ * Keeps the catalog in step with the profile's series folder: a file added,
+ * changed or removed shows up the next time the catalog opens.
+ */
+function watchUserSeriesFolder(ctx: GloomPluginContext): () => void {
+  const registered = new Map<string, RegisteredFile>();
+  let running: Promise<void> = Promise.resolve();
+
+  const sync = async () => {
+    const files = await listSeriesFiles(ctx.getConfig().dataDir);
+    const present = new Set(files.map((file) => file.name));
+    for (const [name, entry] of registered) {
+      if (present.has(name)) continue;
+      entry.dispose();
+      registered.delete(name);
+    }
+    for (const file of files) {
+      const existing = registered.get(file.name);
+      if (existing?.mtimeMs === file.mtimeMs) continue;
+      existing?.dispose();
+      registered.delete(file.name);
+      let definitions: SeriesDefinition[];
+      try {
+        definitions = seriesFromFile(file.name, await file.readText(), file.readText);
+      } catch (error) {
+        ctx.log.warn("Series file skipped", { file: file.name, error: error instanceof Error ? error.message : String(error) });
+        continue;
+      }
+      const disposers = definitions.flatMap((definition) => {
+        try {
+          return [ctx.registerSeries(definition)];
+        } catch (error) {
+          ctx.log.warn("Series skipped", { file: file.name, error: error instanceof Error ? error.message : String(error) });
+          return [];
+        }
+      });
+      registered.set(file.name, { mtimeMs: file.mtimeMs, dispose: () => { for (const dispose of disposers) dispose(); } });
+    }
+  };
+  const refresh = () => {
+    running = running.then(sync, sync);
+    return running;
+  };
+
+  void refresh();
+  const removeRefresher = getSharedRegistry()?.series.addRefresher(refresh);
+  return () => {
+    removeRefresher?.();
+    for (const entry of registered.values()) entry.dispose();
+    registered.clear();
+  };
+}
+
+let stopWatching: (() => void) | null = null;
+
+/**
+ * CSV files in `<data dir>/series/` as catalog series, chartable against
+ * anything else. Files are read where the app can reach the disk: the
+ * terminal, and the desktop's Bun process, which lists them for its view.
+ */
+export const userSeriesModule: PluginModule = {
+  setup(ctx) {
+    const target = getCurrentPluginTarget();
+    if (target !== "cli" && target !== "tui") return;
+    stopWatching?.();
+    stopWatching = watchUserSeriesFolder(ctx);
+  },
+  dispose() {
+    stopWatching?.();
+    stopWatching = null;
+  },
+};

package/src/plugins/builtin/chat/content/new-dm-dialog.tsx

@@ -267,9 +267,11 @@ export function NewDmDialog({
   const startButton = (
     <Button
       label={submitting ? t("Starting") : t("Start")}
-      width={submitting ? 10 : START_BUTTON_WIDTH}
+      // The terminal keeps its column fixed; the desktop sizes to the label and its key.
+      width={nativePaneChrome ? undefined : submitting ? 10 : START_BUTTON_WIDTH}
       variant="primary"
       disabled={!canSubmit}
+      desktopShortcut="Enter"
       stopPropagation
       onPress={() => { void submit(); }}
     />
@@ -362,7 +364,13 @@ export function NewDmDialog({
             pointerEvents: "auto",
           }}
         >
-          <DialogFrame title="New DM" onClose={onCancel} footer={footer} shrinkable>
+          <DialogFrame
+            title="New DM"
+            onClose={onCancel}
+            footer={footer}
+            desktopFooter={items.length > 0 ? { keys: [{ key: "Tab", label: "add" }] } : null}
+            shrinkable
+          >
             <Box flexDirection="column" flexShrink={1} minHeight={0} style={{ gap: 6 }}>
               {field}
               <Text fg={selectedUsernames.length > 0 ? colors.textMuted : colors.textDim} style={ELLIPSIS_STYLE}>

package/src/plugins/builtin/chat/controller/index.ts

@@ -1,3 +1,4 @@
+import { registerAccountSession } from "../../../../account/session";
 import type {
   AppNotificationDelivery,
   AppNotificationRequest,
@@ -757,3 +758,4 @@ export class ChatController {
 }
 
 export const chatController = new ChatController();
+registerAccountSession(chatController);

package/src/plugins/builtin/cloud/askg/controller.ts

@@ -4,13 +4,14 @@ import {
   type ASKGToolResultOutcome,
   type ASKGTransport,
 } from "../../../../api-client/askg";
-import type { ASKGToolExecutor } from "./executor";
+import { toolCallRemainingMs, type ASKGToolExecutor, type ASKGToolPreview } from "./executor";
 import {
   activeTurn,
   askgReducer,
   canRateTurn,
   EMPTY_ASKG_CONVERSATION,
   isTurnRunning,
+  NOT_APPROVED_IN_TIME_NOTE,
   requiresLocalConfirmation,
   type ASKGAction,
   type ASKGConversationState,
@@ -42,6 +43,18 @@ const MAX_HISTORY_TURNS = 8;
 const DEFAULT_TURN_WALL_CLOCK_MS = 120_000;
 /** Sessions are renegotiated a little before they expire. */
 const SESSION_EXPIRY_GRACE_MS = 5_000;
+/**
+ * A confirmation prompt closes this long before the server stops waiting for
+ * its call, so an approval still leaves time for the write and its result.
+ */
+export const CONFIRMATION_CLOSE_MARGIN_MS = 2_000;
+
+/**
+ * How a confirmation prompt ended. `expired` is this app's own deadline for
+ * the call; `abandoned` is the turn giving up on it (the call timed out on the
+ * server, the turn ended, was cancelled or lost its stream).
+ */
+type ConfirmationAnswer = "approved" | "declined" | "expired" | "abandoned";
 
 export interface ASKGControllerManifest {
   tools: ClientToolManifest[];
@@ -146,9 +159,7 @@ export class ASKGSessionController {
   private session: ASKGSessionStartResponse | null = null;
   private sessionRequest: Promise<ASKGSessionStartResponse> | null = null;
   private manifest: ASKGControllerManifest | null = null;
-  private readonly confirmations = new Map<string, (approved: boolean) => void>();
-  /** Calls whose turn ended while they were still waiting to be approved. */
-  private readonly abandonedCalls = new Set<string>();
+  private readonly confirmations = new Map<string, (answer: ConfirmationAnswer) => void>();
   private readonly toolTasks = new Set<Promise<void>>();
   private turnAbort: AbortController | null = null;
   /** Ratings of one answer go out in the order they were made. */
@@ -286,6 +297,8 @@ export class ASKGSessionController {
         signal: abort.signal,
         onEvent: (event) => this.handleEvent(event),
       });
+      // The stream is over, so no approval can reach this turn any more.
+      this.abandonPendingConfirmations();
       // Tool calls delivered late in the stream may still be running.
       await Promise.allSettled([...this.toolTasks]);
     } catch (error) {
@@ -350,6 +363,13 @@ export class ASKGSessionController {
       this.abandonPendingConfirmations();
       return;
     }
+    // The server reports a delegated call it gave up on (timed out, or its
+    // script ended) like one it got a result for. A prompt still open for it
+    // closes: an approval could no longer reach the turn.
+    if (event.type === "tool-executed") {
+      this.settleConfirmation(event.toolCallId, "abandoned");
+      return;
+    }
     if (event.type !== "tool-call") return;
     const task = this.runToolCall(event).finally(() => {
       this.toolTasks.delete(task);
@@ -384,12 +404,43 @@ export class ASKGSessionController {
 
     try {
       let confirmed = false;
+      let confirmedChange: string | undefined;
       if (requiresLocalConfirmation(call)) {
-        this.dispatch({ type: "tool-awaiting-confirmation", toolCallId: call.toolCallId });
-        confirmed = await new Promise<boolean>((resolve) => {
-          this.confirmations.set(call.toolCallId, resolve);
-        });
-        if (this.abandonedCalls.delete(call.toolCallId)) return;
+        const preview = await this.previewCall(call, signal);
+        // The turn ended or moved on while the app looked.
+        if (signal?.aborted || this.toolRowStatus(call.toolCallId) !== "pending") return;
+        if (preview?.kind === "refusal") {
+          await this.deliver(failure(preview.message));
+          return;
+        }
+        if (preview?.kind === "change") confirmedChange = preview.confirmKey;
+        // Nothing to approve: the operation re-checks and asks in the app itself if that changed.
+        if (preview?.kind === "no-change") {
+          confirmed = true;
+        } else {
+          this.dispatch({
+            type: "tool-awaiting-confirmation",
+            toolCallId: call.toolCallId,
+            ...(preview?.kind === "change" ? { preview: preview.summary } : {}),
+          });
+          const answer = await this.awaitConfirmation(
+            call.toolCallId,
+            startedAt + toolCallRemainingMs(call, startedAt),
+          );
+          if (answer === "abandoned") return;
+          if (answer === "expired") {
+            await this.deliver({
+              turnId: call.turnId,
+              toolCallId: call.toolCallId,
+              status: "timeout",
+              truncated: false,
+              elapsedMs: Math.max(0, this.now() - startedAt),
+              note: NOT_APPROVED_IN_TIME_NOTE,
+            });
+            return;
+          }
+          confirmed = answer === "approved";
+        }
         if (!confirmed) {
           await this.deliver({
             turnId: call.turnId,
@@ -413,6 +464,7 @@ export class ASKGSessionController {
       }
       const payload = await executor.execute(call, {
         confirmed: confirmed || !requiresLocalConfirmation(call),
+        ...(confirmedChange ? { confirmedChange } : {}),
         ...(signal ? { signal } : {}),
       });
       await this.deliver(payload);
@@ -425,6 +477,28 @@ export class ASKGSessionController {
     }
   }
 
+  /**
+   * The operation's own account of a call that needs approval, when it has
+   * one. Null keeps the server's description.
+   */
+  private async previewCall(call: ASKGToolCallEvent, signal?: AbortSignal): Promise<ASKGToolPreview | null> {
+    try {
+      const manifest = this.manifest ?? await this.options.loadManifest();
+      this.manifest = manifest;
+      return await this.options.getExecutor(manifest)?.preview?.(call, signal) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private toolRowStatus(toolCallId: string): string | undefined {
+    for (const turn of this.state.turns) {
+      const row = turn.tools.find((entry) => entry.toolCallId === toolCallId);
+      if (row) return row.status;
+    }
+    return undefined;
+  }
+
   /** Records a tool result locally, then posts it to the turn loop. */
   private async deliver(payload: ToolResultPayload): Promise<void> {
     this.dispatch({ type: "tool-result", payload });
@@ -444,25 +518,43 @@ export class ASKGSessionController {
     }
   }
 
-  /** Answers a `user-data` or `broker` confirmation prompt. */
-  resolveConfirmation(toolCallId: string, approved: boolean): void {
+  /**
+   * Waits for the person's answer to one call. The prompt closes on its own
+   * a little before the server stops waiting (`deadlineAt`, by this clock),
+   * so an approval always has time to land; an older server that waits less
+   * than the call declared says so in the frame, and is honoured the same way.
+   */
+  private awaitConfirmation(toolCallId: string, deadlineAt: number): Promise<ConfirmationAnswer> {
+    return new Promise<ConfirmationAnswer>((resolve) => {
+      const timer = setTimeout(
+        () => this.settleConfirmation(toolCallId, "expired"),
+        Math.max(0, deadlineAt - CONFIRMATION_CLOSE_MARGIN_MS - this.now()),
+      );
+      this.confirmations.set(toolCallId, (answer) => {
+        clearTimeout(timer);
+        resolve(answer);
+      });
+    });
+  }
+
+  /** Ends one prompt. Only the first answer counts; a later one does nothing. */
+  private settleConfirmation(toolCallId: string, answer: ConfirmationAnswer): void {
     const resolve = this.confirmations.get(toolCallId);
     if (!resolve) return;
     this.confirmations.delete(toolCallId);
-    resolve(approved);
+    resolve(answer);
   }
 
-  private rejectPendingConfirmations(): void {
-    for (const [toolCallId, resolve] of [...this.confirmations]) {
-      this.confirmations.delete(toolCallId);
-      resolve(false);
-    }
+  /** Answers a `user-data` or `broker` confirmation prompt. */
+  resolveConfirmation(toolCallId: string, approved: boolean): void {
+    this.settleConfirmation(toolCallId, approved ? "approved" : "declined");
   }
 
   /** Drops confirmations whose answer can no longer reach the turn. */
   private abandonPendingConfirmations(): void {
-    for (const toolCallId of this.confirmations.keys()) this.abandonedCalls.add(toolCallId);
-    this.rejectPendingConfirmations();
+    for (const toolCallId of [...this.confirmations.keys()]) {
+      this.settleConfirmation(toolCallId, "abandoned");
+    }
   }
 
   /**

package/src/plugins/builtin/cloud/askg/executor.ts

@@ -32,6 +32,7 @@ import { describeTrimmedLists, fitResultToBytes } from "./result-budget";
 import {
   remoteRequestForTool,
   resolveRemoteToolBinding,
+  toolExecutionTimeoutMs,
 } from "./manifest";
 import {
   ASKGUndoManager,
@@ -67,16 +68,38 @@ export interface ASKGToolExecutorDependencies {
 interface ASKGToolExecutionOptions {
   signal?: AbortSignal;
   confirmed?: boolean;
+  /** The confirmKey of the preview the person approved, so the app does not ask again. */
+  confirmedChange?: string;
 }
 
+/**
+ * What a call needing approval will change, from the operation's own dry run:
+ * the list and listing it resolved rather than the arguments as sent.
+ */
+export type ASKGToolPreview =
+  | { kind: "change"; summary: string; confirmKey: string }
+  /**
+   * Nothing would change (already on the list), so there is nothing to
+   * approve. The operation checks again when it runs and asks in the app
+   * itself if that is no longer so.
+   */
+  | { kind: "no-change" }
+  /** The app refuses the call as asked. */
+  | { kind: "refusal"; message: string };
+
 export interface ASKGToolExecutor {
   execute(
     call: ASKGToolCallEvent,
     options?: ASKGToolExecutionOptions,
   ): Promise<ToolResultPayload>;
+  /** Null when the call has no dry run that says more than its arguments. */
+  preview?(call: ASKGToolCallEvent, signal?: AbortSignal): Promise<ASKGToolPreview | null>;
   undo(token: string, signal?: AbortSignal): Promise<AppliedUndo>;
 }
 
+/** A dry run answers from local state and at most one search. */
+const PREVIEW_TIMEOUT_MS = 3_000;
+
 interface ExecutionValue {
   status: ToolResultStatus;
   result?: unknown;
@@ -214,7 +237,11 @@ function inferRemoteRowCount(value: unknown): number | undefined {
   return 1;
 }
 
-function effectiveTimeoutMs(call: ASKGToolCallEvent, now: number): number {
+/**
+ * How much longer the server waits for this call, by its frame: its timeout,
+ * and never past the time it expires.
+ */
+export function toolCallRemainingMs(call: ASKGToolCallEvent, now: number): number {
   const declared = Math.max(0, call.timeoutMs);
   const expiresAt = Date.parse(call.expiresAt);
   if (!Number.isFinite(expiresAt)) return declared;
@@ -346,7 +373,7 @@ export function createASKGToolExecutor(
       return base({ status: "denied", note: "This tool call requires local confirmation." });
     }
 
-    const timeoutMs = Math.min(manifest.timeoutMs, effectiveTimeoutMs(call, now()));
+    const timeoutMs = Math.min(toolExecutionTimeoutMs(manifest), toolCallRemainingMs(call, now()));
     try {
       const value = await runWithDeadline(async (signal): Promise<ExecutionValue> => {
         if (manifest.source === "headless") {
@@ -375,7 +402,10 @@ export function createASKGToolExecutor(
           }
         }
 
-        const response = await dependencies.remoteHandler(remoteRequestForTool(binding, call.args));
+        const response = await dependencies.remoteHandler(remoteRequestForTool(binding, call.args), {
+          signal,
+          ...(options.confirmed && options.confirmedChange ? { confirmed: options.confirmedChange } : {}),
+        });
         if (!response.ok) {
           return {
             status: "error",
@@ -413,8 +443,32 @@ export function createASKGToolExecutor(
     }
   };
 
+  const preview = async (call: ASKGToolCallEvent, signal?: AbortSignal): Promise<ASKGToolPreview | null> => {
+    const manifest = manifests.get(call.name);
+    if (!manifest || manifest.source !== "remote-op" || manifest.confirm !== "always") return null;
+    const binding = resolveRemoteToolBinding(call.name);
+    if (binding?.kind !== "operation") return null;
+    try {
+      const response = await runWithDeadline(
+        () => dependencies.remoteHandler({ type: "call", operation: binding.operation, input: call.args, dryRun: true, include: [] }),
+        PREVIEW_TIMEOUT_MS,
+        signal,
+      );
+      if (!response.ok) return { kind: "refusal", message: response.error.message };
+      const data = response.data as { summary?: unknown; confirmKey?: unknown; changes?: unknown } | null;
+      if (typeof data?.summary !== "string" || typeof data.confirmKey !== "string") return null;
+      return data.changes === false
+        ? { kind: "no-change" }
+        : { kind: "change", summary: data.summary, confirmKey: data.confirmKey };
+    } catch {
+      // The person still approves the call as the server described it.
+      return null;
+    }
+  };
+
   return {
     execute,
+    preview,
     undo: (token, signal) => undoManager.undo(token, signal),
   };
 }

package/src/plugins/builtin/cloud/askg/manifest.ts

@@ -25,6 +25,12 @@ import {
 
 const HEADLESS_TOOL_TIMEOUT_MS = 30_000;
 const REMOTE_TOOL_TIMEOUT_MS = 10_000;
+/**
+ * A tool that asks first waits for a person to read the prompt and click, so
+ * the server holds the call this long: the minute the terminal relay gives a
+ * confirmation. A server from before the window holds it 10 s.
+ */
+const CONFIRM_TOOL_TIMEOUT_MS = 60_000;
 const REMOTE_RESOURCE_TOOL_NAME = "app.get_resource";
 
 const TOOL_NAME_REGEX = new RegExp(TOOL_NAME_PATTERN);
@@ -166,11 +172,14 @@ function headlessCandidates(registry: PaneFunctionCatalog): ManifestCandidate[]
   return candidates;
 }
 
+/** Ask Gloom's tool results are text, so an operation that answers with a PNG is not offered there. */
+const ASKG_REMOTE_OPERATIONS = REMOTE_OPERATIONS.filter((operation) => !operation.returnsImage);
+
 function remoteCandidates(): ManifestCandidate[] {
-  const descriptors = remoteOperationDescriptors();
   const operationsByName = new Map(
-    REMOTE_OPERATIONS.map((operation) => [remoteOperationToolName(operation.id), operation]),
+    ASKG_REMOTE_OPERATIONS.map((operation) => [remoteOperationToolName(operation.id), operation]),
   );
+  const descriptors = remoteOperationDescriptors().filter((descriptor) => operationsByName.has(descriptor.name));
   const candidates = descriptors.map((descriptor): ManifestCandidate => ({
     token: descriptor.name,
     identity: `operation:${operationsByName.get(descriptor.name)?.id ?? descriptor.name}`,
@@ -181,10 +190,7 @@ function remoteCandidates(): ManifestCandidate[] {
       description: descriptor.description,
       writeTier: descriptor.writeTier,
       inputSchema: descriptor.inputSchema,
-      confirm: descriptor.writeTier === "user-data" || descriptor.writeTier === "broker"
-        ? "always"
-        : "never",
-      timeoutMs: REMOTE_TOOL_TIMEOUT_MS,
+      ...remoteConfirmation(descriptor.writeTier),
     },
   }));
 
@@ -217,6 +223,25 @@ function remoteCandidates(): ManifestCandidate[] {
   return candidates;
 }
 
+/** Account and broker writes ask first, and get the minute that takes. */
+function remoteConfirmation(writeTier: ClientToolManifest["writeTier"]): Pick<ClientToolManifest, "confirm" | "timeoutMs"> {
+  return writeTier === "user-data" || writeTier === "broker"
+    ? { confirm: "always", timeoutMs: CONFIRM_TOOL_TIMEOUT_MS }
+    : { confirm: "never", timeoutMs: REMOTE_TOOL_TIMEOUT_MS };
+}
+
+/**
+ * How long a call may run once it starts. A tool that asks first declares the
+ * window for the person and the write together; the write itself keeps the
+ * budget of every app action, counted from the approval rather than from the
+ * call. The server's deadline for the call still bounds it.
+ */
+export function toolExecutionTimeoutMs(manifest: Pick<ClientToolManifest, "confirm" | "timeoutMs">): number {
+  return manifest.confirm === "always"
+    ? Math.min(manifest.timeoutMs, REMOTE_TOOL_TIMEOUT_MS)
+    : manifest.timeoutMs;
+}
+
 function compareManifests(left: ClientToolManifest, right: ClientToolManifest): number {
   return compareText(left.name, right.name) || compareText(left.source, right.source);
 }
@@ -314,7 +339,7 @@ export async function buildASKGClientManifest(
 
 export function resolveRemoteToolBinding(name: string): RemoteToolBinding | null {
   if (name === REMOTE_RESOURCE_TOOL_NAME) return { kind: "resource" };
-  const operation = REMOTE_OPERATIONS.find((entry) => remoteOperationToolName(entry.id) === name);
+  const operation = ASKG_REMOTE_OPERATIONS.find((entry) => remoteOperationToolName(entry.id) === name);
   return operation ? { kind: "operation", operation: operation.id } : null;
 }