@vellumai/assistant 0.5.16 → 0.6.0

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

@@ -16,7 +16,7 @@
 
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
@@ -38,12 +38,17 @@ import {
   createCanonicalGuardianRequest,
   getCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
+import {
+  buildDecisionActions,
+  GUARDIAN_DECISION_ACTIONS,
+} from "../runtime/guardian-decision-types.js";
 import {
   type GuardianReplyContext,
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
 
@@ -55,10 +60,6 @@ function resetTables(): void {
   pendingInteractions.clear();
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -734,6 +735,62 @@ describe("routing invariant: channel formatting delimiters stripped from code pa
     const resolved = getCanonicalGuardianRequest(req.id);
     expect(resolved!.status).toBe("approved");
   });
+
+  test("*CODE* action — formatting wraps only the code portion", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "A1B2C3",
+      toolName: "shell",
+      inputDigest: "sha256:abc",
+      expiresAt: Date.now() + 60_000,
+    });
+    registerPendingToolApprovalInteraction(req.id, "conv-1", "shell");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "*A1B2C3* approve",
+        conversationId: "conv-1",
+      }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(result.decisionApplied).toBe(true);
+
+    const resolved = getCanonicalGuardianRequest(req.id);
+    expect(resolved!.status).toBe("approved");
+  });
+
+  test("**CODE** action — double-asterisk formatting wraps only the code portion", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "D4E5F6",
+      expiresAt: Date.now() + 60_000,
+    });
+    registerPendingToolApprovalInteraction(req.id, "conv-1", "shell");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "**D4E5F6** reject",
+        conversationId: "conv-1",
+      }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(result.decisionApplied).toBe(true);
+
+    const resolved = getCanonicalGuardianRequest(req.id);
+    expect(resolved!.status).toBe("denied");
+  });
 });
 
 // ===========================================================================
@@ -1649,3 +1706,132 @@ describe("routing invariant: expired requests are excluded from pending discover
     expect(result.decisionApplied).toBe(false);
   });
 });
+
+// ===========================================================================
+// SECTION 12: Kind-specific action sets in prompt mapping
+// ===========================================================================
+
+describe("routing invariant: kind-specific action sets in prompt mapping", () => {
+  beforeEach(() => resetTables());
+
+  test("buildDecisionActions({ forGuardianOnBehalf: true }) includes temporal actions", () => {
+    const actions = buildDecisionActions({ forGuardianOnBehalf: true });
+    const actionIds = actions.map((a) => a.action);
+    expect(actionIds).toContain("approve_once");
+    expect(actionIds).toContain("approve_10m");
+    expect(actionIds).toContain("approve_conversation");
+    expect(actionIds).toContain("reject");
+    // approve_always must NOT be present for guardian-on-behalf
+    expect(actionIds).not.toContain("approve_always");
+  });
+
+  test("non-tool-approval action set is approve_once + reject only", () => {
+    const actions = [
+      GUARDIAN_DECISION_ACTIONS.approve_once,
+      GUARDIAN_DECISION_ACTIONS.reject,
+    ];
+    expect(actions).toHaveLength(2);
+    expect(actions[0].action).toBe("approve_once");
+    expect(actions[1].action).toBe("reject");
+  });
+
+  test("source-code invariant: guardian-action-routes.ts contains kind guard", () => {
+    const srcRoot = resolve(__dirname, "..");
+    const fullPath = join(srcRoot, "runtime/routes/guardian-action-routes.ts");
+    const source = readFileSync(fullPath, "utf-8");
+    expect(source).toContain('req.kind === "tool_approval"');
+  });
+
+  // Integration tests: verify listGuardianDecisionPrompts returns correct
+  // action sets for each canonical request kind.
+
+  test("tool_approval prompt includes temporal actions (approve_10m, approve_conversation)", () => {
+    const convId = "conv-kind-tool-approval";
+    createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "shell",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const prompts = listGuardianDecisionPrompts({ conversationId: convId });
+    expect(prompts).toHaveLength(1);
+
+    const actionIds = prompts[0].actions.map((a) => a.action);
+    expect(actionIds).toContain("approve_once");
+    expect(actionIds).toContain("approve_10m");
+    expect(actionIds).toContain("approve_conversation");
+    expect(actionIds).toContain("reject");
+    expect(actionIds).not.toContain("approve_always");
+  });
+
+  test("pending_question prompt has approve_once + reject only (no temporal actions)", () => {
+    const convId = "conv-kind-pending-question";
+    createCanonicalGuardianRequest({
+      kind: "pending_question",
+      sourceType: "voice",
+      sourceChannel: "phone",
+      conversationId: convId,
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      callSessionId: "call-pq",
+      pendingQuestionId: "pq-kind-test",
+      questionText: "What time works best?",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const prompts = listGuardianDecisionPrompts({ conversationId: convId });
+    expect(prompts).toHaveLength(1);
+
+    const actionIds = prompts[0].actions.map((a) => a.action);
+    expect(actionIds).toEqual(["approve_once", "reject"]);
+    expect(actionIds).not.toContain("approve_10m");
+    expect(actionIds).not.toContain("approve_conversation");
+  });
+
+  test("access_request prompt has approve_once + reject only (no temporal actions)", () => {
+    const convId = "conv-kind-access-request";
+    createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: convId,
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "ingress_access_request",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const prompts = listGuardianDecisionPrompts({ conversationId: convId });
+    expect(prompts).toHaveLength(1);
+
+    const actionIds = prompts[0].actions.map((a) => a.action);
+    expect(actionIds).toEqual(["approve_once", "reject"]);
+    expect(actionIds).not.toContain("approve_10m");
+    expect(actionIds).not.toContain("approve_conversation");
+  });
+
+  test("tool_grant_request prompt has approve_once + reject only (no temporal actions)", () => {
+    const convId = "conv-kind-tool-grant-request";
+    createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      conversationId: convId,
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "file_write",
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const prompts = listGuardianDecisionPrompts({ conversationId: convId });
+    expect(prompts).toHaveLength(1);
+
+    const actionIds = prompts[0].actions.map((a) => a.action);
+    expect(actionIds).toEqual(["approve_once", "reject"]);
+    expect(actionIds).not.toContain("approve_10m");
+    expect(actionIds).not.toContain("approve_conversation");
+  });
+});

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

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 import { eq } from "drizzle-orm";
@@ -17,7 +17,7 @@ mock.module("../util/logger.js", () => ({
 import { upsertContact } from "../contacts/contact-store.js";
 import { createGuardianBinding } from "../contacts/contacts-write.js";
 import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
 import { channelInboundEvents, messages } from "../memory/schema.js";
 import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
@@ -29,10 +29,6 @@ import {
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 function resetTables(): void {
   const db = getDb();
   db.run("DELETE FROM channel_inbound_events");

package/src/__tests__/guardian-verification-voice-binding.test.ts

@@ -2,7 +2,7 @@
  * Regression test: guardian verification calls must create a voice channel
  * binding so the conversation never appears as an unbound desktop conversation.
  */
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -90,15 +90,11 @@ mock.module("../memory/conversation-title-service.js", () => ({
 
 import { startVerificationCall } from "../calls/call-domain.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { initializeDb, resetDb } from "../memory/db.js";
+import { initializeDb } from "../memory/db.js";
 import { getBindingByConversation } from "../memory/external-conversation-store.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 describe("startVerificationCall — voice binding", () => {
   beforeEach(() => {
     mockPreflightResult = {

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -5,7 +5,7 @@
  * granted access without guardian approval, and that invalid/expired/revoked
  * tokens produce the correct deterministic refusal messages.
  */
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
@@ -69,16 +69,12 @@ import {
   upsertContact,
 } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
 import { handleChannelInbound } from "../runtime/routes/channel-routes.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/injection-block.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  assembleContextBlock,
+  assembleInjectionBlock,
+} from "../memory/graph/injection.js";
+import type { MemoryNode, ScoredNode } from "../memory/graph/types.js";
+
+function makeScoredNode(
+  overrides: Partial<MemoryNode> & { content: string },
+): ScoredNode {
+  return {
+    node: {
+      id: "test-id",
+      content: overrides.content,
+      type: overrides.type ?? "episodic",
+      created: overrides.created ?? Date.now() - 3 * 24 * 60 * 60 * 1000,
+      lastAccessed: overrides.lastAccessed ?? Date.now(),
+      lastConsolidated: overrides.lastConsolidated ?? Date.now(),
+      eventDate: overrides.eventDate ?? null,
+      emotionalCharge: overrides.emotionalCharge ?? {
+        valence: 0,
+        intensity: 0,
+        decayCurve: "linear",
+        decayRate: 0,
+        originalIntensity: 0,
+      },
+      fidelity: overrides.fidelity ?? "clear",
+      confidence: overrides.confidence ?? 1,
+      significance: overrides.significance ?? 0.5,
+      stability: overrides.stability ?? 1,
+      reinforcementCount: overrides.reinforcementCount ?? 0,
+      lastReinforced: overrides.lastReinforced ?? Date.now(),
+      sourceConversations: overrides.sourceConversations ?? [],
+      sourceType: overrides.sourceType ?? "direct",
+      narrativeRole: overrides.narrativeRole ?? null,
+      partOfStory: overrides.partOfStory ?? null,
+      imageRefs: overrides.imageRefs ?? null,
+      scopeId: overrides.scopeId ?? "default",
+    },
+    score: 0.8,
+    scoreBreakdown: {
+      semanticSimilarity: 0.5,
+      effectiveSignificance: 0.5,
+      emotionalIntensity: 0,
+      temporalBoost: 0,
+      recencyBoost: 0,
+      triggerBoost: 0,
+      activationBoost: 0,
+    },
+  };
+}
+
+describe("assembleInjectionBlock", () => {
+  test("returns empty string for empty array", () => {
+    expect(assembleInjectionBlock([])).toBe("");
+  });
+
+  test("uses creation age format for nodes without eventDate", () => {
+    const node = makeScoredNode({ content: "Regular memory node" });
+    const result = assembleInjectionBlock([node]);
+    // Should show relative age like "(3d ago)"
+    expect(result).toMatch(/^\- \(\d+[dhm]o? ago\) Regular memory node$/);
+  });
+
+  test("uses event date format for nodes with eventDate", () => {
+    // Set eventDate to 5 days from now
+    const futureDate = Date.now() + 5 * 24 * 60 * 60 * 1000;
+    const node = makeScoredNode({
+      content: "Flight to NYC",
+      eventDate: futureDate,
+    });
+    const result = assembleInjectionBlock([node]);
+    // Should show event date like "Tue Apr 8, 6:00 PM (in 5d) — Flight to NYC"
+    expect(result).toContain("Flight to NYC");
+    expect(result).toMatch(/\(in \d+d\)/);
+    // Should NOT contain the age-based format
+    expect(result).not.toMatch(/\(\d+[dhm]o? ago\)/);
+  });
+
+  test("mixes both formats when nodes have mixed eventDate presence", () => {
+    const regularNode = makeScoredNode({
+      id: "regular",
+      content: "Had coffee with friend",
+    } as Partial<MemoryNode> & { content: string });
+    const eventNode = makeScoredNode({
+      id: "event",
+      content: "Dentist appointment",
+      eventDate: Date.now() + 2 * 24 * 60 * 60 * 1000,
+    } as Partial<MemoryNode> & { content: string });
+
+    const result = assembleInjectionBlock([regularNode, eventNode]);
+    const lines = result.split("\n");
+
+    expect(lines).toHaveLength(2);
+    // First line: regular node with age format
+    expect(lines[0]).toMatch(/\(\d+[dhm]o? ago\) Had coffee with friend/);
+    // Second line: event node with event date format
+    expect(lines[1]).toContain("Dentist appointment");
+    expect(lines[1]).toMatch(/\(in \d+d\)/);
+  });
+
+  test("uses event date format for past event-dated nodes", () => {
+    // Set eventDate to 3 days ago (past event)
+    const pastDate = Date.now() - 3 * 24 * 60 * 60 * 1000;
+    const node = makeScoredNode({
+      content: "Team standup",
+      eventDate: pastDate,
+    });
+    const result = assembleInjectionBlock([node]);
+    // Should show event date format with past indicator, not creation age
+    expect(result).toContain("Team standup");
+    expect(result).toMatch(/\(\d+d ago\)/);
+    // The line should use the event date format (date — content) not age format ((age) content)
+    expect(result).toContain(" — Team standup");
+  });
+
+  test("assembleInjectionBlock formats procedural nodes with [skill] prefix", () => {
+    const node = makeScoredNode({
+      type: "procedural",
+      content:
+        'skill:telegram-setup\nThe "Telegram Setup" skill (telegram-setup) is available.',
+    });
+    const result = assembleInjectionBlock([node]);
+    expect(result).toContain("[skill]");
+    expect(result).toContain("→ use skill_load to activate");
+  });
+});
+
+describe("assembleContextBlock — procedural nodes", () => {
+  test("puts procedural nodes under Skills You Can Use", () => {
+    const node = makeScoredNode({
+      type: "procedural",
+      content:
+        'skill:telegram-setup\nThe "Telegram Setup" skill (telegram-setup) is available.',
+    });
+    const result = assembleContextBlock([node]);
+    expect(result).toContain("### Skills You Can Use");
+    expect(result).toContain("use skill_load to activate");
+  });
+
+  test("strips skill: prefix from old-format content", () => {
+    const node = makeScoredNode({
+      type: "procedural",
+      content:
+        'skill:telegram-setup\nThe "Telegram Setup" skill (telegram-setup) is available.',
+    });
+    const result = assembleContextBlock([node]);
+    // The "skill:telegram-setup" prefix line should be stripped from the rendered output
+    expect(result).not.toContain("skill:telegram-setup\n");
+    // But the skill name in the description should remain
+    expect(result).toContain('The "Telegram Setup" skill');
+  });
+});