@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -34,7 +34,7 @@ let fetchCalls: Array<{ url: string; init?: RequestInit }>;
 let fetchHandler: (
   url: string,
   init?: RequestInit,
-) => { ok: boolean; body: unknown };
+) => { ok: boolean; body: unknown; scopes?: string };
 
 beforeEach(() => {
   mockSecureKeys = {};
@@ -45,10 +45,17 @@ beforeEach(() => {
   globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
     const url = typeof input === "string" ? input : input.toString();
     fetchCalls.push({ url, init });
-    const { ok, body } = fetchHandler(url, init);
+    const { ok, body, scopes } = fetchHandler(url, init);
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+    };
+    // Slack stamps the granted scopes on every Web API response.
+    if (scopes !== undefined) {
+      headers["x-oauth-scopes"] = scopes;
+    }
     return new Response(JSON.stringify(body), {
       status: ok ? 200 : 500,
-      headers: { "content-type": "application/json" },
+      headers,
     });
   }) as typeof globalThis.fetch;
 });
@@ -147,3 +154,144 @@ describe("slack remote probe (auth.test)", () => {
     expect(authTest.message).toMatch(/ECONNREFUSED/);
   });
 });
+
+/**
+ * Slack can install an app with a fraction of the manifest's scopes while
+ * auth.test still succeeds — a live install produced 2 of 18, and the first
+ * real API call failed with missing_scope. auth.test passing is therefore not
+ * evidence the install is usable.
+ */
+describe("slack auth.test response validation", () => {
+  test("reports an unexpected shape instead of trusting the field types", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    // `ok` as a string slips past a cast and makes `!data.ok` decide on a
+    // truthy string rather than a boolean.
+    fetchHandler = () => ({ ok: true, body: { ok: "yes" } });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = snapshot.remoteChecks!.find(
+      (c) => c.name === "auth_test",
+    )!;
+
+    expect(authTest.passed).toBe(false);
+    expect(authTest.message).toMatch(/unexpected response shape/i);
+  });
+
+  test("tolerates unknown fields Slack adds over time", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: true, team: "acme", user: "bot", some_new_field: 42 },
+    });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = snapshot.remoteChecks!.find(
+      (c) => c.name === "auth_test",
+    )!;
+
+    expect(authTest.passed).toBe(true);
+  });
+});
+
+describe("slack scope-grant check", () => {
+  const ALL_REQUIRED = [
+    "app_mentions:read",
+    "assistant:write",
+    "channels:history",
+    "channels:read",
+    "chat:write",
+    "groups:history",
+    "groups:read",
+    "im:history",
+    "im:read",
+    "im:write",
+    "mpim:history",
+    "mpim:read",
+    "users:read",
+  ];
+
+  function okWithScopes(scopes: string) {
+    return () => ({
+      ok: true,
+      body: { ok: true, team_id: "T123", team: "acme", user: "apollobot" },
+      scopes,
+    });
+  }
+
+  test("passes when every required scope was granted", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    fetchHandler = okWithScopes(ALL_REQUIRED.join(","));
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const scopeCheck = snapshot.remoteChecks!.find(
+      (c) => c.name === "scopes_granted",
+    )!;
+
+    expect(scopeCheck.passed).toBe(true);
+  });
+
+  test("ignores declinable scopes the workspace opted out of", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    // No files:read / reactions:* / channels:join — all marked optional in the
+    // manifest, so declining them is a choice, not a fault.
+    fetchHandler = okWithScopes(ALL_REQUIRED.join(","));
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const scopeCheck = snapshot.remoteChecks!.find(
+      (c) => c.name === "scopes_granted",
+    )!;
+
+    expect(scopeCheck.passed).toBe(true);
+  });
+
+  test("catches the silent drop that auth.test reports as healthy", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    // The live symptom: token came back with a couple of scopes.
+    fetchHandler = okWithScopes("channels:history,chat:write");
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const authTest = snapshot.remoteChecks!.find(
+      (c) => c.name === "auth_test",
+    )!;
+    const scopeCheck = snapshot.remoteChecks!.find(
+      (c) => c.name === "scopes_granted",
+    )!;
+
+    // auth.test is happy — that is exactly why this check has to exist.
+    expect(authTest.passed).toBe(true);
+    expect(scopeCheck.passed).toBe(false);
+    expect(scopeCheck.message).toContain("assistant:write");
+    expect(scopeCheck.message).not.toContain("chat:write,");
+    // Recovery order matters: the update prompt gates the reinstall.
+    expect(scopeCheck.message).toMatch(/update prompt/i);
+    expect(scopeCheck.message).toMatch(/Reinstall to Workspace/i);
+  });
+
+  test("stays passing when Slack sends no scope header", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    fetchHandler = () => ({
+      ok: true,
+      body: { ok: true, team_id: "T123", team: "acme", user: "apollobot" },
+    });
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const scopeCheck = snapshot.remoteChecks!.find(
+      (c) => c.name === "scopes_granted",
+    )!;
+
+    expect(scopeCheck.passed).toBe(true);
+    expect(scopeCheck.message).toMatch(/skipped/i);
+  });
+
+  test("tolerates whitespace in the comma-separated header", async () => {
+    mockSecureKeys[credentialKey("slack_channel", "bot_token")] = "xoxb-fake";
+    fetchHandler = okWithScopes(` ${ALL_REQUIRED.join(" , ")} ,, `);
+
+    const [snapshot] = await runSlackRemoteProbe();
+    const scopeCheck = snapshot.remoteChecks!.find(
+      (c) => c.name === "scopes_granted",
+    )!;
+
+    expect(scopeCheck.passed).toBe(true);
+  });
+});

package/src/__tests__/channel-retry-sweep.test.ts

@@ -189,6 +189,10 @@ function seedFailedSlackEvent(opts: {
   externalChatId: string;
   channelTs: string;
   requesterIdentifier?: string;
+  /** Stands in for the `slackInbound` the live path captures onto the payload. */
+  slackInbound?: Record<string, unknown>;
+  /** Extra `sourceMetadata` fields, as the gateway forwards them. */
+  sourceMetadata?: Record<string, unknown>;
 }): string {
   const inbound = deliveryCrud.recordInbound(
     "slack",
@@ -203,7 +207,11 @@ function seedFailedSlackEvent(opts: {
     externalMessageId: opts.channelTs,
     // `sourceMetadata.messageId` is the Slack `ts`; the live path derives the
     // idempotency key's `channelTs` from it (falling back to externalMessageId).
-    sourceMetadata: { messageId: opts.channelTs },
+    sourceMetadata: {
+      messageId: opts.channelTs,
+      ...(opts.sourceMetadata ?? {}),
+    },
+    ...(opts.slackInbound ? { slackInbound: opts.slackInbound } : {}),
     trustCtx: {
       trustClass: opts.trustClass,
       sourceChannel: "slack",
@@ -434,6 +442,85 @@ describe("channel-retry-sweep", () => {
     expect(capturedOptions?.slackInbound?.channelTs).toBe("1700000000.000200");
   });
 
+  test("replays the sender's Slack app context from the captured slackInbound", async () => {
+    seedFailedSlackEvent({
+      trustClass: "guardian",
+      content: "summarize this",
+      externalChatId: "D7654321",
+      channelTs: "1700000000.000300",
+      slackInbound: {
+        channelId: "D7654321",
+        channelTs: "1700000000.000300",
+        appContext: {
+          entities: [{ type: "slack#/types/channel_id", value: "C0123ABC" }],
+        },
+      },
+    });
+
+    let capturedContent: string | undefined;
+    let capturedOptions: { displayContent?: string } | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedContent = content;
+      capturedOptions = options as { displayContent?: string };
+      const messageId = "message-app-context-slack";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    // Without this the replayed turn loses the context that made "summarize
+    // this" resolvable — the model would see a bare deictic reference.
+    expect(capturedContent).toContain("channel: C0123ABC");
+    expect(capturedContent).toContain("summarize this");
+    expect(capturedOptions?.displayContent).toBe("summarize this");
+  });
+
+  test("recovers app context from sourceMetadata when the capture never ran", async () => {
+    // `storePayload` runs at the top of the handler; `storeInboundSlackMetadata`
+    // runs on dispatch, after the awaited Slack backfills. A crash in between
+    // leaves an orphan with full sourceMetadata and no slackInbound, which
+    // recovery promotes onto the sweep — the fallback has to rebuild the
+    // turn-shaping fields or the replayed turn is impoverished.
+    seedFailedSlackEvent({
+      trustClass: "guardian",
+      content: "summarize this",
+      externalChatId: "D7654322",
+      channelTs: "1700000000.000400",
+      sourceMetadata: {
+        appContext: {
+          entities: [{ type: "slack#/types/channel_id", value: "C0456DEF" }],
+        },
+      },
+    });
+
+    let capturedContent: string | undefined;
+    await sweepFailedEvents(async (conversationId, content) => {
+      capturedContent = content;
+      const messageId = "message-app-context-recovered";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    expect(capturedContent).toContain("channel: C0456DEF");
+  });
+
   test("skips retry delivery when a dedup replay's sibling event already owns delivery", async () => {
     const eventId = seedFailedSlackEvent({
       trustClass: "guardian",

package/src/__tests__/channel-setup-panel-ack.test.ts

@@ -11,6 +11,7 @@
 import { describe, expect, test } from "bun:test";
 
 import type { OpenPanelEvent } from "../api/events/open-panel.js";
+import type { AssistantEvent } from "../api/index.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
@@ -18,10 +19,12 @@ import {
   type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
-import type { ServerMessage, SurfaceType } from "../daemon/message-protocol.js";
+import type {
+  SurfaceType,
+} from "../daemon/message-protocol.js";
 
 function makeContext(
-  sent: ServerMessage[] = [],
+  sent: AssistantEvent[] = [],
   overrides: Partial<SurfaceConversationContext> = {},
 ): SurfaceConversationContext {
   return {
@@ -48,12 +51,12 @@ function makeContext(
   };
 }
 
-function findOpenPanel(sent: ServerMessage[]): OpenPanelEvent | undefined {
+function findOpenPanel(sent: AssistantEvent[]): OpenPanelEvent | undefined {
   return sent.find((msg): msg is OpenPanelEvent => msg.type === "open_panel");
 }
 
 async function waitForOpenPanel(
-  sent: ServerMessage[],
+  sent: AssistantEvent[],
 ): Promise<OpenPanelEvent> {
   for (let i = 0; i < 20 && !findOpenPanel(sent); i++) {
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -65,7 +68,7 @@ async function waitForOpenPanel(
 
 describe("ui_show channel_setup acknowledgment", () => {
   test("emits open_panel with a surfaceId and succeeds once the client acks", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const resultPromise = surfaceProxyResolver(ctx, "ui_show", {
@@ -100,7 +103,7 @@ describe("ui_show channel_setup acknowledgment", () => {
   });
 
   test("returns a tool error when the client nacks", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const resultPromise = surfaceProxyResolver(ctx, "ui_show", {
@@ -120,7 +123,7 @@ describe("ui_show channel_setup acknowledgment", () => {
   });
 
   test("fails closed without emitting when no interactive client is connected", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent, { hasNoClient: true });
 
     const result = await surfaceProxyResolver(ctx, "ui_show", {
@@ -134,7 +137,7 @@ describe("ui_show channel_setup acknowledgment", () => {
   });
 
   test("times out into a tool error when no client acknowledges", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
 
     const ack = await openChannelSetupPanel(
@@ -155,7 +158,7 @@ describe("ui_show channel_setup acknowledgment", () => {
   });
 
   test("resolves cancelled when the turn is aborted mid-wait", async () => {
-    const sent: ServerMessage[] = [];
+    const sent: AssistantEvent[] = [];
     const ctx = makeContext(sent);
     const controller = new AbortController();
 

package/src/__tests__/chat-reveal-guard-priming.test.ts

@@ -73,22 +73,19 @@ mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
   backfillMemoryRecallLogMessageId: () => {},
 }));
 
-mock.module(
-  "../plugins/defaults/memory/memory-v2-activation-log-store.js",
-  () => ({
-    backfillMemoryV2ActivationMessageId: () => {},
-  }),
-);
+mock.module("../plugins/defaults/memory/v2/activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
 
 // ── Imports (after mocks) ────────────────────────────────────────────────
 
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { EventHandlerDeps } from "../daemon/conversation-agent-loop-handlers.js";
 import {
   createEventHandlerState,
   dispatchAgentEvent,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { _resetStreamStateForTesting } from "../runtime/assistant-stream-state.js";
 import {
   recordForChatMint,
@@ -107,16 +104,16 @@ import {
   SYNTHETIC_OPENAI_PROJECT_KEY,
 } from "./secret-fixtures.js";
 
-function toolResults(events: ServerMessage[]): string[] {
+function toolResults(events: AssistantEvent[]): string[] {
   return events
     .filter(
-      (e): e is Extract<ServerMessage, { type: "tool_result" }> =>
+      (e): e is Extract<AssistantEvent, { type: "tool_result" }> =>
         (e as { type?: string }).type === "tool_result",
     )
     .map((e) => (typeof e.result === "string" ? e.result : ""));
 }
 
-function createMockDeps(collected: ServerMessage[]): EventHandlerDeps {
+function createMockDeps(collected: AssistantEvent[]): EventHandlerDeps {
   return {
     ctx: {
       conversationId: "test-conversation",
@@ -126,7 +123,7 @@ function createMockDeps(collected: ServerMessage[]): EventHandlerDeps {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (msg: ServerMessage) => {
+    onEvent: (msg: AssistantEvent) => {
       collected.push(msg);
     },
     reqId: "test-req-id",
@@ -146,10 +143,10 @@ function createMockDeps(collected: ServerMessage[]): EventHandlerDeps {
   } as EventHandlerDeps;
 }
 
-function streamedText(events: ServerMessage[]): string {
+function streamedText(events: AssistantEvent[]): string {
   return events
     .filter(
-      (e): e is Extract<ServerMessage, { type: "assistant_text_delta" }> =>
+      (e): e is Extract<AssistantEvent, { type: "assistant_text_delta" }> =>
         (e as { type?: string }).type === "assistant_text_delta",
     )
     .map((e) => e.text)
@@ -182,7 +179,7 @@ beforeEach(() => {
 
 describe("live reveal guard priming barrier", () => {
   test("a text delta dispatched while priming is pending waits for the guard and emits the sentinel", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -223,7 +220,7 @@ describe("live reveal guard priming barrier", () => {
   });
 
   test("a plaintext echo cannot beat the guard onto the wire", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -250,7 +247,7 @@ describe("live reveal guard priming barrier", () => {
   });
 
   test("a denied or failed reveal never reads the store and stays unrevealable", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -308,7 +305,7 @@ describe("live reveal guard priming barrier", () => {
   });
 
   test("a proven reveal primes even when the enclosing command exits non-zero", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -340,7 +337,7 @@ describe("live reveal guard priming barrier", () => {
   });
 
   test("steady-state deltas with no priming in flight emit synchronously", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -354,7 +351,7 @@ describe("live reveal guard priming barrier", () => {
   });
 
   test("a rotate-and-re-reveal in one window guards both served values", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -395,7 +392,7 @@ describe("live reveal guard priming barrier", () => {
 
 describe("reveal stdout redaction on the live tool_result", () => {
   test("an opaque revealed value in the reveal's own stdout is redacted before emit", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -424,7 +421,7 @@ describe("reveal stdout redaction on the live tool_result", () => {
   });
 
   test("buffers the RAW tool result so persist redacts exactly once", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -454,7 +451,7 @@ describe("reveal stdout redaction on the live tool_result", () => {
   });
 
   test("a tool_result that never revealed anything is forwarded unchanged", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -478,10 +475,10 @@ describe("reveal stdout redaction on the live tool_result", () => {
   });
 });
 
-function outputChunks(events: ServerMessage[]): string[] {
+function outputChunks(events: AssistantEvent[]): string[] {
   return events
     .filter(
-      (e): e is Extract<ServerMessage, { type: "tool_output_chunk" }> =>
+      (e): e is Extract<AssistantEvent, { type: "tool_output_chunk" }> =>
         (e as { type?: string }).type === "tool_output_chunk",
     )
     .map((e) => e.chunk);
@@ -489,7 +486,7 @@ function outputChunks(events: ServerMessage[]): string[] {
 
 describe("live tool output chunk redaction", () => {
   test("reveal stdout chunks are redacted before forwarding", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -517,7 +514,7 @@ describe("live tool output chunk redaction", () => {
   });
 
   test("a value split across chunks is held back, then flushed redacted", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -549,7 +546,7 @@ describe("live tool output chunk redaction", () => {
   });
 
   test("a held remainder is DISCARDED at tool_result, never emitted raw", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -587,7 +584,7 @@ describe("live tool output chunk redaction", () => {
   });
 
   test("chunks from a tool with no reveal candidates pass through verbatim", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -608,7 +605,7 @@ describe("live tool output chunk redaction", () => {
   });
 
   test("a later tool echoing an already-promoted value is redacted too", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -662,7 +659,7 @@ describe("for-chat re-mint authority (two legs: staged AND executed)", () => {
   } as Extract<AgentEvent, { type: "tool_result" }>;
 
   test("staged by this run + route-minted: the echoed sentinel re-mints on the live wire", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -694,7 +691,7 @@ describe("for-chat re-mint authority (two legs: staged AND executed)", () => {
     // same identity. That mint passes the watermark and staging checks but
     // carries the OTHER conversation's nonce, so it grants nothing here
     // and the echoed sentinel neutralizes like any forgery.
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -721,7 +718,7 @@ describe("for-chat re-mint authority (two legs: staged AND executed)", () => {
     // other conversation's mint lands later. This run's own mint must
     // still re-mint its echoed sentinel — an identity-only dedupe in the
     // registry would have dropped it in favor of the foreign-nonce record.
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -750,7 +747,7 @@ describe("for-chat re-mint authority (two legs: staged AND executed)", () => {
   });
 
   test("a mint alone — identity never staged by this run — neutralizes", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 
@@ -771,7 +768,7 @@ describe("for-chat re-mint authority (two legs: staged AND executed)", () => {
   });
 
   test("staging alone — a quoted command that never executed — neutralizes", async () => {
-    const events: ServerMessage[] = [];
+    const events: AssistantEvent[] = [];
     const state = createEventHandlerState();
     const deps = createMockDeps(events);
 

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -41,7 +41,7 @@ mock.module("../ipc/cli-client.js", () => ({
 }));
 
 let seedCallCount = 0;
-mock.module("../plugins/defaults/memory/v3/substrate/skill-store.js", () => ({
+mock.module("../plugins/defaults/memory/substrate/skill-store.js", () => ({
   seedV2SkillEntries: async () => {
     seedCallCount += 1;
   },
@@ -88,7 +88,7 @@ async function runCommand(args: string[]): Promise<{ exitCode: number }> {
     const program = buildProgram();
     await program.parseAsync(["node", "assistant", ...args]);
   } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
+    if (process.exitCode === 0) {process.exitCode = 1;}
   } finally {
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;