@desplega.ai/agent-swarm 1.161.0 → 1.162.0

package/src/tests/telemetry-init.test.ts

@@ -78,6 +78,7 @@ describe("initTelemetry", () => {
     expect(writes).toEqual([
       { key: "telemetry_installation_id", value: id as string },
       { key: "telemetry_installed_at", value: installedAt as string },
+      { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
     ]);
   });
 
@@ -96,7 +97,10 @@ describe("initTelemetry", () => {
     const id = _getInstallationIdForTests();
     expect(id).not.toBeNull();
     expect(id).toMatch(/^ephemeral_[0-9a-f]{16}$/);
-    expect(writes).toEqual([]);
+    // Only the org ID is written (the install ID could not be).
+    expect(writes).toEqual([
+      { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
+    ]);
     // Config access is failing — nowhere durable to persist an anchor, so
     // leave it null rather than faking a fresh mint.
     expect(_getInstalledAtForTests()).toBeNull();
@@ -121,7 +125,10 @@ describe("initTelemetry", () => {
       // installed_at failure must not unwind and discard the installationId
       // write that already succeeded.
       expect(id).toMatch(/^install_[0-9a-f]{16}$/);
-      expect(writes).toEqual([{ key: "telemetry_installation_id", value: id as string }]);
+      expect(writes).toEqual([
+        { key: "telemetry_installation_id", value: id as string },
+        { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
+      ]);
       // No fabricated/unpersisted anchor emitted this session.
       expect(_getInstalledAtForTests()).toBeNull();
     });
@@ -141,7 +148,10 @@ describe("initTelemetry", () => {
       // now() as a stand-in install date — that back-fills a wrong date
       // instead of an honestly-absent one. No write, no fabricated anchor.
       expect(_getInstallationIdForTests()).toBe(existing);
-      expect(writes).toEqual([]);
+      // No install-anchor write; the org ID is the only thing minted.
+      expect(writes).toEqual([
+        { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
+      ]);
       expect(_getInstalledAtForTests()).toBeNull();
     });
 
@@ -163,7 +173,9 @@ describe("initTelemetry", () => {
       );
       expect(_getInstallationIdForTests()).toBe(existing);
       expect(_getInstalledAtForTests()).toBe(existingInstalledAt);
-      expect(writes).toEqual([]);
+      expect(writes).toEqual([
+        { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
+      ]);
     });
   });
 
@@ -244,6 +256,7 @@ describe("initTelemetry", () => {
           return undefined;
         },
         async () => {},
+        { generateIfMissing: true },
       );
 
       telemetry.onboarding("step_completed", {
@@ -370,7 +383,9 @@ describe("initTelemetry", () => {
       { generateIfMissing: true },
     );
     expect(_getInstallationIdForTests()).toBe(existing);
-    expect(writesB).toEqual([]);
+    expect(writesB).toEqual([
+      { key: "telemetry_org_id", value: expect.stringMatching(/^org_[0-9a-f]{16}$/) },
+    ]);
   });
 
   describe("_resolveCloudMode (URL → is_cloud)", () => {
@@ -470,8 +485,9 @@ describe("initTelemetry", () => {
       process.env.E2B_SANDBOX_ID = "sbx_test123";
       await initTelemetry(
         "api-server",
-        async () => "install_e2b_test",
+        async (key) => (key === "telemetry_installation_id" ? "install_e2b_test" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "server.started", properties: { port: 3013 } });
@@ -486,8 +502,9 @@ describe("initTelemetry", () => {
       delete process.env.E2B_SANDBOX_ID;
       await initTelemetry(
         "api-server",
-        async () => "install_no_e2b",
+        async (key) => (key === "telemetry_installation_id" ? "install_no_e2b" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -501,8 +518,9 @@ describe("initTelemetry", () => {
       process.env.E2B_SANDBOX_ID = "sbx_override_test";
       await initTelemetry(
         "api-server",
-        async () => "install_e2b_override",
+        async (key) => (key === "telemetry_installation_id" ? "install_e2b_override" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: { is_e2b: false } });
@@ -534,8 +552,9 @@ describe("initTelemetry", () => {
       process.env.MCP_BASE_URL = "https://agent-swarm-mcp.desplega.sh";
       await initTelemetry(
         "worker",
-        async () => "install_cloud_test",
+        async (key) => (key === "telemetry_installation_id" ? "install_cloud_test" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "server.started", properties: { port: 3013 } });
@@ -553,8 +572,9 @@ describe("initTelemetry", () => {
       process.env.MCP_BASE_URL = "http://localhost:3013";
       await initTelemetry(
         "worker",
-        async () => "install_self_test",
+        async (key) => (key === "telemetry_installation_id" ? "install_self_test" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -569,8 +589,9 @@ describe("initTelemetry", () => {
       delete process.env.MCP_BASE_URL;
       await initTelemetry(
         "api-server",
-        async () => "install_no_url",
+        async (key) => (key === "telemetry_installation_id" ? "install_no_url" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -590,8 +611,10 @@ describe("initTelemetry", () => {
       process.env.SWARM_CLOUD = "true";
       await initTelemetry(
         "api-server",
-        async () => "install_hosted_cloud_test",
+        async (key) =>
+          key === "telemetry_installation_id" ? "install_hosted_cloud_test" : undefined,
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "server.started", properties: { port: 3013 } });
@@ -611,8 +634,9 @@ describe("initTelemetry", () => {
       process.env.MCP_BASE_URL = "https://agent-swarm-mcp.desplega.sh";
       await initTelemetry(
         "worker",
-        async () => "install_override_test",
+        async (key) => (key === "telemetry_installation_id" ? "install_override_test" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({
@@ -645,8 +669,9 @@ describe("initTelemetry", () => {
     test("includes the package version on every event and ignores caller overrides", async () => {
       await initTelemetry(
         "worker",
-        async () => "install_version_test",
+        async (key) => (key === "telemetry_installation_id" ? "install_version_test" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: { swarmVersion: "spoofed" } });
@@ -682,8 +707,9 @@ describe("initTelemetry", () => {
       process.env.NODE_ENV = "development";
       await initTelemetry(
         "api-server",
-        async () => "install_default_env",
+        async (key) => (key === "telemetry_installation_id" ? "install_default_env" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -698,8 +724,9 @@ describe("initTelemetry", () => {
       process.env.DESPLEGA_TELEMETRY_ENV = "development";
       await initTelemetry(
         "api-server",
-        async () => "install_explicit_env",
+        async (key) => (key === "telemetry_installation_id" ? "install_explicit_env" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -713,8 +740,9 @@ describe("initTelemetry", () => {
       process.env.NODE_ENV = "test";
       await initTelemetry(
         "api-server",
-        async () => "install_test_env",
+        async (key) => (key === "telemetry_installation_id" ? "install_test_env" : undefined),
         async () => {},
+        { generateIfMissing: true },
       );
 
       track({ event: "test.event", properties: {} });
@@ -915,8 +943,10 @@ describe("initTelemetry", () => {
     test("integration.connected emits only allowlisted provider values", async () => {
       await initTelemetry(
         "api-server",
-        async () => "install_integration_test",
+        async (key) =>
+          key === "telemetry_installation_id" ? "install_integration_test" : undefined,
         async () => {},
+        { generateIfMissing: true },
       );
 
       emitIntegrationConnected("code_repo", "https://github.com/desplega/agent-swarm", true);
@@ -935,8 +965,10 @@ describe("initTelemetry", () => {
     test("integration.connected omits a free-form PII-looking provider", async () => {
       await initTelemetry(
         "api-server",
-        async () => "install_integration_test",
+        async (key) =>
+          key === "telemetry_installation_id" ? "install_integration_test" : undefined,
         async () => {},
+        { generateIfMissing: true },
       );
 
       emitIntegrationConnected("other", "someone@example.com", false);

package/src/tests/telemetry-snapshot.test.ts

@@ -0,0 +1,229 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  getDbClient,
+  initDb,
+} from "../be/db";
+import { attachRole, detachRole } from "../be/rbac-roles";
+import { linkIdentity, mintToken, revokeToken } from "../be/users";
+import { _resetTelemetryStateForTests, initTelemetry } from "../telemetry";
+import { collectOrgSnapshot, emitOrgSnapshotIfDue, LAST_SNAPSHOT_KEY } from "../telemetry-snapshot";
+
+// initTelemetry no-ops when ANONYMIZED_TELEMETRY=false, and the CI env may set it.
+process.env.ANONYMIZED_TELEMETRY = "true";
+
+const TEST_DB_PATH = "./test-telemetry-snapshot.sqlite";
+const ACTOR = { kind: "system", id: "telemetry-snapshot-test" } as const;
+const DAY_MS = 24 * 60 * 60_000;
+
+async function removeTestDb(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File does not exist.
+    }
+  }
+}
+
+function memoryConfig(initial: Record<string, string> = {}) {
+  const store = new Map(Object.entries(initial));
+  return {
+    store,
+    get: async (key: string) => store.get(key),
+    set: async (key: string, value: string) => {
+      store.set(key, value);
+    },
+  };
+}
+
+/** Fixture: 3 active users, 1 suspended, 1 invited, 2 agents. */
+async function seedFixture() {
+  const admin = await createUser({ name: "Admin Person", email: "admin.person@corp.example" });
+  const tokenUser = await createUser({ name: "Token Person" });
+  const revokedUser = await createUser({ name: "Revoked Person" });
+  const suspended = await createUser({
+    name: "Suspended Person",
+    email: "suspended@corp.example",
+    status: "suspended",
+  });
+  const invited = await createUser({ name: "Invited Person", status: "invited" });
+  for (const user of [tokenUser, revokedUser, suspended, invited]) {
+    await detachRole(user.id, "admin");
+    await attachRole(user.id, "requester");
+  }
+
+  await mintToken(tokenUser.id, "live", ACTOR);
+  const revoked = await mintToken(revokedUser.id, "revoked", ACTOR);
+  const revokedRow = await getDbClient().get<{ id: string }>(
+    "SELECT id FROM user_tokens WHERE userId = ?",
+    [revokedUser.id],
+  );
+  await revokeToken(revokedRow?.id ?? revoked.tokenId, ACTOR);
+
+  await linkIdentity(admin.id, "slack", "U-ADMIN", ACTOR);
+  await linkIdentity(admin.id, "github", "admin-gh", ACTOR);
+  await linkIdentity(tokenUser.id, "composio", "c-1", ACTOR);
+  await linkIdentity(tokenUser.id, "kapso", "k-1", ACTOR);
+  await linkIdentity(revokedUser.id, "jira", "j-1", ACTOR);
+  await linkIdentity(revokedUser.id, "linear", "l-1", ACTOR);
+  await linkIdentity(revokedUser.id, "gitlab", "g-1", ACTOR);
+  // A suspended user's links and an invited user's links do not count.
+  await linkIdentity(suspended.id, "slack", "U-SUSPENDED", ACTOR);
+
+  await createAgent({
+    id: "aaaa0000-0000-4000-8000-0000000000a1",
+    name: "A1",
+    isLead: true,
+    status: "idle",
+  });
+  await createAgent({
+    id: "bbbb0000-0000-4000-8000-0000000000b1",
+    name: "B1",
+    isLead: false,
+    status: "idle",
+  });
+
+  // Two recent tasks by one user, one recent by another, one old by a third.
+  const recentA = await createTaskExtended("recent a", { requestedByUserId: admin.id });
+  await createTaskExtended("recent a again", { requestedByUserId: admin.id });
+  await createTaskExtended("recent b", { requestedByUserId: revokedUser.id });
+  const old = await createTaskExtended("old", { requestedByUserId: tokenUser.id });
+  await getDbClient().run("UPDATE agent_tasks SET createdAt = ? WHERE id = ?", [
+    new Date(Date.now() - 10 * DAY_MS).toISOString(),
+    old.id,
+  ]);
+  expect(recentA.id).toBeTruthy();
+  return { admin, tokenUser, revokedUser, suspended, invited };
+}
+
+describe("org snapshot", () => {
+  const originalFetch = globalThis.fetch;
+  let sent: Array<{ event: string; properties: Record<string, unknown> }>;
+
+  beforeEach(async () => {
+    closeDb();
+    await removeTestDb();
+    initDb(TEST_DB_PATH);
+    _resetTelemetryStateForTests();
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    sent = [];
+    globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+      if (init?.body) sent.push(JSON.parse(init.body));
+      return new Response(null, { status: 204 });
+    }) as typeof fetch;
+  });
+
+  afterEach(async () => {
+    globalThis.fetch = originalFetch;
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    _resetTelemetryStateForTests();
+    closeDb();
+    await removeTestDb();
+  });
+
+  async function boot(config = memoryConfig({ telemetry_installation_id: "install_snapshot" })) {
+    await initTelemetry("api-server", config.get, config.set, { generateIfMissing: true });
+    return config;
+  }
+
+  const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+  test("counts match the fixture rows", async () => {
+    await seedFixture();
+    expect(await collectOrgSnapshot()).toEqual({
+      users_total: 3,
+      users_suspended: 1,
+      users_admin: 1,
+      users_with_login: 2, // the admin's email and the live token; the revoked one has neither
+      users_linked_slack: 1,
+      users_linked_github: 1,
+      users_linked_gitlab: 1,
+      users_linked_linear: 1,
+      users_linked_jira: 1,
+      users_linked_other: 1, // composio + kapso on one user count once
+      users_active_7d: 2,
+      agents_total: 2,
+    });
+  });
+
+  test("an empty install snapshots all zeros", async () => {
+    const snapshot = await collectOrgSnapshot();
+    expect(Object.values(snapshot).every((n) => n === 0)).toBe(true);
+  });
+
+  test("the payload has no @, no email local part, no name and no raw user ID", async () => {
+    const { admin, tokenUser } = await seedFixture();
+    const config = await boot();
+    expect(await emitOrgSnapshotIfDue({ getConfig: config.get, setConfig: config.set })).toBe(true);
+    await tick();
+
+    // Seeding fires task events after boot; only the snapshot is under test.
+    const snapshots = sent.filter((e) => e.event === "org.snapshot");
+    expect(snapshots).toHaveLength(1);
+    expect(snapshots[0]?.properties).toMatchObject({ users_total: 3, agents_total: 2 });
+    const text = JSON.stringify(snapshots[0]);
+    expect(text).not.toContain("@");
+    for (const secret of [admin.id, tokenUser.id, "admin.person", "Admin Person", "corp.example"]) {
+      expect(text).not.toContain(secret);
+    }
+  });
+
+  test("one send per 24 hours, across a simulated restart", async () => {
+    await seedFixture();
+    const config = await boot();
+    const t0 = Date.parse("2026-10-01T00:00:00.000Z");
+    const deps = (now: number) => ({
+      getConfig: config.get,
+      setConfig: config.set,
+      now: () => now,
+    });
+
+    expect(await emitOrgSnapshotIfDue(deps(t0))).toBe(true);
+    expect(config.store.get(LAST_SNAPSHOT_KEY)).toBe(new Date(t0).toISOString());
+    expect(await emitOrgSnapshotIfDue(deps(t0 + 60_000))).toBe(false);
+
+    // Restart: module state is gone, the stored timestamp is what remains.
+    _resetTelemetryStateForTests();
+    await boot(config);
+    expect(await emitOrgSnapshotIfDue(deps(t0 + DAY_MS - 60_000))).toBe(false);
+    expect(await emitOrgSnapshotIfDue(deps(t0 + DAY_MS + 60_000))).toBe(true);
+    await tick();
+    expect(sent.filter((e) => e.event === "org.snapshot")).toHaveLength(2);
+  });
+
+  test("two overlapping ticks send once", async () => {
+    await seedFixture();
+    const config = await boot();
+    const deps = { getConfig: config.get, setConfig: config.set };
+    const [a, b] = await Promise.all([emitOrgSnapshotIfDue(deps), emitOrgSnapshotIfDue(deps)]);
+    await tick();
+    expect([a, b]).toEqual([true, true]); // both callers share the one in-flight send
+    expect(sent.filter((e) => e.event === "org.snapshot")).toHaveLength(1);
+  });
+
+  test("nothing is sent or recorded when opted out", async () => {
+    await seedFixture();
+    process.env.ANONYMIZED_TELEMETRY = "false";
+    const config = await boot(memoryConfig());
+    expect(await emitOrgSnapshotIfDue({ getConfig: config.get, setConfig: config.set })).toBe(
+      false,
+    );
+    await tick();
+    expect(sent).toEqual([]);
+    expect(config.store.has(LAST_SNAPSHOT_KEY)).toBe(false);
+  });
+
+  test("nothing is sent or recorded before telemetry has an identity, so the next tick retries", async () => {
+    await seedFixture();
+    const config = memoryConfig(); // never booted: no install ID, no org ID
+    expect(await emitOrgSnapshotIfDue({ getConfig: config.get, setConfig: config.set })).toBe(
+      false,
+    );
+    expect(config.store.has(LAST_SNAPSHOT_KEY)).toBe(false);
+  });
+});

package/src/tests/telemetry-trigger.test.ts

@@ -0,0 +1,200 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  failTask,
+  getDbClient,
+  initDb,
+  updateAgentProfile,
+} from "../be/db";
+import { checkHeartbeatChecklist, createBootTriageTask } from "../heartbeat/heartbeat";
+// Side-effect import: the checklist and boot-triage prompts come from the heartbeat templates.
+import "../heartbeat/templates";
+import { telemetry } from "../telemetry";
+import { _resetTriggerSurfaceCacheForTests, resolveTriggerSurface } from "../telemetry-trigger";
+
+// initTelemetry is not called here, but emitTaskTelemetry checks the opt-out
+// env first, and the CI env may set it.
+process.env.ANONYMIZED_TELEMETRY = "true";
+
+const TEST_DB_PATH = "./test-telemetry-trigger.sqlite";
+const WORKER_ID = "bbbb0000-0000-4000-8000-000000000003";
+const LEAD_ID = "aaaa0000-0000-4000-8000-000000000003";
+
+async function removeTestDb(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File does not exist.
+    }
+  }
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 8; i++) await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+type Call = { event: string; props: Record<string, unknown> };
+
+describe("trigger_surface on task telemetry", () => {
+  let spy: ReturnType<typeof spyOn>;
+  let calls: Call[];
+
+  const forTask = (taskId: string, event: string) =>
+    calls.find((c) => c.props.taskId === taskId && c.event === event);
+
+  beforeEach(async () => {
+    closeDb();
+    await removeTestDb();
+    initDb(TEST_DB_PATH);
+    _resetTriggerSurfaceCacheForTests();
+    await createAgent({ id: WORKER_ID, name: "Trigger Worker", isLead: false, status: "idle" });
+    await createAgent({ id: LEAD_ID, name: "Trigger Lead", isLead: true, status: "idle" });
+    calls = [];
+    spy = spyOn(telemetry, "taskEvent").mockImplementation((event, props) => {
+      calls.push({ event, props: props as Record<string, unknown> });
+    });
+  });
+
+  afterEach(async () => {
+    spy.mockRestore();
+    closeDb();
+    await removeTestDb();
+  });
+
+  test("a slack root with an mcp child and a system follow-up reports slack on every created and completed event", async () => {
+    const root = await createTaskExtended("slack ask", { agentId: LEAD_ID, source: "slack" });
+    const child = await createTaskExtended("delegated", {
+      agentId: WORKER_ID,
+      source: "mcp",
+      parentTaskId: root.id,
+    });
+    const followUp = await createTaskExtended("follow-up", {
+      agentId: LEAD_ID,
+      source: "system",
+      parentTaskId: child.id,
+    });
+    await flush();
+    await completeTask(root.id, "done");
+    await completeTask(child.id, "done");
+    await completeTask(followUp.id, "done");
+    await flush();
+
+    const tasks = [
+      { id: root.id, taskSource: "slack" },
+      { id: child.id, taskSource: "mcp" },
+      { id: followUp.id, taskSource: "system" },
+    ];
+    for (const { id, taskSource } of tasks) {
+      for (const event of ["created", "completed"]) {
+        const call = forTask(id, event);
+        expect(call?.props.trigger_surface).toBe("slack");
+        expect(call?.props.task_source).toBe(taskSource);
+      }
+    }
+  });
+
+  test("a failed child reports its root's surface", async () => {
+    const root = await createTaskExtended("linear ask", { agentId: LEAD_ID, source: "linear" });
+    const child = await createTaskExtended("delegated", {
+      agentId: WORKER_ID,
+      source: "mcp",
+      parentTaskId: root.id,
+    });
+    await flush();
+    await failTask(child.id, "nope");
+    await flush();
+
+    const failed = forTask(child.id, "failed");
+    expect(failed?.props.trigger_surface).toBe("linear");
+    expect(failed?.props.task_source).toBe("mcp");
+  });
+
+  test("no task event carries a source property", async () => {
+    const root = await createTaskExtended("api ask", { agentId: LEAD_ID, source: "api" });
+    await flush();
+    await completeTask(root.id, "done");
+    await flush();
+    expect(calls.length).toBeGreaterThan(0);
+    for (const call of calls) expect("source" in call.props).toBe(false);
+  });
+
+  // The two heartbeat creators default to source "mcp" when they omit `source`,
+  // so each one is run for real and judged on the row it persists and the
+  // task.created event it emits.
+  const heartbeatCreators: Array<{ taskType: string; create: () => Promise<void> }> = [
+    { taskType: "boot-triage", create: createBootTriageTask },
+    {
+      taskType: "heartbeat-checklist",
+      create: async () => {
+        await updateAgentProfile(LEAD_ID, { heartbeatMd: "- Check for stuck tasks\n" });
+        await checkHeartbeatChecklist();
+      },
+    },
+  ];
+
+  for (const { taskType, create } of heartbeatCreators) {
+    test(`a ${taskType} task reports system, not mcp`, async () => {
+      await create();
+      await flush();
+
+      const row = await getDbClient().get<{ id: string; source: string }>(
+        "SELECT id, source FROM agent_tasks WHERE taskType = ?",
+        [taskType],
+      );
+      // The row says system too, so the dashboard UI stops calling it mcp.
+      expect(row?.source).toBe("system");
+
+      const created = forTask(row?.id as string, "created");
+      expect(created?.props.trigger_surface).toBe("system");
+      expect(created?.props.task_source).toBe("system");
+    });
+  }
+
+  test("an orphan (parent row deleted) uses the deepest row that still exists", async () => {
+    const root = await createTaskExtended("root", { agentId: LEAD_ID, source: "github" });
+    const child = await createTaskExtended("child", {
+      agentId: WORKER_ID,
+      source: "mcp",
+      parentTaskId: root.id,
+    });
+    _resetTriggerSurfaceCacheForTests();
+    await getDbClient().run("PRAGMA foreign_keys = OFF");
+    await getDbClient().run("DELETE FROM agent_tasks WHERE id = ?", [root.id]);
+    expect(await resolveTriggerSurface(child.id)).toBe("mcp");
+  });
+
+  test("a task that no longer exists falls back to the caller's source, uncached", async () => {
+    expect(await resolveTriggerSurface("missing-task", "schedule")).toBe("schedule");
+    expect(await resolveTriggerSurface("missing-task", "weird")).toBe("other");
+  });
+
+  test("the root surface is memoized, because a task's root is fixed at creation", async () => {
+    const root = await createTaskExtended("root", { agentId: LEAD_ID, source: "jira" });
+    expect(await resolveTriggerSurface(root.id)).toBe("jira");
+    await getDbClient().run("PRAGMA foreign_keys = OFF");
+    await getDbClient().run("DELETE FROM agent_tasks WHERE id = ?", [root.id]);
+    expect(await resolveTriggerSurface(root.id)).toBe("jira");
+  });
+
+  test("a chain deeper than the cap stops at the cap instead of looping", async () => {
+    // 60 tasks in a line, inserted as raw rows to avoid 60 full createTask calls.
+    const ids = Array.from({ length: 60 }, (_, i) => `chain-${String(i).padStart(2, "0")}`);
+    await getDbClient().run("PRAGMA foreign_keys = OFF");
+    for (const [i, id] of ids.entries()) {
+      await getDbClient().run(
+        `INSERT INTO agent_tasks (id, task, status, source, parentTaskId, createdAt, lastUpdatedAt)
+         VALUES (?, 'x', 'pending', ?, ?, datetime('now'), datetime('now'))`,
+        [id, i === 0 ? "slack" : "mcp", i === 0 ? null : ids[i - 1]],
+      );
+    }
+    // Depth 50 above the tail is chain-09, an mcp task: the walk stopped at the cap.
+    expect(await resolveTriggerSurface("chain-59")).toBe("mcp");
+    // A chain inside the cap reaches the slack root.
+    expect(await resolveTriggerSurface("chain-40")).toBe("slack");
+  });
+});

package/src/tests/template-registry-helpers.ts

@@ -17,6 +17,7 @@
 export async function restoreAllTemplateDefinitions(): Promise<void> {
   const ts = Date.now();
   await import(`../agentmail/templates?t=${ts}`);
+  await import(`../comb/templates?t=${ts}`);
   await import(`../commands/templates?t=${ts}`);
   await import(`../github/templates?t=${ts}`);
   await import(`../gitlab/templates?t=${ts}`);