@downcity/agent 1.1.237 → 1.1.258

package/scripts/{session-recorder.test.mjs → session-messages.test.mjs}

@@ -1,5 +1,5 @@
 /**
- * @file 验证 SessionRecorder 的 Message 快照、Assistant 草稿与实时事件一致性。
+ * @file 验证 SessionMessages 的 Message 快照、Assistant 草稿与实时事件一致性。
  */
 
 import test from "node:test";
@@ -8,10 +8,11 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { JsonlSessionMessageStore } from "../bin/session/recorder/JsonlSessionMessageStore.js";
-import { SessionRecorder } from "../bin/session/recorder/SessionRecorder.js";
-import { SessionRecorderHistoryStore } from "../bin/session/recorder/SessionRecorderHistoryStore.js";
-import { SessionViewService } from "../bin/session/services/SessionViewService.js";
+import { JsonlSessionMessageStore } from "../bin/session/messages/JsonlSessionMessageStore.js";
+import { SessionMessages } from "../bin/session/SessionMessages.js";
+import { SessionApprovalBroker } from "../bin/session/approval/SessionApprovalBroker.js";
+import { compose_session_compaction } from "../bin/session/messages/SessionMessageCompaction.js";
+import { to_executor_history } from "../bin/session/messages/SessionMessageCodec.js";
 import { MockLanguageModelV3 } from "ai/test";
 
 async function create_recorder(session_id = "session-recorder-test") {
@@ -19,7 +20,7 @@ async function create_recorder(session_id = "session-recorder-test") {
   const file_path = path.join(root_path, "active.jsonl");
   const assistant_message_file_path = path.join(root_path, "assistant_message.json");
   const events = [];
-  const recorder = new SessionRecorder({
+  const recorder = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: (mutation) => events.push(mutation),
@@ -41,7 +42,7 @@ async function create_seeded_recorder(session_id, messages) {
     `${messages.map((message) => JSON.stringify(message)).join("\n")}\n`,
     "utf8",
   );
-  const recorder = new SessionRecorder({
+  const recorder = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
@@ -50,6 +51,20 @@ async function create_seeded_recorder(session_id, messages) {
   return { recorder, file_path };
 }
 
+async function compact_messages(recorder, session_id, model) {
+  const plan = await compose_session_compaction({
+    session_id,
+    snapshot: await recorder.context_snapshot(),
+    model,
+  });
+  if (!plan) return false;
+  await recorder.compact_active({
+    through_sequence: plan.through_sequence,
+    summary: plan.summary,
+  });
+  return true;
+}
+
 function create_seeded_user_message(session_id, sequence) {
   return {
     message_id: `user-${String(sequence)}`,
@@ -110,26 +125,42 @@ test("delta 只更新 Assistant 草稿，完成后才写入 active.jsonl", async
   assert.equal(history.some((value) => "variant" in value), false);
 });
 
-test("Tool Part 在文本中间创建后，输入、审批和输出都保持原顺序", async () => {
+test("Tool Runtime 在文本中间保持输入、审批和输出的确定顺序", async () => {
   const { recorder, events, file_path } = await create_recorder("tool-order-test");
+  const approval_broker = new SessionApprovalBroker({
+    session_id: "tool-order-test",
+    messages: recorder,
+  });
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1", segment_index: 1 });
   await writer.apply_chunk({ type: "text-start", id: "text-1" });
   await writer.apply_chunk({ type: "text-delta", id: "text-1", delta: "before" });
   await writer.apply_chunk({ type: "text-end", id: "text-1" });
-  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-1", toolName: "search" });
+  await writer.apply_chunk({ type: "tool-input-start", toolCallId: "call-1", toolName: "shell_exec" });
   await writer.apply_chunk({
     type: "tool-input-available",
     toolCallId: "call-1",
-    toolName: "search",
-    input: { query: "downcity" },
+    toolName: "shell_exec",
+    input: { cmd: "pwd", sandbox: "unrestricted", reason: "Inspect directory" },
   });
   assert.equal(recorder.get_message(writer.message_id).parts[1].state, "ready");
-  await writer.apply_chunk({
-    type: "tool-approval-request",
-    toolCallId: "call-1",
-    approvalId: "approval-1",
+  const approval_handle = await approval_broker.request({
+    shell_id: "shell-1",
+    tool_call_id: "call-1",
+    tool_name: "shell_exec",
+    session_id: "tool-order-test",
+    turn_id: "turn-1",
+    command: "pwd",
+    cwd: "/workspace",
+    reason: "Inspect directory",
+    operation: "exec",
+    timeout_ms: 60_000,
   });
   assert.equal(recorder.get_message(writer.message_id).parts[1].state, "approval-required");
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "approved",
+  });
+  assert.equal(await approval_handle.decision, "approved");
   await writer.apply_chunk({ type: "text-start", id: "text-2" });
   await writer.apply_chunk({ type: "text-delta", id: "text-2", delta: "after" });
   await writer.apply_chunk({ type: "text-end", id: "text-2" });
@@ -145,7 +176,76 @@ test("Tool Part 在文本中间创建后，输入、审批和输出都保持原
     events
       .filter((event) => event.variant === "part" && event.type === "tool")
       .map((event) => [event.part.sequence, event.part.state]),
-    [[2, "input-streaming"], [2, "ready"], [2, "approval-required"], [2, "completed"]],
+    [
+      [2, "input-streaming"],
+      [2, "ready"],
+      [2, "approval-required"],
+      [2, "running"],
+      [2, "completed"],
+    ],
+  );
+});
+
+test("Approval Broker 只接受已经准备完整输入的 Tool", async () => {
+  const { recorder, events } = await create_recorder("tool-ready-barrier-test");
+  const approval_broker = new SessionApprovalBroker({
+    session_id: "tool-ready-barrier-test",
+    messages: recorder,
+  });
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-ready-barrier",
+    segment_index: 1,
+  });
+  const approval_input = {
+    shell_id: "shell-ready-barrier",
+    tool_call_id: "call-ready-barrier",
+    tool_name: "shell_exec",
+    session_id: "tool-ready-barrier-test",
+    turn_id: "turn-ready-barrier",
+    command: "ls -la /Users/example/Desktop",
+    cwd: "/workspace",
+    reason: "Inspect requested desktop files",
+    operation: "exec",
+    timeout_ms: 60_000,
+  };
+  await assert.rejects(
+    approval_broker.request(approval_input),
+    /Streaming Tool Part not found/,
+  );
+  assert.equal(approval_broker.list().length, 0);
+
+  await writer.prepare_tool_input({
+    tool_call_id: "call-ready-barrier",
+    tool_name: "shell_exec",
+    input: {
+      cmd: "ls -la /Users/example/Desktop",
+      sandbox: "unrestricted",
+      reason: "Inspect requested desktop files",
+    },
+  });
+  const approval_handle = await approval_broker.request(approval_input);
+
+  const tool = recorder.get_message(writer.message_id).parts[0];
+  assert.equal(tool.state, "approval-required");
+  assert.equal(tool.approval.approval_id, approval_handle.approval_id);
+  assert.equal(tool.approval.command, approval_input.command);
+  assert.equal(tool.input.cmd, "ls -la /Users/example/Desktop");
+  await approval_broker.resolve({
+    approval_id: approval_handle.approval_id,
+    decision: "denied",
+  });
+  assert.equal(await approval_handle.decision, "denied");
+  await writer.apply_chunk({
+    type: "tool-output-available",
+    toolCallId: "call-ready-barrier",
+    output: { success: false, approval_status: "denied" },
+  });
+  assert.equal(recorder.get_message(writer.message_id).parts[0].state, "failed");
+  assert.deepEqual(
+    events
+      .filter((event) => event.variant === "part" && event.type === "tool")
+      .map((event) => event.part.state),
+    ["ready", "approval-required", "failed"],
   );
 });
 
@@ -248,7 +348,7 @@ test("重启时将 Assistant 草稿收口为 stopped，并将运行中 Action
   await recorder.open_action_message({ message_id: "running-action", action_type: "fork", title: "Forking" });
 
   const recovered_events = [];
-  const recovered = new SessionRecorder({
+  const recovered = new SessionMessages({
     session_id: "recovery-test",
     store: new JsonlSessionMessageStore({ session_id: "recovery-test", file_path }),
     publish: (mutation) => recovered_events.push(mutation),
@@ -292,7 +392,6 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
       parts: [{ part_id: `user-${String(index)}`, type: "text", text: `message ${String(index)}`, state: "done" }],
     });
   }
-  const history_store = new SessionRecorderHistoryStore({ session_id: "compact-test", recorder });
   const model = new MockLanguageModelV3({
     modelId: "compact-model",
     doGenerate: async () => ({
@@ -305,12 +404,7 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
       warnings: [],
     }),
   });
-  const result = await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
-  assert.equal(result.compacted, true);
+  assert.equal(await compact_messages(recorder, "compact-test", model), true);
   assert.equal((await fs.readFile(file_path, "utf8")).includes("message 1"), false);
   const active = await recorder.list_messages({ include_internal: true });
   assert.deepEqual(active.items.map((message) => message.sequence), []);
@@ -322,7 +416,10 @@ test("compact 把 Active 前缀关闭为带累计 Summary 的 Segment", async ()
   });
   assert.deepEqual(segment.items.map((message) => message.sequence), [1, 2, 3, 4, 5, 6]);
   assert.equal(segment.source, "segment");
-  assert.equal((await history_store.list_records()).length, 1);
+  assert.equal(
+    to_executor_history("compact-test", await recorder.context_snapshot()).length,
+    1,
+  );
   await assert.rejects(
     recorder.list_messages({ before_sequence: 0 }),
     /before_sequence must be a positive integer/,
@@ -356,14 +453,13 @@ test("重启后从最新 Segment Summary 与 Active 恢复模型上下文", asyn
     },
   });
 
-  const restarted = new SessionRecorder({
+  const restarted = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
   });
   await restarted.initialize();
-  const context_store = new SessionRecorderHistoryStore({ session_id, recorder: restarted });
-  const context = await context_store.list_records();
+  const context = to_executor_history(session_id, await restarted.context_snapshot());
   assert.deepEqual(
     context.map((message) => message.parts[0]?.text),
     ["summary through 4", "message 5", "message 6"],
@@ -414,7 +510,7 @@ test("Compact 两步提交中断后会清理 Active 与 Segment 的重叠前缀"
     "utf8",
   );
 
-  const restarted = new SessionRecorder({
+  const restarted = new SessionMessages({
     session_id,
     store: new JsonlSessionMessageStore({ session_id, file_path }),
     publish: () => {},
@@ -449,7 +545,6 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
       };
     },
   });
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
   const append_messages = async (start, end) => {
     for (let index = start; index <= end; index += 1) {
       await recorder.append_user_message({
@@ -464,16 +559,12 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
       });
     }
   };
-  const compact = async () => await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
+  const compact = async () => await compact_messages(recorder, session_id, model);
 
   await append_messages(1, 8);
-  assert.equal((await compact()).compacted, true);
+  assert.equal(await compact(), true);
   await append_messages(9, 12);
-  assert.equal((await compact()).compacted, true);
+  assert.equal(await compact(), true);
 
   assert.equal(prompts.length, 2);
   assert.equal(prompts[1].includes("<previous-summary>"), true);
@@ -487,7 +578,7 @@ test("连续 Compact 生成按 sequence 连续的 Segment 与累计 Summary", as
     before_sequence: latest_segment.start_sequence,
   });
   assert.deepEqual(earliest_segment.items.map((message) => message.sequence), [1, 2, 3, 4, 5, 6, 7, 8]);
-  const context = await history_store.list_records();
+  const context = to_executor_history(session_id, await recorder.context_snapshot());
   assert.equal(context[0].parts[0]?.text, "Summary 2");
 });
 
@@ -512,14 +603,7 @@ test("Summary 生成失败时使用确定性 Summary 完成归档", async () =>
       throw new Error("summary unavailable");
     },
   });
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
-  const result = await history_store.compact({
-    model,
-    system: [],
-    force: true,
-  });
-
-  assert.deepEqual(result, { compacted: true });
+  assert.equal(await compact_messages(recorder, session_id, model), true);
   assert.deepEqual((await recorder.list_messages()).items, []);
   const segment_entries = await fs.readdir(path.join(path.dirname(file_path), "segments"));
   assert.equal(segment_entries.length, 1);
@@ -554,52 +638,9 @@ test("内部上下文读取完整快照并保留第 500 条之后的最新消息
   assert.equal(previous.start_sequence, 1);
   assert.equal(previous.end_sequence, 499);
 
-  const history_store = new SessionRecorderHistoryStore({ session_id, recorder });
-  const context = await history_store.list_records();
+  const context = to_executor_history(session_id, await recorder.context_snapshot());
   assert.deepEqual(
     context.map((message) => message.parts[0]?.text),
     ["summary through 499", "message 500", "message 501"],
   );
 });
-
-test("Session fork 可以选择并复制第 500 条之后的消息", async () => {
-  const session_id = "complete-fork-snapshot-test";
-  const messages = Array.from(
-    { length: 501 },
-    (_, index) => create_seeded_user_message(session_id, index + 1),
-  );
-  const { recorder } = await create_seeded_recorder(session_id, messages);
-  let imported_messages = [];
-  const state_service = {
-    emit_action_event: async () => {},
-    get_config: () => ({}),
-  };
-  const view_service = new SessionViewService({
-    agent_id: "fork-agent",
-    project_root: os.tmpdir(),
-    session_id,
-    history_store: new SessionRecorderHistoryStore({ session_id, recorder }),
-    recorder,
-    state_service,
-    logger: { log: async () => {} },
-    is_executing: () => false,
-    get_instruction_system_blocks: () => [],
-    get_managed_plugin_system_blocks: async () => [],
-    get_plugin_system_blocks: async () => [],
-    create_fork_session: async () => ({
-      session: { id: "forked-session", set: async () => {} },
-      history_store: {},
-      recorder: {
-        import_messages: async (input) => {
-          imported_messages = input;
-        },
-      },
-      state_service: { set: async () => {} },
-    }),
-  });
-
-  await view_service.fork("user-501");
-
-  assert.equal(imported_messages.length, 501);
-  assert.equal(imported_messages[500].message_id, "user-501");
-});

package/scripts/session-queue.test.mjs

@@ -0,0 +1,64 @@
+/**
+ * @file 验证 SessionQueue 只维护 Prompt/Command 的确定 FIFO 顺序。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionQueue } from "../bin/session/SessionQueue.js";
+
+function model_command(command_id) {
+  return {
+    type: "session_model",
+    command_id,
+    config: {},
+  };
+}
+
+test("SessionQueue 返回首个 Prompt 及其之前的命令", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_command(model_command("command-1"));
+  const handle = queue.enqueue_prompt({ query: "first" });
+  queue.enqueue_command({ type: "compact", command_id: "compact-1" });
+
+  const next = queue.take_next_prompt();
+  assert.deepEqual(next.commands.map((item) => item.command_id), ["command-1"]);
+  assert.equal(next.prompt.input.query, "first");
+  assert.equal(handle instanceof Promise, true);
+  assert.equal(queue.has_command(), true);
+  assert.equal(queue.has_prompt(), false);
+});
+
+test("SessionQueue drain 保留 Prompt 和 Command 的原始顺序", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_prompt({ query: "steer-1" });
+  queue.enqueue_command(model_command("command-1"));
+  queue.enqueue_prompt({ query: "steer-2" });
+
+  assert.deepEqual(
+    queue.drain().map((item) => item.type),
+    ["prompt", "session_model", "prompt"],
+  );
+  assert.equal(queue.has_prompt(), false);
+});
+
+test("SessionQueue cancel_prompts 取消 Prompt 但保留命令", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_prompt({ query: "queued" });
+  queue.enqueue_command({ type: "compact", command_id: "compact-1" });
+
+  assert.equal(queue.cancel_prompts().length, 1);
+  assert.deepEqual(queue.drain(), [
+    { type: "compact", command_id: "compact-1" },
+  ]);
+});
+
+test("SessionQueue 可以把未处理输入恢复到队列头部", () => {
+  const queue = new SessionQueue();
+  queue.enqueue_command({ type: "compact", command_id: "tail" });
+  queue.restore_front([model_command("head")]);
+
+  assert.deepEqual(
+    queue.drain().map((item) => item.command_id),
+    ["head", "tail"],
+  );
+});

package/scripts/session-shell-approval.test.mjs

@@ -0,0 +1,171 @@
+/**
+ * @file 验证 Session Tool Runtime 向 Shell 传递完整审批归属。
+ *
+ * 关键点（中文）
+ * - 通过真实 Agent、Executor 与 Shell tool loop 发起 unrestricted 请求。
+ * - approval-required Mutation 必须携带当前 Session、Turn 与 Tool Call 标识。
+ * - 用户批准后命令才执行，最终 Tool Part 收口为 completed。
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { MockLanguageModelV3 } from "ai/test";
+import { Agent } from "@downcity/agent";
+import { Shell } from "@downcity/shell";
+
+/** 构造 AI SDK V3 usage。 */
+function create_usage() {
+  return {
+    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 0, text: 0, reasoning: 0 },
+  };
+}
+
+/** 构造要求执行 unrestricted shell_exec 的模型流。 */
+function create_tool_call_stream() {
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({
+          type: "tool-input-start",
+          id: "call_unrestricted",
+          toolName: "shell_exec",
+        });
+        controller.enqueue({
+          type: "tool-input-delta",
+          id: "call_unrestricted",
+          delta: JSON.stringify({
+            cmd: "printf approval-ok",
+            shell: "/bin/sh",
+            login: false,
+            sandbox: "unrestricted",
+            reason: "验证 Session unrestricted 审批归属。",
+          }),
+        });
+        controller.enqueue({
+          type: "tool-input-end",
+          id: "call_unrestricted",
+        });
+        controller.enqueue({
+          type: "tool-call",
+          toolCallId: "call_unrestricted",
+          toolName: "shell_exec",
+          input: JSON.stringify({
+            cmd: "printf approval-ok",
+            shell: "/bin/sh",
+            login: false,
+            sandbox: "unrestricted",
+            reason: "验证 Session unrestricted 审批归属。",
+          }),
+        });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "tool-calls", raw: "tool-calls" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
+}
+
+/** 构造 Tool 执行后的最终文本流。 */
+function create_final_text_stream() {
+  return {
+    stream: new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: [] });
+        controller.enqueue({ type: "text-start", id: "text_1" });
+        controller.enqueue({ type: "text-delta", id: "text_1", delta: "done" });
+        controller.enqueue({ type: "text-end", id: "text_1" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: { unified: "stop", raw: "stop" },
+          usage: create_usage(),
+        });
+        controller.close();
+      },
+    }),
+  };
+}
+
+test("unrestricted Shell 审批保留当前 Turn 并等待用户决定", async () => {
+  const project_root = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-session-shell-approval-"),
+  );
+  let stream_count = 0;
+  const model = new MockLanguageModelV3({
+    modelId: "session-shell-approval-model",
+    doStream: async (options) => {
+      if (!Array.isArray(options.tools) || options.tools.length === 0) {
+        return create_final_text_stream();
+      }
+      stream_count += 1;
+      return stream_count === 1
+        ? create_tool_call_stream()
+        : create_final_text_stream();
+    },
+    doGenerate: async () => ({
+      content: [{ type: "text", text: "Approval test" }],
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: create_usage(),
+      warnings: [],
+    }),
+  });
+  const agent = new Agent({
+    id: "session_shell_approval_agent",
+    path: project_root,
+    model,
+    shell: new Shell(),
+  });
+
+  try {
+    const session = await agent.sessions.create({
+      sessionId: "session_shell_approval",
+    });
+    let approval_snapshot;
+    let approval_result;
+    const unsubscribe = session.subscribe((mutation) => {
+      if (
+        mutation.variant !== "part" ||
+        mutation.type !== "tool" ||
+        mutation.part.state !== "approval-required" ||
+        !mutation.part.approval
+      ) return;
+      approval_snapshot = mutation.part.approval;
+      approval_result = session.resolve_approval({
+        approval_id: mutation.part.approval.approval_id,
+        decision: "approved",
+      });
+    });
+
+    const turn = await session.prompt({ query: "run unrestricted command" });
+    const result = await turn.finished;
+    unsubscribe();
+
+    assert.equal(result.success, true, result.error);
+    assert.equal(stream_count, 2);
+    const messages = await session.messages();
+    const tool_part = messages.items
+      .flatMap((message) => message.type === "assistant" ? message.parts : [])
+      .find((part) => part.type === "tool" && part.tool_call_id === "call_unrestricted");
+    assert.ok(approval_snapshot, JSON.stringify(messages.items));
+    assert.equal(approval_snapshot.session_id, session.id);
+    assert.equal(approval_snapshot.turn_id, turn.id);
+    assert.equal(approval_snapshot.tool_call_id, "call_unrestricted");
+    assert.deepEqual(await approval_result, {
+      success: true,
+      approval_id: approval_snapshot.approval_id,
+      decision: "approved",
+    });
+    assert.equal(tool_part?.state, "completed");
+    assert.equal(tool_part?.output?.output, "approval-ok");
+  } finally {
+    await agent.dispose();
+    await fs.rm(project_root, { recursive: true, force: true });
+  }
+});

package/scripts/session-system-blocks.test.mjs

@@ -9,8 +9,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { createInstructionSystemBlocks } from "../bin/agent/local/AgentInstructions.js";
-import { buildSessionSystemBlocks } from "../bin/session/SessionSystemBuilder.js";
+import { createInstructionSystemBlocks } from "../bin/agent/AgentInstructions.js";
+import { build_session_system_blocks } from "../bin/session/SessionSystem.js";
 
 test("instruction blocks keep Downcity core after custom instruction", () => {
   const blocks = createInstructionSystemBlocks(
@@ -37,19 +37,19 @@ test("instruction blocks keep Downcity core after custom instruction", () => {
 });
 
 test("session system blocks are ordered as instruction, core, plugin, session", async () => {
-  const blocks = await buildSessionSystemBlocks({
-    agentId: "agent-test",
-    projectRoot: "/tmp/downcity-project",
-    sessionId: "session-test",
-    createdAt: Date.UTC(2026, 6, 9, 8, 0, 0),
+  const blocks = await build_session_system_blocks({
+    agent_id: "agent-test",
+    project_root: "/tmp/downcity-project",
+    session_id: "session-test",
+    created_at: Date.UTC(2026, 6, 9, 8, 0, 0),
     timezone: "Asia/Shanghai",
-    getInstructionSystemBlocks: () =>
+    get_instruction_system_blocks: () =>
       createInstructionSystemBlocks(
         ["使用中文回复。"],
         "/tmp/downcity-project",
       ),
-    getManagedPluginSystemBlocks: async () => [],
-    getPluginSystemBlocks: async () => [
+    get_managed_plugin_system_blocks: async () => [],
+    get_plugin_system_blocks: async () => [
       {
         source: "plugin",
         name: "task",

package/scripts/session-title-event.test.mjs

@@ -133,6 +133,7 @@ test("Session logs title generation failure without blocking the session", async
     model: create_failing_title_model(),
   });
   const session = await agent.sessions.create();
+  await session.set({ model: create_failing_title_model() });
 
   try {
     await session.append_user_message({