@desplega.ai/agent-swarm 1.86.0 → 1.87.0

package/src/tests/task-supersede-resume.test.ts

@@ -0,0 +1,722 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  cancelTask,
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  failTask,
+  getDb,
+  getLogsByTaskId,
+  getTaskById,
+  initDb,
+  startTask,
+  supersedeTask,
+  updateAgentStatus,
+} from "../be/db";
+import {
+  createTrackerSync,
+  getTrackerSync,
+  getTrackerSyncByExternalId,
+} from "../be/db-queries/tracker";
+import { buildResumeContextPreamble } from "../commands/context-preamble";
+import { createResumeFollowUp } from "../tasks/worker-follow-up";
+
+const TEST_DB_PATH = "./test-task-supersede-resume.sqlite";
+
+async function cleanup() {
+  try {
+    await unlink(TEST_DB_PATH);
+    await unlink(`${TEST_DB_PATH}-wal`);
+    await unlink(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+}
+
+function freshAgent(prefix: string, opts?: { maxTasks?: number; lastActivityAt?: string }) {
+  const id = `${prefix}-${crypto.randomUUID().slice(0, 8)}`;
+  const agent = createAgent({
+    id,
+    name: prefix,
+    isLead: false,
+    status: "idle",
+  });
+  if (opts?.maxTasks !== undefined || opts?.lastActivityAt) {
+    getDb().run(
+      "UPDATE agents SET maxTasks = COALESCE(?, maxTasks), lastActivityAt = COALESCE(?, lastActivityAt) WHERE id = ?",
+      [opts.maxTasks ?? null, opts.lastActivityAt ?? null, id],
+    );
+  }
+  return agent;
+}
+
+describe("Task Supersede + Resume", () => {
+  beforeAll(async () => {
+    await cleanup();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await cleanup();
+  });
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // 1. supersedeTask() status transition + terminal guards
+  // ──────────────────────────────────────────────────────────────────────────
+
+  describe("supersedeTask()", () => {
+    test("transitions in_progress → superseded and sets finishedAt", () => {
+      const worker = freshAgent("worker-1");
+      const task = createTaskExtended("Test supersede transition", {
+        agentId: worker.id,
+      });
+      startTask(task.id);
+      const inProgress = getTaskById(task.id);
+      expect(inProgress?.status).toBe("in_progress");
+
+      const result = supersedeTask(task.id, {
+        reason: "graceful_shutdown",
+        resumeTaskId: null,
+      });
+      expect(result?.status).toBe("superseded");
+      expect(result?.finishedAt).toBeTruthy();
+
+      const log = getLogsByTaskId(task.id).find((l) => l.eventType === "task_superseded");
+      expect(log).toBeTruthy();
+    });
+
+    test("idempotent — second supersede returns null (alreadyFinished shape)", () => {
+      const worker = freshAgent("worker-1b");
+      const task = createTaskExtended("Idempotent supersede", { agentId: worker.id });
+      startTask(task.id);
+      const first = supersedeTask(task.id, { reason: "graceful_shutdown", resumeTaskId: null });
+      expect(first?.status).toBe("superseded");
+
+      const second = supersedeTask(task.id, {
+        reason: "graceful_shutdown",
+        resumeTaskId: null,
+      });
+      expect(second).toBeNull();
+    });
+
+    test("completeTask on a superseded task short-circuits", () => {
+      const worker = freshAgent("worker-2");
+      const task = createTaskExtended("Complete after supersede", { agentId: worker.id });
+      startTask(task.id);
+      supersedeTask(task.id, { reason: "graceful_shutdown", resumeTaskId: null });
+      const result = completeTask(task.id, "should not happen");
+      expect(result).toBeNull();
+      expect(getTaskById(task.id)?.status).toBe("superseded");
+    });
+
+    test("failTask on a superseded task short-circuits", () => {
+      const worker = freshAgent("worker-3");
+      const task = createTaskExtended("Fail after supersede", { agentId: worker.id });
+      startTask(task.id);
+      supersedeTask(task.id, { reason: "graceful_shutdown", resumeTaskId: null });
+      const result = failTask(task.id, "should not happen");
+      expect(result).toBeNull();
+      expect(getTaskById(task.id)?.status).toBe("superseded");
+    });
+
+    test("cancelTask on a superseded task short-circuits", () => {
+      const worker = freshAgent("worker-4");
+      const task = createTaskExtended("Cancel after supersede", { agentId: worker.id });
+      startTask(task.id);
+      supersedeTask(task.id, { reason: "graceful_shutdown", resumeTaskId: null });
+      const result = cancelTask(task.id, "should not happen");
+      expect(result).toBeNull();
+      expect(getTaskById(task.id)?.status).toBe("superseded");
+    });
+
+    test("supersede on already completed task returns null", () => {
+      const worker = freshAgent("worker-5");
+      const task = createTaskExtended("Complete then supersede", { agentId: worker.id });
+      startTask(task.id);
+      completeTask(task.id, "done");
+      const result = supersedeTask(task.id, {
+        reason: "graceful_shutdown",
+        resumeTaskId: null,
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // 2. createResumeFollowUp()
+  // ──────────────────────────────────────────────────────────────────────────
+
+  describe("createResumeFollowUp()", () => {
+    test("non-workflow parent → creates resume task with inherited fields", () => {
+      const worker = freshAgent("worker-6", { lastActivityAt: new Date().toISOString() });
+      const parent = createTaskExtended("Parent with model+dir+vcs", {
+        agentId: worker.id,
+        model: "openrouter/openai/gpt-5-nano",
+        dir: "/workspace/project-x",
+        vcsRepo: "owner/repo",
+        vcsProvider: "github",
+      });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      expect(result.kind).toBe("created");
+      if (result.kind !== "created") return;
+
+      const child = result.task;
+      expect(child.taskType).toBe("resume");
+      expect(child.parentTaskId).toBe(parent.id);
+      // `model` is DELIBERATELY NOT inherited: a resume task may be claimed by a
+      // different-provider worker, so it must resolve to the claiming agent's
+      // own model at session-init rather than the parent's concrete string.
+      expect(child.model).toBeUndefined();
+      expect(child.dir).toBe("/workspace/project-x");
+      expect(child.vcsRepo).toBe("owner/repo");
+      expect(child.vcsProvider).toBe("github");
+      expect(child.tags).toContain("auto-resume");
+      expect(child.tags).toContain("reason:graceful_shutdown");
+      expect(child.priority).toBeGreaterThanOrEqual(parent.priority);
+    });
+
+    // Guard at the single-source-of-truth level: any child created via
+    // `parentTaskId` must NOT inherit the parent's concrete `model`, but MUST
+    // still inherit other identity-shaped fields (dir, VCS). This is the
+    // consolidated fix covering resume tasks, completion/review follow-ups, and
+    // re-dispatches — a derived task on a different-provider agent would
+    // otherwise die at session-init with a model-incompatibility error.
+    test("createTaskExtended(parentTaskId) does NOT inherit model but DOES inherit dir/vcs", () => {
+      const parent = createTaskExtended("Parent pinned to a provider-specific model", {
+        agentId: freshAgent("worker-model-guard").id,
+        model: "claude-opus-4-8",
+        dir: "/workspace/project-y",
+        vcsRepo: "owner/repo2",
+        vcsProvider: "github",
+      });
+
+      const child = createTaskExtended("Derived task", {
+        source: "system",
+        taskType: "follow-up",
+        parentTaskId: parent.id,
+      });
+
+      // model NOT inherited → resolves to the assignee agent's own model
+      expect(child.model).toBeUndefined();
+      // other identity-shaped fields STILL inherit
+      expect(child.dir).toBe("/workspace/project-y");
+      expect(child.vcsRepo).toBe("owner/repo2");
+      expect(child.vcsProvider).toBe("github");
+
+      // An explicit model on the child is still honored (same-provider creator
+      // deliberately pinning a model is unaffected by the inheritance carve-out).
+      const explicitChild = createTaskExtended("Derived with explicit model", {
+        source: "system",
+        taskType: "follow-up",
+        parentTaskId: parent.id,
+        model: "sonnet",
+      });
+      expect(explicitChild.model).toBe("sonnet");
+    });
+
+    test("non-workflow parent with outputSchema → schema carries forward to resume child", () => {
+      const worker = freshAgent("worker-6-schema", {
+        lastActivityAt: new Date().toISOString(),
+      });
+      const schema = {
+        type: "object",
+        properties: {
+          status: { type: "string", enum: ["ok", "fail"] },
+          report: { type: "string" },
+        },
+        required: ["status"],
+      };
+      const parent = createTaskExtended("Parent with outputSchema", {
+        agentId: worker.id,
+        outputSchema: schema,
+      });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      expect(result.kind).toBe("created");
+      if (result.kind !== "created") return;
+
+      // outputSchema must be preserved so `store-progress` still validates
+      // completion output and the runner still injects structured-output
+      // instructions (PR #594 review feedback).
+      expect(result.task.outputSchema).toEqual(schema);
+    });
+
+    test("non-workflow parent with full VCS identity → all VCS fields carry forward", () => {
+      // PR #594 review: codex flagged that `vcsNumber` (+ url/comment/installation/etc.)
+      // were dropped on resume, breaking webhook routing via findTaskByVcs.
+      // The fix lives in `createTaskExtended`'s parent-inheritance block —
+      // this test guards against regression for ALL VCS identity fields at once.
+      const worker = freshAgent("worker-vcs", {
+        lastActivityAt: new Date().toISOString(),
+      });
+      const parent = createTaskExtended("Parent with full VCS context", {
+        agentId: worker.id,
+        vcsProvider: "github",
+        vcsRepo: "desplega-ai/agent-swarm",
+        vcsNumber: 594,
+        vcsEventType: "pull_request.opened",
+        vcsCommentId: 12345,
+        vcsAuthor: "tarasyarema",
+        vcsUrl: "https://github.com/desplega-ai/agent-swarm/pull/594",
+        vcsInstallationId: 999,
+        vcsNodeId: "PR_kwDOQr3Tmc7abcdef",
+      });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "context_limits",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+
+      expect(result.task.vcsProvider).toBe("github");
+      expect(result.task.vcsRepo).toBe("desplega-ai/agent-swarm");
+      expect(result.task.vcsNumber).toBe(594);
+      expect(result.task.vcsEventType).toBe("pull_request.opened");
+      expect(result.task.vcsCommentId).toBe(12345);
+      expect(result.task.vcsAuthor).toBe("tarasyarema");
+      expect(result.task.vcsUrl).toBe("https://github.com/desplega-ai/agent-swarm/pull/594");
+      expect(result.task.vcsInstallationId).toBe(999);
+      expect(result.task.vcsNodeId).toBe("PR_kwDOQr3Tmc7abcdef");
+    });
+
+    test("Linear-backed parent → tracker_sync row repoints to resume child", () => {
+      // PR #594 review: tracker_sync rows stayed keyed to the (now-terminal)
+      // parent after supersede. Linear outbound completion posts look up by
+      // swarmId, so the resume child's completion never made it back; and
+      // subsequent inbound events found the terminal parent in tracker_sync
+      // and created duplicate tasks.
+      const worker = freshAgent("worker-tracker", {
+        lastActivityAt: new Date().toISOString(),
+      });
+      const parent = createTaskExtended("Parent tracked in Linear", {
+        agentId: worker.id,
+      });
+      startTask(parent.id);
+
+      // Simulate the Linear sync row created when the issue was inbound-claimed.
+      createTrackerSync({
+        provider: "linear",
+        entityType: "task",
+        swarmId: parent.id,
+        externalId: "linear-issue-uuid-12345",
+        externalIdentifier: "ENG-42",
+        externalUrl: "https://linear.app/test/issue/ENG-42",
+      });
+
+      // Sanity: tracker_sync starts pointed at the parent.
+      const before = getTrackerSync("linear", "task", parent.id);
+      expect(before).not.toBeNull();
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+
+      // After resume creation, tracker_sync should now key on the resume child.
+      const parentLookup = getTrackerSync("linear", "task", parent.id);
+      expect(parentLookup).toBeNull();
+      const childLookup = getTrackerSync("linear", "task", result.task.id);
+      expect(childLookup).not.toBeNull();
+      // External identity stays — only swarmId moved.
+      const byExternal = getTrackerSyncByExternalId("linear", "task", "linear-issue-uuid-12345");
+      expect(byExternal?.swarmId).toBe(result.task.id);
+      expect(byExternal?.externalIdentifier).toBe("ENG-42");
+    });
+
+    test("Parent with no tracker_sync → resume creation is a no-op on tracker_sync", () => {
+      const worker = freshAgent("worker-no-tracker", {
+        lastActivityAt: new Date().toISOString(),
+      });
+      const parent = createTaskExtended("Parent without tracker", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      // Just assert it doesn't blow up — repoint returns 0 rows and the
+      // resume task still gets created cleanly.
+      expect(result.kind).toBe("created");
+    });
+
+    test("workflow-step parent → returns workflow-skip (no task created)", () => {
+      const worker = freshAgent("worker-7");
+      const parent = createTaskExtended("Workflow-step parent", {
+        agentId: worker.id,
+      });
+      // Backfill workflowRunStepId directly (createTaskExtended doesn't take
+      // it). Temporarily disable FKs since this test exercises only the
+      // supersede carve-out, not the workflow engine itself.
+      const stepId = crypto.randomUUID();
+      getDb().exec("PRAGMA foreign_keys = OFF");
+      try {
+        getDb().run("UPDATE agent_tasks SET workflowRunStepId = ? WHERE id = ?", [
+          stepId,
+          parent.id,
+        ]);
+      } finally {
+        getDb().exec("PRAGMA foreign_keys = ON");
+      }
+      startTask(parent.id);
+
+      const before = getDb()
+        .prepare<{ count: number }, []>(
+          "SELECT COUNT(*) as count FROM agent_tasks WHERE taskType = 'resume'",
+        )
+        .get();
+      const beforeCount = before?.count ?? 0;
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      expect(result.kind).toBe("workflow-skip");
+      if (result.kind === "workflow-skip") {
+        expect(result.stepId).toBe(stepId);
+      }
+
+      const after = getDb()
+        .prepare<{ count: number }, []>(
+          "SELECT COUNT(*) as count FROM agent_tasks WHERE taskType = 'resume'",
+        )
+        .get();
+      const afterCount = after?.count ?? 0;
+      expect(afterCount).toBe(beforeCount);
+    });
+
+    test("routing: graceful_shutdown ALWAYS goes to pool, even on fresh+capable worker (PR #594 review)", () => {
+      // The worker is exiting moments after this check — keeping the resume on
+      // the same agent would orphan it once `closeAgent` runs. graceful_shutdown
+      // must force the unassigned-pool path regardless of liveness.
+      const worker = freshAgent("worker-fresh-shutdown", {
+        maxTasks: 5,
+        lastActivityAt: new Date().toISOString(),
+      });
+      const parent = createTaskExtended("Routing graceful_shutdown", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "graceful_shutdown",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+      expect(result.task.agentId).toBeNull();
+      expect(result.task.status).toBe("unassigned");
+    });
+
+    test("routing: fresh worker + capacity (non-shutdown) → resume pre-assigned to same worker", () => {
+      // For context_limits / manual_supersede the worker is alive and can
+      // continue handling the resume on a fresh session.
+      const worker = freshAgent("worker-fresh", {
+        maxTasks: 5,
+        lastActivityAt: new Date().toISOString(),
+      });
+      const parent = createTaskExtended("Routing fresh", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "context_limits",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+      expect(result.task.agentId).toBe(worker.id);
+      expect(result.task.status).toBe("pending");
+    });
+
+    test("routing: stale heartbeat → unassigned", () => {
+      const worker = freshAgent("worker-stale", {
+        maxTasks: 5,
+        lastActivityAt: new Date(Date.now() - 5 * 60 * 1000).toISOString(),
+      });
+      const parent = createTaskExtended("Routing stale", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "context_limits",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+      expect(result.task.agentId).toBeNull();
+      expect(result.task.status).toBe("unassigned");
+    });
+
+    test("routing: worker at capacity → unassigned", () => {
+      const worker = freshAgent("worker-full", {
+        maxTasks: 1,
+        lastActivityAt: new Date().toISOString(),
+      });
+      // Parent is already in_progress, which counts as 1 in_progress task →
+      // worker has zero remaining capacity (maxTasks=1).
+      const parent = createTaskExtended("Routing capped", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "context_limits",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+      expect(result.task.agentId).toBeNull();
+    });
+
+    test("routing: offline worker → unassigned", () => {
+      const worker = freshAgent("worker-offline", {
+        maxTasks: 5,
+        lastActivityAt: new Date().toISOString(),
+      });
+      updateAgentStatus(worker.id, "offline");
+      const parent = createTaskExtended("Routing offline", { agentId: worker.id });
+      startTask(parent.id);
+
+      const result = createResumeFollowUp({
+        parentId: parent.id,
+        reason: "context_limits",
+      });
+      if (result.kind !== "created") throw new Error("expected created");
+      expect(result.task.agentId).toBeNull();
+    });
+
+    test("missing parent → skipped(parent_not_found)", () => {
+      const result = createResumeFollowUp({
+        parentId: "00000000-0000-0000-0000-000000000000",
+        reason: "graceful_shutdown",
+      });
+      expect(result.kind).toBe("skipped");
+    });
+  });
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // 3. buildResumeContextPreamble()
+  // ──────────────────────────────────────────────────────────────────────────
+
+  describe("buildResumeContextPreamble()", () => {
+    // Spin a tiny HTTP server emulating the two endpoints the preamble fetches.
+    let server: import("node:http").Server | undefined;
+    let baseUrl = "";
+    let testTaskId = "";
+    let testTaskDescription = "";
+    let mockSessionLogs: Array<{ createdAt: string; content: string }> = [];
+
+    beforeAll(async () => {
+      const { createServer } = await import("node:http");
+      testTaskId = crypto.randomUUID();
+      testTaskDescription =
+        "Build a feature that processes user uploads end-to-end. " +
+        "Include validation, virus scan, S3 upload, and a notification.";
+      mockSessionLogs = [];
+
+      server = createServer((req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        const url = req.url ?? "";
+        if (url === `/api/tasks/${testTaskId}`) {
+          res.writeHead(200);
+          res.end(
+            JSON.stringify({
+              id: testTaskId,
+              task: testTaskDescription,
+              attachments: [],
+            }),
+          );
+          return;
+        }
+        if (url === `/api/tasks/${testTaskId}/session-logs`) {
+          res.writeHead(200);
+          res.end(JSON.stringify({ logs: mockSessionLogs }));
+          return;
+        }
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: "not found" }));
+      });
+      const port = 13099;
+      await new Promise<void>((r) => server?.listen(port, () => r()));
+      baseUrl = `http://localhost:${port}`;
+    });
+
+    afterAll(async () => {
+      if (server) {
+        await new Promise<void>((r) => server?.close(() => r()));
+      }
+    });
+
+    test("preserves the full parent task description", async () => {
+      mockSessionLogs = [];
+      const preamble = await buildResumeContextPreamble(baseUrl, "", testTaskId);
+      expect(preamble).toBeTruthy();
+      expect(preamble).toContain(testTaskDescription);
+      expect(preamble).toContain("Resuming Interrupted Task");
+    });
+
+    test("scrubs secret-shaped values from session-log summaries", async () => {
+      // GitHub PAT-shaped token — matches a structural pattern in
+      // scrubSecrets (regardless of env state).
+      const fakeToken = "ghp_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+      mockSessionLogs = [
+        {
+          createdAt: new Date().toISOString(),
+          content: JSON.stringify({
+            type: "tool_use",
+            name: "Bash",
+            input: { command: `curl -H 'Authorization: ${fakeToken}' https://api` },
+          }),
+        },
+      ];
+
+      const preamble = await buildResumeContextPreamble(baseUrl, "", testTaskId);
+      expect(preamble).toBeTruthy();
+      expect(preamble).not.toContain(fakeToken);
+    });
+
+    test("respects the 4000-token (16000-char) cap when over budget", async () => {
+      // Generate a lot of session logs to push past the cap.
+      mockSessionLogs = Array.from({ length: 200 }, (_, i) => ({
+        createdAt: new Date().toISOString(),
+        content: JSON.stringify({
+          type: "tool_use",
+          name: "Read",
+          input: { file_path: `/workspace/src/long-path-${i}/file-${i}.ts` },
+        }),
+      }));
+
+      const preamble = await buildResumeContextPreamble(baseUrl, "", testTaskId);
+      expect(preamble).toBeTruthy();
+      const text = preamble ?? "";
+      // 4000 tokens * 4 chars/token = 16_000 chars hard cap; allow small
+      // trailing truncation marker.
+      expect(text.length).toBeLessThanOrEqual(16_500);
+      // Description must remain intact.
+      expect(text).toContain(testTaskDescription);
+    });
+
+    test("returns null when parent task is not found", async () => {
+      const preamble = await buildResumeContextPreamble(
+        baseUrl,
+        "",
+        "00000000-0000-0000-0000-000000000999",
+      );
+      expect(preamble).toBeNull();
+    });
+
+    test("cascading resume: walks chain to ORIGINAL task and merges logs across attempts", async () => {
+      // PR #594 review: a resume task being superseded again would have
+      // `buildResumeContextPreamble` reading the immediate parent's synthetic
+      // "Resume interrupted task..." prompt instead of the real description,
+      // and session logs scoped only to that one resume attempt. The fix
+      // walks the parentTaskId chain through taskType="resume" ancestors.
+      const originalId = crypto.randomUUID();
+      const resume1Id = crypto.randomUUID();
+      const originalDescription =
+        "ORIGINAL: implement /api/widgets endpoint with full pagination + validation.";
+      const resume1SyntheticPrompt =
+        "Resume interrupted task.\n\nParent task: ORIGINAL: implement /api/widgets...\n\nReason: graceful_shutdown\n\n[synthetic]";
+
+      // resume2 is what the runner is about to launch. Its `parentTaskId`
+      // is resume1, which is `taskType="resume"`, whose `parentTaskId` is
+      // the original (non-resume).
+      const chainServer = (await import("node:http")).createServer((req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        const url = req.url ?? "";
+        if (url === `/api/tasks/${resume1Id}`) {
+          res.writeHead(200).end(
+            JSON.stringify({
+              id: resume1Id,
+              task: resume1SyntheticPrompt,
+              taskType: "resume",
+              parentTaskId: originalId,
+              attachments: [],
+            }),
+          );
+          return;
+        }
+        if (url === `/api/tasks/${originalId}`) {
+          res.writeHead(200).end(
+            JSON.stringify({
+              id: originalId,
+              task: originalDescription,
+              taskType: undefined,
+              parentTaskId: undefined,
+              attachments: [],
+            }),
+          );
+          return;
+        }
+        if (url?.startsWith(`/api/tasks/${resume1Id}/session-logs`)) {
+          res.writeHead(200).end(
+            JSON.stringify({
+              logs: [
+                {
+                  createdAt: "2026-05-29T12:00:00.000Z",
+                  content: JSON.stringify({
+                    type: "tool_use",
+                    name: "RecentResumeAttempt",
+                    input: { file_path: "/from/resume1" },
+                  }),
+                },
+              ],
+            }),
+          );
+          return;
+        }
+        if (url?.startsWith(`/api/tasks/${originalId}/session-logs`)) {
+          res.writeHead(200).end(
+            JSON.stringify({
+              logs: [
+                {
+                  createdAt: "2026-05-29T10:00:00.000Z",
+                  content: JSON.stringify({
+                    type: "tool_use",
+                    name: "OriginalTaskWork",
+                    input: { file_path: "/from/original" },
+                  }),
+                },
+              ],
+            }),
+          );
+          return;
+        }
+        res.writeHead(404).end(JSON.stringify({ error: "not found" }));
+      });
+      const port = 13100;
+      await new Promise<void>((r) => chainServer.listen(port, () => r()));
+
+      try {
+        // resume2's parentTaskId = resume1.id → walk should reach original.
+        const preamble = await buildResumeContextPreamble(
+          `http://localhost:${port}`,
+          "",
+          resume1Id,
+        );
+        expect(preamble).toBeTruthy();
+        const text = preamble ?? "";
+
+        // The ORIGINAL task description must be in the preamble.
+        expect(text).toContain(originalDescription);
+        // The synthetic "Resume interrupted task" body of the immediate
+        // parent must NOT be the surfaced description.
+        expect(text).not.toContain(resume1SyntheticPrompt);
+        // The original task ID must be the one referenced (not the resume).
+        expect(text).toContain(originalId);
+        // Tool-call summaries from BOTH chain members merged (verify by
+        // presence of both unique names).
+        expect(text).toContain("OriginalTaskWork");
+        expect(text).toContain("RecentResumeAttempt");
+        // Chain-depth notice present (>1 chain length).
+        expect(text).toContain("Resume chain depth: 2");
+      } finally {
+        await new Promise<void>((r) => chainServer.close(() => r()));
+      }
+    });
+  });
+});