@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/runtime/routes/contact-prompt-routes.ts

@@ -1,39 +1,71 @@
 /**
- * IPC route for the `contacts/prompt` CLI command.
+ * IPC routes for the contact forms the guardian fills in their app.
  *
- * Flow:
- *   1. CLI calls `contacts/prompt` IPC route with optional channel/role hints.
- *   2. Daemon broadcasts a `contact_request` to all connected clients.
- *   3. Client shows a contact address input form.
- *   4. User enters an address; client POSTs to the gateway's
- *      `POST /v1/contacts/prompt` HTTP route.
- *   5. Gateway upserts the contact + channel (gateway owns all contact writes).
- *   6. If the prompt was opened with --verify, the gateway reads
- *      `contact_prompt_flags` and attests the new channel.
- *   7. Gateway calls daemon IPC `resolve_contact_prompt` with the new contact info.
- *   8. Daemon resolves the pending promise; `contacts/prompt` IPC returns to CLI.
+ * Two commands park on the guardian-form rail:
+ *   - `contacts/prompt` collects a channel address and binds a channel.
+ *   - `contacts/record-prompt` confirms a contact record write the assistant
+ *     proposed (create, update, delete). No channel is touched.
  *
- * The daemon only broadcasts the prompt and waits. It never writes contacts.
- * All writes go through the gateway.
+ * Flow, identical for both:
+ *   1. CLI calls the IPC route with what the assistant proposes.
+ *   2. The route parks the call in the guardian-form registry, which broadcasts
+ *      a `contact_request` / `contact_record_request` to connected clients.
+ *   3. Client shows the form. The guardian edits and submits, or dismisses.
+ *   4. Client POSTs to the gateway (`/v1/contacts/prompt/submit` or
+ *      `/v1/contacts/record/submit`).
+ *   5. Gateway performs the write (gateway owns all contact writes), attesting
+ *      the channel when the guardian left the verify box checked.
+ *   6. Gateway calls daemon IPC `resolve_contact_prompt`.
+ *   7. The registry resolves the parked promise and the CLI call returns.
+ *
+ * The daemon only broadcasts and waits. It never writes contacts. That is what
+ * makes these commands guardian-gated: with no human at a form, nothing is
+ * written, and the call times out.
+ *
+ * The lifecycle itself lives in `runtime/guardian-form-registry.ts` and is
+ * shared by every guardian form. What is here is the contact-shaped half: the
+ * schemas, the two wire events, and the result the CLI gets back.
  */
 
-import { v4 as uuid } from "uuid";
 import { z } from "zod";
 
-import { getLogger } from "../../util/logger.js";
+import { GUARDIAN_FORM_MAX_TIMEOUT_MS } from "../../util/guardian-form-timeouts.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
+import {
+  getGuardianFormMeta,
+  type GuardianFormClosedReason,
+  hasUnclaimedGuardianForm,
+  openGuardianForm,
+} from "../guardian-form-registry.js";
+import { claimForm, resolveFormFromCallback } from "./guardian-form-routes.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
-const log = getLogger("contact-prompt-routes");
-
-/** Timeout for waiting on the user to submit the contact form (5 min). */
-const CONTACT_PROMPT_TIMEOUT_MS = 300_000;
+/**
+ * Form kinds on the guardian-form rail that carry a contact card.
+ *
+ * The gateway names the same kind when it claims, so these two strings are a
+ * cross-package contract. `contact-form-kinds.test.ts` on each side pins the
+ * literals, since a rename on one side alone would only surface as claims
+ * rejected at runtime.
+ */
+export const CONTACT_ADDRESS_FORM_KIND = "contacts.address";
+export const CONTACT_RECORD_FORM_KIND = "contacts.record";
+const ADDRESS_FORM = CONTACT_ADDRESS_FORM_KIND;
+const RECORD_FORM = CONTACT_RECORD_FORM_KIND;
+const CONTACT_FORMS = [ADDRESS_FORM, RECORD_FORM] as const;
 
-// ---------------------------------------------------------------------------
-// Pending contact prompts
-// ---------------------------------------------------------------------------
+const TimeoutMsParam = z
+  .number()
+  .int()
+  .positive()
+  .max(GUARDIAN_FORM_MAX_TIMEOUT_MS)
+  .optional()
+  .describe(
+    "How long to hold the form open (ms). The caller waits slightly longer than this, so the form closing is what ends the wait. Defaults to 300000.",
+  );
 
+/** What the CLI gets back once the guardian has answered, or not. */
 export interface ContactPromptResult {
   ok: boolean;
   error?: string;
@@ -41,56 +73,28 @@ export interface ContactPromptResult {
   channelId?: string;
   channelType?: string;
   address?: string;
+  /** Whether the channel is attested, as the guardian's checkbox left it. */
+  verified?: boolean;
+  /**
+   * Whether submitted notes reached storage. Absent when none were submitted.
+   * False means the contact was written without them.
+   */
+  notesSaved?: boolean;
+  /** Whether nothing the submission asked for landed. */
+  nothingWritten?: boolean;
 }
 
-interface PendingContactPrompt {
-  resolve: (result: ContactPromptResult) => void;
-  timer: ReturnType<typeof setTimeout>;
-  /** When true, the gateway marks the submitted channel verified (manual attest). */
-  verify: boolean;
-}
-
-const pendingContactPrompts = new Map<string, PendingContactPrompt>();
-
 /**
- * Called by the gateway after it writes the contact and channel.
- * Resolves the pending promise so the CLI's `contacts/prompt` IPC call returns.
+ * Tell every client a contact form is over.
+ *
+ * The form went to all of them, so one client answering leaves the others
+ * holding a card that would now be refused. This is what takes those down.
  */
-function resolveContactPrompt({ body = {} }: RouteHandlerArgs): {
-  resolved: boolean;
-} {
-  const { requestId, contactId, channelId, channelType, address, error } =
-    body as {
-      requestId: string;
-      contactId?: string;
-      channelId?: string;
-      channelType?: string;
-      address?: string;
-      error?: string;
-    };
-  const pending = pendingContactPrompts.get(requestId);
-  if (!pending) {
-    log.warn({ requestId }, "resolve_contact_prompt: no pending prompt found");
-    return { resolved: false };
-  }
-
-  clearTimeout(pending.timer);
-  pendingContactPrompts.delete(requestId);
-
-  if (error) {
-    pending.resolve({ ok: false, error });
-  } else {
-    pending.resolve({
-      ok: true,
-      contactId,
-      channelId,
-      channelType,
-      address,
-    });
-  }
-
-  log.info({ requestId, contactId }, "Contact prompt resolved");
-  return { resolved: true };
+function announceContactFormClosed(
+  requestId: string,
+  reason: GuardianFormClosedReason,
+): void {
+  broadcastMessage({ type: "contact_form_closed", requestId, reason });
 }
 
 // ---------------------------------------------------------------------------
@@ -130,8 +134,62 @@ const ContactPromptParams = z.object({
     .boolean()
     .optional()
     .describe(
-      "When true, submitting the address also marks the channel verified. Same attest as Contacts Verify me.",
+      "Pre-check the form's 'mark verified' box. The guardian's answer on submit decides the attest, so an unchecked box leaves the channel unverified.",
+    ),
+  timeoutMs: TimeoutMsParam,
+});
+
+const ContactRecordPromptParams = z.object({
+  operation: z
+    .enum(["create", "update", "delete"])
+    .describe("Which record write the guardian is being asked to confirm."),
+  contactId: z
+    .string()
+    .optional()
+    .describe("Target contact. Required for update and delete."),
+  currentDisplayName: z
+    .string()
+    .optional()
+    .describe(
+      "The target's current name, resolved by the caller, so the form can show what is changing. Gateway-owned facts are not read here.",
+    ),
+  currentNotes: z
+    .string()
+    .optional()
+    .describe(
+      "The target's current notes, resolved by the caller. The form submits a field only when it differs from what is stored.",
+    ),
+  channels: z
+    .array(z.object({ type: z.string(), address: z.string() }))
+    .optional()
+    .describe(
+      "The target's channels, resolved by the caller, so a delete confirmation can identify the contact and show what access is about to be lost.",
+    ),
+
+  displayName: z
+    .string()
+    .optional()
+    .describe(
+      "Proposed name, prefilled into the form. The guardian can edit it.",
+    ),
+  notes: z
+    .string()
+    .optional()
+    .describe(
+      "Proposed notes, prefilled into the form. The guardian can edit them.",
+    ),
+  notesProposed: z
+    .boolean()
+    .optional()
+    .describe(
+      "Whether the caller asked for these notes explicitly, so the form submits them even when they match what is stored.",
     ),
+  label: z.string().optional().describe("Display label shown in the form."),
+  description: z
+    .string()
+    .optional()
+    .describe("Longer description shown in the form."),
+  timeoutMs: TimeoutMsParam,
 });
 
 const ContactPromptFlagsParams = z.object({
@@ -139,7 +197,7 @@ const ContactPromptFlagsParams = z.object({
 });
 
 // ---------------------------------------------------------------------------
-// Handler
+// Handlers
 // ---------------------------------------------------------------------------
 
 async function handleContactPrompt({
@@ -153,52 +211,112 @@ async function handleContactPrompt({
     description,
     role,
     verify,
+    timeoutMs,
   } = ContactPromptParams.parse(body);
 
-  const requestId = uuid();
+  return openGuardianForm<ContactPromptResult>({
+    kind: ADDRESS_FORM,
+    timeoutMs,
+    // Read back by the gateway when a client too old for the checkbox submits
+    // no answer of its own.
+    meta: { verify: verify === true },
+    logContext: { channel, role, verify: verify === true },
+    broadcast: {
+      open: (requestId) =>
+        broadcastMessage({
+          type: "contact_request",
+          requestId,
+          channel,
+          placeholder,
+          defaultValue,
+          label,
+          description,
+          role,
+          // The checkbox's initial state. Carried in the broadcast so the form
+          // can show what submitting will do; the client's answer is what the
+          // gateway acts on.
+          verify: verify === true,
+        }),
+      closed: announceContactFormClosed,
+    },
+  });
+}
 
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      pendingContactPrompts.delete(requestId);
-      log.warn({ requestId }, "Contact prompt timed out");
-      resolve({ ok: false, error: "Prompt timed out" });
-    }, CONTACT_PROMPT_TIMEOUT_MS);
+/**
+ * Park a proposed contact-record write until the guardian answers the form.
+ *
+ * The daemon writes nothing. It broadcasts the proposal and waits for the
+ * gateway to report what the guardian actually submitted, which may differ
+ * from what was proposed or may be a dismissal.
+ */
+async function handleContactRecordPrompt({
+  body = {},
+}: RouteHandlerArgs): Promise<ContactPromptResult> {
+  const {
+    operation,
+    contactId,
+    currentDisplayName,
+    currentNotes,
+    channels,
+    displayName,
+    notes,
+    notesProposed,
+    label,
+    description,
+    timeoutMs,
+  } = ContactRecordPromptParams.parse(body);
 
-    pendingContactPrompts.set(requestId, {
-      resolve,
-      timer,
-      verify: verify === true,
-    });
+  if (operation !== "create" && !contactId) {
+    return { ok: false, error: `contactId is required to ${operation}` };
+  }
 
-    broadcastMessage({
-      type: "contact_request",
-      requestId,
-      channel,
-      placeholder,
-      defaultValue,
-      label,
-      description,
-      role,
-    });
+  // Clients hold one contact card at a time, so a second broadcast replaces the
+  // first and leaves its command waiting on a form nobody can answer. Refusing
+  // here fails the second command immediately instead, which is a caller that
+  // can retry rather than one that hangs.
+  if (hasUnclaimedGuardianForm(CONTACT_FORMS)) {
+    return {
+      ok: false,
+      error:
+        "Another contact form is already open. Wait for it to be answered, then try again.",
+    };
+  }
 
-    log.info(
-      { requestId, channel, role, verify: verify === true },
-      "Contact prompt broadcast",
-    );
+  return openGuardianForm<ContactPromptResult>({
+    kind: RECORD_FORM,
+    timeoutMs,
+    logContext: { operation, contactId },
+    broadcast: {
+      open: (requestId) =>
+        broadcastMessage({
+          type: "contact_record_request",
+          requestId,
+          operation,
+          contactId,
+          currentDisplayName,
+          currentNotes,
+          channels,
+          displayName,
+          notes,
+          notesProposed,
+          label,
+          description,
+        }),
+      closed: announceContactFormClosed,
+    },
   });
 }
 
 /**
- * Read-only flags for a pending prompt. The gateway asks this after it
- * writes the channel so a `--verify` prompt can attest without the client
- * having to echo the flag on submit.
+ * Read-only flags for a pending prompt. The gateway asks this after it writes
+ * the channel so a `--verify` prompt can attest without the client having to
+ * echo the flag on submit.
  */
 function readContactPromptFlags({ body = {} }: RouteHandlerArgs): {
   verify: boolean;
 } {
   const { requestId } = ContactPromptFlagsParams.parse(body);
-  const pending = pendingContactPrompts.get(requestId);
-  return { verify: pending?.verify === true };
+  return { verify: getGuardianFormMeta(requestId)?.verify === true };
 }
 
 // ---------------------------------------------------------------------------
@@ -217,7 +335,7 @@ export const CONTACT_PROMPT_ROUTES: RouteDefinition[] = [
     handler: handleContactPrompt,
     summary: "Prompt user to register a contact channel",
     description:
-      "Broadcasts a contact_request to connected clients, waits for the user to submit an address via the gateway. The gateway owns the contact write and notifies the daemon via resolve_contact_prompt IPC.",
+      "Broadcasts a contact_request to connected clients, waits for the user to submit an address via the gateway. The gateway owns the contact write and reports it back via resolve_contact_prompt.",
     tags: ["contacts"],
     requestBody: ContactPromptParams,
     responseBody: z.object({
@@ -227,6 +345,29 @@ export const CONTACT_PROMPT_ROUTES: RouteDefinition[] = [
       channelId: z.string().optional(),
       channelType: z.string().optional(),
       address: z.string().optional(),
+      verified: z.boolean().optional(),
+    }),
+  },
+  {
+    operationId: "contacts_record_prompt",
+    endpoint: "contacts/record-prompt",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    handler: handleContactRecordPrompt,
+    summary: "Ask the guardian to confirm a contact record write",
+    description:
+      "Broadcasts a contact_record_request to connected clients and waits for the guardian to submit the form. The gateway owns the write and reports it back via resolve_contact_prompt. Nothing is written if nobody answers.",
+    tags: ["contacts"],
+    requestBody: ContactRecordPromptParams,
+    responseBody: z.object({
+      ok: z.boolean(),
+      error: z.string().optional(),
+      contactId: z.string().optional(),
+      notesSaved: z.boolean().optional(),
+      nothingWritten: z.boolean().optional(),
     }),
   },
   {
@@ -237,12 +378,37 @@ export const CONTACT_PROMPT_ROUTES: RouteDefinition[] = [
       requiredScopes: ["settings.write"],
       allowedPrincipalTypes: ACTOR_PRINCIPALS,
     },
-    handler: resolveContactPrompt,
+    handler: resolveFormFromCallback,
     summary: "Gateway callback: resolve a pending contact prompt",
     description:
-      "Called by the gateway after it writes the contact and channel. Unblocks the waiting contacts/prompt IPC call.",
+      "Called by the gateway after it writes the contact and channel. Unblocks the waiting contacts/prompt call.",
     tags: ["contacts"],
   },
+  {
+    operationId: "contact_prompt_claim",
+    endpoint: "contact_prompt_claim",
+    method: "POST",
+    policy: {
+      requiredScopes: ["settings.write"],
+      allowedPrincipalTypes: ACTOR_PRINCIPALS,
+    },
+    handler: claimForm,
+    summary: "Claim a pending contact form for one submission",
+    description:
+      "Marks a pending form as answered so a second client submitting the same form writes nothing. Returns claimed=false with reason 'already_claimed' when somebody got there first, or 'unknown' when no such form is pending. A granted claim carries the window its write has to report back in.",
+    tags: ["contacts"],
+    requestBody: ContactPromptFlagsParams,
+    responseBody: z.object({
+      claimed: z.boolean(),
+      reason: z.enum(["already_claimed", "unknown"]).optional(),
+      settleMs: z
+        .number()
+        .optional()
+        .describe(
+          "How long a granted claim has to report its write back before the waiting call gives up.",
+        ),
+    }),
+  },
   {
     operationId: "contact_prompt_flags",
     endpoint: "contact_prompt_flags",

package/src/runtime/routes/conversation-routes.ts

@@ -23,8 +23,9 @@ import {
   type ConversationMessage,
   ConversationMessageSchema,
 } from "../../api/responses/conversation-message.js";
+import { GUARDIAN_TERMINAL_REASON_SUPERSEDED } from "../../api/responses/home.js";
+import { syncTerminalGuardianRequestStatus } from "../../approvals/guardian-request-status-sync.js";
 import {
-  decideGuardianRequest,
   expireGuardianRequest,
   listGuardianRequestsOrEmpty,
   listPendingRequestsByScopeOrEmpty,
@@ -97,13 +98,14 @@ import {
   readSlackMetadataFromMessageMetadata,
   type SlackMessageMetadata,
 } from "../../messaging/providers/slack/message-metadata.js";
+import { readProviderMetadata } from "../../messaging/read-provider-metadata.js";
 import { recordOnboardingEvent } from "../../onboarding/onboarding-events-store.js";
 import {
   classifyKind,
   getAttachmentById,
   getAttachmentMetadataForMessage,
   getAttachmentsByIds,
-  getSourcePathsForAttachments,
+  resolveAttachmentsForPersist,
 } from "../../persistence/attachments-store.js";
 import {
   addMessage,
@@ -127,6 +129,7 @@ import {
   getOrCreateConversation,
 } from "../../persistence/conversation-key-store.js";
 import { searchConversations } from "../../persistence/conversation-queries.js";
+import { isNoResponseMetadata } from "../../persistence/conversation-types.js";
 import { linkRequestLogsToMessage } from "../../persistence/llm-request-log-store.js";
 import { MEMORY_RETROSPECTIVE_FORK_SOURCE } from "../../plugins/defaults/memory/memory-retrospective-constants.js";
 import { normalizeOnboardingContext } from "../../prompts/normalize-onboarding.js";
@@ -163,6 +166,7 @@ import {
   resolveActorPrincipalIdForLocalGuardian,
 } from "../local-actor-identity.js";
 import { resolveLocalPrincipalTrustContext } from "../local-principal-trust.js";
+import { stripNoResponseMarkers } from "../no-response.js";
 import * as pendingInteractions from "../pending-interactions.js";
 import {
   publishConversationListAndMetadataChanged,
@@ -194,8 +198,6 @@ import { RouteResponse } from "./types.js";
 
 const log = getLogger("conversation-routes");
 
-/** Matches the `<no_response/>` sentinel used by channel delivery suppression. */
-const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/g;
 const ATTACHMENT_ENTRY_RE = /^attachment:(\d+)$/;
 
 /** Rewrites a rendered `contentOrder` to reflect attachment alignment. */
@@ -997,6 +999,8 @@ export async function handleListMessages({
       {};
     let backgroundToolCompletion: ConversationMessage["backgroundToolCompletion"];
     let systemCard: boolean | undefined;
+    let noResponse: boolean | undefined;
+    let reaction: ConversationMessage["reaction"];
     let providerError: ConversationMessage["providerError"];
     if (msg.metadata) {
       try {
@@ -1009,6 +1013,25 @@ export async function handleListMessages({
         if (isSystemCardMetadata(meta)) {
           systemCard = true;
         }
+        if (isNoResponseMetadata(meta)) {
+          noResponse = true;
+        }
+        // A reaction row, either direction, projects its structured fact so
+        // clients never render the stored "[reaction]" sentinel.
+        if (msg.metadata.includes("reaction")) {
+          const reactionMeta = readProviderMetadata(msg.metadata);
+          if (reactionMeta?.eventKind === "reaction" && reactionMeta.reaction) {
+            reaction = {
+              emoji: reactionMeta.reaction.emoji,
+              op: reactionMeta.reaction.op,
+              targetMessageId: reactionMeta.reaction.targetMessageId,
+              ...(reactionMeta.reaction.actorDisplayName
+                ? { actorDisplayName: reactionMeta.reaction.actorDisplayName }
+                : {}),
+              ...(msg.role === "assistant" ? { selfAuthored: true } : {}),
+            };
+          }
+        }
         // Daemon-persisted provider-failure notices carry the classified
         // error code/category so clients can render a themed card instead
         // of a persona bubble.
@@ -1061,6 +1084,8 @@ export async function handleListMessages({
       backgroundEventNotification: notifications.backgroundEventNotification,
       backgroundToolCompletion,
       systemCard,
+      noResponse,
+      reaction,
       providerError,
       slackMessage,
       clientMessageId: msg.clientMessageId ?? undefined,
@@ -1175,9 +1200,7 @@ export async function handleListMessages({
         const keepIndices: number[] = [];
         const filteredSegments: string[] = [];
         for (let i = 0; i < rendered.textSegments.length; i++) {
-          const cleaned = rendered.textSegments[i]
-            .replace(NO_RESPONSE_INLINE_RE, "")
-            .trim();
+          const cleaned = stripNoResponseMarkers(rendered.textSegments[i]);
           if (cleaned.length > 0) {
             keepIndices.push(i);
             filteredSegments.push(cleaned);
@@ -1201,7 +1224,7 @@ export async function handleListMessages({
             block.type === "text"
               ? {
                   type: "text" as const,
-                  text: block.text.replace(NO_RESPONSE_INLINE_RE, "").trim(),
+                  text: stripNoResponseMarkers(block.text),
                 }
               : block,
           )
@@ -1271,6 +1294,8 @@ export async function handleListMessages({
           ? { backgroundToolCompletion: m.backgroundToolCompletion }
           : {}),
         ...(m.systemCard ? { systemCard: true } : {}),
+        ...(m.noResponse ? { noResponse: true } : {}),
+        ...(m.reaction ? { reaction: m.reaction } : {}),
         ...(m.providerError ? { providerError: m.providerError } : {}),
         ...(m.slackMessage ? { slackMessage: m.slackMessage } : {}),
       };
@@ -2323,18 +2348,16 @@ export async function handleSendMessage(
           source: "auto_deny" as const,
         });
         // Sync the gateway request status so stale "pending" records don't
-        // get matched by later guardian reply routing. Fire-and-forget: the
+        // get matched 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: the
         // in-memory denial is authoritative here; a CAS miss (already
         // decided elsewhere) or a lost sync is reaped by the orphan sweep.
-        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: "auto-deny-idle-send",
+          terminalReason: GUARDIAN_TERMINAL_REASON_SUPERSEDED,
         });
       }
     }
@@ -3027,20 +3050,6 @@ async function handleSearchConversations({
 const suggestionCache = new Map<string, string>();
 const suggestionInFlight = new Map<string, Promise<string | null>>();
 
-function resolveAttachments(attachmentIds: string[]) {
-  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) } : {}),
-  }));
-}
-
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -3260,7 +3269,7 @@ export const ROUTES: RouteDefinition[] = [
         sendMessageDeps: {
           getOrCreateConversation: getOrCreateConversationInstance,
           assistantEventHub,
-          resolveAttachments,
+          resolveAttachments: resolveAttachmentsForPersist,
         },
         approvalConversationGenerator: createApprovalConversationGenerator(),
       }),

package/src/runtime/routes/credential-prompt-routes.ts

@@ -8,6 +8,7 @@
 
 import { z } from "zod";
 
+import { acpConnectCardStillWarranted } from "../../acp/acp-claude-oauth.js";
 import { hasAcpConnectCardRaised } from "../../acp/acp-connect-card-state.js";
 import { isAcpClaudeOauthField } from "../../acp/acp-credentials.js";
 import {
@@ -112,10 +113,18 @@ async function handleCredentialPrompt({ body = {} }: RouteHandlerArgs) {
   // fallback, so `claude setup-token` remains usable where no card can appear.
   if (isAcpClaudeOauthField(validated.service, validated.field)) {
     const conversation = findConversation(validated.conversationId);
+    // The registry says a card was raised; this asks whether it is still one
+    // the user can act on. Auth can be repaired without any credential write
+    // (a `config.json` edit to the agent's `CLAUDE_CODE_OAUTH_TOKEN` does it),
+    // and nothing runs on that path to forget the entry, so an entry alone
+    // would keep suppressing the fallback against a card that stopped
+    // rendering.
     if (
       conversation &&
       conversationSupportsDynamicUi(conversation) &&
-      hasAcpConnectCardRaised(validated.conversationId)
+      validated.conversationId !== undefined &&
+      hasAcpConnectCardRaised(validated.conversationId) &&
+      (await acpConnectCardStillWarranted(validated.conversationId))
     ) {
       return {
         ok: false,

package/src/runtime/routes/debug-bash-routes.ts

@@ -97,6 +97,7 @@ function handleDebugBash({ body }: RouteHandlerArgs): Promise<DebugBashResult> {
       stdio: ["ignore", "pipe", "pipe"],
       detached: true,
       env: buildSanitizedEnv(),
+      windowsHide: true,
     });
 
     const timer = setTimeout(() => {