@desplega.ai/agent-swarm 1.159.0 → 1.161.0

package/src/tests/harness-version.test.ts

@@ -1,20 +1,43 @@
-import { describe, expect, mock, test } from "bun:test";
-import { readPkgVersion } from "../providers/harness-version";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readInstalledCliPackageVersion, readPkgVersion } from "../providers/harness-version";
 
 describe("readPkgVersion", () => {
-  test("reads pi version from the CLI before package.json probes", () => {
+  test("reads the pi version from the installed package without spawning", () => {
+    const spawn = mock(() => ({ stdout: "9.9.9\n", stderr: "", status: 0 }));
+    const requirePackageJson = mock(() => ({ version: "0.0.0" }));
+    const readInstalledVersion = mock(() => "0.79.1");
+
+    const version = readPkgVersion("@earendil-works/pi-coding-agent", {
+      requirePackageJson,
+      spawn,
+      readInstalledVersion,
+    });
+
+    expect(version).toBe("0.79.1");
+    expect(readInstalledVersion).toHaveBeenCalledWith("pi", "@earendil-works/pi-coding-agent");
+    expect(spawn).not.toHaveBeenCalled();
+    expect(requirePackageJson).not.toHaveBeenCalled();
+  });
+
+  test("reads pi version from the CLI when the installed package cannot be found", () => {
     const spawn = mock(() => ({ stdout: "0.79.1\n", stderr: "", status: 0 }));
     const requirePackageJson = mock(() => ({ version: "0.0.0" }));
 
     const version = readPkgVersion("@earendil-works/pi-coding-agent", {
       requirePackageJson,
       spawn,
+      readInstalledVersion: () => undefined,
     });
 
     expect(version).toBe("0.79.1");
     expect(spawn).toHaveBeenCalledWith("pi", ["--version"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5_000,
+      killSignal: "SIGKILL",
     });
     expect(requirePackageJson).not.toHaveBeenCalled();
   });
@@ -26,12 +49,15 @@ describe("readPkgVersion", () => {
     const version = readPkgVersion("@opencode-ai/sdk", {
       requirePackageJson,
       spawn,
+      readInstalledVersion: () => undefined,
     });
 
     expect(version).toBe("1.16.2");
     expect(spawn).toHaveBeenCalledWith("opencode", ["--version"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5_000,
+      killSignal: "SIGKILL",
     });
     expect(requirePackageJson).not.toHaveBeenCalled();
   });
@@ -40,8 +66,49 @@ describe("readPkgVersion", () => {
     const version = readPkgVersion("@earendil-works/pi-coding-agent", {
       requirePackageJson: () => ({ version: "0.79.1" }),
       spawn: mock(() => ({ stdout: "", stderr: "", status: 0 })),
+      readInstalledVersion: () => undefined,
     });
 
     expect(version).toBe("0.79.1");
   });
 });
+
+describe("readInstalledCliPackageVersion", () => {
+  const originalPath = process.env.PATH;
+  const tmpRoots: string[] = [];
+
+  afterEach(() => {
+    process.env.PATH = originalPath;
+    for (const dir of tmpRoots.splice(0)) rmSync(dir, { recursive: true, force: true });
+  });
+
+  /** A global-install layout: `<root>/bin/fake-cli` -> `<root>/lib/node_modules/@acme/fake/dist/bundle/cli.js`. */
+  function installFakeCli(packageName: string, version: string): string {
+    const root = mkdtempSync(join(tmpdir(), "harness-version-"));
+    tmpRoots.push(root);
+    const pkgDir = join(root, "lib", "node_modules", "@acme", "fake");
+    mkdirSync(join(pkgDir, "dist", "bundle"), { recursive: true });
+    mkdirSync(join(root, "bin"), { recursive: true });
+    writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ name: packageName, version }));
+    // A nested package.json without a matching name must be walked past.
+    writeFileSync(join(pkgDir, "dist", "package.json"), JSON.stringify({ type: "module" }));
+    writeFileSync(join(pkgDir, "dist", "bundle", "cli.js"), "#!/usr/bin/env node\n");
+    symlinkSync(join(pkgDir, "dist", "bundle", "cli.js"), join(root, "bin", "fake-cli"));
+    return join(root, "bin");
+  }
+
+  test("resolves the owning package version through the PATH symlink", () => {
+    process.env.PATH = installFakeCli("@acme/fake", "1.2.3");
+    expect(readInstalledCliPackageVersion("fake-cli", "@acme/fake")).toBe("1.2.3");
+  });
+
+  test("returns undefined when the owning package is a different one", () => {
+    process.env.PATH = installFakeCli("@acme/other", "1.2.3");
+    expect(readInstalledCliPackageVersion("fake-cli", "@acme/fake")).toBeUndefined();
+  });
+
+  test("returns undefined when the command is not on PATH", () => {
+    process.env.PATH = installFakeCli("@acme/fake", "1.2.3");
+    expect(readInstalledCliPackageVersion("not-installed-cli", "@acme/fake")).toBeUndefined();
+  });
+});

package/src/tests/http-api-integration.test.ts

@@ -711,6 +711,27 @@ describe("Tasks", () => {
     expect(body.alreadyFinished).toBe(true);
   });
 
+  test("POST /api/tasks/:id/finish — records the provider of a task whose harness never started", async () => {
+    const agentId = randomUUID();
+    expect((await post("/api/agents", { agentId, body: { name: "SpawnFailWorker" } })).status).toBe(
+      201,
+    );
+    const created = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: { task: "Spawn failure provider test", agentId, routingReason: "human_pinned" },
+    });
+    const taskId = created.body.id as string;
+    expect((await get("/api/poll", { agentId })).body.trigger?.taskId).toBe(taskId);
+
+    const finished = await post(`/api/tasks/${taskId}/finish`, {
+      agentId,
+      body: { status: "failed", failureReason: "Spawn failed: no binary", provider: "dsh" },
+    });
+    expect(finished.status).toBe(200);
+    expect(finished.body.task.status).toBe("failed");
+    expect(finished.body.task.provider).toBe("dsh");
+  });
+
   test("POST /api/tasks/:id/finish — terminal retries reject, no-op, or force text only", async () => {
     const agentId = randomUUID();
     const registered = await post("/api/agents", {

package/src/tests/http-task-write-ownership.test.ts

@@ -0,0 +1,195 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { handleTasks } from "../http/tasks";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { type HttpRequestAuth, setRequestAuth } from "../utils/request-auth-context";
+import { listenOnFreePort } from "./test-net";
+
+// Regression: an agent got 200 from HTTP progress and HTTP cancel on another
+// agent's in-progress task. Progress follows task.progress.write (assignee,
+// lead, human); cancel follows the MCP cancel-task policy for agents (lead or
+// creator). Humans and the keyed runner wrapper keep access.
+const ownerId = "aaaa0000-0000-4000-8000-000000000b01";
+const otherId = "bbbb0000-0000-4000-8000-000000000b02";
+const creatorId = "cccc0000-0000-4000-8000-000000000b03";
+const leadId = "dddd0000-0000-4000-8000-000000000b04";
+const userId = "eeee0000-0000-4000-8000-000000000b05";
+
+type Caller =
+  | { as: "operator"; agentId?: string }
+  | { as: "session"; agentId: string }
+  | { as: "user" };
+
+let server: Server;
+let baseUrl: string;
+
+function authFor(caller: Caller): HttpRequestAuth {
+  if (caller.as === "session") {
+    return { kind: "agent", agentId: caller.agentId, taskId: "session-task" };
+  }
+  if (caller.as === "user") {
+    return { kind: "user", userId, user: { id: userId } as never };
+  }
+  return { kind: "operator", fingerprint: "http-task-write-ownership" };
+}
+
+async function post(path: string, caller: Caller, body: unknown) {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-test-caller": JSON.stringify(caller),
+  };
+  if (caller.as === "operator" && caller.agentId) headers["X-Agent-ID"] = caller.agentId;
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  return response.status;
+}
+
+async function inProgressTask() {
+  const row = await createTaskExtended("http write ownership", {
+    agentId: ownerId,
+    creatorAgentId: creatorId,
+    source: "system",
+    followUpConfig: { disabled: true },
+  });
+  await startTask(row.id);
+  return row;
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  await createAgent({ id: ownerId, name: "Owner", isLead: false, status: "idle" });
+  await createAgent({ id: otherId, name: "Other", isLead: false, status: "idle" });
+  await createAgent({ id: creatorId, name: "Creator", isLead: false, status: "idle" });
+  await createAgent({ id: leadId, name: "Lead", isLead: true, status: "idle" });
+
+  server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const caller = JSON.parse(String(req.headers["x-test-caller"])) as Caller;
+    setRequestAuth(req, authFor(caller));
+    res.setHeader("Content-Type", "application/json");
+    const pathSegments = getPathSegments(req.url ?? "");
+    const query = parseQueryParams(req.url ?? "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    if (await handleTasks(req, res, pathSegments, query, myAgentId)) return;
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  const port = await listenOnFreePort(server);
+  baseUrl = `http://127.0.0.1:${port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+describe("POST /api/tasks/{id}/progress ownership", () => {
+  test("another agent on the shared key gets 403 and writes nothing", async () => {
+    const task = await inProgressTask();
+    const status = await post(
+      `/api/tasks/${task.id}/progress`,
+      { as: "operator", agentId: otherId },
+      { progress: "not mine" },
+    );
+    expect(status).toBe(403);
+    expect((await getTaskById(task.id))?.progress).toBeUndefined();
+  });
+
+  test("another agent on a session token gets 403", async () => {
+    const task = await inProgressTask();
+    const status = await post(
+      `/api/tasks/${task.id}/progress`,
+      { as: "session", agentId: otherId },
+      { progress: "not mine" },
+    );
+    expect(status).toBe(403);
+    expect((await getTaskById(task.id))?.progress).toBeUndefined();
+  });
+
+  test("the assignee, a lead, the keyed runner wrapper, and a user may write", async () => {
+    const task = await inProgressTask();
+    const callers: Caller[] = [
+      { as: "operator", agentId: ownerId },
+      { as: "operator", agentId: leadId },
+      { as: "operator" },
+      { as: "user" },
+    ];
+    for (const [i, caller] of callers.entries()) {
+      const status = await post(`/api/tasks/${task.id}/progress`, caller, {
+        progress: `step ${i}`,
+      });
+      expect(status, JSON.stringify(caller)).toBe(200);
+      expect((await getTaskById(task.id))?.progress).toBe(`step ${i}`);
+    }
+  });
+});
+
+describe("POST /api/tasks/{id}/progress on a terminal task", () => {
+  test("late harness progress after completion is a no-op", async () => {
+    const task = await inProgressTask();
+    const caller: Caller = { as: "operator", agentId: ownerId };
+    expect(await post(`/api/tasks/${task.id}/progress`, caller, { progress: "Reading" })).toBe(200);
+    await completeTask(task.id, "done");
+    expect(await post(`/api/tasks/${task.id}/progress`, caller, { progress: "step_end" })).toBe(
+      200,
+    );
+    const after = await getTaskById(task.id);
+    expect(after?.status).toBe("completed");
+    expect(after?.progress).toBe("Reading");
+  });
+});
+
+describe("POST /api/tasks/{id}/cancel ownership", () => {
+  test("an agent that is neither lead nor creator gets 403 and the task keeps running", async () => {
+    const task = await inProgressTask();
+    const status = await post(
+      `/api/tasks/${task.id}/cancel`,
+      { as: "operator", agentId: otherId },
+      { reason: "not mine" },
+    );
+    expect(status).toBe(403);
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+  });
+
+  test("the assignee alone cannot cancel, matching MCP cancel-task", async () => {
+    const task = await inProgressTask();
+    const status = await post(
+      `/api/tasks/${task.id}/cancel`,
+      { as: "operator", agentId: ownerId },
+      {},
+    );
+    expect(status).toBe(403);
+    expect((await getTaskById(task.id))?.status).toBe("in_progress");
+  });
+
+  test("the creator, a lead, the operator, and a user may cancel", async () => {
+    const callers: Caller[] = [
+      { as: "operator", agentId: creatorId },
+      { as: "session", agentId: leadId },
+      { as: "operator" },
+      { as: "user" },
+    ];
+    for (const caller of callers) {
+      const task = await inProgressTask();
+      const status = await post(`/api/tasks/${task.id}/cancel`, caller, { reason: "stop" });
+      expect(status, JSON.stringify(caller)).toBe(200);
+      expect((await getTaskById(task.id))?.status).toBe("cancelled");
+    }
+  });
+});

package/src/tests/internal-ai/complete-structured.test.ts

@@ -1,11 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import { Type } from "typebox";
 import { z } from "zod";
+import { SummaryWithRatingsSchema } from "../../be/memory/raters/llm.js";
 import {
   completeStructured,
+  completeStructuredWithModel,
   defaultSpawnClaudeCli,
 } from "../../utils/internal-ai/complete-structured.js";
 import type { ResolvedCredential } from "../../utils/internal-ai/credentials.js";
+import { summaryToolSchema } from "../../utils/internal-ai/summarize-session.js";
 
 const ResultZodSchema = z.object({
   summary: z.string(),
@@ -69,6 +72,39 @@ describe("completeStructured", () => {
     expect(result).toEqual({ summary: "ok", count: 7 });
   });
 
+  test("session summary with a blank referencesSource is accepted on the first call", async () => {
+    let invocations = 0;
+    const args = {
+      summary: "learned things",
+      ratings: [
+        { id: "m1", score: 0.9, reasoning: "useful", referencesSource: "linear:DES-1" },
+        { id: "m2", score: 0.1, reasoning: "not used", referencesSource: "" },
+        { id: "m3", score: 0.5, reasoning: "neutral", referencesSource: "   " },
+      ],
+    };
+    const result = await completeStructured({
+      zodSchema: SummaryWithRatingsSchema,
+      toolSchema: summaryToolSchema,
+      toolName: "record_session_summary",
+      toolDescription: "Record the session summary.",
+      systemPrompt: "sys",
+      userPrompt: "user",
+      _credentialOverride: {
+        kind: "openrouter",
+        apiKey: "test",
+        modelDefault: "openrouter/deepseek/deepseek-v4.1-flash",
+      },
+      _complete: async () => {
+        invocations++;
+        return makeMsg([
+          { type: "toolCall", id: "call_1", name: "record_session_summary", arguments: args },
+        ]);
+      },
+    });
+    expect(invocations).toBe(1);
+    expect(result?.ratings).toHaveLength(3);
+  });
+
   for (const { label, text, expected } of [
     {
       label: "bare JSON",
@@ -493,3 +529,61 @@ describe("defaultSpawnClaudeCli", () => {
     }
   });
 });
+
+describe("completeStructuredWithModel", () => {
+  const baseOpts = {
+    zodSchema: ResultZodSchema,
+    toolSchema: ResultToolSchema,
+    toolName: "record_result",
+    toolDescription: "Record the result.",
+    systemPrompt: "sys",
+    userPrompt: "user",
+  };
+
+  test("pi-ai path: reports the credential's resolved model next to the data", async () => {
+    const result = await completeStructuredWithModel({
+      ...baseOpts,
+      _credentialOverride: {
+        kind: "openrouter",
+        apiKey: "test",
+        modelDefault: "openrouter/deepseek/deepseek-v4.1-flash",
+      },
+      _complete: async () =>
+        makeMsg([
+          {
+            type: "toolCall",
+            id: "call_1",
+            name: "record_result",
+            arguments: { summary: "ok", count: 7 },
+          },
+        ]),
+    });
+    expect(result).toEqual({
+      data: { summary: "ok", count: 7 },
+      model: "openrouter/deepseek/deepseek-v4.1-flash",
+    });
+  });
+
+  test("assistant-text fallback also reports the model", async () => {
+    const result = await completeStructuredWithModel({
+      ...baseOpts,
+      _credentialOverride: {
+        kind: "openrouter",
+        apiKey: "test",
+        modelDefault: "openrouter/deepseek/deepseek-v4.1-flash",
+      },
+      _complete: async () => makeMsg([{ type: "text", text: '{"summary":"t","count":2}' }]),
+    });
+    expect(result?.model).toBe("openrouter/deepseek/deepseek-v4.1-flash");
+    expect(result?.data).toEqual({ summary: "t", count: 2 });
+  });
+
+  test("claude-cli path: reports the cli model alias", async () => {
+    const result = await completeStructuredWithModel({
+      ...baseOpts,
+      _credentialOverride: { kind: "claude-cli", modelDefault: "haiku" } as ResolvedCredential,
+      _spawnClaudeCli: async () => JSON.stringify({ summary: "cli", count: 1 }),
+    });
+    expect(result).toEqual({ data: { summary: "cli", count: 1 }, model: "haiku" });
+  });
+});

package/src/tests/internal-ai/credentials.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import {
+  DEFAULT_MODEL,
   type ResolveCredentialOptions,
   resolveCredential,
 } from "../../utils/internal-ai/credentials.js";
@@ -34,6 +35,27 @@ describe("resolveCredential", () => {
     }
   });
 
+  test("modelDefault follows the pinned rater model, not DEFAULT_MODEL", async () => {
+    const saved = process.env.MEMORY_RATER_MODEL;
+    delete process.env.MEMORY_RATER_MODEL;
+    const before = { ...DEFAULT_MODEL };
+    try {
+      DEFAULT_MODEL.openrouter = "openrouter/some/bumped-model";
+      DEFAULT_MODEL.anthropic = "anthropic/bumped";
+      const viaOpenRouter = await resolveCredential(
+        makeOpts({ env: { OPENROUTER_API_KEY: "or-1" } }),
+      );
+      expect(viaOpenRouter?.modelDefault).toBe("openrouter/deepseek/deepseek-v4.1-flash");
+      const viaAnthropic = await resolveCredential(
+        makeOpts({ env: { ANTHROPIC_API_KEY: "example-sk-ant-1" } }),
+      );
+      expect(viaAnthropic?.modelDefault).toBe("anthropic/claude-haiku-4-5");
+    } finally {
+      Object.assign(DEFAULT_MODEL, before);
+      if (saved !== undefined) process.env.MEMORY_RATER_MODEL = saved;
+    }
+  });
+
   test("ANTHROPIC_API_KEY when no openrouter", async () => {
     const cred = await resolveCredential(
       makeOpts({ env: { ANTHROPIC_API_KEY: "example-sk-ant-1" } }),

package/src/tests/internal-ai/models.test.ts

@@ -1,6 +1,11 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 import { getBuiltinModel } from "@earendil-works/pi-ai/providers/all";
-import { DEFAULT_MODEL, parseModelStr } from "../../utils/internal-ai/models.js";
+import {
+  DEFAULT_MODEL,
+  MEMORY_RATER_DEFAULT_MODEL,
+  parseModelStr,
+  resolveRaterModelString,
+} from "../../utils/internal-ai/models.js";
 
 describe("internal-ai default models", () => {
   for (const [kind, modelString] of Object.entries(DEFAULT_MODEL)) {
@@ -18,3 +23,32 @@ describe("internal-ai default models", () => {
     });
   }
 });
+
+describe("memory rater default models", () => {
+  const savedEnv = process.env.MEMORY_RATER_MODEL;
+  afterEach(() => {
+    if (savedEnv === undefined) delete process.env.MEMORY_RATER_MODEL;
+    else process.env.MEMORY_RATER_MODEL = savedEnv;
+  });
+
+  for (const [kind, modelString] of Object.entries(MEMORY_RATER_DEFAULT_MODEL)) {
+    if (kind === "claude-cli") continue;
+
+    test(`${kind} rater default resolves in the pinned pi-ai catalog`, () => {
+      const [provider, modelId] = parseModelStr(modelString);
+      const model = getBuiltinModel(
+        provider as Parameters<typeof getBuiltinModel>[0],
+        modelId as never,
+      );
+      expect(model).toBeDefined();
+      expect(model.id).toBe(modelId);
+      expect(model.provider).toBe(provider);
+    });
+  }
+
+  test("MEMORY_RATER_MODEL still overrides every kind", () => {
+    process.env.MEMORY_RATER_MODEL = "openrouter/anthropic/claude-sonnet-4-5";
+    expect(resolveRaterModelString("openrouter")).toBe("openrouter/anthropic/claude-sonnet-4-5");
+    expect(resolveRaterModelString("claude-cli")).toBe("openrouter/anthropic/claude-sonnet-4-5");
+  });
+});

package/src/tests/internal-ai/schema-parity.test.ts

@@ -4,7 +4,7 @@ import { SummaryWithRatingsSchema } from "../../be/memory/raters/llm.js";
 import { summaryToolSchema } from "../../utils/internal-ai/summarize-session.js";
 
 /**
- * 10 valid + 10 invalid fixtures. Both validators (zod via `safeParse`,
+ * Valid + invalid fixtures. Both validators (zod via `safeParse`,
  * typebox via `Value.Check`) must agree on every fixture.
  *
  * Note: zod's `SummaryWithRatingsSchema` defaults `ratings` to `[]` when
@@ -54,6 +54,24 @@ const VALID_CASES: unknown[] = [
     summary: "max-reason",
     ratings: [{ id: "m1", score: 0.5, reasoning: "x".repeat(500) }],
   },
+  // blank referencesSource: models emit "" for "no source". One blank value
+  // must not reject the whole summary; buildRatingsFromLlm drops the edge.
+  {
+    summary: "empty-ref",
+    ratings: [{ id: "m1", score: 0.5, reasoning: "ok", referencesSource: "" }],
+  },
+  {
+    summary: "whitespace-ref",
+    ratings: [{ id: "m1", score: 0.5, reasoning: "ok", referencesSource: "   " }],
+  },
+  // one blank among valid ratings.
+  {
+    summary: "mixed-refs",
+    ratings: [
+      { id: "m1", score: 0.9, reasoning: "ok", referencesSource: "linear:DES-1" },
+      { id: "m2", score: 0.1, reasoning: "ok", referencesSource: "" },
+    ],
+  },
 ];
 
 const INVALID_CASES: unknown[] = [
@@ -74,6 +92,12 @@ const INVALID_CASES: unknown[] = [
   { summary: "ok", ratings: [{ id: "m1", score: -0.1, reasoning: "x" }] },
   // rating with non-string id.
   { summary: "ok", ratings: [{ id: 7, score: 0.5, reasoning: "x" }] },
+  // referencesSource still bounded and typed: only blank became valid.
+  { summary: "ok", ratings: [{ id: "m1", score: 0.5, reasoning: "x", referencesSource: 7 }] },
+  {
+    summary: "ok",
+    ratings: [{ id: "m1", score: 0.5, reasoning: "x", referencesSource: "x".repeat(513) }],
+  },
 ];
 
 describe("schema-parity: SummaryWithRatingsSchema (zod) vs summaryToolSchema (typebox)", () => {

package/src/tests/internal-ai/summarize-session.test.ts

@@ -11,7 +11,7 @@ Tool[Edit]: input={"file":"/tmp/x","old":"a","new":"b"} output="ok"
 Assistant: Done.`.padEnd(200, "x");
 
 describe("summarizeSession", () => {
-  test("pass-through: injected _completeStructured result is returned verbatim", async () => {
+  test("pass-through: injected _completeStructured data is returned with the resolved model", async () => {
     const fake: z.infer<typeof SummaryWithRatingsSchema> = {
       summary: "Learned: X uses Y",
       ratings: [{ id: "mem-1", score: 0.9, reasoning: "very useful" }],
@@ -23,9 +23,25 @@ describe("summarizeSession", () => {
       taskContext: { sourceTaskId: "task-1", agentId: "agent-1" },
       apiUrl: "http://localhost:3013",
       apiKey: "k",
-      _completeStructured: (async () => fake) as any,
+      _completeStructured: (async () => ({
+        data: fake,
+        model: "openrouter/deepseek/deepseek-v4.1-flash",
+      })) as any,
     });
-    expect(result).toEqual(fake);
+    expect(result).toEqual({ ...fake, model: "openrouter/deepseek/deepseek-v4.1-flash" });
+  });
+
+  test("returns null when _completeStructured resolves no result", async () => {
+    const result = await summarizeSession({
+      harness: "pi",
+      transcript: LONG_TRANSCRIPT,
+      retrievals: [],
+      taskContext: { sourceTaskId: "task-1", agentId: "agent-1" },
+      apiUrl: "http://localhost:3013",
+      apiKey: "k",
+      _completeStructured: (async () => null) as any,
+    });
+    expect(result).toBeNull();
   });
 
   test("retrievals are injected into the userPrompt via buildSummaryWithRatingsPrompt", async () => {
@@ -39,7 +55,7 @@ describe("summarizeSession", () => {
       apiKey: "k",
       _completeStructured: (async (opts: { userPrompt: string }) => {
         capturedUserPrompt = opts.userPrompt;
-        return { summary: "x", ratings: [] };
+        return { data: { summary: "x", ratings: [] }, model: "m" };
       }) as any,
     });
     expect(capturedUserPrompt).toContain("mem-abc");
@@ -62,7 +78,7 @@ describe("summarizeSession", () => {
       apiKey: "k",
       _completeStructured: (async (opts: { userPrompt: string }) => {
         capturedUserPrompt = opts.userPrompt;
-        return { summary: "x", ratings: [] };
+        return { data: { summary: "x", ratings: [] }, model: "m" };
       }) as any,
     });
     expect(capturedUserPrompt).toContain("Task: do the thing");
@@ -79,7 +95,7 @@ describe("summarizeSession", () => {
       apiKey: "k",
       _completeStructured: (async () => {
         invocations++;
-        return { summary: "x", ratings: [] };
+        return { data: { summary: "x", ratings: [] }, model: "m" };
       }) as any,
     });
     expect(result).toBeNull();
@@ -97,7 +113,7 @@ describe("summarizeSession", () => {
       apiKey: "k",
       _completeStructured: (async (opts: { callerTag?: string }) => {
         capturedTag = opts.callerTag ?? "";
-        return { summary: "x", ratings: [] };
+        return { data: { summary: "x", ratings: [] }, model: "m" };
       }) as any,
     });
     expect(capturedTag).toBe("session-summary:pi");