@vellumai/assistant 0.4.56 → 0.5.0

package/src/__tests__/migration-import-commit-http.test.ts

@@ -48,13 +48,14 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
 const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "migration-import-commit-http-test-")),
 );
-const testDbDir = join(testDir, "db");
+const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
 mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
-  getDataDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceDir: () => testDir,
   getWorkspaceConfigPath: () => testConfigPath,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -78,9 +79,8 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
-    sandbox: { enabled: false },
   }),
 }));
 
@@ -377,10 +377,13 @@ describe("handleMigrationImport", () => {
     expect(writtenData).toEqual(newDbData);
   });
 
-  test("creates backup of existing files before overwriting", async () => {
+  test("workspace is cleared before restore — files are created fresh", async () => {
+    // Only new-format bundles (workspace/ prefix) trigger workspace clearing.
+    // With clearing, existing files are removed before writing, so all files
+    // in the bundle are "created" (not "overwritten") and no backups are made.
     const newDbData = new Uint8Array([0x01, 0x02, 0x03]);
     const vbundle = createValidVBundle([
-      { path: "data/db/assistant.db", data: newDbData },
+      { path: "workspace/data/db/assistant.db", data: newDbData },
     ]);
     const req = new Request("http://localhost/v1/migrations/import", {
       method: "POST",
@@ -392,29 +395,22 @@ describe("handleMigrationImport", () => {
     const body = (await res.json()) as ImportCommitResponse;
 
     expect(body.success).toBe(true);
-    expect(body.summary.backups_created).toBeGreaterThan(0);
+    expect(body.summary.backups_created).toBe(0);
 
-    // Verify backup was created
-    const dbFile = body.files.find((f) => f.path === "data/db/assistant.db");
+    const dbFile = body.files.find(
+      (f) => f.path === "workspace/data/db/assistant.db",
+    );
     expect(dbFile).toBeDefined();
-    expect(dbFile!.action).toBe("overwritten");
-    expect(dbFile!.backup_path).not.toBeNull();
-    expect(existsSync(dbFile!.backup_path!)).toBe(true);
-
-    // Verify backup contains the original data
-    const backupData = new Uint8Array(readFileSync(dbFile!.backup_path!));
-    expect(backupData).toEqual(EXISTING_DB_DATA);
+    expect(dbFile!.action).toBe("created");
   });
 
-  test("reports correct actions for created and overwritten files", async () => {
-    // Remove the config file so it will be "created" instead of "overwritten"
-    rmSync(testConfigPath, { force: true });
-
+  test("reports all files as created after workspace clear", async () => {
+    // New-format workspace/ paths trigger clearing — both files are fresh.
     const newDbData = new Uint8Array([0xaa, 0xbb]);
     const newConfigData = new TextEncoder().encode('{"provider":"openai"}');
     const vbundle = createValidVBundle([
-      { path: "data/db/assistant.db", data: newDbData },
-      { path: "config/settings.json", data: newConfigData },
+      { path: "workspace/data/db/assistant.db", data: newDbData },
+      { path: "workspace/config.json", data: newConfigData },
     ]);
     const req = new Request("http://localhost/v1/migrations/import", {
       method: "POST",
@@ -427,14 +423,16 @@ describe("handleMigrationImport", () => {
 
     expect(body.success).toBe(true);
 
-    const dbFile = body.files.find((f) => f.path === "data/db/assistant.db");
+    const dbFile = body.files.find(
+      (f) => f.path === "workspace/data/db/assistant.db",
+    );
     const configFile = body.files.find(
-      (f) => f.path === "config/settings.json",
+      (f) => f.path === "workspace/config.json",
     );
 
-    expect(dbFile!.action).toBe("overwritten");
+    // Both are "created" because workspace was cleared before writing
+    expect(dbFile!.action).toBe("created");
     expect(configFile!.action).toBe("created");
-    expect(configFile!.backup_path).toBeNull();
   });
 
   test("summary counts match file details", async () => {
@@ -641,7 +639,7 @@ describe("commitImport", () => {
       { path: "data/db/assistant.db", data: newDbData },
     ]);
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -655,7 +653,7 @@ describe("commitImport", () => {
   });
 
   test("returns validation_failed for invalid bundles", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: new Uint8Array([0xba, 0xad]),
       pathResolver: resolver,
@@ -671,17 +669,16 @@ describe("commitImport", () => {
   });
 
   test("creates parent directories if they do not exist", () => {
-    // Use a path that does not exist yet
-    const nonexistentDir = join(testDir, "new-subdir");
-    const newDbPath = join(nonexistentDir, "assistant.db");
-    const newConfigPath = join(testDir, "new-config.json");
+    // Use a workspace that does not exist yet
+    const nonexistentWorkspace = join(testDir, "new-workspace");
+    const expectedDbPath = join(nonexistentWorkspace, "data", "db", "assistant.db");
 
     const dbData = new Uint8Array([0x01, 0x02, 0x03]);
     const vbundle = createValidVBundle([
       { path: "data/db/assistant.db", data: dbData },
     ]);
 
-    const resolver = new DefaultPathResolver(newDbPath, newConfigPath);
+    const resolver = new DefaultPathResolver(undefined, nonexistentWorkspace);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -690,11 +687,11 @@ describe("commitImport", () => {
     expect(result.ok).toBe(true);
     if (result.ok) {
       expect(result.report.files[0].action).toBe("created");
-      expect(existsSync(newDbPath)).toBe(true);
+      expect(existsSync(expectedDbPath)).toBe(true);
     }
 
     // Clean up
-    rmSync(nonexistentDir, { recursive: true, force: true });
+    rmSync(nonexistentWorkspace, { recursive: true, force: true });
   });
 
   test("post-write integrity: written file SHA-256 matches expected", () => {
@@ -705,7 +702,7 @@ describe("commitImport", () => {
       { path: "data/db/assistant.db", data: newDbData },
     ]);
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -735,7 +732,7 @@ describe("commitImport", () => {
       { path: "config/settings.json", data: newConfigData },
     ]);
 
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const result = commitImport({
       archiveData: vbundle,
       pathResolver: resolver,
@@ -755,6 +752,137 @@ describe("commitImport", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Workspace clearing tests
+// ---------------------------------------------------------------------------
+
+describe("commitImport — workspace clearing", () => {
+  const skillsDir = join(testDir, "skills");
+  const hooksDir = join(testDir, "hooks");
+
+  afterEach(() => {
+    // Restore test fixture files for subsequent tests
+    mkdirSync(testDbDir, { recursive: true });
+    writeFileSync(testDbPath, EXISTING_DB_DATA);
+    writeFileSync(testConfigPath, JSON.stringify(EXISTING_CONFIG, null, 2));
+    // Clean up skills/hooks dirs
+    for (const dir of [skillsDir, hooksDir]) {
+      if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("clears stale files via workspace clearing (new-format workspace/ entries)", () => {
+    mkdirSync(join(skillsDir, "stale-skill"), { recursive: true });
+    writeFileSync(join(skillsDir, "stale-skill", "SKILL.md"), "stale");
+
+    const skillData = new TextEncoder().encode("# New Skill");
+    const vbundle = createValidVBundle([
+      { path: "workspace/skills/new-skill/SKILL.md", data: skillData },
+    ]);
+
+    const resolver = new DefaultPathResolver(undefined, testDir);
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+      workspaceDir: testDir,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    // New skill written
+    expect(existsSync(join(skillsDir, "new-skill", "SKILL.md"))).toBe(true);
+    expect(readFileSync(join(skillsDir, "new-skill", "SKILL.md"), "utf8")).toBe(
+      "# New Skill",
+    );
+
+    // Stale skill removed by workspace clearing
+    expect(existsSync(join(skillsDir, "stale-skill"))).toBe(false);
+  });
+
+  test("old-format skills/ entries do not trigger workspace clearing", () => {
+    mkdirSync(join(skillsDir, "stale-skill"), { recursive: true });
+    writeFileSync(join(skillsDir, "stale-skill", "SKILL.md"), "stale");
+
+    const skillData = new TextEncoder().encode("# New Skill");
+    const vbundle = createValidVBundle([
+      { path: "skills/new-skill/SKILL.md", data: skillData },
+    ]);
+
+    const resolver = new DefaultPathResolver(undefined, testDir);
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+      workspaceDir: testDir,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    // New skill written
+    expect(existsSync(join(skillsDir, "new-skill", "SKILL.md"))).toBe(true);
+
+    // Stale skill survives — old-format bundles don't trigger workspace clearing
+    expect(existsSync(join(skillsDir, "stale-skill", "SKILL.md"))).toBe(true);
+  });
+
+  test("hooks/ entries import to hooksDir (not workspace/hooks/)", () => {
+    // Use a separate hooks dir outside the workspace, like production layout
+    const externalHooksDir = join(testDir, ".hooks-external");
+    mkdirSync(externalHooksDir, { recursive: true });
+
+    const hookData = new TextEncoder().encode("#!/bin/sh\necho new");
+    const vbundle = createValidVBundle([
+      { path: "hooks/new-hook/hook.sh", data: hookData },
+    ]);
+
+    const resolver = new DefaultPathResolver(undefined, testDir, externalHooksDir);
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+      workspaceDir: testDir,
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    // Hook written to the external hooks dir, not workspace/hooks/
+    expect(existsSync(join(externalHooksDir, "new-hook", "hook.sh"))).toBe(true);
+    expect(
+      readFileSync(join(externalHooksDir, "new-hook", "hook.sh"), "utf8"),
+    ).toBe("#!/bin/sh\necho new");
+
+    // Cleanup
+    rmSync(externalHooksDir, { recursive: true, force: true });
+  });
+
+  test("without workspaceDir, no clearing happens", () => {
+    mkdirSync(join(skillsDir, "existing-skill"), { recursive: true });
+    writeFileSync(
+      join(skillsDir, "existing-skill", "SKILL.md"),
+      "should survive",
+    );
+
+    const vbundle = createValidVBundle([
+      { path: "skills/new-skill/SKILL.md", data: new TextEncoder().encode("new") },
+    ]);
+
+    const resolver = new DefaultPathResolver(undefined, testDir);
+    // No workspaceDir — no clearing
+    const result = commitImport({
+      archiveData: vbundle,
+      pathResolver: resolver,
+    });
+
+    expect(result.ok).toBe(true);
+
+    // Existing skill survives (no workspace clearing without workspaceDir)
+    expect(existsSync(join(skillsDir, "existing-skill", "SKILL.md"))).toBe(
+      true,
+    );
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Auth policy registration tests
 // ---------------------------------------------------------------------------

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -34,13 +34,14 @@ function toArrayBuffer(data: Uint8Array): ArrayBuffer {
 const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "migration-import-preflight-http-test-")),
 );
-const testDbDir = join(testDir, "db");
+const testDbDir = join(testDir, "data", "db");
 const testDbPath = join(testDbDir, "assistant.db");
 const testConfigPath = join(testDir, "config.json");
 
 mock.module("../util/platform.js", () => ({
   getRootDir: () => testDir,
-  getDataDir: () => testDir,
+  getDataDir: () => join(testDir, "data"),
+  getWorkspaceDir: () => testDir,
   getWorkspaceConfigPath: () => testConfigPath,
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
@@ -64,9 +65,8 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
-    sandbox: { enabled: false },
   }),
 }));
 
@@ -525,8 +525,8 @@ describe("handleMigrationImportPreflight — validation failures", () => {
 describe("analyzeImport", () => {
   test("detects create when file does not exist on disk", () => {
     const resolver = new DefaultPathResolver(
-      join(testDir, "nonexistent.db"),
-      join(testDir, "nonexistent-config.json"),
+      undefined,
+      join(testDir, "nonexistent-workspace"),
     );
 
     const report = analyzeImport({
@@ -553,7 +553,7 @@ describe("analyzeImport", () => {
   });
 
   test("detects unchanged when file on disk matches bundle", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
 
     const report = analyzeImport({
       manifest: {
@@ -577,7 +577,7 @@ describe("analyzeImport", () => {
   });
 
   test("detects overwrite when file on disk differs from bundle", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
 
     const report = analyzeImport({
       manifest: {
@@ -602,7 +602,7 @@ describe("analyzeImport", () => {
   });
 
   test("flags unknown archive paths as conflicts with skip action", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
 
     const report = analyzeImport({
       manifest: {
@@ -640,7 +640,7 @@ describe("analyzeImport", () => {
   });
 
   test("includes manifest in report", () => {
-    const resolver = new DefaultPathResolver(testDbPath, testConfigPath);
+    const resolver = new DefaultPathResolver(undefined, testDir);
     const manifest = {
       schema_version: "1.0",
       created_at: "2024-01-01T00:00:00.000Z",
@@ -668,29 +668,90 @@ describe("analyzeImport", () => {
 // ---------------------------------------------------------------------------
 
 describe("DefaultPathResolver", () => {
-  test("resolves data/db/assistant.db to configured db path", () => {
+  test("resolves data/db/assistant.db to workspace db path (backward compat)", () => {
     const resolver = new DefaultPathResolver(
-      "/some/db.db",
-      "/some/config.json",
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("data/db/assistant.db")).toBe(
+      "/home/user/.vellum/workspace/data/db/assistant.db",
     );
-    expect(resolver.resolve("data/db/assistant.db")).toBe("/some/db.db");
   });
 
-  test("resolves config/settings.json to configured config path", () => {
+  test("resolves config/settings.json to workspace config path (backward compat)", () => {
     const resolver = new DefaultPathResolver(
-      "/some/db.db",
-      "/some/config.json",
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("config/settings.json")).toBe(
+      "/home/user/.vellum/workspace/config.json",
     );
-    expect(resolver.resolve("config/settings.json")).toBe("/some/config.json");
   });
 
   test("returns null for unknown paths", () => {
     const resolver = new DefaultPathResolver(
-      "/some/db.db",
-      "/some/config.json",
+      undefined,
+      "/home/user/.vellum/workspace",
     );
     expect(resolver.resolve("unknown/path.txt")).toBeNull();
   });
+
+  test("resolves valid skills path via backward compat", () => {
+    const resolver = new DefaultPathResolver(
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("skills/my-skill/SKILL.md")).toBe(
+      "/home/user/.vellum/workspace/skills/my-skill/SKILL.md",
+    );
+  });
+
+  test("resolves workspace/ prefix paths", () => {
+    const resolver = new DefaultPathResolver(
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("workspace/data/db/assistant.db")).toBe(
+      "/home/user/.vellum/workspace/data/db/assistant.db",
+    );
+    expect(resolver.resolve("workspace/config.json")).toBe(
+      "/home/user/.vellum/workspace/config.json",
+    );
+    expect(resolver.resolve("workspace/skills/my-skill/SKILL.md")).toBe(
+      "/home/user/.vellum/workspace/skills/my-skill/SKILL.md",
+    );
+  });
+
+  test("returns null for workspace/ path traversal attempt", () => {
+    const resolver = new DefaultPathResolver(
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("workspace/../../etc/passwd")).toBeNull();
+  });
+
+  test("returns null for skills path traversal attempt (../../etc/passwd)", () => {
+    const resolver = new DefaultPathResolver(
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(resolver.resolve("skills/../../etc/passwd")).toBeNull();
+  });
+
+  test("returns null for skills path traversal attempt (../../../.ssh/authorized_keys)", () => {
+    const resolver = new DefaultPathResolver(
+      undefined,
+      "/home/user/.vellum/workspace",
+    );
+    expect(
+      resolver.resolve("skills/../../../.ssh/authorized_keys"),
+    ).toBeNull();
+  });
+
+  test("returns null for skills paths when workspaceDir is not provided", () => {
+    const resolver = new DefaultPathResolver();
+    expect(resolver.resolve("skills/my-skill/SKILL.md")).toBeNull();
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/migration-validate-http.test.ts

@@ -53,9 +53,8 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
-    sandbox: { enabled: false },
   }),
 }));
 
@@ -307,26 +306,27 @@ describe("validateVBundle", () => {
     expect(manifestError).toBeDefined();
   });
 
-  test("missing data/db/assistant.db returns MISSING_ENTRY error", () => {
-    const manifestData = new TextEncoder().encode(
-      JSON.stringify({
-        schema_version: "1.0",
-        created_at: new Date().toISOString(),
-        files: [],
-        manifest_sha256: "placeholder",
-      }),
-    );
+  test("bundle with only manifest (no data files) is structurally valid", () => {
+    // After the workspace walk refactor, only manifest.json is required.
+    // But the manifest checksum must match for full validity.
+    const manifestWithoutChecksum = {
+      schema_version: "1.0",
+      created_at: new Date().toISOString(),
+      files: [],
+    };
+    const manifestSha256 = sha256Hex(canonicalizeJson(manifestWithoutChecksum));
+    const manifest = {
+      ...manifestWithoutChecksum,
+      manifest_sha256: manifestSha256,
+    };
+    const manifestData = new TextEncoder().encode(JSON.stringify(manifest));
     const tar = createTarArchive([
       { name: "manifest.json", data: manifestData },
     ]);
     const vbundle = gzipSync(tar);
     const result = validateVBundle(vbundle);
 
-    expect(result.is_valid).toBe(false);
-    const dbError = result.errors.find(
-      (e) => e.code === "MISSING_ENTRY" && e.path === "data/db/assistant.db",
-    );
-    expect(dbError).toBeDefined();
+    expect(result.is_valid).toBe(true);
   });
 
   test("invalid manifest JSON returns INVALID_MANIFEST_JSON error", () => {

package/src/__tests__/model-intents.test.ts

@@ -62,10 +62,10 @@ describe("model intents", () => {
       "claude-opus-4-6",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
-      "claude-sonnet-4-6",
+      "claude-opus-4-6",
     );
     expect(resolveModelIntent("openai", "latency-optimized")).toBe(
-      "gpt-4o-mini",
+      "gpt-5.4-nano",
     );
   });
 

package/src/__tests__/no-domain-routing-in-prompt-guard.test.ts

@@ -5,7 +5,7 @@ import { describe, expect, test } from "bun:test";
 /**
  * Guard test: domain-specific routing sections must NOT appear in the system
  * prompt source file. Routing cues now live in skill frontmatter
- * (`activation-hints` / `avoid-when`) and are projected into `<available_skills>` XML.
+ * (`activation-hints` / `avoid-when`) and are projected into the skills catalog.
  *
  * If this test fails, you are re-introducing hardcoded routing into the system
  * prompt. Instead, add `activation-hints` to the skill's SKILL.md frontmatter.

package/src/__tests__/non-member-access-request.test.ts

@@ -623,7 +623,7 @@ describe("access-request-helper unit tests", () => {
     expect(telegram!.status).toBe("sent");
   });
 
-  test("notifyGuardianOfAccessRequest records failed vellum fallback when pipeline has no vellum delivery", async () => {
+  test("notifyGuardianOfAccessRequest skips vellum fallback for same-channel-only routing (telegram)", async () => {
     mockEmitResult = {
       signalId: "sig-no-vellum",
       deduplicated: false,
@@ -657,8 +657,8 @@ describe("access-request-helper unit tests", () => {
       (d) => d.destinationChannel === "telegram",
     );
 
-    expect(vellum).toBeDefined();
-    expect(vellum!.status).toBe("failed");
+    // Same-channel routing skips vellum delivery entirely — no fallback record
+    expect(vellum).toBeUndefined();
     expect(telegram).toBeDefined();
     expect(telegram!.destinationChatId).toBe("guardian-chat-456");
     expect(telegram!.status).toBe("sent");

package/src/__tests__/notification-broadcaster.test.ts

@@ -115,7 +115,7 @@ function makeSignal(
     signalId: "sig-broadcast-001",
     createdAt: Date.now(),
     sourceChannel: "scheduler",
-    sourceSessionId: "sess-001",
+    sourceContextId: "sess-001",
     sourceEventName: "test.event",
     contextPayload: {},
     attentionHints: {

package/src/__tests__/notification-decision-fallback.test.ts

@@ -65,7 +65,7 @@ function makeSignal(
     signalId: "sig-fallback-guardian-1",
     createdAt: Date.now(),
     sourceChannel: "phone",
-    sourceSessionId: "call-session-1",
+    sourceContextId: "call-session-1",
     sourceEventName: "guardian.question",
     contextPayload: {
       questionText: "What is the gate code?",
@@ -308,7 +308,7 @@ describe("access-request instruction enforcement", () => {
       signalId: "sig-access-req-1",
       createdAt: Date.now(),
       sourceChannel: "telegram",
-      sourceSessionId: "tg-session-1",
+      sourceContextId: "tg-session-1",
       sourceEventName: "ingress.access_request",
       contextPayload: {
         senderIdentifier: "Alice",

package/src/__tests__/notification-decision-identity.test.ts

@@ -45,7 +45,9 @@ mock.module("../prompts/system-prompt.js", () => ({
 
 // ── Provider mock with system prompt capture ──────────────────────────
 
-let configuredProvider: { sendMessage: (...args: unknown[]) => Promise<unknown> } | null = null;
+let configuredProvider: {
+  sendMessage: (...args: unknown[]) => Promise<unknown>;
+} | null = null;
 let extractedToolUse: unknown = null;
 let capturedSystemPrompt: string | undefined;
 
@@ -81,7 +83,7 @@ function makeSignal(
     signalId: "sig-identity-test-1",
     createdAt: Date.now(),
     sourceChannel: "phone",
-    sourceSessionId: "call-session-1",
+    sourceContextId: "call-session-1",
     sourceEventName: "guardian.question",
     contextPayload: {
       questionText: "What is the gate code?",
@@ -141,9 +143,7 @@ describe("identity context in notification decision engine", () => {
 
     expect(capturedSystemPrompt).toBeDefined();
     expect(capturedSystemPrompt).toContain("<assistant-identity>");
-    expect(capturedSystemPrompt).toContain(
-      "I am Jarvis, a helpful assistant",
-    );
+    expect(capturedSystemPrompt).toContain("I am Jarvis, a helpful assistant");
     expect(capturedSystemPrompt).toContain("</assistant-identity>");
   });
 
@@ -192,10 +192,9 @@ describe("identity context in notification decision engine", () => {
     configuredProvider = null;
 
     const signal = makeSignal();
-    const decision = await evaluateSignal(
-      signal,
-      ["vellum"] as NotificationChannel[],
-    );
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
 
     // Fallback should produce valid copy regardless of identity context
     expect(decision.fallbackUsed).toBe(true);

package/src/__tests__/notification-decision-strategy.test.ts

@@ -38,7 +38,7 @@ function makeSignal(
     signalId: "sig-test-001",
     createdAt: Date.now(),
     sourceChannel: "scheduler",
-    sourceSessionId: "sess-001",
+    sourceContextId: "sess-001",
     sourceEventName: "test.event",
     contextPayload: {},
     attentionHints: {