@downcity/agent 1.1.337 → 1.1.399

package/scripts/action-schedule-store.test.mjs

@@ -1,5 +1,5 @@
 /**
- * @file 验证 ActionScheduleStore 通过 Workspace FileSystem 持久化异步事件流。
+ * @file 验证 ActionScheduleStore 通过 Workspace execution entry 私有存储持久化异步事件流。
  */
 
 import assert from "node:assert/strict";
@@ -7,17 +7,32 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { ActionScheduleStore, Workspace } from "../bin/index.js";
+import { ActionScheduleStore } from "../bin/index.js";
+import { LocalStorageProvider, Workspace } from "@downcity/workspace";
 
-test("ActionScheduleStore persists through Workspace FileSystem", async (t) => {
+/** 打开 City 提供的 Agent 存储作用域。 */
+function open_agent_scope(storage, agent_id) {
+  return storage.open_scope([
+    "agents",
+    agent_id,
+  ]);
+}
+
+test("ActionScheduleStore persists through the Agent storage scope", async (t) => {
   const workspace_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-action-schedule-"),
   );
   t.after(async () => {
     await fs.rm(workspace_path, { recursive: true, force: true });
   });
-  const workspace = new Workspace({ path: workspace_path });
-  const store = new ActionScheduleStore(workspace.files);
+  const workspace = new Workspace({ id: "test_workspace", path: workspace_path });
+  const storage = open_agent_scope(new LocalStorageProvider(path.join(workspace_path, "data")), "schedule-test");
+  const store = new ActionScheduleStore(
+    storage.files,
+    storage.root_path,
+    "schedule-test",
+    "test_workspace",
+  );
 
   const created = await store.create_job({
     plugin_name: "demo",
@@ -25,6 +40,8 @@ test("ActionScheduleStore persists through Workspace FileSystem", async (t) => {
     payload: { value: 1 },
     run_at_ms: Date.now() - 1,
   });
+  assert.equal(created.agent_id, "schedule-test");
+  assert.equal(created.workspace_id, "test_workspace");
   assert.equal((await store.list_due_pending_jobs(Date.now())).length, 1);
   assert.equal(await store.mark_job_running(created.id), true);
   assert.equal((await store.get_job_by_id(created.id))?.status, "running");
@@ -42,10 +59,13 @@ test("ActionScheduleStore serializes cross-instance pending claims", async (t) =
   t.after(async () => {
     await fs.rm(workspace_path, { recursive: true, force: true });
   });
-  const first_workspace = new Workspace({ path: workspace_path });
-  const second_workspace = new Workspace({ path: workspace_path });
-  const first_store = new ActionScheduleStore(first_workspace.files);
-  const second_store = new ActionScheduleStore(second_workspace.files);
+  const first_workspace = new Workspace({ id: "test_workspace", path: workspace_path });
+  const second_workspace = new Workspace({ id: "test_workspace", path: workspace_path });
+  const shared_storage = new LocalStorageProvider(path.join(workspace_path, "data"));
+  const first_storage = open_agent_scope(shared_storage, "schedule-test");
+  const second_storage = open_agent_scope(shared_storage, "schedule-test");
+  const first_store = new ActionScheduleStore(first_storage.files, first_storage.root_path, "schedule-test", "test_workspace");
+  const second_store = new ActionScheduleStore(second_storage.files, second_storage.root_path, "schedule-test", "test_workspace");
   const created = await first_store.create_job({
     plugin_name: "demo",
     action_name: "run",
@@ -73,8 +93,9 @@ test("ActionScheduleStore only allows running jobs to enter terminal states", as
   t.after(async () => {
     await fs.rm(workspace_path, { recursive: true, force: true });
   });
-  const workspace = new Workspace({ path: workspace_path });
-  const store = new ActionScheduleStore(workspace.files);
+  const workspace = new Workspace({ id: "test_workspace", path: workspace_path });
+  const storage = open_agent_scope(new LocalStorageProvider(path.join(workspace_path, "data")), "schedule-test");
+  const store = new ActionScheduleStore(storage.files, storage.root_path, "schedule-test", "test_workspace");
 
   const cancelled = await store.create_job({
     plugin_name: "demo",
@@ -99,3 +120,52 @@ test("ActionScheduleStore only allows running jobs to enter terminal states", as
 
   await workspace.dispose();
 });
+
+test("ActionScheduleStore filters shared Workspace jobs by Agent ownership", async (t) => {
+  const workspace_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-action-schedule-owner-"),
+  );
+  t.after(async () => {
+    await fs.rm(workspace_path, { recursive: true, force: true });
+  });
+  const data_root_path = path.join(workspace_path, "data");
+  const first_workspace = new Workspace({
+    id: "test_workspace",
+    path: workspace_path,
+  });
+  const second_workspace = new Workspace({
+    id: "test_workspace",
+    path: workspace_path,
+  });
+  const shared_storage = new LocalStorageProvider(data_root_path);
+  const first_storage = open_agent_scope(shared_storage, "first-agent");
+  const second_storage = open_agent_scope(shared_storage, "second-agent");
+  const first_store = new ActionScheduleStore(
+    first_storage.files,
+    first_storage.root_path,
+    "first-agent",
+    "test_workspace",
+  );
+  const second_store = new ActionScheduleStore(
+    second_storage.files,
+    second_storage.root_path,
+    "second-agent",
+    "test_workspace",
+  );
+  const created = await first_store.create_job({
+    plugin_name: "demo",
+    action_name: "run",
+    payload: null,
+    run_at_ms: Date.now(),
+  });
+
+  assert.equal((await first_store.list_jobs()).length, 1);
+  assert.equal((await second_store.list_jobs()).length, 0);
+  assert.equal(await second_store.get_job_by_id(created.id), null);
+  assert.equal(await second_store.mark_job_running(created.id), false);
+
+  await Promise.all([
+    first_workspace.dispose(),
+    second_workspace.dispose(),
+  ]);
+});

package/scripts/agent-compiler.mjs

@@ -21,6 +21,8 @@ const packageRoot = path.resolve(__dirname, "..");
 const srcRoot = path.join(packageRoot, "src");
 const tsc_entry = module_require.resolve("typescript/bin/tsc");
 const tsc_alias_entry = module_require.resolve("tsc-alias/dist/bin/index.js");
+const rewrite_alias_script = path.join(packageRoot, "scripts/rewrite-build-aliases.mjs");
+const verify_alias_script = path.join(packageRoot, "scripts/verify-build-aliases.mjs");
 const generatedHeader = [
   "/**",
   " * 自动生成文件，请勿手改。",
@@ -80,7 +82,7 @@ async function writeGeneratedModule(sourcePath) {
   return true;
 }
 
-async function generateTextModules() {
+async function generate_text_modules() {
   const sourceFiles = await collectTextModuleSources(srcRoot);
   let updatedCount = 0;
   for (const sourcePath of sourceFiles) {
@@ -117,22 +119,24 @@ function spawnCommand(command, args, options = {}) {
 }
 
 async function runBuild() {
-  await generateTextModules();
+  await generate_text_modules();
   await Promise.all([
     fsp.rm(path.join(packageRoot, "bin"), { recursive: true, force: true }),
     fsp.rm(path.join(packageRoot, "tsconfig.tsbuildinfo"), { force: true }),
   ]);
   await spawnCommand(process.execPath, [tsc_entry]);
   await spawnCommand(process.execPath, [tsc_alias_entry, "-f"]);
+  await spawnCommand(process.execPath, [rewrite_alias_script]);
+  await spawnCommand(process.execPath, [verify_alias_script]);
 }
 
 async function runTypecheck() {
-  await generateTextModules();
+  await generate_text_modules();
   await spawnCommand(process.execPath, [tsc_entry, "--noEmit"]);
 }
 
 async function runDev() {
-  await generateTextModules();
+  await generate_text_modules();
 
   const watchers = [];
   const watchedDirs = new Set();
@@ -174,7 +178,7 @@ async function runDev() {
 
   async function regenerate() {
     try {
-      const result = await generateTextModules();
+      const result = await generate_text_modules();
       if (result.updatedCount > 0) {
         console.log(
           `[agent-compiler] regenerated ${String(result.updatedCount)} of ${String(result.sourceCount)} text module(s)`,
@@ -250,7 +254,7 @@ if (mode === "build") {
 } else if (mode === "dev") {
   await runDev();
 } else if (mode === "generate") {
-  const result = await generateTextModules();
+  const result = await generate_text_modules();
   console.log(
     `[agent-compiler] generated ${String(result.sourceCount)} text module(s), updated ${String(result.updatedCount)}`,
   );

package/scripts/agent-env-shell-sandbox.test.mjs

@@ -12,8 +12,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { Agent, Workspace } from "@downcity/agent";
-import { Shell } from "@downcity/shell";
+import { Agent } from "@downcity/agent";
+import { Workspace } from "@downcity/workspace";
+import { Shell } from "@downcity/workspace";
+import { create_workspace_entry } from "../bin/internal/index.js";
 import { create_platform_sandbox } from "./PlatformSandbox.mjs";
 
 async function execute_shell(agent, cmd) {
@@ -43,14 +45,12 @@ test("workspace set_env and patch_env are visible in shell safe sandbox", async
   const previous_host_value = process.env.HOST_ONLY_ENV_REPRO;
   process.env.HOST_ONLY_ENV_REPRO = "host_secret";
 
-  const workspace = new Workspace({
-    path: root_path,
+  const workspace = new Workspace({ id: "test_workspace",
+    path: root_path, data_root_path: path.join(root_path, "data"),
     shell: new Shell({ sandbox }),
   });
-  const agent = new Agent({
-    id: "agent-env-shell-sandbox-test",
-    workspace,
-  });
+  const agent = new Agent({ id: "agent-env-shell-sandbox-test" });
+  const entry = create_workspace_entry(agent, workspace);
 
   try {
     workspace.set_env({
@@ -60,7 +60,7 @@ test("workspace set_env and patch_env are visible in shell safe sandbox", async
     });
 
     const first_output = await execute_shell(
-      agent,
+      entry,
       'printf "CURRENT=%s\\nDC=%s\\nREMOVED=%s\\nHOST_ONLY=%s\\n" "$DYNAMIC_ENV_REPRO" "$DC_DYNAMIC_REPRO" "$REMOVED_ENV_REPRO" "$HOST_ONLY_ENV_REPRO"',
     );
     assert.match(first_output, /CURRENT=initial_value/);
@@ -75,7 +75,7 @@ test("workspace set_env and patch_env are visible in shell safe sandbox", async
     });
 
     const second_output = await execute_shell(
-      agent,
+      entry,
       'printf "CURRENT=%s\\nADDED=%s\\nREMOVED=%s\\nHOST_ONLY=%s\\n" "$DYNAMIC_ENV_REPRO" "$ADDED_ENV_REPRO" "$REMOVED_ENV_REPRO" "$HOST_ONLY_ENV_REPRO"',
     );
     assert.match(second_output, /CURRENT=updated_value/);

package/scripts/agent-env.test.mjs

@@ -8,9 +8,9 @@ import path from "node:path";
 import test from "node:test";
 import {
   Agent,
-  Workspace,
-  resolve_workspace_env,
 } from "../bin/index.js";
+import { create_workspace_entry } from "../bin/internal/index.js";
+import { Workspace, resolve_workspace_env } from "@downcity/workspace";
 
 function create_project_root() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "downcity-agent-env-"));
@@ -44,13 +44,11 @@ test("Agent 运行时只使用显式 id，不读取完整项目 config", async (
       id: "legacy_id",
       version: "9.9.9",
     }));
-    const agent = new Agent({
-      id: "sdk_id",
-      workspace: new Workspace({ path: project_root }),
-    });
+    const agent = new Agent({ id: "sdk_id" });
+    const entry = create_workspace_entry(agent, new Workspace({ id: "test_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
     assert.equal(agent.id, "sdk_id");
-    assert.equal(agent.workspace.path, fs.realpathSync(project_root));
-    await agent.ready();
+    assert.equal(entry.workspace.path, fs.realpathSync(project_root));
+    await entry.sessions.create({ session_id: "env_runtime" });
     await agent.dispose();
   } finally {
     fs.rmSync(project_root, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });

package/scripts/agent-multi-workspace.test.mjs

@@ -0,0 +1,213 @@
+/** 验证一个 Agent 可以进入多个 Workspace，且 Plugin Context 与生命周期彼此隔离。 */
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { Agent, create_plugin } from "../bin/index.js";
+import { create_workspace_entry, get_workspace_entry } from "../bin/internal/index.js";
+import { Workspace } from "@downcity/workspace";
+
+test("one Agent enters multiple Workspaces with contextual Plugin execution", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-workspaces-"));
+  const lifecycle_events = [];
+  const contexts = [];
+  const plugin = create_plugin({
+    name: "context_probe",
+    title: "Context Probe",
+    description: "Records the current Workspace Context.",
+    lifecycle: {
+      start: ({ agent_id }) => lifecycle_events.push(`start:${agent_id}`),
+      enter_workspace: ({ workspace_id }) => lifecycle_events.push(`enter:${workspace_id}`),
+      leave_workspace: ({ workspace_id }) => lifecycle_events.push(`leave:${workspace_id}`),
+      stop: ({ agent_id }) => lifecycle_events.push(`stop:${agent_id}`),
+    },
+    actions: {
+      inspect: {
+        description: "Read the current Workspace Context.",
+        execute: ({ context }) => {
+          contexts.push({
+            agent_id: context.agent_id,
+            workspace_id: context.workspace_id,
+            workspace_path: context.workspace_path,
+            data_path: context.data_path,
+          });
+          return { success: true, data: contexts.at(-1) };
+        },
+      },
+    },
+  });
+  await Promise.all([
+    fs.mkdir(path.join(root, "sdk")),
+    fs.mkdir(path.join(root, "homepage")),
+  ]);
+  const agent = new Agent({ id: "coder", plugins: [plugin] });
+  const first = create_workspace_entry(agent, new Workspace({
+    id: "sdk",
+    path: path.join(root, "sdk"),
+    data_root_path: path.join(root, "data"),
+  }));
+  const second = create_workspace_entry(agent, new Workspace({
+    id: "homepage",
+    path: path.join(root, "homepage"),
+    data_root_path: path.join(root, "data"),
+  }));
+
+  try {
+    const [first_result, second_result] = await Promise.all([
+      first.plugins.run_action({ plugin: "context_probe", action: "inspect" }),
+      second.plugins.run_action({ plugin: "context_probe", action: "inspect" }),
+    ]);
+    assert.equal(first_result.data.workspace_id, "sdk");
+    assert.equal(second_result.data.workspace_id, "homepage");
+    assert.deepEqual(new Set(contexts.map((item) => item.workspace_id)), new Set(["sdk", "homepage"]));
+    assert.equal(contexts[0].data_path, contexts[1].data_path);
+    assert.match(contexts[0].data_path, /\/memory\/agents\/coder\/plugins\/context_probe$/u);
+    assert.equal(lifecycle_events.filter((item) => item === "start:coder").length, 1);
+    assert.equal(lifecycle_events.filter((item) => item.startsWith("enter:")).length, 0);
+
+    await first.leave();
+    assert.equal(get_workspace_entry(agent, "sdk"), null);
+    assert.equal(get_workspace_entry(agent, "homepage"), second);
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+
+});
+
+test("Plugin runtime data is isolated by Agent and shared across Workspaces", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-plugin-data-"));
+  const contexts = [];
+  const plugin = create_plugin({
+    name: "data_probe",
+    title: "Data Probe",
+    description: "Records its runtime data path.",
+    actions: {
+      inspect: {
+        description: "Read the runtime data path.",
+        execute: ({ context }) => {
+          contexts.push({ agent_id: context.agent_id, workspace_id: context.workspace_id, data_path: context.data_path });
+          return { success: true, data: { data_path: context.data_path } };
+        },
+      },
+    },
+  });
+  await Promise.all([
+    fs.mkdir(path.join(root, "one")),
+    fs.mkdir(path.join(root, "two")),
+    fs.mkdir(path.join(root, "three")),
+  ]);
+  const agent_a = new Agent({ id: "data_agent_a", plugins: [plugin] });
+  const agent_b = new Agent({ id: "data_agent_b", plugins: [create_plugin({
+    name: "data_probe",
+    title: "Data Probe",
+    description: "Records its runtime data path.",
+    actions: {
+      inspect: {
+        description: "Read the runtime data path.",
+        execute: ({ context }) => {
+          contexts.push({ agent_id: context.agent_id, workspace_id: context.workspace_id, data_path: context.data_path });
+          return { success: true, data: { data_path: context.data_path } };
+        },
+      },
+    },
+  })] });
+  const first = create_workspace_entry(agent_a, new Workspace({ id: "one", path: path.join(root, "one"), data_root_path: path.join(root, "data") }));
+  const second = create_workspace_entry(agent_a, new Workspace({ id: "two", path: path.join(root, "two"), data_root_path: path.join(root, "data") }));
+  const third = create_workspace_entry(agent_b, new Workspace({ id: "three", path: path.join(root, "three"), data_root_path: path.join(root, "data") }));
+  try {
+    await Promise.all([
+      first.plugins.run_action({ plugin: "data_probe", action: "inspect" }),
+      second.plugins.run_action({ plugin: "data_probe", action: "inspect" }),
+      third.plugins.run_action({ plugin: "data_probe", action: "inspect" }),
+    ]);
+    const agent_a_paths = contexts.filter((item) => item.agent_id === "data_agent_a").map((item) => item.data_path);
+    const agent_b_paths = contexts.filter((item) => item.agent_id === "data_agent_b").map((item) => item.data_path);
+    assert.equal(new Set(agent_a_paths).size, 1);
+    assert.equal(new Set(agent_b_paths).size, 1);
+    assert.notEqual(agent_a_paths[0], agent_b_paths[0]);
+    assert.match(agent_a_paths[0], /\/memory\/agents\/data_agent_a\/plugins\/data_probe$/u);
+    assert.match(agent_b_paths[0], /\/memory\/agents\/data_agent_b\/plugins\/data_probe$/u);
+  } finally {
+    await Promise.all([agent_a.dispose(), agent_b.dispose()]);
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("Plugin can ignore Workspace while still receiving its Context", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-global-plugin-"));
+  let calls = 0;
+  const plugin = create_plugin({
+    name: "counter",
+    title: "Counter",
+    description: "Uses only Agent-level state.",
+    actions: {
+      increment: {
+        description: "Increment Agent-level state.",
+        execute: () => ({ success: true, data: { value: ++calls } }),
+      },
+    },
+  });
+  await Promise.all([
+    fs.mkdir(path.join(root, "one")),
+    fs.mkdir(path.join(root, "two")),
+  ]);
+  const agent = new Agent({ id: "global_counter", plugins: [plugin] });
+  const first = create_workspace_entry(agent, new Workspace({
+    id: "one",
+    path: path.join(root, "one"),
+    data_root_path: path.join(root, "data"),
+  }));
+  const second = create_workspace_entry(agent, new Workspace({
+    id: "two",
+    path: path.join(root, "two"),
+    data_root_path: path.join(root, "data"),
+  }));
+  try {
+    assert.equal((await first.plugins.run_action({ plugin: "counter", action: "increment" })).data.value, 1);
+    assert.equal((await second.plugins.run_action({ plugin: "counter", action: "increment" })).data.value, 2);
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
+test("Workspace cleanup continues after one Plugin leave failure", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-cleanup-"));
+  const lifecycle_events = [];
+  const failing_plugin = create_plugin({
+    name: "failing_cleanup",
+    lifecycle: {
+      leave_workspace: ({ workspace_id }) => {
+        lifecycle_events.push(`failing:${workspace_id}`);
+        throw new Error("cleanup failed");
+      },
+    },
+  });
+  const healthy_plugin = create_plugin({
+    name: "healthy_cleanup",
+    lifecycle: {
+      leave_workspace: ({ workspace_id }) => lifecycle_events.push(`healthy:${workspace_id}`),
+    },
+  });
+  const agent = new Agent({
+    id: "cleanup_agent",
+    plugins: [failing_plugin, healthy_plugin],
+  });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "cleanup",
+    path: root,
+    data_root_path: path.join(root, "data"),
+  }));
+
+  try {
+    await entry.sessions.list();
+    await entry.leave();
+    assert.equal(get_workspace_entry(agent, "cleanup"), null);
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});

package/scripts/agent-ready.test.mjs

@@ -12,8 +12,10 @@ 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 { Workspace } from "@downcity/workspace";
 import { create_plugin } from "../bin/plugin/core/PluginActionFactory.js";
 
 function create_deferred() {
@@ -103,7 +105,7 @@ test("session.prompt waits for agent runtime ready before model execution", asyn
       },
     },
   });
-  const model = new MockLanguageModelV3({
+  const model = new MockModelClient({
     modelId: "agent-ready-model",
     doStream: async () => {
       model_stream_calls += 1;
@@ -138,13 +140,13 @@ test("session.prompt waits for agent runtime ready before model execution", asyn
   });
   const agent = new Agent({
     id: "ready_agent",
-    workspace: new Workspace({ path: agent_path }),
     plugins: [blocking_plugin],
     model,
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "ready_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: "ready_session",
     });
     const prompt_promise = session.prompt({
@@ -159,14 +161,67 @@ test("session.prompt waits for agent runtime ready before model execution", asyn
     const result = await turn.finished;
 
     assert.equal(result.success, true);
-    assert.equal(model_stream_calls, 2);
+    assert.equal(model_stream_calls, 1);
   } finally {
     lifecycle_ready.resolve();
     await agent.dispose();
   }
 });
 
-test("agent ready isolates plugin lifecycle start failures", async () => {
+test("agent.plugins waits for lifecycle start before direct action execution", async () => {
+  const agent_path = await fs.mkdtemp(
+    path.join(os.tmpdir(), "downcity-agent-plugin-ready-"),
+  );
+  const lifecycle_ready = create_deferred();
+  let lifecycle_started = false;
+  let action_calls = 0;
+  const plugin = create_plugin({
+    name: "direct-action",
+    title: "Direct Action",
+    description: "Waits for lifecycle before direct calls",
+    lifecycle: {
+      start: async () => {
+        await lifecycle_ready.promise;
+        lifecycle_started = true;
+      },
+    },
+    actions: {
+      status: {
+        description: "Read lifecycle status",
+        execute: async () => {
+          action_calls += 1;
+          return { success: true, data: { lifecycle_started } };
+        },
+      },
+    },
+  });
+  const agent = new Agent({
+    id: "plugin_ready_agent",
+    plugins: [plugin],
+  });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "plugin_ready_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
+
+  try {
+    const action_promise = entry.plugins.run_action({
+      plugin: "direct-action",
+      action: "status",
+    });
+    assert.equal(await is_settled(action_promise), false);
+    assert.equal(action_calls, 0);
+
+    lifecycle_ready.resolve();
+    const result = await action_promise;
+    assert.equal(result.success, true);
+    assert.equal(result.data.lifecycle_started, true);
+    assert.equal(action_calls, 1);
+  } finally {
+    lifecycle_ready.resolve();
+    await agent.dispose();
+    await fs.rm(agent_path, { recursive: true, force: true });
+  }
+});
+
+test("首次 Session 操作等待初始化并隔离 Plugin lifecycle 启动失败", async () => {
   const agent_path = await fs.mkdtemp(
     path.join(os.tmpdir(), "downcity-agent-ready-isolation-"),
   );
@@ -189,12 +244,12 @@ test("agent ready isolates plugin lifecycle start failures", async () => {
   });
   const agent = new Agent({
     id: "ready_isolation_agent",
-    workspace: new Workspace({ path: agent_path }),
     plugins: [failing_plugin, healthy_plugin],
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "isolation_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
 
   try {
-    await agent.ready();
+    await entry.sessions.create({ session_id: "initial_barrier" });
 
     assert.equal(healthy_started, true);
     assert.equal(agent.plugins.status("failing")?.status, "error");
@@ -210,8 +265,8 @@ test("Agent registers PluginRegistry tools and removes them with the last action
   );
   const agent = new Agent({
     id: "state_plugin_tools_agent",
-    workspace: new Workspace({ path: agent_path }),
   });
+  const entry = create_workspace_entry(agent, new Workspace({ id: "plugin_tools_workspace", path: agent_path, data_root_path: path.join(agent_path, "data") }));
   const action_plugin = create_plugin({
     name: "dynamic_action",
     actions: {
@@ -223,18 +278,18 @@ test("Agent registers PluginRegistry tools and removes them with the last action
   });
 
   try {
-    assert.equal(agent.tools.plugin_read, undefined);
-    assert.equal(agent.tools.plugin_call, undefined);
+    assert.equal(entry.tools.plugin_read, undefined);
+    assert.equal(entry.tools.plugin_call, undefined);
 
     await agent.plugins.register(action_plugin);
 
-    assert.notEqual(agent.tools.plugin_read, undefined);
-    assert.notEqual(agent.tools.plugin_call, undefined);
+    assert.notEqual(entry.tools.plugin_read, undefined);
+    assert.notEqual(entry.tools.plugin_call, undefined);
 
     await agent.plugins.unregister("dynamic_action");
 
-    assert.equal(agent.tools.plugin_read, undefined);
-    assert.equal(agent.tools.plugin_call, undefined);
+    assert.equal(entry.tools.plugin_read, undefined);
+    assert.equal(entry.tools.plugin_call, undefined);
   } finally {
     await agent.dispose();
   }