@vellumai/assistant 0.4.43 → 0.4.44

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -152,7 +152,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -223,7 +223,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -289,7 +289,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -361,7 +361,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -428,7 +428,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -489,7 +489,7 @@ describe("handleSendMessage canonical guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      setStateSignalListener: () => {},
+      updateClient: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},

package/src/__tests__/credential-security-invariants.test.ts

@@ -228,9 +228,10 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "mcp/client.ts", // MCP client cached-token lookup
       "oauth/token-persistence.ts", // OAuth token persistence (set/delete tokens)
       "runtime/routes/secret-routes.ts", // HTTP secret management routes (set/delete secrets)
+      "daemon/ride-shotgun-handler.ts", // learn session cookie persistence
       "daemon/session-messaging.ts", // credential storage during session messaging
       "runtime/routes/settings-routes.ts", // settings routes OAuth credential lookup (client_id/client_secret/access tokens)
-      "util/cookie-session.ts", // shared cookie-session persistence (session CRUD via credential store)
+      "twitter/platform-proxy-client.ts", // managed Twitter proxy auth token lookup
     ]);
 
     const thisDir = dirname(fileURLToPath(import.meta.url));

package/src/__tests__/error-handler-friendly-messages.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+
+import { withErrorHandling } from "../runtime/middleware/error-handler.js";
+import { ConfigError, ProviderNotConfiguredError } from "../util/errors.js";
+
+describe("withErrorHandling – friendly error messages", () => {
+  test("ProviderNotConfiguredError returns actionable message for anthropic", async () => {
+    const response = await withErrorHandling("test", async () => {
+      throw new ProviderNotConfiguredError("anthropic", []);
+    });
+
+    expect(response.status).toBe(422);
+    const body = (await response.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("UNPROCESSABLE_ENTITY");
+    expect(body.error.message).toContain("No API key configured");
+    expect(body.error.message).toContain("ANTHROPIC_API_KEY");
+    expect(body.error.message).toContain("vellum hatch");
+  });
+
+  test("ProviderNotConfiguredError tailors env var to requested provider", async () => {
+    const response = await withErrorHandling("test", async () => {
+      throw new ProviderNotConfiguredError("openai", []);
+    });
+
+    expect(response.status).toBe(422);
+    const body = (await response.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.message).toContain("OPENAI_API_KEY");
+    expect(body.error.message).not.toContain("ANTHROPIC_API_KEY");
+  });
+
+  test("generic ConfigError still returns its own message", async () => {
+    const response = await withErrorHandling("test", async () => {
+      throw new ConfigError("Twilio phone number not configured.");
+    });
+
+    expect(response.status).toBe(422);
+    const body = (await response.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.message).toBe("Twilio phone number not configured.");
+  });
+});

package/src/__tests__/managed-twitter-guardrails.test.ts

@@ -106,7 +106,11 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../security/secure-keys.js", () => ({
-  getSecureKey: (account: string) => secureKeyStore[account] ?? undefined,
+  getSecureKey: (account: string) => {
+    if (account === "credential:vellum:platform_assistant_id")
+      return "ast_test123";
+    return secureKeyStore[account] ?? undefined;
+  },
   setSecureKey: (account: string, value: string) => {
     secureKeyStore[account] = value;
     return true;

package/src/__tests__/onboarding-template-contract.test.ts

@@ -28,15 +28,6 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("change it later");
     });
 
-    test("creates Home Base silently in the background", () => {
-      const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("app_create");
-      expect(lower).toContain("set_as_home_base");
-      // Must NOT open or announce it
-      expect(lower).toContain("do not open it with `app_open`");
-      expect(lower).toContain("do not announce it");
-    });
-
     test("contains naming intent markers so the first reply includes naming cues", () => {
       const lower = bootstrap.toLowerCase();
       // The template must prompt the assistant to ask about names.
@@ -84,7 +75,6 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("work role");
       expect(lower).toContain("2 suggestions shown");
       expect(lower).toContain("selected one, deferred both");
-      expect(lower).toContain("home base");
     });
 
     test("contains refusal policy", () => {

package/src/__tests__/provider-fail-open-selection.test.ts

@@ -32,6 +32,7 @@ import {
   listProviders,
   resolveProviderSelection,
 } from "../providers/registry.js";
+import { ProviderNotConfiguredError } from "../util/errors.js";
 
 /**
  * Tests for fail-open provider selection: when the configured primary provider
@@ -138,11 +139,20 @@ describe("getFailoverProvider (fail-open)", () => {
     expect(provider).toBeDefined();
   });
 
-  test("throws ConfigError when no providers are available", () => {
+  test("throws ProviderNotConfiguredError when no providers are available", () => {
     setupNoProviders();
     expect(() => getFailoverProvider("gemini", ["fireworks"])).toThrow(
-      /No providers available/,
+      ProviderNotConfiguredError,
     );
+    try {
+      getFailoverProvider("gemini", ["fireworks"]);
+    } catch (err) {
+      expect(err).toBeInstanceOf(ProviderNotConfiguredError);
+      const typed = err as ProviderNotConfiguredError;
+      expect(typed.requestedProvider).toBe("gemini");
+      expect(typed.registeredProviders).toEqual([]);
+      expect(typed.message).toMatch(/No providers available/);
+    }
   });
 
   test("single available provider returns it directly (no failover wrapper)", () => {

package/src/__tests__/send-endpoint-busy.test.ts

@@ -112,7 +112,6 @@ function makeCompletingSession(): Session {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
     updateClient: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
@@ -165,7 +164,6 @@ function makeHangingSession(): Session {
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
     updateClient: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
@@ -246,7 +244,6 @@ function makePendingApprovalSession(
     setCommandIntent: () => {},
     setTurnChannelContext: () => {},
     setTurnInterfaceContext: () => {},
-    setStateSignalListener: () => {},
     updateClient: () => {},
     hasAnyPendingConfirmation: () => pending.size > 0,
     hasPendingConfirmation: (candidateRequestId: string) =>

package/src/__tests__/session-confirmation-signals.test.ts

@@ -6,7 +6,7 @@
  * - handleConfirmationResponse emits both confirmation_state_changed and
  *   assistant_activity_state events centrally
  * - emitActivityState produces monotonically increasing activityVersion
- * - setStateSignalListener routes signals to an external callback (HTTP/SSE)
+ * - sendToClient receives state signals (confirmation_state_changed, assistant_activity_state)
  * - "deny" decisions produce 'denied' state, "allow" produces 'approved'
  */
 import { mkdtempSync, rmSync } from "node:fs";
@@ -521,40 +521,21 @@ describe("activity version ordering", () => {
   });
 });
 
-describe("state signal listener", () => {
-  test("setStateSignalListener routes emitActivityState to external callback", () => {
+describe("sendToClient receives state signals", () => {
+  test("emitActivityState delivers to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-    const signalMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     session.emitActivityState("thinking", "message_dequeued", "assistant_turn");
 
-    // Both sendToClient and signal listener should receive the message
     expect(
       clientMsgs.filter((m) => m.type === "assistant_activity_state"),
     ).toHaveLength(1);
-    expect(
-      signalMsgs.filter((m) => m.type === "assistant_activity_state"),
-    ).toHaveLength(1);
-
-    // Messages should be identical
-    const clientMsg = clientMsgs.find(
-      (m) => m.type === "assistant_activity_state",
-    );
-    const signalMsg = signalMsgs.find(
-      (m) => m.type === "assistant_activity_state",
-    );
-    expect(clientMsg).toEqual(signalMsg);
   });
 
-  test("setStateSignalListener routes emitConfirmationStateChanged to external callback", () => {
+  test("emitConfirmationStateChanged delivers to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-    const signalMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     session.emitConfirmationStateChanged({
       sessionId: "conv-signals-test",
@@ -566,41 +547,22 @@ describe("state signal listener", () => {
     expect(
       clientMsgs.filter((m) => m.type === "confirmation_state_changed"),
     ).toHaveLength(1);
-    expect(
-      signalMsgs.filter((m) => m.type === "confirmation_state_changed"),
-    ).toHaveLength(1);
   });
 
-  test("without state signal listener, only sendToClient receives messages", () => {
+  test("handleConfirmationResponse delivers state signals to sendToClient", () => {
     const clientMsgs: ServerMessage[] = [];
-
     const session = makeSession((msg) => clientMsgs.push(msg));
-    // No setStateSignalListener call
-
-    session.emitActivityState("idle", "message_complete", "global");
-
-    expect(
-      clientMsgs.filter((m) => m.type === "assistant_activity_state"),
-    ).toHaveLength(1);
-  });
-
-  test("state signal listener receives handleConfirmationResponse emissions", () => {
-    const signalMsgs: ServerMessage[] = [];
-
-    // Use no-op sendToClient (simulates HTTP session with no socket)
-    const session = makeSession(() => {});
-    session.setStateSignalListener((msg) => signalMsgs.push(msg));
 
     seedPendingConfirmation(session, "req-signal-confirm");
     session.handleConfirmationResponse("req-signal-confirm", "allow");
 
-    const confirmSignal = signalMsgs.find(
+    const confirmSignal = clientMsgs.find(
       (m) =>
         m.type === "confirmation_state_changed" &&
         "requestId" in m &&
         (m as { requestId: string }).requestId === "req-signal-confirm",
     );
-    const activitySignal = signalMsgs.find(
+    const activitySignal = clientMsgs.find(
       (m) =>
         m.type === "assistant_activity_state" &&
         "reason" in m &&

package/src/__tests__/starter-task-flow.test.ts

@@ -4,30 +4,20 @@ import type { ServerMessage, SurfaceType } from "../daemon/message-protocol.js";
 
 mock.module("../memory/app-store.js", () => ({
   getApp: (id: string) => {
-    if (id !== "home-base-app") return null;
+    if (id !== "test-app") return null;
     return {
       id,
-      name: "Home Base",
-      htmlDefinition:
-        '<main id="home-base-root" data-vellum-home-base="v1"></main>',
+      name: "Test App",
+      description: "A test app",
+      htmlDefinition: "<main>Test App</main>",
     };
   },
+  getAppPreview: () => null,
   updateApp: () => {
     throw new Error("updateApp should not be called in this test");
   },
 }));
 
-mock.module("../home-base/prebuilt/seed.js", () => ({
-  findSeededHomeBaseApp: () => ({ id: "home-base-app" }),
-  getPrebuiltHomeBasePreview: () => ({
-    title: "Home Base",
-    subtitle: "Dashboard",
-    description: "Preview",
-    icon: "🏠",
-    metrics: [{ label: "Starter tasks", value: "3" }],
-  }),
-}));
-
 import {
   createSurfaceMutex,
   handleSurfaceAction,
@@ -70,12 +60,12 @@ describe("starter task surface actions", () => {
     ctx.pendingSurfaceActions.set("surf-1", { surfaceType: "dynamic_page" });
 
     handleSurfaceAction(ctx, "surf-1", "relay_prompt", {
-      prompt: "Help me customize Home Base with a calmer palette.",
+      prompt: "Help me customize the app with a calmer palette.",
       task: "change_look_and_feel",
     });
 
     expect(forwarded).toEqual([
-      "Help me customize Home Base with a calmer palette.",
+      "Help me customize the app with a calmer palette.",
     ]);
     expect(ctx.pendingSurfaceActions.has("surf-1")).toBe(true);
   });
@@ -133,7 +123,7 @@ describe("starter task surface actions", () => {
     ctx.sendToClient = (msg) => sent.push(msg);
 
     const result = await surfaceProxyResolver(ctx, "app_open", {
-      app_id: "home-base-app",
+      app_id: "test-app",
     });
 
     expect(result.isError).toBe(false);
@@ -141,7 +131,7 @@ describe("starter task surface actions", () => {
       surfaceId: string;
       appId: string;
     };
-    expect(parsed.appId).toBe("home-base-app");
+    expect(parsed.appId).toBe("test-app");
     expect(ctx.pendingSurfaceActions.get(parsed.surfaceId)?.surfaceType).toBe(
       "dynamic_page",
     );

package/src/__tests__/system-prompt.test.ts

@@ -320,13 +320,12 @@ describe("buildSystemPrompt", () => {
       expect(result).not.toContain("use `app_update` to change the HTML");
     });
 
-    test("onboarding playbook uses app_file_edit for accent color, not app_update", () => {
+    test("onboarding playbook does not reference Home Base for accent color", () => {
       // Starter task playbooks only included during onboarding (BOOTSTRAP.md exists)
       writeFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "# First run");
       const result = buildSystemPrompt();
-      expect(result).toContain(
-        "using `app_file_edit` to update the theme styles",
-      );
+      // The make_it_yours playbook should not reference Home Base anymore
+      expect(result).not.toContain("Home Base dashboard");
       expect(result).not.toContain(
         "using `app_update` to regenerate the Home Base HTML",
       );

package/src/__tests__/trust-store.test.ts

@@ -874,13 +874,13 @@ describe("Trust Store", () => {
       );
     });
 
-    test("findHighestPriorityRule matches default allow for host_bash", () => {
+    test("findHighestPriorityRule matches default ask for host_bash", () => {
       const match = findHighestPriorityRule("host_bash", ["ls"], "/tmp");
       expect(match).not.toBeNull();
-      expect(match!.id).toBe("default:allow-host_bash-global");
-      expect(match!.decision).toBe("allow");
+      expect(match!.id).toBe("default:ask-host_bash-global");
+      expect(match!.decision).toBe("ask");
       expect(match!.priority).toBe(
-        DEFAULT_PRIORITY_BY_ID.get("default:allow-host_bash-global")!,
+        DEFAULT_PRIORITY_BY_ID.get("default:ask-host_bash-global")!,
       );
     });
 

package/src/__tests__/twitter-platform-proxy-client.test.ts

@@ -7,11 +7,14 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 let mockApiKey: string | undefined = "test-api-key-123";
 let mockPlatformEnvUrl = "https://platform.vellum.ai";
 let mockPlatformAssistantId = "ast_abc123";
+let mockPlatformAssistantIdFromStore: string | undefined = undefined;
 let mockConfigBaseUrl = "";
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKey: (account: string) => {
     if (account === "credential:vellum:assistant_api_key") return mockApiKey;
+    if (account === "credential:vellum:platform_assistant_id")
+      return mockPlatformAssistantIdFromStore;
     return undefined;
   },
 }));
@@ -73,12 +76,17 @@ beforeEach(() => {
   mockApiKey = "test-api-key-123";
   mockPlatformEnvUrl = "https://platform.vellum.ai";
   mockPlatformAssistantId = "ast_abc123";
+  mockPlatformAssistantIdFromStore = undefined;
   mockConfigBaseUrl = "";
   lastFetchArgs = null;
   fetchResponse = {
     ok: true,
     status: 200,
-    json: async () => ({ data: { id: "12345", text: "Hello world" } }),
+    json: async () => ({
+      status: 200,
+      headers: {},
+      body: { data: { id: "12345", text: "Hello world" } },
+    }),
   };
 });
 
@@ -114,9 +122,22 @@ describe("prerequisite resolution", () => {
   });
 
   test("resolvePlatformAssistantId returns the env value", () => {
+    mockPlatformAssistantIdFromStore = undefined;
     expect(resolvePlatformAssistantId()).toBe("ast_abc123");
   });
 
+  test("resolvePlatformAssistantId prefers secure key store over env", () => {
+    mockPlatformAssistantIdFromStore = "ast_from_store";
+    mockPlatformAssistantId = "ast_from_env";
+    expect(resolvePlatformAssistantId()).toBe("ast_from_store");
+  });
+
+  test("resolvePlatformAssistantId falls back to env when store is empty", () => {
+    mockPlatformAssistantIdFromStore = undefined;
+    mockPlatformAssistantId = "ast_from_env";
+    expect(resolvePlatformAssistantId()).toBe("ast_from_env");
+  });
+
   test("resolvePrerequisites returns all values when present", () => {
     const prereqs = resolvePrerequisites();
     expect(prereqs.platformBaseUrl).toBe("https://platform.vellum.ai");
@@ -205,9 +226,9 @@ describe("proxyTwitterCall", () => {
     });
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.method).toBe("POST");
-    expect(parsed.path).toBe("/2/tweets");
-    expect(parsed.body).toEqual({ text: "Hello world" });
+    expect(parsed.request.method).toBe("POST");
+    expect(parsed.request.path).toBe("/2/tweets");
+    expect(parsed.request.body).toEqual({ text: "Hello world" });
   });
 
   test("GET-style request includes query parameters", async () => {
@@ -218,16 +239,20 @@ describe("proxyTwitterCall", () => {
     });
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.method).toBe("GET");
-    expect(parsed.path).toBe("/2/users/me");
-    expect(parsed.query).toEqual({ "user.fields": "name,username" });
+    expect(parsed.request.method).toBe("GET");
+    expect(parsed.request.path).toBe("/2/users/me");
+    expect(parsed.request.query).toEqual({ "user.fields": "name,username" });
   });
 
   test("returns parsed response data on success", async () => {
     fetchResponse = {
       ok: true,
       status: 200,
-      json: async () => ({ data: { id: "99", text: "ok" } }),
+      json: async () => ({
+        status: 200,
+        headers: {},
+        body: { data: { id: "99", text: "ok" } },
+      }),
     };
 
     const result = await proxyTwitterCall({
@@ -412,16 +437,16 @@ describe("postTweet", () => {
     await postTweet("Hello from proxy");
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.method).toBe("POST");
-    expect(parsed.path).toBe("/2/tweets");
-    expect(parsed.body.text).toBe("Hello from proxy");
+    expect(parsed.request.method).toBe("POST");
+    expect(parsed.request.path).toBe("/2/tweets");
+    expect(parsed.request.body.text).toBe("Hello from proxy");
   });
 
   test("includes reply metadata when replyToId is provided", async () => {
     await postTweet("This is a reply", { replyToId: "tweet_789" });
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.body.reply).toEqual({
+    expect(parsed.request.body.reply).toEqual({
       in_reply_to_tweet_id: "tweet_789",
     });
   });
@@ -432,9 +457,9 @@ describe("getMe", () => {
     await getMe({ "user.fields": "name,username,profile_image_url" });
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.method).toBe("GET");
-    expect(parsed.path).toBe("/2/users/me");
-    expect(parsed.query).toEqual({
+    expect(parsed.request.method).toBe("GET");
+    expect(parsed.request.path).toBe("/2/users/me");
+    expect(parsed.request.query).toEqual({
       "user.fields": "name,username,profile_image_url",
     });
   });
@@ -443,8 +468,8 @@ describe("getMe", () => {
     await getMe();
 
     const parsed = JSON.parse(lastFetchArgs![1].body as string);
-    expect(parsed.method).toBe("GET");
-    expect(parsed.path).toBe("/2/users/me");
-    expect(parsed.query).toBeUndefined();
+    expect(parsed.request.method).toBe("GET");
+    expect(parsed.request.path).toBe("/2/users/me");
+    expect(parsed.request.query).toBeUndefined();
   });
 });

package/src/cli/commands/amazon/index.ts

@@ -22,12 +22,7 @@ import {
   SessionExpiredError,
   viewCart,
 } from "./client.js";
-import {
-  clearSession,
-  importFromRecording,
-  loadSession,
-  saveSession,
-} from "./session.js";
+import { clearSession, loadSession, saveSession } from "./session.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -82,7 +77,7 @@ export function registerAmazonCommand(program: Command): void {
   const amz = program
     .command("amazon")
     .description(
-      "Shop on Amazon and Amazon Fresh. Requires a session imported from a Ride Shotgun recording.",
+      'Shop on Amazon and Amazon Fresh. Requires an active session (use "refresh" to authenticate).',
     )
     .option("--json", "Machine-readable JSON output");
 
@@ -98,8 +93,7 @@ Session lifecycle:
   2. "refresh-headless" reads cookies directly from Chrome's local SQLite database.
      No visible browser window is needed, but Chrome must already be signed into Amazon.
   3. "status" checks whether a valid session exists.
-  4. "login" imports a session from a previously saved Ride Shotgun recording file.
-  5. "logout" clears the saved session.
+  4. "logout" clears the saved session.
 
 Product workflow: search for products, view details/variations by ASIN, then add
 to cart. Use --fresh flag for Amazon Fresh grocery items throughout the workflow.
@@ -118,35 +112,6 @@ Examples:
   $ assistant amazon order place --payment-method-id pm_abc123`,
   );
 
-  // =========================================================================
-  // login — import session from a recording
-  // =========================================================================
-  amz
-    .command("login")
-    .description("Import an Amazon session from a Ride Shotgun recording")
-    .requiredOption("--recording <path>", "Path to the recording JSON file")
-    .addHelpText(
-      "after",
-      `
-Imports Amazon session cookies from a previously saved Ride Shotgun recording
-file. The recording must contain captured cookies from an authenticated Amazon
-session. Typically used to restore a session from a saved recording rather than
-re-authenticating via "refresh".
-
-Examples:
-  $ assistant amazon login --recording /path/to/recording.json
-  $ assistant amazon login --recording ~/recordings/amazon-2024-01-15.json`,
-    )
-    .action(async (opts: { recording: string }, cmd: Command) => {
-      await run(cmd, async () => {
-        const session = await importFromRecording(opts.recording);
-        return {
-          message: "Session imported successfully",
-          cookieCount: session.cookies.length,
-        };
-      });
-    });
-
   // =========================================================================
   // logout — clear saved session
   // =========================================================================
@@ -158,7 +123,7 @@ Examples:
       `
 Removes all saved Amazon session cookies from local storage. After logout,
 all shopping commands will fail until a new session is established via
-"refresh", "refresh-headless", or "login".
+"refresh" or "refresh-headless".
 
 Examples:
   $ assistant amazon logout`,