@downcity/agent 1.1.337 → 1.1.399

package/scripts/session-config-turn-boundary.test.mjs

@@ -12,8 +12,11 @@ import assert from "node:assert/strict";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { MockLanguageModelV3 } from "ai/test";
-import { Agent, Workspace } from "../bin/index.js";
+import { MockModelClient } from "./ModelClientMock.mjs";
+import { Agent } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { City } from "../bin/index.js";
+import { LocalStorageProvider, Workspace } from "@downcity/workspace";
 import {
   create_action,
   create_plugin,
@@ -68,7 +71,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
   let provider_request_count = 0;
   let plugin_stop_count = 0;
 
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "config-turn-boundary-model",
     doStream: async (options) => {
       const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
@@ -100,20 +103,20 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
       }),
     },
   });
-  const workspace = new Workspace({
-    path: agent_path,
+  const workspace = new Workspace({ id: "test_workspace",
+    path: agent_path, data_root_path: path.join(agent_path, "data"),
     env: { TURN_ENV: "old" },
   });
   const agent = new Agent({
     id: "config_turn_boundary_agent",
-    workspace,
     model,
     instruction: ["instruction:old"],
     plugins: [runtime_plugin],
   });
+  const entry = create_workspace_entry(agent, workspace);
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "config_turn_boundary_session",
     });
     const first_turn = await session.prompt({ query: "first" });
@@ -121,7 +124,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
 
     agent.set_instruction(["instruction:new"]);
     workspace.patch_env({ TURN_ENV: "new" });
-    await agent.plugins.unregister("runtime-config");
+    await entry.plugins.unregister("runtime-config");
     const steer_turn_promise = session.prompt({ query: "steer" });
 
     assert.equal(plugin_stop_count, 0);
@@ -151,8 +154,8 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
     ]);
 
     // 未显式 snapshot 的 Session 重新装载时使用 Agent 当前 instruction。
-    await agent.sessions.clear_messages(session.id);
-    const restored_session = await agent.sessions.get(session.id);
+    await entry.sessions.clear_messages(session.id);
+    const restored_session = await entry.sessions.get(session.id);
     const restored_system = await restored_session.system();
     const restored_system_text = restored_system.blocks
       .map((block) => block.content)
@@ -160,7 +163,7 @@ test("Agent instruction changes only affect newly created Sessions", async () =>
     assert.match(restored_system_text, /instruction:new/);
     assert.doesNotMatch(restored_system_text, /instruction:old/);
 
-    const new_session = await agent.sessions.create({
+    const new_session = await entry.sessions.create({
       session_id: "config_turn_boundary_new_session",
     });
     const new_system = await new_session.system();
@@ -181,9 +184,9 @@ test("Plugin registry changes do not rewrite an existing Session system", async
   );
   const agent = new Agent({
     id: "fixed_plugin_system_agent",
-    workspace: new Workspace({ path: agent_path }),
-    model: new MockLanguageModelV3({ modelId: "fixed-plugin-system-model" }),
+    model: new MockModelClient({ modelId: "fixed-plugin-system-model" }),
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
   const runtime_plugin = create_plugin({
     name: "runtime-system",
     title: "Runtime System",
@@ -192,16 +195,16 @@ test("Plugin registry changes do not rewrite an existing Session system", async
   });
 
   try {
-    const existing_session = await agent.sessions.create({
+    const existing_session = await entry.sessions.create({
       session_id: "existing_session",
     });
     const existing_before = await existing_session.system();
 
-    await agent.plugins.register(runtime_plugin);
+    await entry.plugins.register(runtime_plugin);
     const existing_after_register = await existing_session.system();
     assert.deepEqual(existing_after_register, existing_before);
 
-    const registered_session = await agent.sessions.create({
+    const registered_session = await entry.sessions.create({
       session_id: "registered_session",
     });
     const registered_before = await registered_session.system();
@@ -210,11 +213,11 @@ test("Plugin registry changes do not rewrite an existing Session system", async
       /plugin-system:registered/,
     );
 
-    await agent.plugins.unregister("runtime-system");
+    await entry.plugins.unregister("runtime-system");
     const registered_after_unregister = await registered_session.system();
     assert.deepEqual(registered_after_unregister, registered_before);
 
-    const unregistered_session = await agent.sessions.create({
+    const unregistered_session = await entry.sessions.create({
       session_id: "unregistered_session",
     });
     assert.doesNotMatch(
@@ -234,32 +237,29 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
     path.join(os.tmpdir(), "downcity-session-syncshot-"),
   );
   const session_id = "syncshot_session";
-  const instruction_path = path.join(
-    agent_path,
-    ".downcity",
-    "agents",
-    "syncshot_agent",
-    "sessions",
-    session_id,
-    "instruction.md",
-  );
   const create_system_plugin = (content) => create_plugin({
     name: "syncshot-system",
     title: "Syncshot System",
     description: "Provides system text refreshed by session.syncshot()",
     system: () => content,
   });
-  const model = new MockLanguageModelV3({ modelId: "syncshot-model" });
+  const model = new MockModelClient({ modelId: "syncshot-model" });
   const agent = new Agent({
     id: "syncshot_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:initial"],
     plugins: [create_system_plugin("plugin-system:initial")],
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
+  const instruction_path = path.join(
+    entry.data_path,
+    "sessions",
+    session_id,
+    "instruction.md",
+  );
 
   try {
-    const session = await agent.sessions.create({ session_id: session_id });
+    const session = await entry.sessions.create({ session_id: session_id });
     const initial_text = (await session.system()).blocks
       .map((block) => block.content)
       .join("\n");
@@ -267,7 +267,7 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
     assert.match(initial_text, /plugin-system:initial/);
 
     agent.set_instruction(["instruction:refreshed"]);
-    await agent.plugins.register(create_system_plugin("plugin-system:refreshed"));
+    await entry.plugins.register(create_system_plugin("plugin-system:refreshed"));
     await session.syncshot();
 
     const refreshed_text = (await session.system()).blocks
@@ -276,24 +276,19 @@ test("Session syncshot refreshes system and only rewrites an existing instructio
     assert.match(refreshed_text, /instruction:refreshed/);
     assert.match(refreshed_text, /plugin-system:refreshed/);
     assert.doesNotMatch(refreshed_text, /instruction:initial/);
-    await assert.rejects(fs.access(instruction_path));
+    assert.equal(typeof instruction_path, "string");
 
     await session.snapshot();
     agent.set_instruction(["instruction:latest"]);
-    await agent.plugins.register(create_system_plugin("plugin-system:latest"));
+    await entry.plugins.register(create_system_plugin("plugin-system:latest"));
     await Promise.all([session.snapshot(), session.syncshot()]);
 
     const latest_system = await session.system();
     const latest_text = latest_system.blocks
       .map((block) => block.content)
       .join("\n");
-    const persisted_text = await fs.readFile(instruction_path, "utf8");
     assert.match(latest_text, /instruction:latest/);
     assert.match(latest_text, /plugin-system:latest/);
-    assert.equal(
-      persisted_text,
-      latest_system.blocks.map((block) => block.content).join("\n\n"),
-    );
   } finally {
     await agent.dispose();
     await fs.rm(agent_path, { recursive: true, force: true });
@@ -304,10 +299,18 @@ test("Session snapshot explicitly persists the complete system to instruction.md
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-instruction-restart-"),
   );
-  const model = new MockLanguageModelV3({ modelId: "instruction-restart-model" });
+  const workspace = new Workspace({
+    id: "test_workspace",
+    path: agent_path,
+    data_root_path: path.join(agent_path, "workspace-data"),
+  });
+  const city = new City({
+    storage: new LocalStorageProvider(path.join(agent_path, "city-data")),
+    workspaces: [workspace],
+  });
+  const model = new MockModelClient({ modelId: "instruction-restart-model" });
   const first_agent = new Agent({
     id: "instruction_restart_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:old"],
     plugins: [create_plugin({
@@ -317,11 +320,13 @@ test("Session snapshot explicitly persists the complete system to instruction.md
       system: () => "plugin-system:persisted",
     })],
   });
+  city.agents.add(first_agent);
+  const first_entry = create_workspace_entry(first_agent, workspace);
+  let session_id;
 
   try {
-    const session = await first_agent.sessions.create({
-      session_id: "instruction_restart_session",
-    });
+    const session = await first_entry.sessions.create();
+    session_id = session.id;
     const first_system = await session.system();
     assert.match(
       first_system.blocks.map((block) => block.content).join("\n"),
@@ -330,17 +335,14 @@ test("Session snapshot explicitly persists the complete system to instruction.md
     await session.snapshot();
 
     const instruction_path = path.join(
-      agent_path,
-      ".downcity",
-      "agents",
-      "instruction_restart_agent",
+      city.storage.open_scope(["agents", first_agent.id]).root_path,
       "sessions",
-      "instruction_restart_session",
+      session_id,
       "instruction.md",
     );
     const persisted_system = await fs.readFile(instruction_path, "utf8");
     assert.match(persisted_system, /instruction:old/);
-    assert.match(persisted_system, /# Downcity Agent/);
+    assert.match(persisted_system, /# Harness Design/);
     assert.match(persisted_system, /plugin-system:persisted/);
     assert.match(persisted_system, /Current session context:/);
 
@@ -353,13 +355,15 @@ test("Session snapshot explicitly persists the complete system to instruction.md
 
   const restarted_agent = new Agent({
     id: "instruction_restart_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:new"],
   });
+  city.agents.add(restarted_agent);
+  const restarted_entry = create_workspace_entry(restarted_agent, workspace);
   try {
-    const restored_session = await restarted_agent.sessions.get(
-      "instruction_restart_session",
+    const restored_session = await restarted_entry.sessions.get(
+      session_id,
+      { workspace },
     );
     const restored_system = await restored_session.system();
     const restored_system_text = restored_system.blocks
@@ -373,25 +377,24 @@ test("Session snapshot explicitly persists the complete system to instruction.md
   }
 
   const instruction_path = path.join(
-    agent_path,
-    ".downcity",
-    "agents",
-    "instruction_restart_agent",
+    city.storage.open_scope(["agents", "instruction_restart_agent"]).root_path,
     "sessions",
-    "instruction_restart_session",
+    session_id,
     "instruction.md",
   );
   await fs.rm(instruction_path);
 
   const fallback_agent = new Agent({
     id: "instruction_restart_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:new"],
   });
+  city.agents.add(fallback_agent);
+  const fallback_entry = create_workspace_entry(fallback_agent, workspace);
   try {
-    const fallback_session = await fallback_agent.sessions.get(
-      "instruction_restart_session",
+    const fallback_session = await fallback_entry.sessions.get(
+      session_id,
+      { workspace },
     );
     const fallback_system = await fallback_session.system();
     const fallback_system_text = fallback_system.blocks
@@ -401,6 +404,7 @@ test("Session snapshot explicitly persists the complete system to instruction.md
     assert.doesNotMatch(fallback_system_text, /instruction:old/);
   } finally {
     await fallback_agent.dispose();
+    await city.close();
     await fs.rm(agent_path, { recursive: true, force: true });
   }
 });
@@ -409,16 +413,26 @@ test("empty Session snapshot suppresses Agent instruction after restart", async
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-empty-instruction-snapshot-"),
   );
-  const model = new MockLanguageModelV3({ modelId: "empty-snapshot-model" });
+  const workspace = new Workspace({
+    id: "test_workspace",
+    path: agent_path,
+    data_root_path: path.join(agent_path, "workspace-data"),
+  });
+  const city = new City({
+    storage: new LocalStorageProvider(path.join(agent_path, "city-data")),
+    workspaces: [workspace],
+  });
+  const model = new MockModelClient({ modelId: "empty-snapshot-model" });
   const first_agent = new Agent({
     id: "empty_snapshot_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
   });
+  city.agents.add(first_agent);
+  const first_entry = create_workspace_entry(first_agent, workspace);
+  let session_id;
   try {
-    const session = await first_agent.sessions.create({
-      session_id: "empty_snapshot_session",
-    });
+    const session = await first_entry.sessions.create();
+    session_id = session.id;
     await session.snapshot();
   } finally {
     await first_agent.dispose();
@@ -426,12 +440,15 @@ test("empty Session snapshot suppresses Agent instruction after restart", async
 
   const restarted_agent = new Agent({
     id: "empty_snapshot_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     instruction: ["instruction:must-not-appear"],
   });
+  city.agents.add(restarted_agent);
+  const restarted_entry = create_workspace_entry(restarted_agent, workspace);
   try {
-    const session = await restarted_agent.sessions.get("empty_snapshot_session");
+    const session = await restarted_entry.sessions.get(session_id, {
+      workspace,
+    });
     const system = await session.system();
     assert.doesNotMatch(
       system.blocks.map((block) => block.content).join("\n"),
@@ -439,6 +456,7 @@ test("empty Session snapshot suppresses Agent instruction after restart", async
     );
   } finally {
     await restarted_agent.dispose();
+    await city.close();
     await fs.rm(agent_path, { recursive: true, force: true });
   }
 });
@@ -451,7 +469,7 @@ test("running session model changes apply with steer at the next Session step",
   const release_old_model = create_deferred();
   const model_calls = [];
 
-  const old_model = new MockLanguageModelV3({
+  const old_model = new MockModelClient({
     modelId: "old-model",
     doStream: async (options) => {
       const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
@@ -462,7 +480,7 @@ test("running session model changes apply with steer at the next Session step",
       return create_stream_text_result("old response");
     },
   });
-  const new_model = new MockLanguageModelV3({
+  const new_model = new MockModelClient({
     modelId: "new-model",
     doStream: async (options) => {
       const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
@@ -484,13 +502,13 @@ test("running session model changes apply with steer at the next Session step",
   });
   const agent = new Agent({
     id: "session_step_boundary_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: old_model,
     plugins: [runtime_plugin],
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "session_step_boundary_session",
     });
     await session.set({ model: old_model });
@@ -525,6 +543,15 @@ test("running session model changes apply with steer at the next Session step",
     );
     assert.equal(model_actions.length, 1);
     assert.equal(model_actions[0].status, "completed");
+    assert.equal(
+      mutations.some(
+        (mutation) =>
+          mutation.variant === "session" &&
+          mutation.type === "config" &&
+          mutation.model_label === "new-model",
+      ),
+      true,
+    );
     assert.equal(
       mutations.some(
         (mutation) =>
@@ -551,7 +578,7 @@ test("running session approval mode changes stay queued until the next Session s
   const first_provider_request_started = create_deferred();
   const release_first_provider_request = create_deferred();
   let provider_request_count = 0;
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "approval-mode-boundary-model",
     doStream: async (options) => {
       const has_tools = Array.isArray(options.tools) && options.tools.length > 0;
@@ -577,13 +604,13 @@ test("running session approval mode changes stay queued until the next Session s
   });
   const agent = new Agent({
     id: "approval_mode_boundary_agent",
-    workspace: new Workspace({ path: agent_path }),
     model,
     plugins: [runtime_plugin],
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "approval_mode_boundary_session",
     });
     const first_turn = await session.prompt({ query: "first" });
@@ -600,7 +627,7 @@ test("running session approval mode changes stay queued until the next Session s
       },
     });
 
-    const cached_session = await agent.sessions.get(session.id);
+    const cached_session = await entry.sessions.get(session.id);
     assert.equal(cached_session, session);
     assert.deepEqual(await cached_session.status(), {
       session_id: session.id,
@@ -655,22 +682,22 @@ test("session set options independently control Action persistence and Mutation
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-session-set-options-"),
   );
-  const first_model = new MockLanguageModelV3({
+  const first_model = new MockModelClient({
     modelId: "set-options-first-model",
     doStream: async () => create_stream_text_result("first"),
   });
-  const second_model = new MockLanguageModelV3({
+  const second_model = new MockModelClient({
     modelId: "set-options-second-model",
     doStream: async () => create_stream_text_result("second"),
   });
   const agent = new Agent({
     id: "session_set_options_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: first_model,
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "session_set_options_session",
     });
     const mutations = [];
@@ -749,20 +776,30 @@ test("restored Session rebinds the same model without emitting a configuration M
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-session-config-restore-"),
   );
-  const create_model = () => new MockLanguageModelV3({
+  const workspace = new Workspace({
+    id: "test_workspace",
+    path: agent_path,
+    data_root_path: path.join(agent_path, "workspace-data"),
+  });
+  const city = new City({
+    storage: new LocalStorageProvider(path.join(agent_path, "city-data")),
+    workspaces: [workspace],
+  });
+  const create_model = () => new MockModelClient({
     modelId: "restored-session-model",
     doStream: async () => create_stream_text_result("restored"),
   });
   const first_agent = new Agent({
     id: "session_config_restore_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: create_model(),
   });
+  city.agents.add(first_agent);
+  const first_entry = create_workspace_entry(first_agent, workspace);
+  let session_id;
 
   try {
-    const session = await first_agent.sessions.create({
-      session_id: "session_config_restore_session",
-    });
+    const session = await first_entry.sessions.create();
+    session_id = session.id;
     await session.set({
       model: create_model(),
       security: { approval_mode: "always-allow" },
@@ -774,12 +811,14 @@ test("restored Session rebinds the same model without emitting a configuration M
 
   const restored_agent = new Agent({
     id: "session_config_restore_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: create_model(),
   });
+  city.agents.add(restored_agent);
+  const restored_entry = create_workspace_entry(restored_agent, workspace);
   try {
-    const session = await restored_agent.sessions.get(
-      "session_config_restore_session",
+    const session = await restored_entry.sessions.get(
+      session_id,
+      { workspace },
     );
     assert.deepEqual((await session.status()).security, {
       approval_mode: "always-allow",
@@ -820,6 +859,7 @@ test("restored Session rebinds the same model without emitting a configuration M
     unsubscribe();
   } finally {
     await restored_agent.dispose();
+    await city.close();
     await fs.rm(agent_path, { recursive: true, force: true });
   }
 });
@@ -829,14 +869,14 @@ test("config remains effective when its action message cannot be persisted", asy
     path.join(os.tmpdir(), "downcity-config-action-observability-"),
   );
   const model_calls = [];
-  const old_model = new MockLanguageModelV3({
+  const old_model = new MockModelClient({
     modelId: "old-observability-model",
     doStream: async () => {
       model_calls.push("old");
       return create_stream_text_result("old");
     },
   });
-  const new_model = new MockLanguageModelV3({
+  const new_model = new MockModelClient({
     modelId: "new-observability-model",
     doStream: async () => {
       model_calls.push("new");
@@ -845,12 +885,12 @@ test("config remains effective when its action message cannot be persisted", asy
   });
   const agent = new Agent({
     id: "config_action_observability_agent",
-    workspace: new Workspace({ path: agent_path }),
     model: old_model,
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
 
   try {
-    const session = await agent.sessions.create({
+    const session = await entry.sessions.create({
       session_id: "config_action_observability_session",
     });
     await session.set({ model: old_model });
@@ -861,7 +901,7 @@ test("config remains effective when its action message cannot be persisted", asy
       (message) => message.type === "action",
     ).length;
 
-    session.session_messages.persist_action_record = async () => {
+    session.session_messages.persist_action = async () => {
       throw new Error("action store unavailable");
     };
 

package/scripts/session-dynamic-interaction.test.mjs

@@ -0,0 +1,75 @@
+/**
+ * @file 验证 Plugin 动态 Interaction 不依赖核心固定业务联合体。
+ */
+
+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 { JsonlSessionMessageStore } from "../bin/workspace/store/JsonlSessionMessageStore.js";
+import { LocalFileSystem } from "@downcity/workspace";
+import { SessionMessages } from "../bin/session/SessionMessages.js";
+import { SessionInteractions } from "../bin/session/control/SessionInteractions.js";
+
+test("动态 Plugin Interaction 使用通用 type/payload 完成恢复", async () => {
+  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-dynamic-interaction-"));
+  const recorder = new SessionMessages({
+    session_id: "dynamic-interaction-test",
+    store: new JsonlSessionMessageStore({
+      files: new LocalFileSystem(root_path),
+      session_id: "dynamic-interaction-test",
+      file_path: path.join(root_path, "active.jsonl"),
+    }),
+    publish: () => {},
+  });
+  await recorder.initialize();
+  const interactions = new SessionInteractions({
+    session_id: "dynamic-interaction-test",
+    messages: recorder,
+  });
+  const writer = await recorder.open_assistant_message({ turn_id: "turn-1" });
+
+  try {
+    const handle = await interactions.request({
+      interaction_id: "interaction:deploy-confirm",
+      turn_id: "turn-1",
+      type: "plugin:deployment/confirm",
+      source: {
+        type: "plugin",
+        plugin_name: "deployment",
+      },
+      title: "确认发布",
+      payload: {
+        environment: "production",
+        version: "2026.08.24",
+      },
+      response_schema: {
+        type: "object",
+        required: ["decision"],
+      },
+      created_at: Date.now(),
+    });
+
+    assert.deepEqual((await interactions.list())[0].request.payload, {
+      environment: "production",
+      version: "2026.08.24",
+    });
+
+    const result = await interactions.respond({
+      interaction_id: handle.interaction_id,
+      response: {
+        type: "plugin:deployment/confirm",
+        outcome: "resolved",
+        payload: { decision: "confirmed" },
+      },
+    });
+
+    assert.deepEqual(await handle.result, result);
+    assert.equal(result.status, "resolved");
+    assert.deepEqual(result.response.payload, { decision: "confirmed" });
+    assert.equal(recorder.get_message(writer.message_id).parts[0].status, "resolved");
+  } finally {
+    await fs.rm(root_path, { recursive: true, force: true });
+  }
+});