@vellumai/assistant 0.12.2-dev.202609170320.2f82e57 → 0.12.2-dev.202609170629.61d51c8

package/docs/architecture/memory.md

@@ -270,6 +270,12 @@ under `memory.v3.*`. The `memory.v2.enabled` flag gates only the v2 injection
 engine's turn-time selection; the substrate runs whenever
 `usesConceptPageMemory()` holds.
 
+`memory.v3.poolLog.captureInput` (off by default) makes the v3 selector
+persist its exact per-turn input beside the always-written pool audit
+(`memory_v3_pool_inputs`, `memory_v3_pool_texts`), for offline selector
+evaluation and training data; the memory plugin `AGENTS.md` documents the
+tables.
+
 `src/plugins/defaults/memory/AGENTS.md` carries the details that matter when
 you touch this: the three substrate keys whose names differ from their v2 twin,
 the three disjoint places the dense/sparse sum-to-1 invariant is checked, and

package/docs/desktop-browser-cli.md

@@ -33,3 +33,5 @@ The client records key and mouse presses before dispatch. On release it opens a
 Validation: focused client tests exercise shared snapshot/click behavior, namespace isolation, stale references, target changes, cancellation and uncertain-input cleanup. Lease tests cover browser ownership, cancellation and cleanup independently of native input. The Linux smoke script exercises real Chrome, the CLI and visible pointer feedback.
 
 The desktop header icon pulses in the assistant's avatar accent color while a browser automation lease is active, including between browser commands. It shares the progress indicator's accent and neutral fallback. Reduced-motion clients show a solid accent. Setup status exposes the optional `automationActive` field; `desktop_activity_changed` events refresh it on acquisition and cancellation or release. Installation progress retains its `assistant:self:desktop` sync invalidations. The indicator reads status without starting installation, and reconnects refetch the current lease state.
+
+Desktop streaming checks the current in-memory gateway feature flags during connection startup. Once connected, frame and drain callbacks do not check feature flags or load workspace configuration. Turning the flag off prevents new connections; an existing stream continues until it closes or the desktop stops.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609170320.2f82e57",
+  "version": "0.12.2-dev.202609170629.61d51c8",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-wake-delegation-prompt.test.ts

@@ -74,6 +74,7 @@ function makeTarget(onRun: (conv: Conversation) => void): {
     subagentAllowedTools: undefined as ReadonlySet<string> | undefined,
     subagentToolGateMode: undefined as string | undefined,
     toolContextPin: undefined,
+    delegateIndependentTasksReplay: undefined as boolean | undefined,
     preactivatedSkillIds: undefined as readonly string[] | undefined,
     setSubagentAllowedTools: (tools?: ReadonlySet<string>) => {
       target.subagentAllowedTools = tools;
@@ -82,9 +83,12 @@ function makeTarget(onRun: (conv: Conversation) => void): {
       target.preactivatedSkillIds = ids;
     },
     // The section's gate, rendered as a marker so the assertions turn on the
-    // real predicate rather than on a stubbed answer.
+    // real predicate rather than on a stubbed answer. Mirrors
+    // `Conversation.buildCurrentSystemPrompt`: a replayed rendered state wins
+    // over the derivation.
     buildCurrentSystemPrompt: () =>
-      canSpawnSubagentsForTurn(target as unknown as Conversation)
+      (target.delegateIndependentTasksReplay ??
+      canSpawnSubagentsForTurn(target as unknown as Conversation))
         ? `base ${DELEGATION_SECTION}`
         : "base",
     // Mirrors `Conversation.syncLoopSystemPrompt`.
@@ -156,6 +160,64 @@ describe("the delegation section on a direct wake", () => {
     expect(promptDuringRun).toContain(DELEGATION_SECTION);
   });
 
+  test("a replaying wake renders the section its source rendered", async () => {
+    let promptDuringRun = "";
+    const { target, loopPrompt } = makeTarget(() => {
+      promptDuringRun = loopPrompt();
+    });
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "test hint",
+        source: "scheduler",
+        // The memory retrospective's shape: an allowlist with no spawn path,
+        // gated at execution...
+        allowedTools: ["remember", "skill_load"],
+        toolGateMode: "execution",
+        // ...replaying an interactive source whose live turn rendered the
+        // section.
+        wireToolDefinitions: [
+          { name: "remember", description: "Save", input_schema: {} },
+        ],
+        delegateIndependentTasks: true,
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(promptDuringRun).toContain(DELEGATION_SECTION);
+    // The replay comes off with the rest of the wake's scope.
+    expect(target.delegateIndependentTasksReplay).toBeUndefined();
+  });
+
+  test("a replaying wake renders the section off when its source did", async () => {
+    // A channel-delivered source records the section off. Replaying that
+    // keeps the fork's prompt in parity even though this wake's own scope
+    // could spawn.
+    let promptDuringRun = "";
+    const { target, loopPrompt } = makeTarget(() => {
+      promptDuringRun = loopPrompt();
+    });
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "test hint",
+        source: "scheduler",
+        allowedTools: ["skill_load", "skill_execute", "subagent_spawn"],
+        toolGateMode: "execution",
+        wireToolDefinitions: [
+          { name: "skill_load", description: "Load", input_schema: {} },
+        ],
+        delegateIndependentTasks: false,
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(promptDuringRun).not.toContain(DELEGATION_SECTION);
+    expect(promptDuringRun.length).toBeGreaterThan(0);
+  });
+
   test("the restored prompt is built without the wake's persona", async () => {
     // `wakePersonaOverride` feeds `buildCurrentSystemPrompt`, so a rebuild
     // that ran before the clear would leave the loop holding the wake's

package/src/__tests__/conversation-rendered-delegation-state.test.ts

@@ -0,0 +1,276 @@
+/**
+ * `Conversation.buildCurrentSystemPrompt` captures the delegation-section
+ * state the prompt it builds renders (`renderedDelegateIndependentTasks`),
+ * which the wire-surface recorder persists for a retrospective fork to
+ * replay. The loop sends the prompt built before the run and never rebuilds
+ * it mid-run, so the captured state has to be the one that build used: not a
+ * re-derivation at send time, and not the state of a build that failed while
+ * the loop kept its previous prompt.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede Conversation import
+// ---------------------------------------------------------------------------
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => true,
+}));
+
+// The builder under the conversation's control: records the options each
+// build receives and can be made to throw, which is what a wake's prompt
+// sync swallows before running on the previous prompt.
+let builtWith: Array<Record<string, unknown> | undefined> = [];
+let throwOnBuild = false;
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: (options?: Record<string, unknown>) => {
+    if (throwOnBuild) {
+      throw new Error("prompt build failed");
+    }
+    builtWith.push(options);
+    return "system prompt";
+  },
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: `msg-${Date.now()}` }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../persistence/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: `att-${Date.now()}` }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
+  ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
+    constructor() {}
+    updateConfig() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+    resetOverflowRecovery() {}
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../persistence/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
+    setSystemPrompt() {}
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Import Conversation AFTER mocks
+// ---------------------------------------------------------------------------
+
+import { Conversation } from "../daemon/conversation.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProvider() {
+  return {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+let conversationSeq = 0;
+
+/**
+ * A conversation whose prompt is built, or, given a prompt other than the
+ * builder's, one running on a verbatim system-prompt override.
+ */
+function makeConversation(systemPrompt = "system prompt"): Conversation {
+  conversationSeq += 1;
+  return new Conversation(
+    `conv-rendered-delegation-${conversationSeq}`,
+    makeProvider(),
+    systemPrompt,
+    (_msg: AssistantEvent) => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+}
+
+function lastBuildDelegation(): unknown {
+  return builtWith.at(-1)?.delegateIndependentTasks;
+}
+
+beforeEach(() => {
+  builtWith = [];
+  throwOnBuild = false;
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Conversation.buildCurrentSystemPrompt delegation-state capture", () => {
+  test("captures the state the build rendered and hands the builder the same value", () => {
+    const conversation = makeConversation();
+    expect(conversation.renderedDelegateIndependentTasks).toBeUndefined();
+
+    conversation.buildCurrentSystemPrompt();
+
+    // An unrestricted turn can spawn, so the section renders on.
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+    expect(lastBuildDelegation()).toBe(true);
+  });
+
+  test("a change to the gate's inputs after the build does not touch the captured state until the next build", () => {
+    const conversation = makeConversation();
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    // The loop is still sending the prompt built above, so the recorder must
+    // see that prompt's state, whatever the gate would derive now.
+    conversation.setSubagentAllowedTools(new Set(["remember"]));
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(false);
+    expect(lastBuildDelegation()).toBe(false);
+  });
+
+  test("a failed build leaves the previously captured state in place", () => {
+    const conversation = makeConversation();
+    conversation.buildCurrentSystemPrompt();
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+
+    // A wake's prompt sync swallows this and runs on the previous prompt,
+    // whose section is still on, even though a rebuild would now render it
+    // off.
+    conversation.setSubagentAllowedTools(new Set(["remember"]));
+    throwOnBuild = true;
+    expect(() => conversation.buildCurrentSystemPrompt()).toThrow(
+      "prompt build failed",
+    );
+
+    expect(conversation.renderedDelegateIndependentTasks).toBe(true);
+  });
+
+  test("a verbatim system-prompt override captures unknown", () => {
+    const conversation = makeConversation("override prompt");
+    builtWith = [];
+
+    expect(conversation.buildCurrentSystemPrompt()).toBe("override prompt");
+
+    expect(conversation.renderedDelegateIndependentTasks).toBeNull();
+    // The override is returned as is; nothing is built.
+    expect(builtWith).toEqual([]);
+  });
+
+  test("a replaying wake's recorded state wins over the derivation", () => {
+    const conversation = makeConversation();
+    // Replaying a channel-sourced conversation that recorded the section off,
+    // on a wake whose own scope could spawn.
+    conversation.delegateIndependentTasksReplay = false;
+
+    conversation.buildCurrentSystemPrompt();
+
+    expect(conversation.renderedDelegateIndependentTasks).toBe(false);
+    expect(lastBuildDelegation()).toBe(false);
+  });
+});

package/src/__tests__/db-conversation-tool-surface.test.ts

@@ -1,8 +1,9 @@
 /**
- * Tests for the per-conversation wire tool-surface record
- * (`persistence/conversation-tool-surface.ts`): the resolver records the
- * tools array a live turn sends, fork wakes read it back verbatim, and an
- * unchanged surface is never rewritten.
+ * Tests for the per-conversation wire surface record
+ * (`persistence/conversation-tool-surface.ts`): the send-boundary recorder
+ * stores the tools array a live turn sends with the delegation-section state
+ * its prompt rendered, fork wakes read both back verbatim, and an unchanged
+ * surface is never rewritten.
  */
 
 import { Database } from "bun:sqlite";
@@ -11,12 +12,18 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import {
+  getConversationToolSurface as getConversationToolSurfaceViaPluginApi,
+  getRecordedConversationToolSurface,
+} from "../persistence/conversation-plugin-facade.js";
+import {
+  type ConversationToolSurface,
   getConversationToolSurface,
   hashConversationToolSurface,
   recordConversationToolSurface,
 } from "../persistence/conversation-tool-surface.js";
 import { clearStoredDb, setStoredDb } from "../persistence/db-singleton.js";
 import { migrateCreateConversationToolSurfaces } from "../persistence/migrations/378-create-conversation-tool-surfaces.js";
+import { migrateConversationToolSurfacesDelegateIndependentTasks } from "../persistence/migrations/380-conversation-tool-surfaces-delegate-independent-tasks.js";
 import * as schema from "../persistence/schema/index.js";
 import type { ToolDefinition } from "../providers/types.js";
 
@@ -29,6 +36,7 @@ beforeEach(() => {
   sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
   const db = drizzle(sqlite, { schema });
   migrateCreateConversationToolSurfaces(db);
+  migrateConversationToolSurfacesDelegateIndependentTasks(db);
   setStoredDb("main", db, () => sqlite.close());
 });
 
@@ -45,6 +53,11 @@ const TOOLS: ToolDefinition[] = [
   { name: "bell_jingle", description: "Ring", input_schema: {} },
 ];
 
+const SURFACE: ConversationToolSurface = {
+  tools: TOOLS,
+  delegateIndependentTasks: true,
+};
+
 function storedRow(): { tools_hash: string; updated_at: number } | null {
   return sqlite
     .query(
@@ -54,12 +67,12 @@ function storedRow(): { tools_hash: string; updated_at: number } | null {
 }
 
 describe("recordConversationToolSurface", () => {
-  test("stores the array and returns its content hash", () => {
-    const hash = recordConversationToolSurface("conv-1", TOOLS);
+  test("stores the surface and returns its content hash", () => {
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
 
-    expect(hash).toBe(hashConversationToolSurface(TOOLS));
+    expect(hash).toBe(hashConversationToolSurface(SURFACE));
     expect(storedRow()?.tools_hash).toBe(hash);
-    expect(getConversationToolSurface("conv-1")).toEqual(TOOLS);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
   });
 
   test("replays the exact array, including key order and extra fields", () => {
@@ -70,15 +83,31 @@ describe("recordConversationToolSurface", () => {
     } as unknown as ToolDefinition;
     const tools = [...TOOLS, serverTool];
 
-    recordConversationToolSurface("conv-1", tools);
+    recordConversationToolSurface("conv-1", {
+      tools,
+      delegateIndependentTasks: false,
+    });
 
-    expect(JSON.stringify(getConversationToolSurface("conv-1"))).toBe(
+    expect(JSON.stringify(getConversationToolSurface("conv-1")?.tools)).toBe(
       JSON.stringify(tools),
     );
   });
 
+  test("the delegation-section state round-trips, unknown included", () => {
+    for (const delegateIndependentTasks of [true, false, null]) {
+      recordConversationToolSurface("conv-1", {
+        tools: TOOLS,
+        delegateIndependentTasks,
+      });
+
+      expect(
+        getConversationToolSurface("conv-1")?.delegateIndependentTasks,
+      ).toBe(delegateIndependentTasks);
+    }
+  });
+
   test("an unchanged surface with a known hash skips the write", () => {
-    const hash = recordConversationToolSurface("conv-1", TOOLS);
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
     const before = storedRow()!.updated_at;
     sqlite
       .query(
@@ -86,13 +115,13 @@ describe("recordConversationToolSurface", () => {
       )
       .run(before - 1000, "conv-1");
 
-    recordConversationToolSurface("conv-1", TOOLS, hash);
+    recordConversationToolSurface("conv-1", SURFACE, hash);
 
     expect(storedRow()!.updated_at).toBe(before - 1000);
   });
 
   test("an unchanged surface with no known hash compares against the stored row before writing", () => {
-    recordConversationToolSurface("conv-1", TOOLS);
+    recordConversationToolSurface("conv-1", SURFACE);
     const marker = 42;
     sqlite
       .query(
@@ -102,14 +131,27 @@ describe("recordConversationToolSurface", () => {
 
     // A freshly loaded conversation knows no hash yet; the stored row matches,
     // so nothing is rewritten.
-    recordConversationToolSurface("conv-1", TOOLS, undefined);
+    recordConversationToolSurface("conv-1", SURFACE, undefined);
 
     expect(storedRow()!.updated_at).toBe(marker);
   });
 
-  test("a changed surface overwrites the stored one", () => {
-    const first = recordConversationToolSurface("conv-1", TOOLS);
-    const changed = TOOLS.slice(0, 1);
+  test("a changed array overwrites the stored surface", () => {
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, tools: TOOLS.slice(0, 1) };
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+
+  test("a change to the delegation-section state alone overwrites it too", () => {
+    // The state is part of the hash: a turn whose scope flips the section
+    // (a background run's allowlist after an interactive turn) records it.
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, delegateIndependentTasks: false };
 
     const second = recordConversationToolSurface("conv-1", changed, first);
 
@@ -117,6 +159,26 @@ describe("recordConversationToolSurface", () => {
     expect(storedRow()?.tools_hash).toBe(second);
     expect(getConversationToolSurface("conv-1")).toEqual(changed);
   });
+
+  test("a row recorded before the state existed reads unknown and is replaced on the next record", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", JSON.stringify(TOOLS), "pre-upgrade-hash", 1);
+
+    expect(getConversationToolSurface("conv-1")).toEqual({
+      tools: TOOLS,
+      delegateIndependentTasks: null,
+    });
+
+    // The stored hash predates the state, so the next live turn's record
+    // rewrites the row with it.
+    const hash = recordConversationToolSurface("conv-1", SURFACE, undefined);
+
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
+  });
 });
 
 describe("getConversationToolSurface", () => {
@@ -135,10 +197,25 @@ describe("getConversationToolSurface", () => {
   });
 
   test("the row cascades with its conversation", () => {
-    recordConversationToolSurface("conv-1", TOOLS);
+    recordConversationToolSurface("conv-1", SURFACE);
 
     sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
 
     expect(getConversationToolSurface("conv-1")).toBeNull();
   });
 });
+
+describe("plugin facade", () => {
+  test("the array accessor is a projection of the recorded surface", async () => {
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toBeNull();
+    expect(await getRecordedConversationToolSurface("conv-1")).toBeNull();
+
+    recordConversationToolSurface("conv-1", SURFACE);
+
+    expect(await getRecordedConversationToolSurface("conv-1")).toEqual(SURFACE);
+    // The array shape the public `@vellumai/plugin-api` accessor returns.
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toEqual(
+      TOOLS,
+    );
+  });
+});