@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/guardian-decision-primitive-canonical.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("../util/logger.js", () => ({
   getLogger: () =>
@@ -23,7 +23,7 @@ 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 { scopedApprovalGrants } from "../memory/schema.js";
 
 initializeDb();
@@ -35,10 +35,6 @@ function resetTables(): void {
   db.run("DELETE FROM canonical_guardian_requests");
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -736,8 +732,12 @@ describe("mintCanonicalRequestGrant", () => {
     const db = getDb();
     const grants = db.select().from(scopedApprovalGrants).all();
     expect(grants.length).toBe(1);
-    expect(grants[0].expiresAt).toBeGreaterThanOrEqual(before + GRANT_TTL_10M_MS);
-    expect(grants[0].expiresAt).toBeLessThanOrEqual(Date.now() + GRANT_TTL_10M_MS);
+    expect(grants[0].expiresAt).toBeGreaterThanOrEqual(
+      before + GRANT_TTL_10M_MS,
+    );
+    expect(grants[0].expiresAt).toBeLessThanOrEqual(
+      Date.now() + GRANT_TTL_10M_MS,
+    );
   });
 
   test("mints grant with no wall-clock expiry for approve_conversation", () => {

package/src/__tests__/guardian-dispatch.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";
 
 import type { ConversationCreatedInfo } from "../notifications/broadcaster.js";
 import type { NotificationDeliveryResult } from "../notifications/types.js";
@@ -71,7 +71,7 @@ import {
   createPendingQuestion,
 } from "../calls/call-store.js";
 import { dispatchGuardianQuestion } from "../calls/guardian-dispatch.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { conversations } from "../memory/schema.js";
 
 initializeDb();
@@ -125,10 +125,6 @@ describe("guardian-dispatch", () => {
     resetTables();
   });
 
-  afterAll(() => {
-    resetDb();
-  });
-
   test("creates a guardian action request and vellum delivery from pipeline results", async () => {
     const convId = "conv-dispatch-1";
     ensureConversation(convId);

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

@@ -6,15 +6,7 @@
  * Non-tool-approval requests and rejections must NOT mint grants.
  */
 
-import {
-  afterAll,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Test isolation: in-memory SQLite via temp directory
@@ -30,7 +22,7 @@ mock.module("../util/logger.js", () => ({
 import { GRANT_TTL_MS } from "../approvals/guardian-decision-primitive.js";
 import type { Conversation } from "../daemon/conversation.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 {
   createApprovalRequest,
   getPendingApprovalForRequest,
@@ -46,10 +38,6 @@ import "../memory/scoped-approval-grants.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/guardian-principal-id-roundtrip.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("../util/logger.js", () => ({
   getLogger: () =>
@@ -13,7 +13,7 @@ import {
   resolveCanonicalGuardianRequest,
   updateCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 
 initializeDb();
 
@@ -28,10 +28,6 @@ describe("guardianPrincipalId roundtrip", () => {
     resetTables();
   });
 
-  afterAll(() => {
-    resetDb();
-  });
-
   // ── canonical_guardian_requests ──────────────────────────────────────
 
   describe("canonical_guardian_requests", () => {

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__/heartbeat-service.test.ts

@@ -1,4 +1,4 @@
-import { rmSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -18,6 +18,9 @@ let mockConfig = {
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
 }));
 
 // Mock conversation store
@@ -43,6 +46,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     totalEstimatedCost: 0,
     title: null,
   }),
+  getMessageById: () => null,
   provenanceFromTrustContext: () => ({
     source: "user",
     trustContext: undefined,
@@ -72,7 +76,16 @@ mock.module("../memory/conversation-title-service.js", () => ({
 }));
 
 // Import after mocks are set up
-const { HeartbeatService } = await import("../heartbeat/heartbeat-service.js");
+const { HeartbeatService, isShallowProfile } =
+  await import("../heartbeat/heartbeat-service.js");
+
+// Read the bundled template files so we can write them into the test workspace
+const templatesDir = join(import.meta.dirname!, "..", "prompts", "templates");
+const IDENTITY_TEMPLATE = readFileSync(
+  join(templatesDir, "IDENTITY.md"),
+  "utf-8",
+);
+const USER_TEMPLATE = readFileSync(join(templatesDir, "USER.md"), "utf-8");
 
 describe("HeartbeatService", () => {
   let processMessageCalls: Array<{
@@ -83,8 +96,11 @@ describe("HeartbeatService", () => {
   let alerterCalls: Array<{ type: string; title: string; body: string }>;
 
   afterEach(() => {
-    // Clean up HEARTBEAT.md between tests so file-existence tests don't leak
+    // Clean up workspace files between tests so file-existence tests don't leak
     rmSync(join(testWorkspaceDir, "HEARTBEAT.md"), { force: true });
+    rmSync(join(testWorkspaceDir, "IDENTITY.md"), { force: true });
+    rmSync(join(testWorkspaceDir, "USER.md"), { force: true });
+    rmSync(join(testWorkspaceDir, ".reengagement-ts"), { force: true });
   });
 
   beforeEach(() => {
@@ -228,6 +244,24 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(0);
   });
 
+  test("active hours skip still advances nextRunAt", async () => {
+    mockConfig.heartbeat.activeHoursStart = 9;
+    mockConfig.heartbeat.activeHoursEnd = 17;
+
+    const service = createService({ getCurrentHour: () => 3 });
+    service.start();
+
+    const before = Date.now();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(0);
+    expect(service.nextRunAt).not.toBeNull();
+    expect(service.nextRunAt!).toBeGreaterThanOrEqual(
+      before + mockConfig.heartbeat.intervalMs,
+    );
+    service.stop();
+  });
+
   test("active hours guard allows within window", async () => {
     mockConfig.heartbeat.activeHoursStart = 9;
     mockConfig.heartbeat.activeHoursEnd = 17;
@@ -360,6 +394,22 @@ describe("HeartbeatService", () => {
     expect(alerterCalls[0].body).toBe("LLM timeout");
   });
 
+  test("successful run updates lastRunAt and nextRunAt", async () => {
+    const service = createService();
+    expect(service.lastRunAt).toBeNull();
+    expect(service.nextRunAt).toBeNull();
+
+    const before = Date.now();
+    await service.runOnce();
+
+    expect(service.lastRunAt).not.toBeNull();
+    expect(service.lastRunAt!).toBeGreaterThanOrEqual(before);
+    expect(service.nextRunAt).not.toBeNull();
+    expect(service.nextRunAt!).toBeGreaterThanOrEqual(
+      before + mockConfig.heartbeat.intervalMs,
+    );
+  });
+
   test("alerts on conversation creation failure", async () => {
     // Override createConversation to throw via a fresh import trick:
     // Since createConversation is mocked at module level, we simulate
@@ -442,4 +492,131 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(1);
     expect(processMessageCalls[0].options?.speed).toBe("fast");
   });
+
+  describe("isShallowProfile", () => {
+    test("returns true when both IDENTITY.md and USER.md are unmodified templates", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      expect(isShallowProfile()).toBe(true);
+    });
+
+    test("returns false when IDENTITY.md has been customized", () => {
+      writeFileSync(
+        join(testWorkspaceDir, "IDENTITY.md"),
+        "# IDENTITY.md\n\n- **Name:** Jarvis\n",
+      );
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      expect(isShallowProfile()).toBe(false);
+    });
+
+    test("returns false when USER.md has been customized", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(
+        join(testWorkspaceDir, "USER.md"),
+        "# USER.md\n\n- Preferred name/reference: Alice\n",
+      );
+
+      expect(isShallowProfile()).toBe(false);
+    });
+
+    test("returns false when neither file exists", () => {
+      expect(isShallowProfile()).toBe(false);
+    });
+  });
+
+  describe("relationship-depth prompt injection", () => {
+    test("includes <relationship-depth> when profile is shallow", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).toContain("<relationship-depth>");
+      expect(prompt).toContain("profile is still sparse");
+      expect(includedReengagement).toBe(true);
+    });
+
+    test("omits <relationship-depth> when profile is not shallow", () => {
+      writeFileSync(
+        join(testWorkspaceDir, "IDENTITY.md"),
+        "# IDENTITY.md\n\n- **Name:** Jarvis\n",
+      );
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).not.toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(false);
+    });
+
+    test("omits <relationship-depth> when cooldown has not elapsed", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      // Write a recent timestamp to simulate cooldown not elapsed
+      writeFileSync(
+        join(testWorkspaceDir, ".reengagement-ts"),
+        Date.now().toString(),
+      );
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).not.toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(false);
+    });
+
+    test("includes <relationship-depth> when cooldown has elapsed", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      // Write a timestamp from 19 hours ago
+      const nineteenHoursAgo = Date.now() - 19 * 60 * 60 * 1000;
+      writeFileSync(
+        join(testWorkspaceDir, ".reengagement-ts"),
+        nineteenHoursAgo.toString(),
+      );
+
+      const service = createService();
+      const { prompt, includedReengagement } =
+        service.buildPrompt("- Check things");
+
+      expect(prompt).toContain("<relationship-depth>");
+      expect(includedReengagement).toBe(true);
+    });
+
+    test("does not record timestamp when processMessage fails", async () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService({
+        processMessage: async () => {
+          throw new Error("LLM timeout");
+        },
+      });
+
+      await service.runOnce();
+
+      // The reengagement timestamp file should NOT exist since delivery failed
+      const tsPath = join(testWorkspaceDir, ".reengagement-ts");
+      expect(existsSync(tsPath)).toBe(false);
+    });
+
+    test("records timestamp after successful delivery", async () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+
+      const service = createService();
+      await service.runOnce();
+
+      // The reengagement timestamp file should exist after successful delivery
+      const tsPath = join(testWorkspaceDir, ".reengagement-ts");
+      expect(existsSync(tsPath)).toBe(true);
+    });
+  });
 });