@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/__tests__/db-acp-history.test.ts

@@ -5,6 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrate230AcpSessionHistory } from "../memory/migrations/230-acp-session-history.js";
+import { migrateAcpSessionHistoryCwd } from "../memory/migrations/272-acp-session-history-cwd.js";
 import * as schema from "../memory/schema.js";
 
 function createTestDb() {
@@ -282,3 +283,103 @@ describe("acp_session_history migration", () => {
     expect(row?.id).toBe("history-rerun");
   });
 });
+
+describe("acp_session_history cwd migration (272)", () => {
+  function readColumns(raw: Database): Map<string, ColumnRow> {
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    return new Map(columns.map((c) => [c.name, c]));
+  }
+
+  test("adds a nullable cwd TEXT column to an upgraded table", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    expect(readColumns(raw).has("cwd")).toBe(false);
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const cwd = readColumns(raw).get("cwd");
+    expect(cwd).toBeDefined();
+    expect(cwd?.type).toBe("TEXT");
+    expect(cwd?.notnull).toBe(0);
+  });
+
+  test("re-running is a no-op, including with a cleared checkpoint", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    migrateAcpSessionHistoryCwd(db);
+
+    // Second run short-circuits on the completed checkpoint.
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    // Even with the checkpoint cleared (simulating crash recovery), the
+    // column-existence guard makes the ALTER a no-op.
+    raw
+      .query(`DELETE FROM memory_checkpoints WHERE key = ?`)
+      .run("migration_acp_session_history_cwd_v1");
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    expect(columns.filter((c) => c.name === "cwd")).toHaveLength(1);
+  });
+
+  test("legacy rows read back with cwd null; new rows round-trip cwd", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+
+    // Legacy row inserted before the cwd column existed.
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run("legacy-1", "agent-old", "acp-old", "conv-old", 100, "completed");
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const legacy = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'legacy-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(legacy?.cwd).toBeNull();
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status, cwd
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "new-1",
+        "agent-new",
+        "acp-new",
+        "conv-new",
+        200,
+        "completed",
+        "/Users/me/project",
+      );
+
+    const fresh = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'new-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(fresh?.cwd).toBe("/Users/me/project");
+  });
+});

package/src/__tests__/dynamic-page-surface.test.ts

@@ -94,6 +94,37 @@ describe("ui_show dynamic_page app substitute guard", () => {
     expect(proxied).toBe(false);
   });
 
+  test("rejects dynamic_page with a clean title but substantial interactive html", async () => {
+    let proxied = false;
+
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "dynamic_page",
+        title: "Labor Market Stats",
+        data: {
+          html:
+            "<div id='root'></div><script>" +
+            "const data=[/*...*/];".padEnd(2100, "/") +
+            "new Chart(document.getElementById('root'), {});</script>",
+          preview: { title: "Labor Market Stats" },
+        },
+      },
+      {
+        conversationId: "conversation-123",
+        workingDir: "/tmp",
+        trustClass: "guardian",
+        proxyToolResolver: async () => {
+          proxied = true;
+          return { content: "proxied", isError: false };
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(proxied).toBe(false);
+  });
+
   test("allows transient non-app dynamic_page surfaces", async () => {
     let proxied = false;
 

package/src/__tests__/empty-response-hook.test.ts

@@ -31,7 +31,7 @@ import {
   REFUSAL_NUDGE_TEXT,
 } from "../plugins/defaults/empty-response/hooks/stop.js";
 import stop from "../plugins/defaults/empty-response/hooks/stop.js";
-import { defaultEmptyResponsePlugin } from "../plugins/defaults/empty-response/register.js";
+import { defaultEmptyResponsePlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,

package/src/__tests__/file-write-tool.test.ts

@@ -260,3 +260,66 @@ describe("file_write tool PKB re-index hook", () => {
     expect(existsSync(join(workingDir, "pkb", "oops.md"))).toBe(true);
   });
 });
+
+describe("file_write artifact-HTML guard", () => {
+  test("rejects a self-contained interactive HTML visualization", async () => {
+    const dir = makeTempDir();
+    const html =
+      "<!doctype html><html><head><title>Food Market</title></head>" +
+      "<body><canvas id='c'></canvas><script>" +
+      ("const data=[{x:1,y:2}];").padEnd(4000, "/") +
+      "new Chart(document.getElementById('c'), {data});</script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "food-market-stats.html", content: html },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(existsSync(join(dir, "food-market-stats.html"))).toBe(false);
+  });
+
+  test("allows app-builder's thin shell index.html (external module script)", async () => {
+    const dir = makeTempDir();
+    const shell =
+      "<!doctype html><html><head>" +
+      "<link rel='stylesheet' href='/src/styles.css'>".padEnd(3200, " ") +
+      "</head><body><div id='app'></div>" +
+      "<script type='module' src='/src/main.tsx'></script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "src/index.html", content: shell },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "src", "index.html"))).toBe(true);
+  });
+
+  test("allows a small/static HTML snippet", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      { path: "note.html", content: "<html><body><h1>Hi</h1></body></html>" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "note.html"))).toBe(true);
+  });
+
+  test("allows a non-HTML file even with inline script-like content", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      {
+        path: "notes.md",
+        content:
+          "<script>" + "x".padEnd(2000, "x") + "</script>" + "\n# notes\n",
+      },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "notes.md"))).toBe(true);
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -27,6 +27,7 @@ const ALLOWLIST = new Set([
   "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
+  "apps/macos/src/main/bundle-flow.ts", // Electron main calls the local gateway (gatewayPort) with a Guardian token to scan bundles
   ".claude/skills/update/SKILL.md", // daemon health check script
 
   // --- Test fixtures that poll the daemon directly (gateway may require auth) ---
@@ -84,12 +85,26 @@ function isGatewayInternal(filePath: string): boolean {
   return filePath.startsWith("gateway/");
 }
 
+/** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
+const INTERPOLATED_PORT_ALLOWLIST = new Set([
+  "apps/macos/src/main/bundle-flow.ts",
+  // Electron main bridges the host proxy to a local assistant's gateway
+  // (gatewayPort) over loopback with a Guardian-minted gateway token — same
+  // class as bundle-flow.ts. Added with #34049 (host proxy for cloud/managed
+  // assistants); the allowlist entry was missed there.
+  "apps/macos/src/main/host-proxy-router.ts",
+]);
+
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */
-function filterViolations(files: string[]): string[] {
+function filterViolations(
+  files: string[],
+  extraAllowlist?: Set<string>,
+): string[] {
   return files.filter((f) => {
     if (isTestFile(f)) return false;
     if (isGatewayInternal(f)) return false;
     if (ALLOWLIST.has(f)) return false;
+    if (extraAllowlist?.has(f)) return false;
     return true;
   });
 }
@@ -181,7 +196,7 @@ describe("gateway-only API consumption guard", () => {
     }
 
     const files = grepOutput.split("\n").filter((f) => f.length > 0);
-    const violations = filterViolations(files);
+    const violations = filterViolations(files, INTERPOLATED_PORT_ALLOWLIST);
 
     if (violations.length > 0) {
       const message = [

package/src/__tests__/guardian-grant-minting.test.ts

@@ -20,7 +20,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -21,7 +21,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
@@ -51,9 +51,7 @@ import {
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import {
-  listGuardianDecisionPrompts,
-} from "../runtime/routes/guardian-action-routes.js";
+import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
 
@@ -1334,6 +1332,97 @@ describe("routing invariant: callback buttons route through canonical primitive"
   });
 });
 
+// ===========================================================================
+// SECTION 8b: route-owned (directResolve) confirmations resolve via the
+// channel/guardian-action path too.
+//
+// The ACP spawn/steer approval gate (acp-routes.ts, ATL-822) registers
+// pending confirmations with a `directResolve` callback rather than a
+// Conversation.prompter. The tool_approval resolver must fire that callback
+// directly; otherwise a guardian approval submitted over a channel never
+// reaches the waiting route and the spawn/resume hangs until timeout.
+// ===========================================================================
+
+describe("routing invariant: directResolve interactions resolve via guardian decisions", () => {
+  beforeEach(() => resetTables());
+
+  function registerDirectResolveInteraction(
+    requestId: string,
+    conversationId: string,
+  ): string[] {
+    const decisions: string[] = [];
+    pendingInteractions.register(requestId, {
+      conversationId,
+      kind: "confirmation",
+      confirmationDetails: {
+        toolName: "acp_spawn",
+        input: { agent: "claude", task: "t", cwd: "/work" },
+        riskLevel: "high",
+        executionTarget: "host",
+        allowlistOptions: [],
+        scopeOptions: [],
+        persistentDecisionsAllowed: false,
+      },
+      directResolve: (d) => decisions.push(d),
+    });
+    return decisions;
+  }
+
+  test("channel approval fires directResolve('allow') with no live Conversation", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    // Deliberately no _conversationMocks entry: the prompter path would have
+    // failed with conversation_not_found, proving directResolve is what runs.
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:approve_once`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["allow"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("approved");
+  });
+
+  test("channel rejection fires directResolve('deny')", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:reject`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["deny"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("denied");
+  });
+});
+
 // ===========================================================================
 // SECTION 9: Destination hints do not bypass principal binding for tool_approval
 // ===========================================================================

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -143,7 +143,7 @@ mock.module("../util/logger.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { handleConfirmationResponse } from "../daemon/handlers/conversations.js";
 
 describe("handleConfirmationResponse canonical status sync", () => {

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -56,6 +56,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   countCompletedHeartbeatRuns: mock(() => 10),
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/heartbeat-service.test.ts

@@ -32,6 +32,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   listHeartbeatRuns: mockListHeartbeatRuns,
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/history-repair-hook.test.ts

@@ -21,8 +21,8 @@ import type {
   UserPromptSubmitContext,
 } from "../plugin-api/types.js";
 import userPromptSubmit from "../plugins/defaults/history-repair/hooks/user-prompt-submit.js";
-import { defaultHistoryRepairPlugin } from "../plugins/defaults/history-repair/register.js";
 import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import { defaultHistoryRepairPlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,
@@ -40,6 +40,10 @@ const noopLogger: PluginLogger = {
 function makeCtx(messages: Message[]): UserPromptSubmitContext {
   return {
     conversationId: "conv-test",
+    userMessageId: "msg-test",
+    requestId: "req-test",
+    modelProfileKey: null,
+    isNonInteractive: false,
     prompt: "",
     originalMessages: messages,
     latestMessages: messages,

package/src/__tests__/host-app-control-proxy.test.ts

@@ -372,6 +372,49 @@ describe("HostAppControlProxy", () => {
       proxy.dispose();
     });
 
+    test("non-start tool with mismatched target client is rejected", async () => {
+      mockActorMap.set("client-A", "user-1");
+      mockActorMap.set("client-B", "user-1");
+      const proxy = new HostAppControlProxy("conv-1");
+      const startCtrl = new AbortController();
+
+      const pStart = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        startCtrl.signal,
+        "user-1",
+        "client-A",
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await pStart;
+      sentMessages.length = 0;
+
+      const result = await proxy.request(
+        "app_control_type",
+        {
+          tool: "type",
+          app: "com.example.editor",
+          text: "hello",
+        },
+        "conv-1",
+        new AbortController().signal,
+        "user-1",
+        "client-B",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("client-A");
+      expect(result.content).toContain("client-B");
+      expect(result.content).toContain("app_control_start");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
     test("non-start tool with case-different but otherwise matching app is allowed", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const startCtrl = new AbortController();
@@ -1297,6 +1340,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(
@@ -1332,6 +1376,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(

package/src/__tests__/host-app-control-routes.test.ts

@@ -47,7 +47,7 @@ interface FakeConversation {
 
 const conversations = new Map<string, FakeConversation>();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversations.get(id),
 }));
 

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -8,9 +8,9 @@
  *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
  *
  * Resolution goes through conversation.hostCuProxy?.resolve(...). The
- * conversation store is mocked to return a controlled conversation object.
+ * conversation registry is mocked to return a controlled conversation object.
  *
- * Note: host-cu-routes.ts has a deep import chain (conversation-store →
+ * Note: host-cu-routes.ts has a deep import chain (conversation-registry →
  * conversation.ts → ces-client → service-contracts) that requires mocking
  * before the module loads. We use dynamic imports to ensure all mocks are
  * registered before the route module is evaluated.
@@ -75,7 +75,7 @@ const conversationStore = new Map<
   { hostCuProxy?: { processObservation: (...args: unknown[]) => void } }
 >();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) =>
     conversationStore.get(conversationId),
 }));

package/src/__tests__/inference-profile-reaper.test.ts

@@ -7,6 +7,11 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import {
   createConversation,
   getConversation,
@@ -113,6 +118,63 @@ describe("inference-profile-session-reaper", () => {
     subscription.dispose();
   });
 
+  test("syncs the live in-memory Conversation instance for each cleared session", async () => {
+    // GIVEN an expired session-backed override persisted on a conversation row
+    const conv = createConversation("reaper-live-sync");
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-live",
+      Date.now() - 1,
+    );
+
+    // AND a live Conversation instance registered for that conversation,
+    // seeded with the same override state the reaper is about to expire
+    const appliedStates: Array<{
+      profile: string | null;
+      sessionId: string | null;
+      expiresAt: number | null;
+    }> = [];
+    const liveConversation = {
+      conversationId: conv.id,
+      inferenceProfile: "balanced",
+      inferenceProfileSessionId: "session-live",
+      inferenceProfileExpiresAt: Date.now() - 1,
+      applyInferenceProfileState(
+        this: {
+          inferenceProfile: string | null;
+          inferenceProfileSessionId: string | null;
+          inferenceProfileExpiresAt: number | null;
+        },
+        state: {
+          profile: string | null;
+          sessionId: string | null;
+          expiresAt: number | null;
+        },
+      ) {
+        appliedStates.push(state);
+        this.inferenceProfile = state.profile;
+        this.inferenceProfileSessionId = state.sessionId;
+        this.inferenceProfileExpiresAt = state.expiresAt;
+      },
+    } as unknown as Conversation;
+    setConversation(conv.id, liveConversation);
+
+    // WHEN the reaper sweeps the expired session
+    tickInferenceProfileReaper();
+
+    // THEN the live instance is cleared in lock-step with the DB row, so the
+    // per-turn override derivation reads the cleared state without re-fetching
+    expect(appliedStates).toEqual([
+      { profile: null, sessionId: null, expiresAt: null },
+    ]);
+    expect(liveConversation.inferenceProfile).toBeNull();
+    expect(liveConversation.inferenceProfileSessionId).toBeNull();
+    expect(liveConversation.inferenceProfileExpiresAt).toBeNull();
+
+    deleteConversation(conv.id);
+  });
+
   test("CAS protection: row with NULL expiresAt (sticky override) is not touched", async () => {
     const conv = createConversation("reaper-cas-conv");