@vellumai/assistant 0.10.9-staging.1 → 0.10.9-staging.2

package/src/__tests__/mtime-cache.test.ts

@@ -679,6 +679,48 @@ describe("plugin runtime activation", () => {
     expect(readFileSync(initMarker, "utf8").trim().split("\n")).toHaveLength(1);
   });
 
+  test("a runtime install is reconciled even when the sentinel mtime never moves (coarse-mtime filesystems)", async () => {
+    await populateCacheAtBoot(); // empty plugins dir
+
+    // Pin every sentinel write back to the SAME timestamp, simulating a
+    // filesystem whose mtime granularity can't distinguish two rewrites (the
+    // virtiofs / 9p / network mounts the watcher polls precisely because their
+    // timestamps are unreliable). Only the sentinel's size + inode move — and
+    // the reconcile gate keys on those, not mtime alone.
+    const FIXED = new Date("2020-01-01T00:00:00.000Z");
+    const pinMtime = (): void =>
+      utimesSync(getSourceVersionsPath(), FIXED, FIXED);
+
+    // First install → publish → dispatch. Pin the mtime so the SECOND publish
+    // below shares it exactly.
+    const dirA = freshPluginDir("coarse-a");
+    writePackageJson(dirA, { ...SIMPLE_PKG, name: "coarse-a" });
+    writeTool(dirA, "coarse-a-tool", TOOL_SRC("coarse-a-tool"));
+    expect(publishSourceChanges()).toBe(true);
+    pinMtime();
+    await getUserHooksFor("user-prompt-submit");
+    await loadPluginTools();
+    expect(
+      getAllToolDefinitions().some((t) => t.name === "coarse-a-tool"),
+    ).toBe(true);
+
+    // Second install → publish → pin the SAME mtime as the first. An mtime-only
+    // gate would see no change and never reconcile (the plugin would go live
+    // only at the next daemon restart); the composite signature still moves —
+    // the atomic rename swaps in a fresh inode and the sentinel grew — so the
+    // plugin goes live on the very next dispatch.
+    const dirB = freshPluginDir("coarse-b");
+    writePackageJson(dirB, { ...SIMPLE_PKG, name: "coarse-b" });
+    writeTool(dirB, "coarse-b-tool", TOOL_SRC("coarse-b-tool"));
+    expect(publishSourceChanges()).toBe(true);
+    pinMtime();
+    await getUserHooksFor("user-prompt-submit");
+    await loadPluginTools();
+    expect(
+      getAllToolDefinitions().some((t) => t.name === "coarse-b-tool"),
+    ).toBe(true);
+  });
+
   test("activation is idempotent — republishing without changes does not re-run init", async () => {
     const dir = freshPluginDir("idem-plugin");
     writePackageJson(dir, { ...SIMPLE_PKG, name: "idem-plugin" });

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -23,7 +23,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
     );
   });
 
-  test("google provider row contains bearer injection templates for 3 Google API hosts", () => {
+  test("google provider row contains bearer injection templates for 4 Google API hosts", () => {
     const provider = getProvider("google");
 
     expect(provider).toBeDefined();
@@ -36,7 +36,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
       valuePrefix: string;
     }>;
 
-    expect(templates).toHaveLength(3);
+    expect(templates).toHaveLength(4);
 
     const byHost = new Map(templates.map((t) => [t.hostPattern, t]));
 
@@ -44,6 +44,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
       "gmail.googleapis.com",
       "www.googleapis.com",
       "people.googleapis.com",
+      "docs.googleapis.com",
     ]) {
       const tpl = byHost.get(host);
       expect(tpl).toBeDefined();

package/src/__tests__/outlook-messaging-provider.test.ts

@@ -473,6 +473,7 @@ describe("Outlook messaging provider", () => {
         conn,
         "original-msg-id",
         "Reply text",
+        undefined,
       );
       expect(mockSendMessage).not.toHaveBeenCalled();
       expect(result).toMatchObject({
@@ -481,6 +482,76 @@ describe("Outlook messaging provider", () => {
       });
     });
 
+    test("attaches files to a new message as Graph file attachments", async () => {
+      const conn = createMockConnection();
+      await outlookMessagingProvider.sendMessage(
+        conn,
+        "recipient@example.com",
+        "See attached",
+        {
+          subject: "Docs",
+          attachments: [
+            {
+              filename: "report.pdf",
+              mimeType: "application/pdf",
+              data: Buffer.from("pdf-bytes"),
+            },
+          ],
+        },
+      );
+
+      expect(mockSendMessage).toHaveBeenCalledWith(conn, {
+        message: {
+          subject: "Docs",
+          body: { contentType: "text", content: "See attached" },
+          toRecipients: [
+            { emailAddress: { address: "recipient@example.com" } },
+          ],
+          attachments: [
+            {
+              "@odata.type": "#microsoft.graph.fileAttachment",
+              name: "report.pdf",
+              contentType: "application/pdf",
+              contentBytes: Buffer.from("pdf-bytes").toString("base64"),
+            },
+          ],
+        },
+      });
+    });
+
+    test("forwards attachments to replyToMessage when replying", async () => {
+      const conn = createMockConnection();
+      await outlookMessagingProvider.sendMessage(
+        conn,
+        "conv-id",
+        "Reply body",
+        {
+          inReplyTo: "original-msg-id",
+          attachments: [
+            {
+              filename: "report.pdf",
+              mimeType: "application/pdf",
+              data: Buffer.from("pdf-bytes"),
+            },
+          ],
+        },
+      );
+
+      expect(mockReplyToMessage).toHaveBeenCalledWith(
+        conn,
+        "original-msg-id",
+        "Reply body",
+        [
+          {
+            "@odata.type": "#microsoft.graph.fileAttachment",
+            name: "report.pdf",
+            contentType: "application/pdf",
+            contentBytes: Buffer.from("pdf-bytes").toString("base64"),
+          },
+        ],
+      );
+    });
+
     test("throws when connection is undefined", async () => {
       await expect(
         outlookMessagingProvider.sendMessage(

package/src/__tests__/plugin-app-serve-routes.test.ts

@@ -0,0 +1,163 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { ROUTES as APP_MGMT_ROUTES } from "../runtime/routes/app-management-routes.js";
+import { ROUTES as APP_ROUTES } from "../runtime/routes/app-routes.js";
+import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
+import type {
+  ResponseHeaderArgs,
+  RouteDefinition,
+  RouteHandlerArgs,
+} from "../runtime/routes/types.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+
+let workspaceDir: string;
+
+function findRoute(routes: RouteDefinition[], operationId: string) {
+  const route = routes.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`Route not found: ${operationId}`);
+  }
+  return route;
+}
+
+/** Install a plugin with a package.json and one bundled app directory. */
+function installPluginApp(
+  plugin: string,
+  app: string,
+  files: Record<string, string>,
+): void {
+  const appDir = join(getWorkspacePluginsDir(), plugin, "apps", app);
+  mkdirSync(appDir, { recursive: true });
+  writeFileSync(
+    join(getWorkspacePluginsDir(), plugin, "package.json"),
+    JSON.stringify({ name: plugin, version: "1.0.0" }),
+  );
+  for (const [rel, content] of Object.entries(files)) {
+    const full = join(appDir, rel);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, content);
+  }
+}
+
+beforeEach(() => {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-plugin-serve-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+describe("plugin app serve routes", () => {
+  test("pages_serve renders a single-file plugin app's index.html", () => {
+    installPluginApp("acme", "dash", {
+      "index.html": "<div id='root'>Plugin Home</div>",
+    });
+    const handler = findRoute(APP_ROUTES, "pages_serve").handler;
+    const html = handler({
+      pathParams: { appId: "plugins~acme~dash" },
+    } as RouteHandlerArgs) as string;
+
+    expect(html).toContain("Plugin Home");
+    expect(html).toContain("<!DOCTYPE html>");
+  });
+
+  test("pages_serve 404s for an unknown / non-plugin id", () => {
+    const handler = findRoute(APP_ROUTES, "pages_serve").handler;
+    expect(() =>
+      handler({
+        pathParams: { appId: "plugins~acme~missing" },
+      } as RouteHandlerArgs),
+    ).toThrow(NotFoundError);
+  });
+
+  test("servePageHeaders CSP: single-file allows inline scripts, multifile does not", () => {
+    installPluginApp("acme", "single", {
+      "index.html": "<div>x</div>",
+    });
+    installPluginApp("acme", "multi", {
+      "dist/index.html": "<script src='main.js'></script>",
+    });
+    const route = findRoute(APP_ROUTES, "pages_serve");
+    const headersFn = route.responseHeaders as (
+      args: ResponseHeaderArgs,
+    ) => Record<string, string>;
+
+    const single = headersFn({ pathParams: { appId: "plugins~acme~single" } });
+    const multi = headersFn({ pathParams: { appId: "plugins~acme~multi" } });
+
+    expect(single["Content-Security-Policy"]).toContain(
+      "script-src 'self' 'unsafe-inline'",
+    );
+    expect(multi["Content-Security-Policy"]).toContain("script-src 'self';");
+    expect(multi["Content-Security-Policy"]).not.toContain(
+      "script-src 'self' 'unsafe-inline'",
+    );
+  });
+
+  test("apps_asset serves a bundled asset from a plugin app dir", () => {
+    installPluginApp("acme", "dash", {
+      "index.html": "<div>x</div>",
+      "logo.svg": "<svg>logo</svg>",
+    });
+    const handler = findRoute(APP_ROUTES, "apps_asset").handler;
+    const bytes = handler({
+      pathParams: { appId: "plugins~acme~dash", path: "logo.svg" },
+    } as RouteHandlerArgs) as Uint8Array;
+
+    expect(Buffer.from(bytes).toString("utf-8")).toBe("<svg>logo</svg>");
+  });
+
+  test("apps_asset rejects traversal out of a plugin app dir", () => {
+    installPluginApp("acme", "dash", { "index.html": "<div>x</div>" });
+    const handler = findRoute(APP_ROUTES, "apps_asset").handler;
+    expect(() =>
+      handler({
+        pathParams: { appId: "plugins~acme~dash", path: "../../package.json" },
+      } as RouteHandlerArgs),
+    ).toThrow(BadRequestError);
+  });
+
+  test("apps_dist_file serves a compiled asset from a plugin app dist/", () => {
+    installPluginApp("acme", "multi", {
+      "dist/index.html": "<html></html>",
+      "dist/main.js": "console.log(1)",
+    });
+    const handler = findRoute(APP_ROUTES, "apps_dist_file").handler;
+    const bytes = handler({
+      pathParams: { appId: "plugins~acme~multi", filename: "main.js" },
+    } as RouteHandlerArgs) as Uint8Array;
+
+    expect(Buffer.from(bytes).toString("utf-8")).toBe("console.log(1)");
+  });
+});
+
+describe("plugin apps are read-only over the management surface", () => {
+  test("apps_delete rejects a plugin app id", () => {
+    installPluginApp("acme", "dash", { "index.html": "<div>x</div>" });
+    const handler = findRoute(APP_MGMT_ROUTES, "apps_delete").handler;
+    expect(() =>
+      handler({
+        pathParams: { id: "plugins~acme~dash" },
+        headers: {},
+      } as RouteHandlerArgs),
+    ).toThrow(BadRequestError);
+  });
+
+  test("apps_data_mutate rejects a plugin app id", () => {
+    installPluginApp("acme", "dash", { "index.html": "<div>x</div>" });
+    const handler = findRoute(APP_MGMT_ROUTES, "apps_data_mutate").handler;
+    expect(() =>
+      handler({
+        pathParams: { id: "plugins~acme~dash" },
+        body: { method: "create", data: {} },
+      } as RouteHandlerArgs),
+    ).toThrow(BadRequestError);
+  });
+});

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -191,6 +191,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../runtime/capabilities.js",
     "../../../runtime/services/auto-analysis-guard.js",
     "../../../runtime/sync/resource-sync-events.js",
+    "../../../telemetry/watchdog-events-store.js",
     "../../../tools/registry.js",
     "../../../tools/types.js",
     "../../../types.js",

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -13,6 +13,21 @@ import type { SkillSource } from "../config/skills.js";
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 const mockRefreshSkillCapabilityMemories = mock(() => {});
 
+const watchdogEvents: Array<{
+  checkName: string;
+  value?: number | null;
+  detail?: Record<string, unknown> | null;
+}> = [];
+mock.module("../telemetry/watchdog-events-store.js", () => ({
+  recordWatchdogEvent: (record: {
+    checkName: string;
+    value?: number | null;
+    detail?: Record<string, unknown> | null;
+  }) => {
+    watchdogEvents.push(record);
+  },
+}));
+
 mock.module("../daemon/skill-memory-refresh.js", () => ({
   refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
@@ -88,6 +103,7 @@ beforeEach(() => {
   mockRefreshSkillCapabilityMemories.mockClear();
   skillCardJobUpserts = [];
   skillCardUpsertThrows = false;
+  watchdogEvents.length = 0;
 });
 
 afterEach(() => {
@@ -146,6 +162,16 @@ describe("scaffold_managed_skill tool", () => {
     expect(skill).toBeDefined();
     expect(skill!.name).toBe("Test Skill");
     expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+
+    // A genuine create emits the central authoring counter, attributed to
+    // the user for a non-retrospective origin.
+    expect(watchdogEvents).toEqual([
+      {
+        checkName: "skill_authored",
+        value: 1,
+        detail: { authored_by: "user" },
+      },
+    ]);
   });
 
   test("accepts legacy add_to_index input without returning index metadata", async () => {
@@ -202,6 +228,12 @@ describe("scaffold_managed_skill tool", () => {
       makeContext(),
     );
     expect(result3.isError).toBe(false);
+
+    // Only the original create counts — the overwrite refined an existing
+    // skill and must not emit a second authoring event.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_authored"),
+    ).toHaveLength(1);
   });
 
   test("rejects missing required fields", async () => {
@@ -691,6 +723,15 @@ describe("scaffold_managed_skill tool", () => {
 
     expect(result.isError).toBe(false);
     expect(installMetaFor("retro-skill")?.author).toBe("assistant");
+    // The central authoring counter attributes the create to the
+    // retrospective.
+    expect(watchdogEvents).toEqual([
+      {
+        checkName: "skill_authored",
+        value: 1,
+        detail: { authored_by: "retrospective" },
+      },
+    ]);
   });
 
   test('tags author "user" for a normal (non-retrospective) scaffold', async () => {
@@ -851,6 +892,12 @@ describe("scaffold_managed_skill tool", () => {
         ),
       ),
     ).toBe(true);
+
+    // Only the V1 create counts toward authoring — the V2 refinement of an
+    // existing skill emits no second event.
+    expect(
+      watchdogEvents.filter((e) => e.checkName === "skill_authored"),
+    ).toHaveLength(1);
   });
 
   // ── Conversation lineage (retrospective-authored skills) ───────────────────

package/src/__tests__/subagent-notify-parent.test.ts

@@ -79,6 +79,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: () => {},
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import { isToolActiveForContext } from "../daemon/conversation-tool-setup.js";
 import type { SubagentRecord } from "../persistence/subagent-store.js";
 import { notifyParentFromChild } from "../subagent/notify.js";
@@ -171,7 +172,7 @@ describe("notify_parent tool definition", () => {
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(false);
   });
 
@@ -181,7 +182,7 @@ describe("notify_parent tool definition", () => {
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(false);
   });
 
@@ -192,7 +193,7 @@ describe("notify_parent tool definition", () => {
       skillProjectionState: new Map(),
       skillProjectionCache: new Map(),
       toolsDisabledDepth: 0,
-    } as unknown as import("../daemon/conversation-tool-setup.js").SkillProjectionContext;
+    } as unknown as Conversation;
     expect(isToolActiveForContext("notify_parent", ctx)).toBe(true);
   });
 });

package/src/__tests__/subagent-tool-filtering.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   isToolActiveForContext,
-  type SkillProjectionContext,
   SUBAGENT_ONLY_TOOL_NAMES,
 } from "../daemon/conversation-tool-setup.js";
 
@@ -18,48 +18,48 @@ describe("subagent-only tool filtering", () => {
   });
 
   test("hides subagent-only tools from main conversations (isSubagent=false)", () => {
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       isSubagent: false,
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext(TEST_TOOL_NAME, ctx)).toBe(false);
   });
 
   test("hides subagent-only tools when isSubagent is undefined", () => {
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext(TEST_TOOL_NAME, ctx)).toBe(false);
   });
 
   test("shows subagent-only tools to subagent conversations (isSubagent=true)", () => {
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: true,
       isSubagent: true,
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext(TEST_TOOL_NAME, ctx)).toBe(true);
   });
 
   test("does not affect regular tools when isSubagent is false", () => {
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       isSubagent: false,
-    };
+    } as unknown as Conversation;
 
     // A regular tool not in SUBAGENT_ONLY_TOOL_NAMES should still be active
     expect(isToolActiveForContext("bash", ctx)).toBe(true);
@@ -68,14 +68,14 @@ describe("subagent-only tool filtering", () => {
   test("respects subagentAllowedTools — tools outside the allowlist are inactive", () => {
     // Mirrors `createResolveToolsCallback`'s post-filter so callers see the
     // same final tool set the LLM receives.
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       isSubagent: true,
       subagentAllowedTools: new Set(["bash"]),
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext("bash", ctx)).toBe(true);
     expect(isToolActiveForContext("ask_question", ctx)).toBe(false);
@@ -86,28 +86,28 @@ describe("subagent-only tool filtering", () => {
     // `subagentToolGateMode: "execution"` keeps the full tool surface on the
     // wire for provider prompt-cache parity; the executor callback rejects
     // non-allowlisted calls instead.
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       subagentAllowedTools: new Set(["remember"]),
       subagentToolGateMode: "execution",
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext("remember", ctx)).toBe(true);
     expect(isToolActiveForContext("bash", ctx)).toBe(true);
   });
 
   test("explicit wire gate mode filters exactly like the absent default", () => {
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       subagentAllowedTools: new Set(["remember"]),
       subagentToolGateMode: "wire",
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext("remember", ctx)).toBe(true);
     expect(isToolActiveForContext("bash", ctx)).toBe(false);
@@ -116,14 +116,14 @@ describe("subagent-only tool filtering", () => {
   test("execution gate mode still applies non-allowlist filters (toolsDisabledDepth)", () => {
     // The execution gate only bypasses the subagent allowlist's wire filter;
     // every other visibility rule still applies.
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 1,
       hasNoClient: false,
       subagentAllowedTools: new Set(["remember"]),
       subagentToolGateMode: "execution",
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext("remember", ctx)).toBe(false);
     expect(isToolActiveForContext("bash", ctx)).toBe(false);
@@ -132,12 +132,12 @@ describe("subagent-only tool filtering", () => {
   test("returns false for every tool when toolsDisabledDepth > 0", () => {
     // `createResolveToolsCallback` returns an empty tool list when tools are
     // disabled; mirror it here so this helper reports the same final tool set.
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 1,
       hasNoClient: false,
-    };
+    } as unknown as Conversation;
 
     expect(isToolActiveForContext("bash", ctx)).toBe(false);
     expect(isToolActiveForContext("ask_question", ctx)).toBe(false);
@@ -146,13 +146,13 @@ describe("subagent-only tool filtering", () => {
   test("under disk-pressure cleanup mode, only cleanup-safe tools are active", () => {
     // `createResolveToolsCallback` restricts the turn to cleanup-safe tools
     // (`file_remove`, `bash`, etc.); ensure the helper agrees.
-    const ctx: SkillProjectionContext = {
+    const ctx = {
       skillProjectionState: new Map(),
       skillProjectionCache: {},
       toolsDisabledDepth: 0,
       hasNoClient: false,
       diskPressureCleanupModeActive: true,
-    };
+    } as unknown as Conversation;
 
     // `bash` is in DISK_PRESSURE_CLEANUP_TOOL_NAMES; `ask_question` is not.
     expect(isToolActiveForContext("bash", ctx)).toBe(true);

package/src/__tests__/subagent-tool-gate-mode.test.ts

@@ -72,10 +72,10 @@ mock.module("../daemon/conversation-skill-tools.js", () => ({
 // Imports after mocks are in place
 // ---------------------------------------------------------------------------
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createResolveToolsCallback,
   createToolExecutor,
-  type SkillProjectionContext,
   type ToolSetupContext,
 } from "../daemon/conversation-tool-setup.js";
 import {
@@ -95,14 +95,14 @@ function makeToolDef(name: string): ToolDefinition {
 }
 
 function makeProjectionCtx(
-  overrides: Partial<SkillProjectionContext> = {},
-): SkillProjectionContext {
+  overrides: Partial<Conversation> = {},
+): Conversation {
   return {
     skillProjectionState: new Map(),
     skillProjectionCache: {} as SkillProjectionCache,
     toolsDisabledDepth: 0,
     ...overrides,
-  };
+  } as unknown as Conversation;
 }
 
 function makeSetupCtx(
@@ -237,8 +237,8 @@ describe("createResolveToolsCallback — toolContextPin", () => {
 
   /** Execution-gate ctx shaped like a clientless fork-retrospective wake. */
   function clientlessExecutionCtx(
-    overrides: Partial<SkillProjectionContext> = {},
-  ): SkillProjectionContext {
+    overrides: Partial<Conversation> = {},
+  ): Conversation {
     return makeProjectionCtx({
       hasNoClient: true,
       subagentAllowedTools: new Set(["remember"]),