@downcity/agent 1.1.408 → 1.1.437

package/city-test/session-model.test.mjs

@@ -1,169 +0,0 @@
-/**
- * @file 验证 RemoteAgent 通过 RPC 控制 Session。
- *
- * 关键点（中文）
- * - RemoteAgent 只传递 model_id，模型实例由 Agent Server 宿主解析。
- * - compact 只验证 command 被远程 Session 接受，不应自行启动 turn。
- */
-
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import net from "node:net";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { Agent, RemoteAgent } from "../bin/index.js";
-import { create_workspace_entry } from "../bin/internal/index.js";
-import { Workspace } from "../../workspace/bin/index.js";
-import { AgentRPC } from "../bin/city/transport/rpc/AgentRPC.js";
-
-const network_tests_enabled = process.env.DOWNCITY_RUN_NETWORK_TESTS === "1";
-
-async function reserve_port() {
-  const server = net.createServer();
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve);
-  });
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : 0;
-  await new Promise((resolve, reject) => {
-    server.close((error) => (error ? reject(error) : resolve()));
-  });
-  return port;
-}
-
-async function send_rpc_request(port, request) {
-  return await new Promise((resolve, reject) => {
-    const socket = net.createConnection({ host: "127.0.0.1", port });
-    let buffered = "";
-    socket.setTimeout(2_000);
-    socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
-    socket.on("data", (chunk) => {
-      buffered += chunk.toString("utf8");
-      const newline_index = buffered.indexOf("\n");
-      if (newline_index < 0) return;
-      socket.destroy();
-      resolve(JSON.parse(buffered.slice(0, newline_index)));
-    });
-    socket.once("timeout", () => reject(new Error("RPC request timed out")));
-    socket.once("error", reject);
-  });
-}
-
-test("RPC resolves model_id through the host and queues compact", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const project_root = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-server-session-model-"),
-  );
-  const model = {
-    modelId: "host-model",
-    provider: "test",
-  };
-  const agent = new Agent({
-    id: "rpc_model_agent",
-    model,
-  });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "rpc_model_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
-  let resolved_model_id = "";
-  const rpc = new AgentRPC(entry, {
-    resolve_session_model: (model_id) => {
-      resolved_model_id = model_id;
-      return {
-        modelId: model_id,
-        provider: "test",
-      };
-    },
-  });
-  const port = await reserve_port();
-  const remote_agent = new RemoteAgent({
-    url: `rpc://127.0.0.1:${port}`,
-  });
-  try {
-    await rpc.listen({ host: "127.0.0.1", port });
-    const session = await remote_agent.sessions.create({
-      session_id: "rpc-model-session",
-    });
-    const initial_info = await session.get_info();
-    assert.equal("modelId" in initial_info, false);
-    assert.equal(initial_info.model_label, "host-model");
-    await session.set({ model_id: "selected-model" });
-    assert.equal(resolved_model_id, "selected-model");
-    assert.equal((await session.get_info()).model_label, "selected-model");
-    await session.compact();
-  } finally {
-    await remote_agent.close();
-    await rpc.close();
-    await agent.dispose();
-    await fs.rm(project_root, { recursive: true, force: true });
-  }
-});
-
-test("RPC rejects remote model switching when the host has no resolver", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const project_root = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-server-model-resolver-required-"),
-  );
-  const agent = new Agent({
-    id: "rpc_model_resolver_required_agent",
-    model: { modelId: "host-model", provider: "test" },
-  });
-  const entry = create_workspace_entry(agent, new Workspace({ id: "resolver_workspace", path: project_root, data_root_path: path.join(project_root, "data") }));
-  const rpc = new AgentRPC(entry);
-  const port = await reserve_port();
-  const remote_agent = new RemoteAgent({ url: `rpc://127.0.0.1:${port}` });
-  try {
-    await rpc.listen({ host: "127.0.0.1", port });
-    const session = await remote_agent.sessions.create({ session_id: "resolver-required" });
-    await assert.rejects(
-      session.set({ model_id: "selected-model" }),
-      /model switching is not configured by the host/,
-    );
-  } finally {
-    await remote_agent.close();
-    await rpc.close();
-    await agent.dispose();
-    await fs.rm(project_root, { recursive: true, force: true });
-  }
-});
-
-test("internal RPC 让宿主重新加载 Workspace Env", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const project_root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-server-env-reload-"));
-  const workspace = new Workspace({
-    id: "env_workspace",
-    path: project_root, data_root_path: path.join(project_root, "data"),
-    env: { BEFORE: "value" },
-  });
-  const agent = new Agent({ id: "rpc_env_agent" });
-  const entry = create_workspace_entry(agent, workspace);
-  let reload_count = 0;
-  const rpc = new AgentRPC(entry, {
-    reload_workspace_env: () => {
-      reload_count += 1;
-      const env = { AFTER: "value" };
-      workspace.set_env(env);
-      return env;
-    },
-  });
-  const port = await reserve_port();
-  try {
-    await rpc.listen({ host: "127.0.0.1", port });
-    const frame = await send_rpc_request(port, {
-      id: "reload-env",
-      method: "internal.workspace.reload_env",
-    });
-    assert.equal(frame.success, true);
-    assert.equal(frame.data.reloaded, true);
-    assert.equal(frame.data.key_count, 1);
-    assert.equal(reload_count, 1);
-    assert.deepEqual(workspace.get_env(), { AFTER: "value" });
-  } finally {
-    await rpc.close();
-    await agent.dispose();
-    await fs.rm(project_root, { recursive: true, force: true });
-  }
-});

package/city-test/transport-lifecycle.test.mjs

@@ -1,164 +0,0 @@
-/**
- * @file 验证 Agent HTTP/RPC transport 的协议错误与服务生命周期。
- *
- * 关键点（中文）
- * - HTTP 路由应将输入错误、领域错误映射为稳定 JSON 响应。
- * - transport 的 listen、binding 与 close 必须可重复调用且状态一致。
- */
-
-import assert from "node:assert/strict"
-import net from "node:net"
-import test from "node:test"
-import { AgentHTTP } from "../bin/city/transport/http/AgentHTTP.js"
-import { AgentRPC } from "../bin/city/transport/rpc/AgentRPC.js"
-
-const network_tests_enabled = process.env.DOWNCITY_RUN_NETWORK_TESTS === "1"
-
-async function reserve_port() {
-  const server = net.createServer()
-  await new Promise((resolve, reject) => {
-    server.once("error", reject)
-    server.listen(0, "127.0.0.1", resolve)
-  })
-  const address = server.address()
-  const port = typeof address === "object" && address ? address.port : 0
-  await new Promise((resolve, reject) => {
-    server.close((error) => error ? reject(error) : resolve())
-  })
-  return port
-}
-
-function create_transport_agent() {
-  return {
-    sessions: {
-      async list() {
-        throw new Error("session list failed")
-      },
-    },
-    plugins: {
-      async run_action({ plugin, action, payload }) {
-        if (action === "throw") throw new Error("plugin failed")
-        return { success: true, data: { plugin, action, payload } }
-      },
-    },
-  }
-}
-
-test("AgentHTTP exposes stable validation and domain error responses", async () => {
-  const http = new AgentHTTP(create_transport_agent())
-  const router = http.router()
-  assert.equal(http.router(), router)
-  assert.equal(http.server(), http.server())
-
-  const missing_plugin = await router.request("/api/plugins/action", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ action_name: "run" }),
-  })
-  assert.equal(missing_plugin.status, 400)
-  assert.deepEqual(await missing_plugin.json(), {
-    success: false,
-    error: "plugin_name is required",
-  })
-
-  const missing_action = await router.request("/api/plugins/action", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ plugin_name: "test" }),
-  })
-  assert.equal(missing_action.status, 400)
-  assert.equal((await missing_action.json()).error, "action_name is required")
-
-  const plugin_failure = await router.request("/api/plugins/action", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ plugin_name: "test", action_name: "throw" }),
-  })
-  assert.equal(plugin_failure.status, 500)
-  assert.equal((await plugin_failure.json()).error, "plugin failed")
-
-  const session_failure = await router.request("/api/sdk/sessions")
-  assert.equal(session_failure.status, 500)
-  assert.equal((await session_failure.json()).error, "session list failed")
-  assert.equal((await router.request("/unknown")).status, 404)
-})
-
-test("AgentHTTP listen, binding and close remain idempotent", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const http = new AgentHTTP(create_transport_agent())
-  const handle = http.server()
-  assert.equal(handle.binding(), null)
-  await assert.rejects(handle.listen({ port: 0 }), /valid TCP port/iu)
-
-  const port = await reserve_port()
-  const [first_binding, second_binding] = await Promise.all([
-    handle.listen({ host: "127.0.0.1", port }),
-    handle.listen({ host: "127.0.0.1", port }),
-  ])
-  assert.deepEqual(second_binding, first_binding)
-  assert.deepEqual(handle.binding(), first_binding)
-  assert.equal((await fetch(`${first_binding.url}/unknown`)).status, 404)
-
-  await http.close()
-  await http.close()
-  assert.equal(handle.binding(), null)
-  assert.equal(http.server(), handle)
-})
-
-test("AgentHTTP close queued during listen releases the new server", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const http = new AgentHTTP(create_transport_agent())
-  const handle = http.server()
-  const port = await reserve_port()
-  const listen_promise = handle.listen({ host: "127.0.0.1", port })
-  const close_promise = handle.close()
-  await Promise.all([listen_promise, close_promise])
-  assert.equal(handle.binding(), null)
-
-  const probe = net.createServer()
-  await new Promise((resolve, reject) => {
-    probe.once("error", reject)
-    probe.listen(port, "127.0.0.1", resolve)
-  })
-  await new Promise((resolve) => probe.close(resolve))
-})
-
-test("AgentRPC listen, binding and close remain idempotent", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const rpc = new AgentRPC(create_transport_agent())
-  const port = await reserve_port()
-  assert.equal(rpc.binding(), null)
-  try {
-    const [first_binding, second_binding] = await Promise.all([
-      rpc.listen({ host: "127.0.0.1", port }),
-      rpc.listen({ host: "127.0.0.1", port }),
-    ])
-    assert.deepEqual(second_binding, first_binding)
-    assert.deepEqual(rpc.binding(), first_binding)
-  } finally {
-    await rpc.close()
-    await rpc.close()
-  }
-  assert.equal(rpc.binding(), null)
-})
-
-test("AgentRPC close queued during listen releases the new server", {
-  skip: !network_tests_enabled,
-}, async () => {
-  const rpc = new AgentRPC(create_transport_agent())
-  const port = await reserve_port()
-  const listen_promise = rpc.listen({ host: "127.0.0.1", port })
-  const close_promise = rpc.close()
-  await Promise.all([listen_promise, close_promise])
-  assert.equal(rpc.binding(), null)
-
-  const probe = net.createServer()
-  await new Promise((resolve, reject) => {
-    probe.once("error", reject)
-    probe.listen(port, "127.0.0.1", resolve)
-  })
-  await new Promise((resolve) => probe.close(resolve))
-})

package/scripts/PlatformSandbox.mjs

@@ -1,17 +0,0 @@
-/** @file Agent 集成测试按当前宿主加载对应平台 Sandbox Adapter。 */
-
-export async function create_platform_sandbox() {
-  if (process.platform === "darwin") {
-    const { MacOsSeatbeltSandbox } = await import("@downcity/sandbox-macos");
-    return new MacOsSeatbeltSandbox();
-  }
-  if (process.platform === "linux") {
-    const { LinuxBubblewrapSandbox } = await import("@downcity/sandbox-linux");
-    return new LinuxBubblewrapSandbox();
-  }
-  if (process.platform === "win32") {
-    const { WindowsMxcSandbox } = await import("@downcity/sandbox-windows-mxc");
-    return new WindowsMxcSandbox();
-  }
-  throw new Error(`Unsupported test platform: ${process.platform}`);
-}

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

@@ -1,171 +0,0 @@
-/**
- * @file 验证 ActionScheduleStore 通过 Workspace execution entry 私有存储持久化异步事件流。
- */
-
-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 { ActionScheduleStore } from "../bin/index.js";
-import { LocalStorageProvider, Workspace } from "@downcity/workspace";
-
-/** 打开 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({ 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",
-    action_name: "run",
-    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");
-  assert.equal(await store.reset_running_jobs_to_pending(), 1);
-  assert.equal(await store.cancel_pending_job(created.id), true);
-  assert.equal((await store.get_job_by_id(created.id))?.status, "cancelled");
-
-  await workspace.dispose();
-});
-
-test("ActionScheduleStore serializes cross-instance pending claims", async (t) => {
-  const workspace_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-action-schedule-lock-"),
-  );
-  t.after(async () => {
-    await fs.rm(workspace_path, { recursive: true, force: true });
-  });
-  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",
-    payload: null,
-    run_at_ms: Date.now(),
-  });
-
-  const claims = await Promise.all([
-    first_store.mark_job_running(created.id),
-    second_store.mark_job_running(created.id),
-  ]);
-  assert.deepEqual(claims.sort(), [false, true]);
-  assert.equal((await first_store.get_job_by_id(created.id))?.status, "running");
-
-  await Promise.all([
-    first_workspace.dispose(),
-    second_workspace.dispose(),
-  ]);
-});
-
-test("ActionScheduleStore only allows running jobs to enter terminal states", async (t) => {
-  const workspace_path = await fs.mkdtemp(
-    path.join(os.tmpdir(), "downcity-action-schedule-state-"),
-  );
-  t.after(async () => {
-    await fs.rm(workspace_path, { recursive: true, force: true });
-  });
-  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",
-    action_name: "cancelled",
-    payload: null,
-    run_at_ms: Date.now(),
-  });
-  assert.equal(await store.cancel_pending_job(cancelled.id), true);
-  assert.equal(await store.mark_job_succeeded(cancelled.id), false);
-  assert.equal((await store.get_job_by_id(cancelled.id))?.status, "cancelled");
-
-  const running = await store.create_job({
-    plugin_name: "demo",
-    action_name: "running",
-    payload: null,
-    run_at_ms: Date.now(),
-  });
-  assert.equal(await store.mark_job_running(running.id), true);
-  assert.equal(await store.mark_job_succeeded(running.id), true);
-  assert.equal(await store.mark_job_failed(running.id, "late failure"), false);
-  assert.equal((await store.get_job_by_id(running.id))?.status, "succeeded");
-
-  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-env-shell-sandbox.test.mjs

@@ -1,94 +0,0 @@
-/**
- * @file 验证 Agent 动态 env 会进入 shell safe sandbox。
- *
- * 关键点（中文）
- * - 测试编译后的 package 入口，确保 SDK 用户拿到的行为与源码一致。
- * - 只允许 Agent env 中显式存在的 key 进入 safe sandbox，不继承完整宿主环境。
- */
-
-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 { 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) {
-  const result = await agent.tools.shell_exec.execute(
-    {
-      cmd,
-      shell: "/bin/sh",
-      login: false,
-      timeout_ms: 5000,
-      sandbox: "safe",
-    },
-    { toolCallId: "agent-env-shell-sandbox-test" },
-  );
-  assert.equal(result.success, true, result.error || result.output);
-  return String(result.output || "");
-}
-
-test("workspace set_env and patch_env are visible in shell safe sandbox", async (t) => {
-  const sandbox = await create_platform_sandbox();
-  const preflight = await sandbox.preflight();
-  if (!preflight.ok) {
-    t.skip(`safe sandbox unavailable: ${preflight.issues.map((issue) => issue.message).join("; ")}`);
-    return;
-  }
-
-  const root_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-env-"));
-  const previous_host_value = process.env.HOST_ONLY_ENV_REPRO;
-  process.env.HOST_ONLY_ENV_REPRO = "host_secret";
-
-  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" });
-  const entry = create_workspace_entry(agent, workspace);
-
-  try {
-    workspace.set_env({
-      DYNAMIC_ENV_REPRO: "initial_value",
-      DC_DYNAMIC_REPRO: "dc_initial",
-      REMOVED_ENV_REPRO: "remove_me",
-    });
-
-    const first_output = await execute_shell(
-      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/);
-    assert.match(first_output, /DC=dc_initial/);
-    assert.match(first_output, /REMOVED=remove_me/);
-    assert.match(first_output, /HOST_ONLY=\n/);
-
-    workspace.patch_env({
-      DYNAMIC_ENV_REPRO: "updated_value",
-      ADDED_ENV_REPRO: "added_value",
-      REMOVED_ENV_REPRO: null,
-    });
-
-    const second_output = await execute_shell(
-      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/);
-    assert.match(second_output, /ADDED=added_value/);
-    assert.match(second_output, /REMOVED=\n/);
-    assert.match(second_output, /HOST_ONLY=\n/);
-  } finally {
-    await agent.dispose();
-    await fs.rm(root_path, { recursive: true, force: true });
-    if (previous_host_value === undefined) {
-      delete process.env.HOST_ONLY_ENV_REPRO;
-    } else {
-      process.env.HOST_ONLY_ENV_REPRO = previous_host_value;
-    }
-  }
-});

package/scripts/agent-env.test.mjs

@@ -1,56 +0,0 @@
-/**
- * Agent 项目环境变量装配测试。
- */
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import {
-  Agent,
-} 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-"));
-}
-
-test("Workspace 显式 env 覆盖项目 .env 且不修改 process.env", () => {
-  const project_root = create_project_root();
-  const original_value = process.env.DOWNCITY_ENV_TEST;
-  try {
-    fs.writeFileSync(
-      path.join(project_root, ".env"),
-      "DOWNCITY_ENV_TEST=project\nPROJECT_ONLY=value\n",
-    );
-    const env = resolve_workspace_env(project_root, {
-      DOWNCITY_ENV_TEST: "host",
-      HOST_ONLY: "value",
-    });
-    assert.equal(env.DOWNCITY_ENV_TEST, "host");
-    assert.equal(env.HOST_ONLY, "value");
-    assert.equal(env.PROJECT_ONLY, "value");
-    assert.equal(process.env.DOWNCITY_ENV_TEST, original_value);
-  } finally {
-    fs.rmSync(project_root, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  }
-});
-
-test("Agent 运行时只使用显式 id，不读取完整项目 config", async () => {
-  const project_root = create_project_root();
-  try {
-    fs.writeFileSync(path.join(project_root, "downcity.json"), JSON.stringify({
-      id: "legacy_id",
-      version: "9.9.9",
-    }));
-    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(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 });
-  }
-});