@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/acp/__tests__/auth-required.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Pins the two shapes a Claude auth failure travels in, plus the
+ * wire-contract literals. Losing either shape silently degrades an actionable
+ * "reconnect Claude" failure into an opaque one.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { AcpAuthRequiredEventSchema } from "../../api/events/acp-auth-required.js";
+import { AcpSessionErrorEventSchema } from "../../api/events/acp-session-error.js";
+import {
+  ACP_CLAUDE_AUTH_REQUIRED_CODE,
+  AcpAuthRequiredError,
+  AUTH_REQUIRED_CODE,
+  CLAUDE_ACP_COMMAND,
+  isAcpAuthRequired,
+  isClaudeAuthFailureMessage,
+} from "../auth-required.js";
+
+describe("isAcpAuthRequired", () => {
+  test("recognizes the raw JSON-RPC rejection from the agent", () => {
+    // What the adapter actually sends: a plain object off the wire, not an
+    // instance of any class we control.
+    expect(isAcpAuthRequired({ code: AUTH_REQUIRED_CODE })).toBe(true);
+  });
+
+  test("recognizes our own error after the retry path gives up", () => {
+    expect(isAcpAuthRequired(new AcpAuthRequiredError("claude", "nope"))).toBe(
+      true,
+    );
+  });
+
+  test("does not fire on other failures", () => {
+    expect(isAcpAuthRequired(new Error("Internal error"))).toBe(false);
+    expect(isAcpAuthRequired({ code: -32601 })).toBe(false);
+    expect(isAcpAuthRequired(null)).toBe(false);
+    expect(isAcpAuthRequired(undefined)).toBe(false);
+    expect(isAcpAuthRequired("auth_required")).toBe(false);
+  });
+
+  test("uses the ACP-specified code", () => {
+    // Matches the SDK's RequestError.authRequired(); drifting from it would
+    // silently stop classifying every auth failure.
+    expect(AUTH_REQUIRED_CODE).toBe(-32000);
+  });
+});
+
+describe("isClaudeAuthFailureMessage", () => {
+  test("matches the live rejected-credential failure verbatim", () => {
+    // Captured from a real claude-agent-acp run against a revoked token: the
+    // adapter relays the CLI's failure as a -32603 internal error carrying
+    // this text, NOT as the structured auth_required rejection. This message
+    // is the reported bug, so it must classify.
+    expect(
+      isClaudeAuthFailureMessage(
+        "Internal error: Failed to authenticate. API Error: 401 OAuth access token has been revoked.",
+      ),
+    ).toBe(true);
+  });
+
+  test("is insensitive to the server's variable suffix", () => {
+    // The CLI-authored prefix is the stable part; the API's suffix varies.
+    expect(
+      isClaudeAuthFailureMessage(
+        "Failed to authenticate. API Error: 401 OAuth access token has expired. Re-authenticate to continue.",
+      ),
+    ).toBe(true);
+  });
+
+  test("matches the CLI's other auth phrasings", () => {
+    expect(
+      isClaudeAuthFailureMessage(
+        "Session expired. Please run /login to sign in again.",
+      ),
+    ).toBe(true);
+    expect(isClaudeAuthFailureMessage("Not logged in")).toBe(true);
+  });
+
+  test("does not fire on ordinary failures", () => {
+    expect(isClaudeAuthFailureMessage("Internal error")).toBe(false);
+    expect(isClaudeAuthFailureMessage("ECONNRESET: connection reset")).toBe(
+      false,
+    );
+    expect(
+      isClaudeAuthFailureMessage("Command failed: login.sh: not found"),
+    ).toBe(false);
+    expect(isClaudeAuthFailureMessage(undefined)).toBe(false);
+    expect(isClaudeAuthFailureMessage("")).toBe(false);
+  });
+});
+
+describe("AcpAuthRequiredError", () => {
+  test("is an Error that carries the agent id and its message", () => {
+    const err = new AcpAuthRequiredError("claude", "needs a reconnect");
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("AcpAuthRequiredError");
+    expect(err.agentId).toBe("claude");
+    expect(err.message).toBe("needs a reconnect");
+  });
+});
+
+describe("event shape is additive-safe for older clients", () => {
+  test("acp_session_error rejects unknown keys, which is why the signal is not a field on it", () => {
+    // Clients drop a whole event over an unknown key (strict schemas plus a
+    // safeParse fallback to `unknown`), so new signals must ride new event
+    // types; this pins the strictness that forces that.
+    const result = AcpSessionErrorEventSchema.safeParse({
+      type: "acp_session_error",
+      acpSessionId: "acp-1",
+      error: "boom",
+      someFutureField: "x",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("acp_session_error still parses in its unchanged shape", () => {
+    expect(
+      AcpSessionErrorEventSchema.safeParse({
+        type: "acp_session_error",
+        acpSessionId: "acp-1",
+        error: "boom",
+      }).success,
+    ).toBe(true);
+  });
+
+  test("acp_auth_required carries the code and an optional anchor", () => {
+    const parsed = AcpAuthRequiredEventSchema.parse({
+      type: "acp_auth_required",
+      acpSessionId: "acp-1",
+      authCode: ACP_CLAUDE_AUTH_REQUIRED_CODE,
+      agent: "claude",
+      parentToolUseId: "tool-1",
+    });
+    expect(parsed.authCode).toBe(ACP_CLAUDE_AUTH_REQUIRED_CODE);
+    expect(parsed.parentToolUseId).toBe("tool-1");
+
+    // The anchor is optional: a run not started by a tool call has none.
+    expect(
+      AcpAuthRequiredEventSchema.safeParse({
+        type: "acp_auth_required",
+        acpSessionId: "acp-1",
+        authCode: ACP_CLAUDE_AUTH_REQUIRED_CODE,
+        agent: "claude",
+      }).success,
+    ).toBe(true);
+  });
+});
+
+describe("wire contract", () => {
+  test("the client marker matches the web literal", () => {
+    // Paired with ACP_CLAUDE_AUTH_REQUIRED_CODE in
+    // clients/web/src/domains/chat/utils/acp-connect.ts. A silent rename on
+    // either side turns the Connect card off with nothing failing.
+    expect(ACP_CLAUDE_AUTH_REQUIRED_CODE).toBe("acp_claude_auth_required");
+  });
+
+  test("the adapter gate matches the resolved command basename", () => {
+    // Compared against SessionEntry.command, which is already a basename.
+    expect(CLAUDE_ACP_COMMAND).toBe("claude-agent-acp");
+  });
+});

package/src/acp/acp-claude-oauth.ts

@@ -33,7 +33,14 @@ import {
  * `CLAUDE_CODE_OAUTH_TOKEN` requires.
  */
 export const CLAUDE_OAUTH_CONFIG: OAuth2Config = {
-  authorizeUrl: "https://claude.ai/oauth/authorize",
+  // The claude.ai-account authorize endpoint, matching the Claude Code CLI's
+  // own CLAUDE_AI_AUTHORIZE_URL. Shared by both flows: the loopback path
+  // builds its URL from this in `prepareOAuth2Flow`, the manual path in
+  // `buildClaudeAuthorizeUrl`. Only the claude.com/cai host completes a
+  // grant; the legacy claude.ai host still renders a working-looking consent
+  // screen but rejects every authorize POST, so a wrong host here looks
+  // functional until the final click of a real sign-in.
+  authorizeUrl: "https://claude.com/cai/oauth/authorize",
   tokenExchangeUrl: "https://platform.claude.com/v1/oauth/token",
   clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
   scopes: ["user:inference"],
@@ -53,12 +60,22 @@ export const CLAUDE_OAUTH_CONFIG: OAuth2Config = {
 export const CLAUDE_MANUAL_REDIRECT_URI =
   "https://platform.claude.com/oauth/code/callback";
 
-/** Build the Claude authorize URL for a PKCE flow. */
+/**
+ * Build the Claude authorize URL for the MANUAL (paste) PKCE flow.
+ *
+ * `code=true` tells Claude to render the `code#state` string on the callback
+ * page for the user to copy, which is the whole mechanism of the manual flow;
+ * Claude rejects a manual-redirect grant without it. The loopback flow
+ * performs a real redirect instead and must NOT send it; that URL is built
+ * separately in `prepareOAuth2Flow`, which is why this builder can include
+ * the param unconditionally.
+ */
 export function buildClaudeAuthorizeUrl(
   redirectUri: string,
   pkce: { codeChallenge: string; state: string },
 ): string {
   const params = new URLSearchParams({
+    code: "true",
     response_type: "code",
     client_id: CLAUDE_OAUTH_CONFIG.clientId,
     redirect_uri: redirectUri,

package/src/acp/agent-process.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { AcpAgentProcess } from "./agent-process.js";
+import { AcpAuthRequiredError, isAcpAuthRequired } from "./auth-required.js";
 import type { AcpAgentConfig } from "./types.js";
 
 const config: AcpAgentConfig = { command: "noop", args: [] };
@@ -114,3 +115,102 @@ describe("AcpAgentProcess.markStderr / stderrSince", () => {
     expect(proc.stderrSince(mark)).toBe("fresh failure");
   });
 });
+
+// ---------------------------------------------------------------------------
+// createSession: structured auth_required handling through the real retry path
+// ---------------------------------------------------------------------------
+
+/**
+ * Wires a process with a fake protocol connection and advertised auth methods,
+ * following the same no-child-process injection style as `feed` above. The
+ * retry logic under test (`withAuthRetry`, method selection, the typed throw)
+ * runs for real.
+ */
+function wireProcess(opts: {
+  authMethods: unknown[];
+  newSession: () => Promise<unknown>;
+  env?: Record<string, string>;
+}): { proc: AcpAgentProcess; authenticateCalls: () => number } {
+  const proc = new AcpAgentProcess("test-agent", config, clientFactory);
+  let authed = 0;
+  (proc as unknown as { connection: unknown }).connection = {
+    newSession: opts.newSession,
+    authenticate: async () => {
+      authed += 1;
+      return {};
+    },
+  };
+  (proc as unknown as { initializeResponse: unknown }).initializeResponse = {
+    authMethods: opts.authMethods,
+  };
+  (proc as unknown as { spawnedEnv: unknown }).spawnedEnv = opts.env ?? {};
+  return { proc, authenticateCalls: () => authed };
+}
+
+const TERMINAL_ONLY_METHODS = [
+  { id: "claude-ai-login", name: "Claude Subscription", type: "terminal" },
+];
+
+describe("AcpAgentProcess.createSession auth_required handling", () => {
+  test("a structured auth_required rejection with only terminal methods becomes AcpAuthRequiredError", async () => {
+    // The wire shape the adapter actually sends: a plain JSON-RPC error
+    // object, not an Error subclass. With no satisfiable env_var method the
+    // retry path must surface the typed error the session manager and the
+    // spawn tool classify on; losing the type here silently degrades the
+    // whole recovery surface back into a generic failure.
+    const { proc } = wireProcess({
+      authMethods: TERMINAL_ONLY_METHODS,
+      newSession: () =>
+        Promise.reject({ code: -32000, message: "Authentication required" }),
+    });
+
+    const err: unknown = await proc.createSession("/tmp").then(
+      () => null,
+      (e: unknown) => e,
+    );
+
+    expect(err).toBeInstanceOf(AcpAuthRequiredError);
+    expect((err as AcpAuthRequiredError).agentId).toBe("test-agent");
+    expect(isAcpAuthRequired(err)).toBe(true);
+  });
+
+  test("a satisfiable env_var method authenticates and retries instead of throwing", async () => {
+    let calls = 0;
+    const { proc, authenticateCalls } = wireProcess({
+      authMethods: [
+        {
+          id: "api-key",
+          name: "Use SOME_KEY",
+          type: "env_var",
+          vars: [{ name: "SOME_KEY" }],
+        },
+      ],
+      env: { SOME_KEY: "value" },
+      newSession: () => {
+        calls += 1;
+        return calls === 1
+          ? Promise.reject({ code: -32000, message: "Authentication required" })
+          : Promise.resolve({ sessionId: "session-1" });
+      },
+    });
+
+    await expect(proc.createSession("/tmp")).resolves.toBe("session-1");
+    expect(authenticateCalls()).toBe(1);
+  });
+
+  test("a non-auth rejection passes through untyped", async () => {
+    const { proc } = wireProcess({
+      authMethods: TERMINAL_ONLY_METHODS,
+      newSession: () =>
+        Promise.reject({ code: -32603, message: "Internal error" }),
+    });
+
+    const err: unknown = await proc.createSession("/tmp").then(
+      () => null,
+      (e: unknown) => e,
+    );
+
+    expect(err).not.toBeInstanceOf(AcpAuthRequiredError);
+    expect(isAcpAuthRequired(err)).toBe(false);
+  });
+});

package/src/acp/agent-process.ts

@@ -20,16 +20,11 @@ import type {
 import * as acp from "@agentclientprotocol/sdk";
 
 import { getLogger } from "../util/logger.js";
+import { AcpAuthRequiredError, isAcpAuthRequired } from "./auth-required.js";
 import type { AcpAgentConfig } from "./types.js";
 
 const log = getLogger("acp");
 
-/**
- * JSON-RPC error code agents use to signal that authentication is required
- * (matches the SDK's RequestError.authRequired()).
- */
-const AUTH_REQUIRED_CODE = -32000;
-
 /**
  * Rough byte cap for retained stderr. Oldest lines are evicted once the sum of
  * retained line lengths exceeds this, so the stderr ring (read via stderrSince)
@@ -37,19 +32,6 @@ const AUTH_REQUIRED_CODE = -32000;
  */
 const STDERR_RETENTION_BYTES = 4096;
 
-/**
- * Detects the ACP auth-required error. Checks the `code` property rather than
- * `instanceof acp.RequestError` so plain JSON-RPC error objects are also
- * recognized.
- */
-function isAuthRequiredError(err: unknown): boolean {
-  return (
-    typeof err === "object" &&
-    err !== null &&
-    (err as { code?: unknown }).code === AUTH_REQUIRED_CODE
-  );
-}
-
 function isEnvVarMethod(
   method: AuthMethod,
 ): method is AuthMethodEnvVar & { type: "env_var" } {
@@ -296,7 +278,7 @@ export class AcpAgentProcess {
     try {
       return await op();
     } catch (err) {
-      if (!isAuthRequiredError(err)) {
+      if (!isAcpAuthRequired(err)) {
         throw err;
       }
 
@@ -306,12 +288,23 @@ export class AcpAgentProcess {
 
       const method = this.selectEnvVarAuthMethod();
       if (!method) {
-        throw new Error(
-          `ACP agent "${this.agentId}" requires authentication. ` +
-            `Advertised methods: ${this.describeAuthMethods()}. ` +
-            "Set the required env var under acp.agents.<id>.env in config.json, " +
-            "collect it securely via 'assistant credentials prompt --service acp --field <field> --label \"<label>\"', " +
-            "or complete the agent's own login flow in the workspace.",
+        // Typed so the session manager can tell an auth failure from a crash
+        // and surface a re-authentication path. The remediation text is split
+        // by what the agent advertises: env-var and `credentials prompt`
+        // advice only helps when an env_var method exists to satisfy, and for
+        // terminal-login-only adapters it sends the user chasing a CLI
+        // workaround for a credential the app repairs on its own.
+        throw new AcpAuthRequiredError(
+          this.agentId,
+          this.hasEnvVarAuthMethod()
+            ? `ACP agent "${this.agentId}" requires authentication. ` +
+                `Advertised methods: ${this.describeAuthMethods()}. ` +
+                "Set the required env var under acp.agents.<id>.env in config.json, " +
+                "or collect it securely via 'assistant credentials prompt --service acp --field <field> --label \"<label>\"'."
+            : `ACP agent "${this.agentId}" requires authentication and its ` +
+                "stored credential was not accepted. Advertised methods: " +
+                `${this.describeAuthMethods()}. None can be completed headlessly, ` +
+                "so the credential has to be reconnected.",
         );
       }
 
@@ -325,6 +318,16 @@ export class AcpAgentProcess {
     }
   }
 
+  /**
+   * Whether the agent advertises any `env_var` auth method at all, satisfiable
+   * or not. Distinguishes "we could not satisfy the env var it wants" from
+   * "env vars are not how this agent authenticates", which are different
+   * problems with different fixes.
+   */
+  private hasEnvVarAuthMethod(): boolean {
+    return this.authMethods.some(isEnvVarMethod);
+  }
+
   /**
    * Renders the agent's advertised auth methods for error messages, e.g.
    * `"Login with ChatGPT" (chatgpt), "Use OPENAI_API_KEY" (env var OPENAI_API_KEY)`.

package/src/acp/auth-required.ts

@@ -0,0 +1,102 @@
+/**
+ * Detection of Claude authentication failures on ACP runs.
+ *
+ * These failures reach the daemon in two shapes, and both are needed:
+ *
+ * 1. No credentials at all: the adapter raises a structured ACP
+ *    `auth_required` rejection (JSON-RPC -32000). {@link isAcpAuthRequired}.
+ * 2. Credentials present but rejected (the expired/revoked case): the CLI
+ *    surfaces the API 401 as an error message it authors, and the adapter
+ *    relays it as a generic -32603 internal error, NOT as `auth_required`.
+ *    {@link isClaudeAuthFailureMessage}.
+ *
+ * A positive detection becomes {@link ACP_CLAUDE_AUTH_REQUIRED_CODE} on the
+ * `acp_auth_required` event, which the client turns into the inline
+ * "Connect Claude Code" card.
+ */
+
+export { ACP_CLAUDE_AUTH_REQUIRED_CODE } from "../api/events/acp-auth-required.js";
+
+/**
+ * JSON-RPC error code agents use to signal that authentication is required
+ * (matches the ACP SDK's `RequestError.authRequired()`).
+ */
+export const AUTH_REQUIRED_CODE = -32000;
+
+/**
+ * An agent rejected an operation with `auth_required` and the daemon has no
+ * way to satisfy it. A distinct type so the classification survives to the
+ * session manager, where the failure becomes an event the UI can act on.
+ */
+export class AcpAuthRequiredError extends Error {
+  constructor(
+    readonly agentId: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "AcpAuthRequiredError";
+  }
+}
+
+/**
+ * Detects the structured auth-required signal in either shape it travels: the
+ * raw JSON-RPC rejection from the agent, or our own
+ * {@link AcpAuthRequiredError}. Checks the `code` property rather than an
+ * `instanceof` so plain JSON-RPC error objects are recognized too.
+ */
+export function isAcpAuthRequired(err: unknown): boolean {
+  if (err instanceof AcpAuthRequiredError) {
+    return true;
+  }
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    (err as { code?: unknown }).code === AUTH_REQUIRED_CODE
+  );
+}
+
+/**
+ * The Claude CLI's own auth-failure phrasings. Unanchored (no ^/$) because
+ * the messages arrive with adapter framing ("Internal error: ...") or as a
+ * line `deriveFailureError` picked out of stderr.
+ */
+const CLAUDE_AUTH_FAILURE_PATTERNS: readonly RegExp[] = [
+  /Failed to authenticate\b/,
+  /Please run \/login/,
+  /\bNot logged in\b/,
+];
+
+/**
+ * Whether a failure message is a Claude authentication failure. Callers gate
+ * on the adapter (`claude-agent-acp`) BEFORE consulting this: the patterns
+ * are Claude-specific, and the marker built on them promises a repair only
+ * the Connect Claude flow can perform.
+ */
+export function isClaudeAuthFailureMessage(
+  message: string | undefined,
+): boolean {
+  return (
+    message != null &&
+    CLAUDE_AUTH_FAILURE_PATTERNS.some((pattern) => pattern.test(message))
+  );
+}
+
+/** The adapter whose auth failures the Connect Claude flow can repair. */
+export const CLAUDE_ACP_COMMAND = "claude-agent-acp";
+
+/**
+ * Model-facing text accompanying a Claude auth failure wherever the inline
+ * Connect card is raised (the tool result for a pre-spawn rejection, the
+ * parent notification for a post-spawn one), so the model points at the card
+ * instead of inventing a remedy (CLI commands, pasted tokens, or a card that
+ * is not there). Bans placement words because card position is a UI detail
+ * the model cannot see.
+ */
+export const ACP_AUTH_RECOVERY_GUIDANCE =
+  "The Claude Code connection needs to be re-authorized. The app shows the " +
+  'user an inline "Connect Claude Code" card. Reply with ONE short sentence: ' +
+  "ask them to click Connect to sign in again, and tell them you'll continue " +
+  "automatically once they are connected. Do NOT say where the card is; never " +
+  'say "below", "above", "at the bottom", or "here". Do NOT tell them to run ' +
+  "`claude setup-token`, paste a token in chat, run credential CLI commands, " +
+  "or re-run the agent yourself; the card and auto-continue handle it.";

package/src/acp/session-manager.test.ts

@@ -5,6 +5,7 @@ import {
   deleteConversation,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import { hasAcpConnectCardRaised } from "./acp-connect-card-state.js";
 import { VellumAcpClientHandler } from "./client-handler.js";
 import { AcpSessionManager } from "./session-manager.js";
 
@@ -310,3 +311,121 @@ describe("AcpSessionManager parent notification", () => {
     expect((manager.getStatus() as unknown[]).length).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Auth-required recovery surface
+// ---------------------------------------------------------------------------
+
+describe("AcpSessionManager auth-required recovery surface", () => {
+  /** The live-captured shape of a rejected-credential failure. */
+  const authFailure = () =>
+    Promise.reject(
+      new Error(
+        "Internal error: Failed to authenticate. API Error: 401 OAuth access token has been revoked.",
+      ),
+    );
+
+  /** Drives an auth-shaped prompt failure through firePromptInBackground. */
+  async function driveAuthFailure(opts: {
+    id: string;
+    command: string;
+    parentToolUseId?: string;
+    cancelled?: boolean;
+  }) {
+    const manager = new AcpSessionManager(1);
+    const parentId = `parent-${opts.id}`;
+    const { conversation, persistUserMessage, loopRan } = mockConversation();
+    setConversation(parentId, conversation);
+    registered.push(parentId);
+
+    const entry = injectSession(
+      manager,
+      opts.id,
+      parentId,
+      fakeProcess(authFailure),
+    );
+    entry.command = opts.command;
+    (entry as { parentToolUseId?: string }).parentToolUseId =
+      opts.parentToolUseId;
+    if (opts.cancelled) {
+      entry.state.status = "cancelled";
+    }
+
+    await fire(manager, opts.id, entry).catch(() => {});
+    if (!opts.cancelled) {
+      await loopRan;
+    }
+
+    const events = (
+      entry.sendToVellum as ReturnType<typeof mock>
+    ).mock.calls.map((c) => c[0] as { type: string } & Record<string, unknown>);
+    const firstPersist = persistUserMessage.mock.calls[0] as unknown as
+      | [{ content: string }]
+      | undefined;
+    return {
+      parentId,
+      authEvent: events.find((e) => e.type === "acp_auth_required"),
+      persistedContent: firstPersist?.[0].content,
+    };
+  }
+
+  test("claude failure with an anchor raises the full surface: event, registry mark, guidance", async () => {
+    const r = await driveAuthFailure({
+      id: "sess-auth-anchor",
+      command: "claude-agent-acp",
+      parentToolUseId: "tool-anchor-1",
+    });
+
+    expect(r.authEvent).toMatchObject({
+      acpSessionId: "sess-auth-anchor",
+      authCode: "acp_claude_auth_required",
+      agent: "claude",
+      parentToolUseId: "tool-anchor-1",
+    });
+    // The credential-prompt route consults this registry to redirect a
+    // redundant secure prompt at the card instead of stacking a second one.
+    expect(hasAcpConnectCardRaised(r.parentId)).toBe(true);
+    expect(r.persistedContent).toContain("Connect Claude Code");
+  });
+
+  test("claude failure without an anchor keeps the plain failure: no event, no mark, no guidance", async () => {
+    // No spawning tool call means no transcript row to render the card under;
+    // guidance would point the model at a card that cannot appear.
+    const r = await driveAuthFailure({
+      id: "sess-auth-noanchor",
+      command: "claude-agent-acp",
+    });
+
+    expect(r.authEvent).toBeUndefined();
+    expect(hasAcpConnectCardRaised(r.parentId)).toBe(false);
+    expect(r.persistedContent).not.toContain("Connect Claude Code");
+  });
+
+  test("a run the user already stopped raises nothing: no event, no registry mark, no parent turn", async () => {
+    // The client never renders a card for a cancelled run, and the
+    // prompt-dedup registry is never cleared, so marking it here would
+    // suppress the secure token prompt for the daemon's lifetime against a
+    // card that does not exist.
+    const r = await driveAuthFailure({
+      id: "sess-auth-cancelled",
+      command: "claude-agent-acp",
+      parentToolUseId: "tool-anchor-3",
+      cancelled: true,
+    });
+
+    expect(r.authEvent).toBeUndefined();
+    expect(hasAcpConnectCardRaised(r.parentId)).toBe(false);
+    expect(r.persistedContent).toBeUndefined();
+  });
+
+  test("a non-claude adapter never raises the surface, even on an auth-shaped failure", async () => {
+    const r = await driveAuthFailure({
+      id: "sess-auth-codex",
+      command: "codex-acp",
+      parentToolUseId: "tool-anchor-2",
+    });
+
+    expect(r.authEvent).toBeUndefined();
+    expect(hasAcpConnectCardRaised(r.parentId)).toBe(false);
+  });
+});