@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,16 +1,19 @@
 import { describe, expect, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type {
   ChannelCapabilities,
   UnifiedTurnContextOptions,
 } from "../daemon/conversation-runtime-assembly.js";
 import {
   applyRuntimeInjections,
+  buildSubagentStatusBlock,
   buildUnifiedTurnContextBlock,
   findLastInjectedNowContent,
   injectChannelCapabilityContext,
   injectChannelCommandContext,
   injectNowScratchpad,
+  injectSubagentStatus,
   isGroupChatType,
   resolveChannelCapabilities,
   stripChannelCapabilityContext,
@@ -18,6 +21,7 @@ import {
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
 import type { Message } from "../providers/types.js";
+import type { SubagentState } from "../subagent/types.js";
 
 // ---------------------------------------------------------------------------
 // resolveChannelCapabilities
@@ -601,8 +605,10 @@ describe("applyRuntimeInjections — injection mode", () => {
       supportsVoiceInput: false,
     } as ChannelCapabilities,
     unifiedTurnContext:
-      "<turn_context>\ntimestamp: 2026-03-04 (Tue) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
+      "<turn_context>\ncurrent_time: 2026-03-04 (Tuesday) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
     nowScratchpad: "Current focus: shipping PR 3",
+    pkbContext: "essentials content here",
+    pkbActive: true,
     isNonInteractive: true,
   };
 
@@ -620,6 +626,8 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<non_interactive_context>");
     expect(allText).toContain("<NOW.md");
+    expect(allText).toContain("<system_reminder>");
+    expect(allText).toContain("<pkb>");
   });
 
   test("explicit mode: 'full' behaves the same as default", () => {
@@ -653,6 +661,8 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).not.toContain("<channel_command_context>");
     expect(allText).not.toContain("<active_workspace>");
     expect(allText).not.toContain("<NOW.md");
+    expect(allText).not.toContain("<system_reminder>");
+    expect(allText).not.toContain("<pkb>");
   });
 
   test("minimal mode preserves safety-critical blocks", () => {
@@ -889,7 +899,7 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
         content: [
           {
             type: "text",
-            text: "<turn_context>\ntimestamp: 2026-04-02 (Thu) 01:52:33 -05:00 (America/Chicago)\ninterface: macos\n</turn_context>",
+            text: "<turn_context>\ncurrent_time: 2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)\ninterface: macos\n</turn_context>",
           },
           { type: "text", text: "Hello" },
         ],
@@ -1078,7 +1088,7 @@ describe("buildUnifiedTurnContextBlock", () => {
     const text = buildUnifiedTurnContextBlock(options);
     const lines = text.split("\n");
     expect(lines[0]).toBe("<turn_context>");
-    expect(lines[1]).toBe("timestamp: 2026-04-02T12:00:00Z");
+    expect(lines[1]).toBe("current_time: 2026-04-02T12:00:00Z");
     expect(lines[2]).toBe("interface: macos");
     expect(lines[3]).toBe("</turn_context>");
     expect(lines).toHaveLength(4);
@@ -1089,46 +1099,89 @@ describe("buildUnifiedTurnContextBlock", () => {
   });
 
   test("non-guardian trusted_contact: all actor fields + behavioral guidance", () => {
-    const options: UnifiedTurnContextOptions = {
-      timestamp: "2026-04-02T12:00:00Z",
-      interfaceName: "telegram",
-      channelName: "telegram",
-      actorContext: {
-        sourceChannel: "telegram",
-        canonicalActorIdentity: "trusted-user-1",
-        actorIdentifier: "@jeff_handle",
-        actorDisplayName: "Jeff",
-        actorSenderDisplayName: "Jeffrey",
-        actorMemberDisplayName: "Jeff",
-        trustClass: "trusted_contact",
-        guardianIdentity: "guardian-user-1",
-        memberStatus: "active",
-        memberPolicy: "allow",
-      },
-    };
-
-    const text = buildUnifiedTurnContextBlock(options);
-    expect(text).toContain("<turn_context>");
-    expect(text).toContain("timestamp: 2026-04-02T12:00:00Z");
-    expect(text).toContain("interface: telegram");
-    expect(text).toContain("source_channel: telegram");
-    expect(text).toContain("canonical_actor_identity: trusted-user-1");
-    expect(text).toContain("actor_identifier: @jeff_handle");
-    expect(text).toContain("actor_display_name: Jeff");
-    expect(text).toContain("actor_sender_display_name: Jeffrey");
-    expect(text).toContain("actor_member_display_name: Jeff");
-    expect(text).toContain("trust_class: trusted_contact");
-    expect(text).toContain("guardian_identity: guardian-user-1");
-    expect(text).toContain("member_status: active");
-    expect(text).toContain("member_policy: allow");
-    // Behavioral guidance
-    expect(text).toContain("trusted contact (non-guardian)");
-    expect(text).toContain("attempt to fulfill it normally");
-    expect(text).toContain(
-      "tool execution layer will automatically deny it and escalate",
-    );
-    expect(text).toContain('their name is "Jeff"');
-    expect(text).toContain("</turn_context>");
+    _setOverridesForTesting({ "permission-controls-v2": false });
+    try {
+      const options: UnifiedTurnContextOptions = {
+        timestamp: "2026-04-02T12:00:00Z",
+        interfaceName: "telegram",
+        channelName: "telegram",
+        actorContext: {
+          sourceChannel: "telegram",
+          canonicalActorIdentity: "trusted-user-1",
+          actorIdentifier: "@jeff_handle",
+          actorDisplayName: "Jeff",
+          actorSenderDisplayName: "Jeffrey",
+          actorMemberDisplayName: "Jeff",
+          trustClass: "trusted_contact",
+          guardianIdentity: "guardian-user-1",
+          memberStatus: "active",
+          memberPolicy: "allow",
+        },
+      };
+
+      const text = buildUnifiedTurnContextBlock(options);
+      expect(text).toContain("<turn_context>");
+      expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
+      expect(text).toContain("interface: telegram");
+      expect(text).toContain("source_channel: telegram");
+      expect(text).toContain("canonical_actor_identity: trusted-user-1");
+      expect(text).toContain("actor_identifier: @jeff_handle");
+      expect(text).toContain("actor_display_name: Jeff");
+      expect(text).toContain("actor_sender_display_name: Jeffrey");
+      expect(text).toContain("actor_member_display_name: Jeff");
+      expect(text).toContain("trust_class: trusted_contact");
+      expect(text).toContain("guardian_identity: guardian-user-1");
+      expect(text).toContain("member_status: active");
+      expect(text).toContain("member_policy: allow");
+      // Behavioral guidance
+      expect(text).toContain("trusted contact (non-guardian)");
+      expect(text).toContain("attempt to fulfill it normally");
+      expect(text).toContain(
+        "tool execution layer will automatically deny it and escalate",
+      );
+      expect(text).toContain('their name is "Jeff"');
+      expect(text).toContain("</turn_context>");
+    } finally {
+      _setOverridesForTesting({});
+    }
+  });
+
+  test("non-guardian trusted_contact under v2: guidance shifts to conversational guardian confirmation", () => {
+    _setOverridesForTesting({ "permission-controls-v2": true });
+
+    try {
+      const options: UnifiedTurnContextOptions = {
+        timestamp: "2026-04-02T12:00:00Z",
+        interfaceName: "telegram",
+        channelName: "telegram",
+        actorContext: {
+          sourceChannel: "telegram",
+          canonicalActorIdentity: "trusted-user-1",
+          actorIdentifier: "@jeff_handle",
+          actorDisplayName: "Jeff",
+          actorSenderDisplayName: "Jeffrey",
+          actorMemberDisplayName: "Jeff",
+          trustClass: "trusted_contact",
+          guardianIdentity: "guardian-user-1",
+          memberStatus: "active",
+          memberPolicy: "allow",
+        },
+      };
+
+      const text = buildUnifiedTurnContextBlock(options);
+      expect(text).toContain("trusted contact (non-guardian)");
+      expect(text).toContain(
+        "confirming the guardian's intent conversationally",
+      );
+      expect(text).toContain(
+        "ask the guardian to enable computer access for this conversation",
+      );
+      expect(text).not.toContain(
+        "tool execution layer will automatically deny it and escalate",
+      );
+    } finally {
+      _setOverridesForTesting({});
+    }
   });
 
   test("non-guardian unknown: all actor fields + unknown guidance", () => {
@@ -1145,7 +1198,7 @@ describe("buildUnifiedTurnContextBlock", () => {
 
     const text = buildUnifiedTurnContextBlock(options);
     expect(text).toContain("<turn_context>");
-    expect(text).toContain("timestamp: 2026-04-02T12:00:00Z");
+    expect(text).toContain("current_time: 2026-04-02T12:00:00Z");
     expect(text).toContain("canonical_actor_identity: unknown");
     expect(text).toContain("trust_class: unknown");
     expect(text).toContain("non-guardian account");
@@ -1306,7 +1359,7 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).not.toContain("interface:");
     const lines = text.split("\n");
     expect(lines[0]).toBe("<turn_context>");
-    expect(lines[1]).toBe("timestamp: 2026-04-02T12:00:00Z");
+    expect(lines[1]).toBe("current_time: 2026-04-02T12:00:00Z");
     expect(lines[2]).toBe("</turn_context>");
   });
 
@@ -1338,6 +1391,61 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("contact_notes: Prefers short replies");
     expect(text).toContain("contact_interaction_count: 42");
   });
+
+  test("time_since_last_message: emitted right after current_time when provided", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: "2d ago",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    const lines = text.split("\n");
+    expect(lines[0]).toBe("<turn_context>");
+    expect(lines[1]).toBe("current_time: 2026-04-02T12:00:00Z");
+    expect(lines[2]).toBe("time_since_last_message: 2d ago");
+    expect(lines[3]).toBe("interface: macos");
+    expect(lines[4]).toBe("</turn_context>");
+  });
+
+  test("time_since_last_message: omitted when null", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: null,
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: omitted when field absent (backward-compat)", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: works on non-guardian path", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "telegram",
+      channelName: "telegram",
+      timeSinceLastMessage: "yesterday",
+      actorContext: {
+        sourceChannel: "telegram",
+        canonicalActorIdentity: "user-1",
+        trustClass: "trusted_contact",
+      },
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).toContain("time_since_last_message: yesterday");
+    expect(text).toContain("canonical_actor_identity: user-1");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1353,7 +1461,7 @@ describe("applyRuntimeInjections with unifiedTurnContext", () => {
   ];
 
   const sampleBlock =
-    "<turn_context>\ntimestamp: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
+    "<turn_context>\ncurrent_time: 2026-04-02T12:00:00Z\ninterface: macos\n</turn_context>";
 
   test("injects unifiedTurnContext when provided", () => {
     const result = applyRuntimeInjections(baseMessages, {
@@ -1494,3 +1602,173 @@ describe("findLastInjectedNowContent", () => {
     expect(findLastInjectedNowContent(messages)).toBe("User focus");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Subagent status injection
+// ---------------------------------------------------------------------------
+
+function makeSubagentState(
+  overrides: Partial<SubagentState> & { label: string; id: string },
+): SubagentState {
+  return {
+    config: {
+      id: overrides.id,
+      parentConversationId: "parent-conv",
+      label: overrides.label,
+      objective: "test objective",
+      ...overrides.config,
+    },
+    status: overrides.status ?? "running",
+    conversationId: `conv-${overrides.id}`,
+    isFork: overrides.isFork ?? false,
+    createdAt: overrides.createdAt ?? Date.now() - 60_000,
+    startedAt: overrides.startedAt ?? Date.now() - 55_000,
+    completedAt: overrides.completedAt,
+    error: overrides.error,
+    usage: overrides.usage ?? {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCost: 0,
+    },
+  };
+}
+
+describe("buildSubagentStatusBlock", () => {
+  test("returns null for empty children array", () => {
+    expect(buildSubagentStatusBlock([])).toBeNull();
+  });
+
+  test("formats running subagent with elapsed time", () => {
+    const children = [
+      makeSubagentState({
+        id: "abc-123",
+        label: "research-auth",
+        status: "running",
+      }),
+    ];
+    const block = buildSubagentStatusBlock(children)!;
+    expect(block).toContain("<active_subagents>");
+    expect(block).toContain("</active_subagents>");
+    expect(block).toContain('[running] "research-auth" (abc-123)');
+    expect(block).toContain("elapsed:");
+    expect(block).toContain("subagent_read");
+  });
+
+  test("formats pending subagent without elapsed time for terminal", () => {
+    const children = [
+      makeSubagentState({
+        id: "def-456",
+        label: "plan-feature",
+        status: "completed",
+        completedAt: Date.now(),
+      }),
+    ];
+    const block = buildSubagentStatusBlock(children)!;
+    expect(block).toContain('[completed] "plan-feature" (def-456)');
+    expect(block).not.toContain("elapsed:");
+  });
+
+  test("includes error for failed subagent", () => {
+    const children = [
+      makeSubagentState({
+        id: "ghi-789",
+        label: "run-tests",
+        status: "failed",
+        error: "Process exited with code 1",
+      }),
+    ];
+    const block = buildSubagentStatusBlock(children)!;
+    expect(block).toContain('[failed] "run-tests" (ghi-789)');
+    expect(block).toContain("error: Process exited with code 1");
+  });
+
+  test("includes both active and terminal subagents", () => {
+    const children = [
+      makeSubagentState({ id: "a", label: "researcher", status: "running" }),
+      makeSubagentState({ id: "b", label: "coder", status: "completed" }),
+      makeSubagentState({
+        id: "c",
+        label: "planner",
+        status: "failed",
+        error: "timeout",
+      }),
+    ];
+    const block = buildSubagentStatusBlock(children)!;
+    expect(block).toContain('"researcher"');
+    expect(block).toContain('"coder"');
+    expect(block).toContain('"planner"');
+  });
+});
+
+describe("injectSubagentStatus", () => {
+  test("appends status block to user message", () => {
+    const msg: Message = {
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+    };
+    const result = injectSubagentStatus(
+      msg,
+      "<active_subagents>\ntest\n</active_subagents>",
+    );
+    expect(result.content).toHaveLength(2);
+    expect(
+      (result.content[1] as { type: string; text: string }).text,
+    ).toContain("<active_subagents>");
+  });
+});
+
+describe("applyRuntimeInjections — subagent status", () => {
+  const userMsg: Message = {
+    role: "user",
+    content: [{ type: "text", text: "user message" }],
+  };
+
+  test("includes subagent status in full mode", () => {
+    const result = applyRuntimeInjections([userMsg], {
+      subagentStatusBlock:
+        "<active_subagents>\n- [running] test\n</active_subagents>",
+      mode: "full",
+    });
+    const tail = result[result.length - 1];
+    const texts = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(true);
+  });
+
+  test("skips subagent status in minimal mode", () => {
+    const result = applyRuntimeInjections([userMsg], {
+      subagentStatusBlock:
+        "<active_subagents>\n- [running] test\n</active_subagents>",
+      mode: "minimal",
+    });
+    const tail = result[result.length - 1];
+    const texts = tail.content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(false);
+  });
+});
+
+describe("stripInjectionsForCompaction — subagent status", () => {
+  test("strips <active_subagents> blocks", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "hello" },
+          {
+            type: "text",
+            text: '<active_subagents>\n- [running] "test" (id)\n</active_subagents>',
+          },
+        ],
+      },
+    ];
+    const result = stripInjectionsForCompaction(messages);
+    const texts = result[0].content
+      .filter((b): b is { type: "text"; text: string } => b.type === "text")
+      .map((b) => b.text);
+    expect(texts.some((t) => t.includes("<active_subagents>"))).toBe(false);
+    expect(texts).toContain("hello");
+  });
+});

package/src/__tests__/conversation-skill-tools.test.ts

@@ -1829,7 +1829,7 @@ describe("bundled skill: browser", () => {
     sessionState = new Map<string, string>();
   });
 
-  test("browser skill activation via loaded_skill marker registers all 14 tools in allowedToolNames", () => {
+  test("browser skill activation via loaded_skill marker registers all browser tools in allowedToolNames", () => {
     mockCatalog = [makeSkill("browser", "/path/to/bundled-skills/browser")];
     mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
 
@@ -1876,7 +1876,7 @@ describe("bundled skill: browser", () => {
 
     const tools = mockRegisteredTools.get("browser");
     expect(tools).toBeDefined();
-    expect(tools!.length).toBe(14);
+    expect(tools!.length).toBe(BROWSER_TOOL_NAMES.length);
 
     for (const tool of tools!) {
       expect(tool.origin).toBe("skill");
@@ -2610,10 +2610,13 @@ describe("browser skill migration harness", () => {
     expect(id1).not.toBe(id2);
   });
 
-  test("BROWSER_TOOL_NAMES contains all 14 browser tools", () => {
-    expect(BROWSER_TOOL_NAMES).toHaveLength(14);
+  test("BROWSER_TOOL_NAMES contains all browser tools", () => {
+    expect(BROWSER_TOOL_NAMES).toHaveLength(17);
     expect(BROWSER_TOOL_NAMES).toContain("browser_navigate");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_attach");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_detach");
     expect(BROWSER_TOOL_NAMES).toContain("browser_fill_credential");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_status");
   });
 
   test("assertBrowserToolsPresent passes when all tools present", () => {

package/src/__tests__/conversation-slash-commands.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  classifySlash,
   resolveSlash,
   type SlashContext,
 } from "../daemon/conversation-slash.js";
@@ -148,3 +149,35 @@ describe("resolveSlash command contract", () => {
     expect(result.message).toContain("Pairing is not available");
   });
 });
+
+describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
+  // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
+  // effects (/pair registers a pairing request and writes a QR PNG). The
+  // pure classifier is synchronous, takes no side-effecting dependencies,
+  // and must agree with resolveSlash's `kind`.
+  const cases: Array<{ input: string; kind: "passthrough" | "compact" | "unknown" }> = [
+    { input: "/pair", kind: "unknown" },
+    { input: "/models", kind: "unknown" },
+    { input: "/status", kind: "unknown" },
+    { input: "/commands", kind: "unknown" },
+    { input: "/compact", kind: "compact" },
+    { input: "/model", kind: "unknown" },
+    { input: "/model foo", kind: "unknown" },
+    { input: "/opus", kind: "unknown" },
+    { input: "hello", kind: "passthrough" },
+    { input: "  /compact  ", kind: "compact" },
+    { input: "/pair foo", kind: "passthrough" },
+    { input: "/models foo", kind: "passthrough" },
+  ];
+
+  for (const { input, kind } of cases) {
+    test(`classifies ${JSON.stringify(input)} as ${kind}`, async () => {
+      expect(classifySlash(input)).toBe(kind);
+      const resolved = await resolveSlash(
+        input,
+        makeSlashContext({ userMessageInterface: "macos" }),
+      );
+      expect(resolved.kind).toBe(kind);
+    });
+  }
+});