@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/runtime/trust-verdict-consumer.ts

@@ -0,0 +1,172 @@
+/**
+ * Consume a gateway-stamped {@link TrustVerdict} into the daemon's local
+ * trust shapes.
+ *
+ * The gateway resolves a per-actor verdict from its ACL DB and stamps it onto
+ * inbound `sourceMetadata`. These pure mappers turn that verdict into the same
+ * {@link TrustContext} / {@link ResolvedMember} the local resolver would have
+ * produced — ACL + identity only. INFO fields (notes, userFile, contactType,
+ * interactionCount) are never carried on the wire; the consumer re-joins them
+ * locally by contactId.
+ */
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+import type { ChannelId } from "../channels/types.js";
+import { channelStatusToMemberStatus } from "../contacts/member-status.js";
+import type {
+  ChannelPolicy,
+  ChannelStatus,
+  ContactChannel,
+  ContactWithChannels,
+} from "../contacts/types.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import type { ActorTrustContext } from "./actor-trust-resolver.js";
+import { toTrustContext } from "./actor-trust-resolver.js";
+import type { ResolvedMember } from "./routes/inbound-stages/acl-enforcement.js";
+
+export interface TrustVerdictTransport {
+  sourceChannel: ChannelId;
+  conversationExternalId: string;
+  actorUsername?: string;
+  actorDisplayName?: string;
+}
+
+/**
+ * Build a {@link TrustContext} from a gateway verdict + transport identity.
+ *
+ * Reassembles an {@link ActorTrustContext} (mirroring `resolveActorTrust`) and
+ * routes it through {@link toTrustContext}, so the output is byte-identical to
+ * the local resolution path.
+ */
+export function trustContextFromVerdict(
+  verdict: TrustVerdict,
+  input: TrustVerdictTransport,
+): TrustContext {
+  const canonicalSenderId = verdict.canonicalSenderId;
+  const memberDisplayName = verdict.memberDisplayName;
+  const senderDisplayName = input.actorDisplayName;
+  const username = input.actorUsername;
+  const identifier = username
+    ? `@${username}`
+    : (canonicalSenderId ?? undefined);
+
+  const actorTrustContext: ActorTrustContext = {
+    canonicalSenderId,
+    guardianBindingMatch: verdict.guardianExternalUserId
+      ? {
+          guardianExternalUserId: verdict.guardianExternalUserId,
+          guardianDeliveryChatId: verdict.guardianDeliveryChatId ?? null,
+        }
+      : null,
+    guardianPrincipalId: verdict.guardianPrincipalId,
+    memberRecord: null,
+    trustClass: verdict.trustClass,
+    actorMetadata: {
+      identifier,
+      displayName: memberDisplayName ?? senderDisplayName,
+      senderDisplayName,
+      memberDisplayName,
+      username,
+      channel: input.sourceChannel,
+      trustStatus: verdict.trustClass,
+    },
+  };
+
+  const context = toTrustContext(
+    actorTrustContext,
+    input.conversationExternalId,
+  );
+
+  // Stamp the verdict's ACL member fields onto the context so downstream turn
+  // assembly reads member status/policy from the verdict rather than a local
+  // re-resolution. The contact ID anchors the local info-only join.
+  const member = resolvedMemberFromVerdict(verdict);
+  if (member) {
+    context.requesterContactId = member.contact.id;
+    context.memberStatus = channelStatusToMemberStatus(member.channel.status);
+    context.memberPolicy = member.channel.policy;
+  }
+
+  return context;
+}
+
+// Allowed ACL enum values, kept in sync with the ContactChannel union types.
+const CHANNEL_STATUS_VALUES: readonly ChannelStatus[] = [
+  "active",
+  "pending",
+  "revoked",
+  "blocked",
+  "unverified",
+];
+const CHANNEL_POLICY_VALUES: readonly ChannelPolicy[] = [
+  "allow",
+  "deny",
+  "escalate",
+];
+
+function isChannelStatus(value: string): value is ChannelStatus {
+  return (CHANNEL_STATUS_VALUES as readonly string[]).includes(value);
+}
+
+function isChannelPolicy(value: string): value is ChannelPolicy {
+  return (CHANNEL_POLICY_VALUES as readonly string[]).includes(value);
+}
+
+/**
+ * Build a synthetic {@link ResolvedMember} from a gateway verdict.
+ *
+ * ACL + identity only; info fields are placeholders, re-joined locally by
+ * contactId. Returns null for memberless verdicts.
+ */
+export function resolvedMemberFromVerdict(
+  verdict: TrustVerdict,
+): ResolvedMember | null {
+  if (!verdict.contactId || !verdict.channelId) return null;
+  // Member verdict requires valid known status+policy enums, else null
+  // (fail-closed): a partial/mixed-version verdict (absent OR
+  // present-but-unknown ACL value) must not synthesize an active/allow channel
+  // that would skip ingress ACL gates.
+  if (!verdict.status || !verdict.policy) return null;
+  if (!isChannelStatus(verdict.status) || !isChannelPolicy(verdict.policy)) {
+    return null;
+  }
+
+  const channel: ContactChannel = {
+    id: verdict.channelId,
+    contactId: verdict.contactId,
+    type: verdict.type ?? "",
+    address: verdict.address ?? "",
+    isPrimary: false,
+    externalChatId: verdict.externalChatId ?? null,
+    status: verdict.status,
+    policy: verdict.policy,
+    verifiedAt: verdict.verifiedAt ?? null,
+    verifiedVia: verdict.verifiedVia ?? null,
+    inviteId: null,
+    revokedReason: null,
+    blockedReason: null,
+    lastSeenAt: null,
+    interactionCount: 0,
+    lastInteraction: null,
+    updatedAt: null,
+    createdAt: 0,
+  };
+
+  const contact: ContactWithChannels = {
+    id: verdict.contactId,
+    displayName: verdict.memberDisplayName ?? "",
+    notes: null,
+    lastInteraction: null,
+    interactionCount: 0,
+    createdAt: 0,
+    updatedAt: 0,
+    role: verdict.trustClass === "guardian" ? "guardian" : "contact",
+    contactType: "human",
+    principalId: verdict.guardianPrincipalId ?? null,
+    userFile: null,
+    channels: [channel],
+  };
+
+  return { contact, channel };
+}

package/src/schedule/scheduler.ts

@@ -1,3 +1,4 @@
+import { getConfig } from "../config/loader.js";
 import {
   checkDiskPressureBackgroundGate,
   diskPressureBackgroundSkipLogFields,
@@ -85,14 +86,6 @@ const TICK_INTERVAL_MS = 15_000;
  */
 const WAKE_MAX_RETRIES = 20;
 
-/**
- * Hard timeout for `talk`-mode scheduled jobs. Schedules can do
- * non-trivial work (research, summarize the day, etc.), so the cap is
- * generous; it exists primarily so a wedged turn cannot block the next
- * scheduler tick indefinitely. Mirrors the heartbeat/filing budgets.
- */
-const SCHEDULE_TALK_TIMEOUT_MS = 30 * 60 * 1000;
-
 /**
  * Apply retry policy on schedule-execution failure. Retries are scheduled by
  * `applyRetryDecision`; once retries are exhausted, the `emitAlert` callback
@@ -362,6 +355,7 @@ export async function runScheduleDueWorkOnce(
           conversationId: wakeConversationId,
           hint: job.message,
           source: "defer",
+          persistTriggerAsEvent: true,
           ...(job.inferenceProfile
             ? { forceOverrideProfile: job.inferenceProfile }
             : {}),
@@ -718,7 +712,10 @@ export async function runScheduleDueWorkOnce(
         ...(job.inferenceProfile
           ? { overrideProfile: job.inferenceProfile }
           : {}),
-        timeoutMs: SCHEDULE_TALK_TIMEOUT_MS,
+        // Hard timeout for talk-mode scheduled turns: bounds a wedged turn so
+        // it cannot block the next scheduler tick. Configurable via
+        // timeouts.scheduleTurnTimeoutSec (default 1800s).
+        timeoutMs: getConfig().timeouts.scheduleTurnTimeoutSec * 1000,
         origin: "schedule",
         groupId: "system:scheduled",
         conversationType: "scheduled",

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -241,7 +241,7 @@ import {
 } from "./activation-funnel.js";
 import { UsageTelemetryReporter } from "./usage-telemetry-reporter.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -59,7 +59,9 @@ beforeEach(() => {
   };
 });
 
-const validInput = {
+// A single question used to build batches. The tool only accepts the
+// batched `{ questions: [...] }` shape.
+const singleQ = {
   question: "Which fruit?",
   description: "Pick one to add to the smoothie.",
   options: [
@@ -69,12 +71,7 @@ const validInput = {
   freeTextPlaceholder: "Type a fruit",
 };
 
-const singleQ = {
-  question: validInput.question,
-  description: validInput.description,
-  options: validInput.options,
-  freeTextPlaceholder: validInput.freeTextPlaceholder,
-};
+const validInput = { questions: [singleQ] };
 
 describe("askQuestionTool definition", () => {
   test("exposes the expected schema shape and description language", () => {
@@ -91,7 +88,6 @@ describe("askQuestionTool definition", () => {
     expect(def.description).toContain("remove guessing");
     expect(def.description).toContain("a question is skipped");
     expect(def.description).toContain("every question in the batch is skipped");
-    // Batching language is back now that the prompter handles batches.
     expect(def.description).toContain("Batch related clarifications");
     expect(def.description).toContain("up to 5");
     expect(def.description).toContain("Skip button");
@@ -99,13 +95,23 @@ describe("askQuestionTool definition", () => {
     const schema = def.input_schema as {
       properties: Record<
         string,
-        { type?: string; minItems?: number; maxItems?: number }
+        {
+          type?: string;
+          items?: {
+            properties?: Record<
+              string,
+              { type?: string; minItems?: number; maxItems?: number }
+            >;
+          };
+        }
       >;
       required?: string[];
     };
-    expect(schema.properties.options?.type).toBe("array");
-    expect(schema.properties.options?.minItems).toBe(2);
-    expect(schema.properties.options?.maxItems).toBe(4);
+    const optionsSchema =
+      schema.properties.questions?.items?.properties?.options;
+    expect(optionsSchema?.type).toBe("array");
+    expect(optionsSchema?.minItems).toBe(2);
+    expect(optionsSchema?.maxItems).toBe(4);
   });
 });
 
@@ -132,17 +138,17 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(1);
     expect(calls[0]?.conversationId).toBe("conv-1");
     expect(calls[0]?.questions).toHaveLength(1);
-    expect(calls[0]?.questions[0]?.question).toBe(validInput.question);
-    expect(calls[0]?.questions[0]?.description).toBe(validInput.description);
-    expect(calls[0]?.questions[0]?.options).toEqual(validInput.options);
+    expect(calls[0]?.questions[0]?.question).toBe(singleQ.question);
+    expect(calls[0]?.questions[0]?.description).toBe(singleQ.description);
+    expect(calls[0]?.questions[0]?.options).toEqual(singleQ.options);
     expect(calls[0]?.questions[0]?.freeTextPlaceholder).toBe(
-      validInput.freeTextPlaceholder,
+      singleQ.freeTextPlaceholder,
     );
     expect(calls[0]?.toolUseId).toBe("tu-1");
 
     expect(result.isError).toBe(false);
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: a (Apple)`,
+      `Question "${singleQ.question}" → Option: a (Apple)`,
     );
   });
 
@@ -150,7 +156,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "b" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: b (Banana)`,
+      `Question "${singleQ.question}" → Option: b (Banana)`,
     );
     expect(result.isError).toBe(false);
   });
@@ -159,7 +165,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "ghost" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Option: ghost ((unknown))`,
+      `Question "${singleQ.question}" → Option: ghost ((unknown))`,
     );
     expect(result.isError).toBe(false);
   });
@@ -168,7 +174,7 @@ describe("AskQuestionTool.execute", () => {
     setNextResult(singleCompleted({ decision: "free_text", text: "Cherry" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
     expect(result.content).toBe(
-      `Question "${validInput.question}" → Free text: Cherry`,
+      `Question "${singleQ.question}" → Free text: Cherry`,
     );
     expect(result.isError).toBe(false);
   });
@@ -176,7 +182,7 @@ describe("AskQuestionTool.execute", () => {
   test("formats skipped result", async () => {
     setNextResult(singleCompleted({ decision: "skipped" }));
     const result = await askQuestionTool.execute(validInput, makeContext());
-    expect(result.content).toBe(`Question "${validInput.question}" → Skipped`);
+    expect(result.content).toBe(`Question "${singleQ.question}" → Skipped`);
     expect(result.isError).toBe(false);
   });
 
@@ -200,10 +206,10 @@ describe("AskQuestionTool.execute", () => {
     expect(result.content).toBe("Question aborted");
   });
 
-  test("rejects input with fewer than 2 options", async () => {
+  test("rejects a question with fewer than 2 options", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
-      { ...validInput, options: [{ id: "a", label: "Apple" }] },
+      { questions: [{ ...singleQ, options: [{ id: "a", label: "Apple" }] }] },
       makeContext(),
     );
     expect(result.isError).toBe(true);
@@ -211,17 +217,21 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input with more than 4 options", async () => {
+  test("rejects a question with more than 4 options", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
       {
-        ...validInput,
-        options: [
-          { id: "a", label: "A" },
-          { id: "b", label: "B" },
-          { id: "c", label: "C" },
-          { id: "d", label: "D" },
-          { id: "e", label: "E" },
+        questions: [
+          {
+            ...singleQ,
+            options: [
+              { id: "a", label: "A" },
+              { id: "b", label: "B" },
+              { id: "c", label: "C" },
+              { id: "d", label: "D" },
+              { id: "e", label: "E" },
+            ],
+          },
         ],
       },
       makeContext(),
@@ -230,10 +240,10 @@ describe("AskQuestionTool.execute", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input with empty question", async () => {
+  test("rejects a question with empty text", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
     const result = await askQuestionTool.execute(
-      { ...validInput, question: "" },
+      { questions: [{ ...singleQ, question: "" }] },
       makeContext(),
     );
     expect(result.isError).toBe(true);
@@ -254,18 +264,6 @@ describe("AskQuestionTool.execute", () => {
 // ── Batched input ───────────────────────────────────────────────────
 
 describe("AskQuestionTool batched input", () => {
-  test("normalizes legacy flat input into a one-element batch forwarded to the prompter", async () => {
-    setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
-
-    const result = await askQuestionTool.execute(validInput, makeContext());
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.questions).toHaveLength(1);
-    expect(calls[0]?.questions[0]?.question).toBe(validInput.question);
-    expect(calls[0]?.questions[0]?.options).toEqual(validInput.options);
-    expect(result.isError).toBe(false);
-  });
-
   test("accepts a single-element `questions` batch", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
@@ -454,7 +452,7 @@ describe("AskQuestionTool batched input", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects input missing both `questions` and flat fields", async () => {
+  test("rejects input missing `questions`", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
     const result = await askQuestionTool.execute({}, makeContext());
@@ -464,11 +462,17 @@ describe("AskQuestionTool batched input", () => {
     expect(calls).toHaveLength(0);
   });
 
-  test("rejects legacy `question` without `options`", async () => {
+  test("rejects the dropped flat single-question shape", async () => {
     setNextResult(singleCompleted({ decision: "option", optionId: "a" }));
 
     const result = await askQuestionTool.execute(
-      { question: "Hi?" },
+      {
+        question: "Hi?",
+        options: [
+          { id: "a", label: "A" },
+          { id: "b", label: "B" },
+        ],
+      },
       makeContext(),
     );
 
@@ -479,7 +483,7 @@ describe("AskQuestionTool batched input", () => {
 });
 
 describe("askQuestionTool definition (batched schema)", () => {
-  test("exposes `questions[]` shape, keeps legacy fields, omits per-question id", () => {
+  test("exposes `questions[]` shape, requires it, and drops the flat fields", () => {
     const def = askQuestionTool;
     const schema = def.input_schema as unknown as {
       properties: Record<
@@ -517,8 +521,12 @@ describe("askQuestionTool definition (batched schema)", () => {
 
     expect(questions?.items?.required).toEqual(["question", "options"]);
 
-    // Legacy fields still present.
-    expect(schema.properties.question).toBeDefined();
-    expect(schema.properties.options).toBeDefined();
+    // `questions` is the only top-level input now.
+    expect(schema.required).toEqual(["questions"]);
+    expect(Object.keys(schema.properties)).toEqual(["questions"]);
+
+    // The legacy flat fields are gone.
+    expect(schema.properties.question).toBeUndefined();
+    expect(schema.properties.options).toBeUndefined();
   });
 });

package/src/tools/ask-question/ask-question-tool.ts

@@ -40,35 +40,16 @@ const SingleQuestionSchema = z.object({
 // input with ≥6 entries is rejected with a clear Zod error.
 const MAX_QUESTIONS_PER_BATCH = 5;
 
-// Both the new batched shape (`questions[]`) and the legacy flat shape are
-// accepted. `execute()` normalizes legacy callers into a one-element
-// `questions` array before forwarding to the prompter.
-const InputSchema = z
-  .object({
-    questions: z
-      .array(SingleQuestionSchema)
-      .min(1)
-      .max(MAX_QUESTIONS_PER_BATCH, {
-        message: `At most ${MAX_QUESTIONS_PER_BATCH} questions per batch; split into multiple turns if you need more.`,
-      })
-      .optional(),
-    // Legacy flat fields. Optional so batched callers can omit them; when
-    // present and `questions` is absent, they are normalized into a
-    // one-element batch in `execute()`.
-    question: z.string().min(1).optional(),
-    description: z.string().optional(),
-    options: z.array(OptionSchema).min(2).max(4).optional(),
-    freeTextPlaceholder: z.string().optional(),
-  })
-  .refine(
-    (v) =>
-      v.questions !== undefined ||
-      (v.question !== undefined && v.options !== undefined),
-    {
-      message:
-        "Provide `questions` (preferred) or the legacy flat fields (`question` + `options`).",
-    },
-  );
+// Callers pass a (possibly single-element) batch of questions. `execute()`
+// forwards them straight to the prompter.
+const InputSchema = z.object({
+  questions: z
+    .array(SingleQuestionSchema)
+    .min(1)
+    .max(MAX_QUESTIONS_PER_BATCH, {
+      message: `At most ${MAX_QUESTIONS_PER_BATCH} questions per batch; split into multiple turns if you need more.`,
+    }),
+});
 
 export type SingleQuestion = z.infer<typeof SingleQuestionSchema>;
 export type AskQuestionInput = z.infer<typeof InputSchema>;
@@ -111,8 +92,7 @@ const DESCRIPTION = [
   "context shown beneath the label.",
 ].join("\n");
 
-// Shared option-schema fragment used by both the batched `questions[]`
-// shape and the legacy flat `options` field.
+// Option-schema fragment for the items in `questions[].options`.
 const OPTION_ITEMS_SCHEMA = {
   type: "object",
   properties: {
@@ -150,12 +130,11 @@ export const askQuestionTool = {
   input_schema: {
     type: "object",
     properties: {
-      // ── Recommended shape ─────────────────────────────────────
       questions: {
         type: "array",
         minItems: 1,
         maxItems: MAX_QUESTIONS_PER_BATCH,
-        description: `Recommended shape. 1–${MAX_QUESTIONS_PER_BATCH} clarifying questions to ask in a single turn. Use a batch when several independent ambiguities block progress; ask one at a time when they're sequentially dependent. Past ${MAX_QUESTIONS_PER_BATCH} questions you should be implementing, not asking.`,
+        description: `1–${MAX_QUESTIONS_PER_BATCH} clarifying questions to ask in a single turn. Use a batch when several independent ambiguities block progress; ask one at a time when they're sequentially dependent. Past ${MAX_QUESTIONS_PER_BATCH} questions you should be implementing, not asking.`,
         items: {
           type: "object",
           properties: {
@@ -185,35 +164,8 @@ export const askQuestionTool = {
           required: ["question", "options"],
         },
       },
-      // ── Legacy single-question fields ─────────────────────────
-      // Kept optional so existing prompt caches and any single-question
-      // callers continue to work. New callers should use `questions`.
-      question: {
-        type: "string",
-        description:
-          "Legacy: the single clarifying question. Prefer `questions[]` for new code.",
-      },
-      description: {
-        type: "string",
-        description:
-          "Legacy: optional one-line context shown beneath the question. Prefer `questions[].description`.",
-      },
-      options: {
-        type: "array",
-        minItems: 2,
-        maxItems: 4,
-        description:
-          "Legacy: 2–4 structured options. Prefer `questions[].options`. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-        items: OPTION_ITEMS_SCHEMA,
-      },
-      freeTextPlaceholder: {
-        type: "string",
-        description:
-          "Legacy: optional placeholder text for the free-text fallback input. Prefer `questions[].freeTextPlaceholder`.",
-      },
     },
-    // No top-level `required` — caller must supply either `questions`
-    // or the legacy flat trio (`question` + `options`). Enforced in Zod.
+    required: ["questions"],
   },
 
   async execute(
@@ -228,18 +180,7 @@ export const askQuestionTool = {
       };
     }
 
-    // Normalize legacy flat input into a one-element `questions` batch so
-    // downstream code only has to deal with the batched shape. The refine
-    // above guarantees `question` and `options` are present whenever
-    // `questions` is absent.
-    const questions: SingleQuestion[] = parsed.data.questions ?? [
-      {
-        question: parsed.data.question!,
-        description: parsed.data.description,
-        options: parsed.data.options!,
-        freeTextPlaceholder: parsed.data.freeTextPlaceholder,
-      },
-    ];
+    const questions: SingleQuestion[] = parsed.data.questions;
 
     const prompter = new QuestionPrompter();
     const result = await prompter.prompt({

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -296,4 +296,24 @@ describe("executeBrowserStatus", () => {
     expect(extension.available).toBe(true);
     expect(extension.details.transport).toBe("extension-ws");
   });
+
+  test("reports extension as connected when probe fails on the Chrome Web Store / extensions gallery", async () => {
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
+    probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
+    probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
+      "cdp_error",
+      "The extensions gallery cannot be scripted.",
+    );
+
+    const result = await executeBrowserStatus({}, makeContext());
+    expect(result.isError).toBe(false);
+    const payload = JSON.parse(result.content);
+    const extension = payload.modes.find(
+      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
+    );
+    expect(extension).toBeDefined();
+    expect(extension.available).toBe(true);
+    expect(extension.verified).toBe("active_probe");
+    expect(extension.details.restrictedActiveTab).toBe(true);
+  });
 });

package/src/tools/browser/browser-execution.ts

@@ -345,10 +345,22 @@ function collectRemediationHints(
 
 /**
  * Detect the common extension CDP failure where the active tab is a
- * restricted Chrome internal page (e.g. `chrome://newtab`).
+ * page Chrome forbids extensions from scripting — either a privileged
+ * `chrome://` internal page (e.g. `chrome://newtab`) or the Chrome Web
+ * Store / extensions gallery (which yields "The extensions gallery
+ * cannot be scripted."). The latter is especially common right after
+ * install, when the Web Store page is still the active tab.
+ *
+ * Keep this restricted-error match in sync with the Page.navigate
+ * recovery in the chrome-extension dispatcher (host-browser-dispatcher.ts,
+ * separate package, duplicated by necessity): the status side reports the
+ * tab as recoverable, and the navigate side must actually recover it.
  */
 function isRestrictedChromePageProbeError(error: CdpError): boolean {
-  return error.message.toLowerCase().includes("chrome://");
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("chrome://") || message.includes("cannot be scripted")
+  );
 }
 
 /**
@@ -2450,9 +2462,9 @@ async function checkExtensionModeStatus(
       verified: "active_probe",
       autoCandidate,
       summary:
-        "Extension mode transport is connected, but the active Chrome tab is a restricted chrome:// page. Switch to a regular website tab if browser actions fail.",
+        "Extension mode transport is connected, but the active Chrome tab is a page Chrome won't let extensions script (a chrome:// page or the Chrome Web Store / extensions gallery). Switch to a regular website tab if browser actions fail.",
       userActions: [
-        "Switch Chrome to a regular http(s) tab (not chrome://...) and retry.",
+        "Switch Chrome to a regular http(s) tab — not a chrome:// page or the Chrome Web Store / extensions gallery — and retry.",
       ],
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: {

package/src/tools/document/document-comment-tool.test.ts

@@ -20,7 +20,7 @@ import {
   executeCommentResolve,
 } from "./document-comment-tool.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers