@vellumai/assistant 0.6.2 → 0.6.3

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>");
   });
 
@@ -1353,7 +1406,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 +1547,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-starter-routes.test.ts

@@ -11,6 +11,7 @@ mock.module("../util/logger.js", () => ({
 
 import { getSqlite, initializeDb } from "../memory/db.js";
 import {
+  CONVERSATION_STARTERS_STALE_TTL_MS,
   conversationStarterRouteDefinitions,
   orderStrongestFirst,
 } from "../runtime/routes/conversation-starter-routes.js";
@@ -89,22 +90,57 @@ function insertMemoryItem(scopeId = "default") {
   );
 }
 
+function setCheckpoint(key: string, value: string, updatedAt = Date.now()) {
+  getSqlite().run(
+    `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
+    [key, value, updatedAt],
+  );
+}
+
+function insertStarterJob(scopeId = "default", status = "pending") {
+  const now = Date.now();
+  getSqlite().run(
+    `INSERT INTO memory_jobs (
+      id, type, payload, status, attempts, deferrals, run_after, last_error,
+      started_at, created_at, updated_at
+    ) VALUES (?, 'generate_conversation_starters', ?, ?, 0, 0, ?, NULL, NULL, ?, ?)`,
+    [uuid(), JSON.stringify({ scopeId }), status, now, now, now],
+  );
+}
+
+function countStarterJobs() {
+  return (
+    getSqlite()
+      .prepare(
+        `SELECT COUNT(*) AS c FROM memory_jobs WHERE type = 'generate_conversation_starters'`,
+      )
+      .get() as { c: number }
+  ).c;
+}
+
 beforeEach(() => {
   clearTables();
 });
 
 describe("GET /v1/conversation-starters", () => {
   test("returns ready status with starters when they exist", async () => {
+    const now = Date.now();
     insertStarter({
       label: "Draft a PR summary",
       prompt: "Draft a summary for my latest PR",
       category: "development",
+      createdAt: now,
     });
     insertStarter({
       label: "Check Slack threads",
       prompt: "Check my unread Slack threads",
       category: "communication",
+      createdAt: now,
     });
+    setCheckpoint("conversation_starters:last_gen_at:default", String(now));
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "2");
+    insertMemoryItem();
+    insertMemoryItem();
 
     const res = await dispatch("conversation-starters");
     const body = (await res.json()) as {
@@ -119,6 +155,96 @@ describe("GET /v1/conversation-starters", () => {
     expect(body.total).toBe(2);
   });
 
+  test("returns refreshing with existing starters when the batch is stale and enqueues one refresh job", async () => {
+    const now = Date.now();
+    insertStarter({
+      label: "Draft a PR summary",
+      prompt: "Draft a summary for my latest PR",
+      category: "development",
+      createdAt: now - 1_000,
+    });
+    insertStarter({
+      label: "Check Slack threads",
+      prompt: "Check my unread Slack threads",
+      category: "communication",
+      createdAt: now - 2_000,
+    });
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(now - CONVERSATION_STARTERS_STALE_TTL_MS - 1_000),
+    );
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "2");
+    insertMemoryItem();
+    insertMemoryItem();
+
+    const res = await dispatch("conversation-starters");
+    const body = (await res.json()) as {
+      starters: unknown[];
+      total: number;
+      status: string;
+    };
+
+    expect(res.status).toBe(200);
+    expect(body.status).toBe("refreshing");
+    expect(body.starters).toHaveLength(2);
+    expect(countStarterJobs()).toBe(1);
+  });
+
+  test("returns refreshing with existing starters when the checkpoint count is ahead of active memory and enqueues one refresh job", async () => {
+    const now = Date.now();
+    insertStarter({
+      label: "Draft a PR summary",
+      prompt: "Draft a summary for my latest PR",
+      category: "development",
+      createdAt: now,
+    });
+    setCheckpoint("conversation_starters:last_gen_at:default", String(now));
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "5");
+    insertMemoryItem();
+    insertMemoryItem();
+
+    const res = await dispatch("conversation-starters");
+    const body = (await res.json()) as {
+      starters: unknown[];
+      total: number;
+      status: string;
+    };
+
+    expect(res.status).toBe(200);
+    expect(body.status).toBe("refreshing");
+    expect(body.starters).toHaveLength(1);
+    expect(countStarterJobs()).toBe(1);
+  });
+
+  test("does not enqueue duplicate refresh jobs when a starter job is already active", async () => {
+    const now = Date.now();
+    insertStarter({
+      label: "Draft a PR summary",
+      prompt: "Draft a summary for my latest PR",
+      category: "development",
+      createdAt: now,
+    });
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(now - CONVERSATION_STARTERS_STALE_TTL_MS - 1_000),
+    );
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
+    insertMemoryItem();
+    insertStarterJob("default");
+
+    const res = await dispatch("conversation-starters");
+    const body = (await res.json()) as {
+      starters: unknown[];
+      total: number;
+      status: string;
+    };
+
+    expect(res.status).toBe(200);
+    expect(body.status).toBe("refreshing");
+    expect(body.starters).toHaveLength(1);
+    expect(countStarterJobs()).toBe(1);
+  });
+
   test("returns empty status when no memory items exist", async () => {
     const res = await dispatch("conversation-starters");
     const body = (await res.json()) as {