@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/daemon/conversation-store.ts

@@ -184,18 +184,18 @@ export async function getOrCreateConversation(
   // messages live in memory on the instance being disposed, and the queue
   // drains via an async dispatch after the current turn releases, so
   // `isProcessing()` can read false while a queued turn is still pending:
-  // rebuilding in that gap would silently drop those messages. The conversation
-  // stays stale and is rebuilt on a later call.
+  // rebuilding in that gap would silently drop those messages. In-flight
+  // subagents are the same: the parent reads idle between its own tool calls
+  // while children still run, and rebuilding would abort them. The
+  // conversation stays stale and is rebuilt on a later call.
   if (
     !conversation ||
-    (conversation.isStale() &&
-      !conversation.isProcessing() &&
-      !conversation.hasQueuedMessages())
+    (conversation.isStale() && !conversation.hasInFlightWork())
   ) {
     if (conversation) {
-      // Stale rebuild: the conversation id lives on, so abort in-flight
-      // children but keep terminal subagent results readable for the
-      // retention window.
+      // Stale rebuild: the conversation id lives on, so abort any children
+      // that raced into flight after the idle check and keep terminal
+      // subagent results readable for the retention window.
       getSubagentManager().abortAllForParent(conversationId);
       conversation.dispose();
     }
@@ -400,32 +400,22 @@ export function clearAllActiveConversations(): number {
 
 /**
  * Evict in-memory conversations after a config/prompt/skills reload so the next
- * turn rebuilds them against the new config. Idle conversations are disposed and
- * dropped; busy ones are marked stale so they're rebuilt once their current turn
- * finishes. Conversations with in-flight subagents are left in place so a
- * reload does not abort those children. Also used when provider credentials
+ * turn rebuilds them against the new config. Conversations with in-flight work
+ * (a live turn, a queued successor, or an active subagent) are marked stale
+ * and rebuilt by `getOrCreateConversation` once that work finishes. Idle
+ * conversations are disposed and dropped. Also used when provider credentials
  * change.
  */
 export function evictConversationsForReload(): void {
   const subagentManager = getSubagentManager();
   for (const [id, conversation] of conversationEntries()) {
-    // A conversation with queued messages is not idle: the queue drains via an
-    // async dispatch after the current turn releases, so `isProcessing()` can
-    // read false while a queued turn is still pending. Disposing in that gap
-    // would silently drop the queued messages, so mark it stale instead and
-    // let it rebuild once the queue has run.
-    if (!conversation.isProcessing() && !conversation.hasQueuedMessages()) {
-      // Same protection the TTL/LRU evictor applies: an idle parent still
-      // owns mid-task children, and aborting them here would kill that work.
-      if (subagentManager.hasActiveChildren(id)) {
-        continue;
-      }
-      subagentManager.abortAllForParent(id);
-      conversation.dispose();
-      deleteConversation(id);
-      removeFromEvictor(id);
-    } else {
+    if (conversation.hasInFlightWork()) {
       conversation.markStale();
+      continue;
     }
+    subagentManager.abortAllForParent(id);
+    conversation.dispose();
+    deleteConversation(id);
+    removeFromEvictor(id);
   }
 }

package/src/daemon/conversation-surfaces.ts

@@ -543,19 +543,29 @@ export function findPersistedSurfaceInfo(
  * user-action completion paths: the underlying request is already resolved, so
  * withholding the announcement on a transient write failure strands a live,
  * clickable approval card for a decision that has already been made.
+ *
+ * Returns whether the completion persisted durably (see
+ * {@link markSurfaceCompleted}); the broadcast goes out either way. A caller
+ * whose own receipt depends on the card staying completed across a reload
+ * (the expiry sweep) holds that receipt back on false and retries.
  */
 export function completeSurfaceAndNotify(
   conversationId: string,
   surfaceId: string,
   summary: string,
-): void {
-  markSurfaceCompleted({ conversationId }, surfaceId, summary);
+): boolean {
+  const persisted = markSurfaceCompleted(
+    { conversationId },
+    surfaceId,
+    summary,
+  );
   broadcastMessage({
     type: "ui_surface_complete",
     conversationId,
     surfaceId,
     summary,
   });
+  return persisted;
 }
 
 /**

package/src/daemon/conversation-tool-setup.ts

@@ -8,6 +8,7 @@
 
 import type { AssistantEvent } from "../api/index.js";
 import {
+  type ClientOs,
   type HostProxyCapability,
   parseClientOs,
   supportsHostProxy,
@@ -15,6 +16,7 @@ import {
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
 import { isMemoryEnabled } from "../config/memory-v3-gate.js";
+import { supportsChannelReaction } from "../messaging/providers/index.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
@@ -433,8 +435,7 @@ export function createToolExecutor(
       toolUseId,
       isPlatformHosted: getIsPlatform(),
       transportInterface: ctx.transportInterface,
-      clientOs:
-        parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ?? undefined,
+      clientOs: resolveTurnClientOs(ctx).clientOs,
       overrideProfile: ctx.currentTurnOverrideProfile,
       cronRunId: ctx.currentTurnCronRunId,
       invokingCallSite: ctx.currentCallSite ?? "mainAgent",
@@ -713,14 +714,14 @@ export const ALLOWLIST_ONLY_TOOL_NAMES = new Set<string>([
 ]);
 
 /**
- * Windows parity gate: skill tools may declare `supported_client_os`; drop
- * them when the turn's client OS (or pinned OS for wakes) is not listed.
+ * Host OS of the client driving this turn. The Electron renderer reports
+ * `interface: "web"` and carries the real OS in `clientOs`, so this prefers
+ * the frozen per-turn value and only falls back to a desktop transport.
  */
-function isToolSupportedOnClientOs(name: string, ctx: Conversation): boolean {
-  const supportedClientOs = getTool(name)?.supportedClientOs;
-  if (!supportedClientOs) {
-    return true;
-  }
+function resolveTurnClientOs(ctx: Conversation): {
+  clientOs: ClientOs | undefined;
+  transportInterface: Conversation["transportInterface"];
+} {
   const pin = ctx.toolContextPin;
   const transportInterface = pin
     ? pin.transportInterface
@@ -731,6 +732,19 @@ function isToolSupportedOnClientOs(name: string, ctx: Conversation): boolean {
       (transportInterface === "macos" || transportInterface === "windows"
         ? transportInterface
         : undefined));
+  return { clientOs, transportInterface };
+}
+
+/**
+ * Windows parity gate: skill tools may declare `supported_client_os`; drop
+ * them when the turn's client OS (or pinned OS for wakes) is not listed.
+ */
+function isToolSupportedOnClientOs(name: string, ctx: Conversation): boolean {
+  const supportedClientOs = getTool(name)?.supportedClientOs;
+  if (!supportedClientOs) {
+    return true;
+  }
+  const { clientOs, transportInterface } = resolveTurnClientOs(ctx);
   return supportsClientOsForSkillTool(supportedClientOs, name, {
     clientOs,
     transportInterface,
@@ -808,6 +822,20 @@ export function isToolActiveForContext(
       return true;
     }
   }
+  // The react capability follows the transport's declaration: the tool is on
+  // the wire exactly when the turn's channel transport implements `react`,
+  // so the model never sees an option the channel cannot honor. The turn's
+  // own capabilities take precedence over the conversation's structural ones
+  // (same order as `conversationSupportsDynamicUi`): an app-side turn on a
+  // channel-origin conversation has no channel message to react to, and the
+  // executor's channel comes from the turn. Wake pins read as no channel
+  // and hide it.
+  if (name === "react_to_message") {
+    const turnChannel = pin
+      ? undefined
+      : (ctx.currentTurnChannelCapabilities ?? channelCapabilities)?.channel;
+    return supportsChannelReaction(turnChannel);
+  }
   if (UI_SURFACE_TOOL_NAMES.has(name)) {
     if (
       channelCapabilities?.channel === "slack" &&
@@ -871,7 +899,8 @@ export function isToolActiveForContext(
   if (PLATFORM_TOOL_NAMES.has(name)) {
     // Check the *client's* platform, not the daemon's process.platform.
     // In Docker the daemon runs on Linux but the connected client may be macOS.
-    return channelCapabilities?.clientOS === "macos" && !hasNoClient;
+    const { clientOs } = resolveTurnClientOs(ctx);
+    return (clientOs === "macos" || clientOs === "windows") && !hasNoClient;
   }
   if (SUBAGENT_ONLY_TOOL_NAMES.has(name)) {
     return ctx.isSubagent === true;

package/src/daemon/conversation.ts

@@ -21,7 +21,7 @@ import { AgentLoop } from "../agent/loop.js";
 import type { AssistantActivityStateEvent } from "../api/events/assistant-activity-state.js";
 import type { ConfirmationStateChangedEvent } from "../api/events/confirmation-state-changed.js";
 import type { AssistantEvent } from "../api/index.js";
-import { decideGuardianRequest } from "../channels/gateway-guardian-requests.js";
+import { syncTerminalGuardianRequestStatus } from "../approvals/guardian-request-status-sync.js";
 import type {
   ChannelId,
   InterfaceId,
@@ -41,6 +41,7 @@ import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
 } from "../context/post-turn-tool-result-truncation.js";
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
 import { isGuardianCardRow } from "../notifications/approval-card-data.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
@@ -55,6 +56,7 @@ import {
   setConversationProcessingStartedAt,
 } from "../persistence/conversation-crud.js";
 import { getResolvedConversationDirPath } from "../persistence/conversation-directories.js";
+import { extractTextFromStoredMessageContent } from "../persistence/message-content.js";
 import { reportSlowSync } from "../persistence/slow-sync-log.js";
 import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
 import {
@@ -137,6 +139,7 @@ import type {
 } from "./conversation-queue-manager.js";
 import { MessageQueue } from "./conversation-queue-manager.js";
 import {
+  applySightFrameRetention,
   type ChannelCapabilities,
   getSlackCompactionWatermarkForPrefix,
   getSlackWatermarkAdvanceForRowPrefix,
@@ -172,6 +175,8 @@ import { filterMessagesForUntrustedActor } from "./message-provenance.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import { isHostProxyTransport } from "./message-types/conversations.js";
 import { conversationMetadataSyncTag } from "./message-types/sync.js";
+import { renderReactionHistoryText } from "./reaction-history-render.js";
+import type { QueuedReactionRecord } from "./reaction-record.js";
 import {
   resolveSummarizeBoundary,
   startsNewTurn,
@@ -538,6 +543,14 @@ export class Conversation {
   /** @internal */ currentTurnSourceActorPrincipalId?: string;
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
   /** @internal */ loadedHistoryPersonalMemoryAllowed?: boolean;
+  /** @internal */ loadedHistoryStale = false;
+  /**
+   * @internal Reactions the current turn delivered, awaiting their durable
+   * rows. Written mid-turn by the react tool, drained by the agent loop at
+   * the turn boundary so the rows never land between a tool_use and its
+   * tool_result.
+   */
+  pendingReactionRecords: QueuedReactionRecord[] = [];
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
   /**
@@ -887,6 +900,16 @@ export class Conversation {
           conv.createdAt,
         );
       },
+      // Compaction rebuilds history from the stored rows, so it can retain
+      // camera frames the turn's pre-run pass had already stubbed, and the
+      // rebuilt array is sent on the next request of that same turn. Re-running
+      // the retention pass here is what holds the frame bound across a
+      // compaction instead of only from the next turn onward. The row read
+      // repeats rather than sharing the pre-run pass's map: compactions are
+      // rare, and a map captured before the turn's awaits would describe a
+      // conversation that has since gained rows.
+      transformCompactedHistory: (messages) =>
+        applySightFrameRetention(messages, this.conversationId),
     });
     createContextWindowManager({
       provider,
@@ -1052,6 +1075,9 @@ export class Conversation {
 
   async loadFromDb(): Promise<LoadFromDbResult> {
     const loadStartedAt = performance.now();
+    // Cleared before the rows are read: a channel event persisted mid-load
+    // re-marks the flag, so the next turn reloads rather than missing it.
+    this.loadedHistoryStale = false;
     const trustClass = this.trustContext?.trustClass;
     const canAccessMemory = resolveCapabilities(trustClass).canAccessMemory;
     const allDbMessages = getMessages(this.conversationId);
@@ -1142,6 +1168,44 @@ export class Conversation {
       }
       return v3PrunedSlugsMemo;
     };
+    // Provider-id → row-text index for reaction target resolution, built
+    // lazily on the first reaction row: most conversations carry none, so
+    // most loads never walk the rows a second time. Keyed over the full
+    // (unsliced) history so a reaction whose target was compacted out of
+    // context still resolves its quote.
+    let reactionTargetIndexMemo: Map<string, string> | null = null;
+    const resolveReactionTarget = (
+      targetMessageId: string,
+    ): string | undefined => {
+      if (reactionTargetIndexMemo === null) {
+        reactionTargetIndexMemo = new Map();
+        for (const row of dbMessages) {
+          const rowMeta = readProviderMetadata(row.metadata);
+          // A deleted target is a logical erasure (same rule as the Slack
+          // transcript renderer), so its text is never quoted back.
+          if (
+            rowMeta?.eventKind === "message" &&
+            rowMeta.deletedAt === undefined &&
+            rowMeta.messageId
+          ) {
+            const text = extractTextFromStoredMessageContent(row.content);
+            if (text) {
+              // A split reply posts several provider messages from one row;
+              // a reaction may name any of them.
+              for (const id of [
+                rowMeta.messageId,
+                ...(rowMeta.additionalMessageIds ?? []),
+              ]) {
+                if (!reactionTargetIndexMemo.has(id)) {
+                  reactionTargetIndexMemo.set(id, text);
+                }
+              }
+            }
+          }
+        }
+      }
+      return reactionTargetIndexMemo.get(targetMessageId);
+    };
     const parsedMessages: Message[] = slicedDbMessages.map((m, index, arr) => {
       const isPreStripped = index < preStrippedCount;
       const role = m.role as "user" | "assistant";
@@ -1149,6 +1213,38 @@ export class Conversation {
 
       content = reinjectAttachmentPathAnnotations(content, role, m.metadata);
 
+      // Channel facts stamped in metadata render at load time rather than
+      // at persist time, so every stored row reads correctly whenever it
+      // was written: a reaction row's "[reaction]" sentinel renders as who
+      // reacted with what to which message, and a deleted row's original
+      // text gives way to a deletion marker (the delete intercepts stamp
+      // metadata and deliberately leave the content column untouched). The
+      // substring guard keeps the per-row metadata parse off rows that can
+      // carry neither fact: both envelopes spell these keys literally, in
+      // providerMeta and in nested slackMeta alike.
+      if (
+        m.metadata &&
+        (m.metadata.includes("reaction") || m.metadata.includes("deletedAt"))
+      ) {
+        const providerMeta = readProviderMetadata(m.metadata);
+        if (providerMeta?.eventKind === "reaction") {
+          const rendered = renderReactionHistoryText(
+            providerMeta,
+            resolveReactionTarget,
+            // An assistant-role reaction row is the assistant's own act,
+            // persisted by the react tool.
+            { selfAuthored: role === "assistant" },
+          );
+          if (rendered) {
+            content = [{ type: "text", text: rendered }];
+          }
+        } else if (role === "user" && providerMeta?.deletedAt !== undefined) {
+          // Neutral marker, no actor: Discord deletes can be authorless
+          // (`actorUnattributed`), so the marker never claims who deleted.
+          content = [{ type: "text", text: "[This message was deleted]" }];
+        }
+      }
+
       // Re-inject persisted injection blocks from metadata so it survives
       // conversation reloads (eviction, restart, fork).
       if (role === "user" && m.metadata && !isPreStripped) {
@@ -1522,6 +1618,7 @@ export class Conversation {
       this.trustContext,
     );
     if (
+      !this.loadedHistoryStale &&
       this.loadedHistoryTrustClass === currentTrustClass &&
       this.loadedHistoryPersonalMemoryAllowed === currentPersonalMemoryAllowed
     ) {
@@ -1530,6 +1627,22 @@ export class Conversation {
     await this.loadFromDb();
   }
 
+  /**
+   * Mark the resident history stale: a channel event (a reaction, edit, or
+   * delete) was persisted straight to the store while this conversation was
+   * loaded, so `this.messages` no longer reflects the rows. The next
+   * {@link ensureActorScopedHistory} reloads instead of reusing the resident
+   * history.
+   */
+  markHistoryStale(): void {
+    this.loadedHistoryStale = true;
+  }
+
+  /** Queue a delivered reaction for its durable row at the turn boundary. */
+  queueReactionRecord(record: QueuedReactionRecord): void {
+    this.pendingReactionRecords.push(record);
+  }
+
   /**
    * Deliver an event through the conversation's sink, then to every observer.
    * The single emission point for conversation-level events (activity state,
@@ -1878,6 +1991,18 @@ export class Conversation {
     return !this.queue.isEmpty;
   }
 
+  /**
+   * True when dropping this instance would lose work that is still in flight:
+   * a live turn, a queued successor, or a child subagent.
+   */
+  hasInFlightWork(): boolean {
+    return (
+      this.isProcessing() ||
+      this.hasQueuedMessages() ||
+      getSubagentManager().hasActiveChildren(this.conversationId)
+    );
+  }
+
   /** FIFO snapshot of the messages currently waiting in the in-memory queue.
    * Read-only — used to surface queued user messages in history responses. */
   snapshotQueuedMessages(): QueuedMessage[] {
@@ -1963,20 +2088,16 @@ export class Conversation {
     });
 
     // Sync the gateway request status so stale "pending" records don't get
-    // matched by later guardian reply routing. Fire-and-forget: this method
-    // is sync with many callers (HTTP handlers, /v1/confirm, channel
-    // bridges), the in-memory resolution above is authoritative, and a CAS
-    // miss (the decision primitive already resolved it, e.g. the channel
-    // approval path) is expected and harmless.
-    void decideGuardianRequest({
-      id: requestId,
-      expectedStatus: "pending",
+    // matched by later guardian reply routing, and withdraw the request's
+    // approval cards when this sync is the write that landed. Fire-and-forget:
+    // this method is sync with many callers (HTTP handlers, /v1/confirm,
+    // channel bridges), the in-memory resolution above is authoritative, and
+    // a CAS miss (the decision primitive already resolved it and withdrew the
+    // cards itself, e.g. the channel approval path) is expected and harmless.
+    void syncTerminalGuardianRequestStatus({
+      requestId,
       status: resolvedState,
-    }).catch((err) => {
-      log.warn(
-        { err, requestId },
-        "Post-confirmation guardian request status sync failed",
-      );
+      syncContext: "post-confirmation",
     });
   }
 
@@ -2304,6 +2425,20 @@ export class Conversation {
     }
   }
 
+  /**
+   * Trim this conversation's aged camera frames out of a history about to be
+   * sent to a provider, keeping only the newest few as real images.
+   *
+   * Thin binding of {@link applySightFrameRetention} to the conversation's own
+   * id, for the send paths that hold the instance rather than a turn context:
+   * the compaction pipeline's summarizer input, and the wake, which sends its
+   * run input itself. Best-effort inside, so a failed row read degrades to the
+   * untrimmed history.
+   */
+  trimAgedSightFrames(messages: Message[]): Message[] {
+    return applySightFrameRetention(messages, this.conversationId);
+  }
+
   /**
    * Auto-threshold compaction gate. Runs the same durable compaction
    * pipeline as {@link forceCompact} (summary call, circuit-breaker
@@ -2403,8 +2538,16 @@ export class Conversation {
             },
           )
         : null;
-    const messagesToCompact =
-      slackChronologicalContext?.messages ?? this.messages;
+    // Trim aged camera frames out of the summarizer's own input. Compaction
+    // sends this array to a provider like any other request, so a long camera
+    // session would otherwise put every frame it ever captured into the summary
+    // call, which is the payload-size and many-image rejection retention exists
+    // to prevent. Safe against the caller-fixed boundary below: the pass
+    // replaces blocks inside messages and never adds, drops, or reorders one,
+    // so `fixedTailStartIndex` still names the same message.
+    const messagesToCompact = this.trimAgedSightFrames(
+      slackChronologicalContext?.messages ?? this.messages,
+    );
     const compactedRowCountAtCall = this.contextCompactedMessageCount;
     let result = await defaultCompact({
       conversationId: this.conversationId,

package/src/daemon/daemon-control.ts

@@ -1,4 +1,4 @@
-import { execSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import {
   closeSync,
   existsSync,
@@ -23,6 +23,8 @@ import {
   getPidPath,
   getWorkspaceConfigPath,
 } from "../util/platform.js";
+import { readRawProcessCommand } from "../util/process-table.js";
+import { isDaemonCommand } from "../util/worker-ownership.js";
 
 const log = getLogger("lifecycle");
 
@@ -116,24 +118,11 @@ function isProcessRunning(pid: number): boolean {
 }
 
 /**
- * Check whether a PID belongs to a vellum daemon process (a bun process
- * running the daemon's main.ts). Prevents signaling an unrelated process
- * that reused a stale PID.
+ * Check whether a PID belongs to a vellum daemon process. Prevents signalling
+ * an unrelated process that reused a stale PID.
  */
 function isVellumDaemonProcess(pid: number): boolean {
-  try {
-    const cmd = execSync(`ps -ww -p ${pid} -o command=`, {
-      encoding: "utf-8",
-      timeout: 3000,
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    // The daemon is spawned as `bun run <path>/main.ts` — look for bun
-    // running our daemon entry point.
-    return cmd.includes("bun") && cmd.includes("daemon/main.ts");
-  } catch {
-    // Process exited or ps failed — treat as not ours.
-    return false;
-  }
+  return isDaemonCommand(readRawProcessCommand(pid));
 }
 
 /** Normalize a bind address to a connectable host for health checks.

package/src/daemon/handlers/config-model.test.ts

@@ -65,6 +65,7 @@ describe("projectProviderForWire", () => {
     const wire = projectProviderForWire(gemini!);
     const modelIds = wire.models.map((model) => model.id);
     const expectedGemini3ModelIds = [
+      "gemini-3.7-flash",
       "gemini-3.6-flash",
       "gemini-3.5-flash",
       "gemini-3.5-flash-lite",

package/src/daemon/handlers/conversations.ts

@@ -1,5 +1,6 @@
 import { peekAcpSessionManager } from "../../acp/index.js";
-import { decideGuardianRequest } from "../../channels/gateway-guardian-requests.js";
+import { GUARDIAN_TERMINAL_REASON_SUPERSEDED } from "../../api/responses/home.js";
+import { syncTerminalGuardianRequestStatus } from "../../approvals/guardian-request-status-sync.js";
 import {
   clearAll,
   getConversation,
@@ -522,18 +523,16 @@ export function supersedePendingInteractionsOnEnqueue(
           source: "auto_deny" as const,
         });
         // Sync the gateway request so stale "pending" rows aren't matched
-        // by later guardian reply routing. Fire-and-forget from this sync
-        // path: the in-memory denial is authoritative, and a CAS miss
+        // by later guardian reply routing, and withdraw the request's
+        // delivered approval cards so no surface keeps offering a decision
+        // that can no longer resolve anything. Fire-and-forget from this
+        // sync path: the in-memory denial is authoritative, and a CAS miss
         // (already decided elsewhere) is expected and harmless.
-        void decideGuardianRequest({
-          id: interaction.requestId,
-          expectedStatus: "pending",
+        void syncTerminalGuardianRequestStatus({
+          requestId: interaction.requestId,
           status: "denied",
-        }).catch((err) => {
-          log.warn(
-            { err, requestId: interaction.requestId },
-            "Auto-deny guardian request status sync failed",
-          );
+          syncContext: "supersede-on-enqueue",
+          terminalReason: GUARDIAN_TERMINAL_REASON_SUPERSEDED,
         });
       }
     }

package/src/daemon/install-assistant-command.ts

@@ -262,6 +262,7 @@ function commandResolvesElsewhere(
     const resolved = execFileSync("/usr/bin/which", [commandName], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
     }).trim();
     return resolved !== "" && !candidatePaths.has(resolved);
   } catch {

package/src/daemon/lifecycle.ts

@@ -461,19 +461,16 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Expire stale pending guardian requests left over from before this
-    // process started. Daemon-keyed by design: interaction-bound kinds die
-    // with THIS process's in-memory pendingInteractions map, so the daemon
-    // triggers the gateway op at its own boot — the gateway never runs it
-    // on its own restart. Two categories are cleaned up:
-    //
-    // 1. Interaction-bound kinds (tool_approval, pending_question) — their
-    //    in-memory pending-interaction session references are gone, so they
-    //    can never be completed.
-    // 2. Any pending request whose expiresAt has already passed — persistent
-    //    kinds (access_request, tool_grant_request) that expired while the
-    //    daemon was stopped are transitioned so dedup logic doesn't return
-    //    stale rows.
+    // Expire interaction-bound guardian requests (tool_approval,
+    // pending_question) left over from before this process started: their
+    // in-memory pending-interaction session references are gone, so they
+    // can never be completed. Daemon-keyed by design: the daemon triggers
+    // the gateway op at its own boot, and the gateway never runs it on its
+    // own restart. Persistent kinds (access_request, tool_grant_request) are
+    // never touched here, whatever their deadline: their expiry belongs to
+    // the periodic sweep, which owns the card-withdrawal and
+    // requester-notice fan-out, and the dedupe reads are deadline-aware so
+    // a past-deadline row waiting for the sweep suppresses nothing.
     //
     // Startup must not block on the gateway (daemon startup philosophy):
     // on failure the periodic sweep still reaps time-expired rows, and

package/src/daemon/message-types/sync.ts

@@ -20,6 +20,10 @@ export const SYNC_TAGS = {
   conversationsList: "conversations:list",
   featureFlagsClient: "feature-flags:client",
   featureFlagsAssistant: "feature-flags:assistant",
+  /** ACP credential-failure markers, which drive the inline Connect card.
+   *  Invalidated when a token write retires them, so a client holding a
+   *  restored prompt for the replaced token stops offering it. */
+  acpAuthRecovery: "acp:auth-recovery",
 } as const;
 
 export type KnownSyncInvalidationTag =

package/src/daemon/process-message.ts

@@ -19,10 +19,7 @@ import {
   parseChannelId,
   parseInterfaceId,
 } from "../channels/types.js";
-import {
-  getAttachmentsByIds,
-  getSourcePathsForAttachments,
-} from "../persistence/attachments-store.js";
+import { resolveAttachmentsForPersist } from "../persistence/attachments-store.js";
 import {
   addMessage,
   getConversation,
@@ -362,19 +359,7 @@ async function prepareConversationForMessage(
   });
 
   const attachments = attachmentIds
-    ? (() => {
-        const resolved = getAttachmentsByIds(attachmentIds, {
-          hydrateFileData: true,
-        });
-        const sourcePaths = getSourcePathsForAttachments(attachmentIds);
-        return resolved.map((a) => ({
-          id: a.id,
-          filename: a.originalFilename,
-          mimeType: a.mimeType,
-          data: a.dataBase64,
-          ...(sourcePaths.has(a.id) ? { filePath: sourcePaths.get(a.id) } : {}),
-        }));
-      })()
+    ? resolveAttachmentsForPersist(attachmentIds)
     : [];
 
   return { conversation, attachments };