@jpssff/vanor 0.1.0

package/base/test/session.test.js

@@ -0,0 +1,324 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { readSessionState, saveLatestSessionId, Session, latestSession, listSessions, listUserMessages } from "../core/session.js";
+import { createHarness } from "../core/harness.js";
+import { NullLogger } from "../logger.js";
+
+function tempPaths() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "vanor-session-"));
+  return {
+    root,
+    state: path.join(root, "state.json"),
+    sessions: path.join(root, "sessions"),
+    memory: path.join(root, "memory"),
+    working: path.join(root, "memory", "working"),
+    skills: path.join(root, "skills"),
+  };
+}
+
+test("Session.load 恢复消息、summary、usage 与模型", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const s = new Session(paths, logger, { id: "sess_restore", model: "p/m1" }).start();
+  s.addMessage({ id: "u1", role: "user", content: "旧问题", meta: {} });
+  s.addMessage({ id: "a1", role: "assistant", content: "旧回答", meta: {} });
+  s.addCompaction({ summary: "旧摘要", replaced: 1 });
+  s.setModel("p/m2");
+  s.addUsage({ promptTokens: 10, completionTokens: 5, totalTokens: 15 });
+
+  const loaded = Session.load(paths, logger, "sess_restore");
+  assert.ok(loaded);
+  assert.equal(loaded.id, "sess_restore");
+  assert.equal(loaded.model, "p/m2");
+  assert.equal(loaded.summary, "旧摘要");
+  assert.equal(loaded.messages.length, 1);
+  assert.equal(loaded.messages[0].content, "旧回答");
+  assert.equal(loaded.usage.totalTokens, 15);
+  assert.equal(loaded.restored, true);
+});
+
+test("listUserMessages 从 JSONL 读取完整用户消息历史", () => {
+  const paths = tempPaths();
+  const s = new Session(paths, new NullLogger(), { id: "sess_messages", model: "p/m" }).start();
+  s.addMessage({ id: "u1", role: "user", content: "第一个问题", meta: { timestamp: "2026-06-07T08:00:00.000Z" } });
+  s.addMessage({ id: "a1", role: "assistant", content: "回答", meta: {} });
+  s.addMessage({ id: "u2", role: "user", content: "第二个问题", meta: { timestamp: "2026-06-07T08:01:00.000Z" } });
+  s.addCompaction({ summary: "摘要", replaced: 2 });
+  s.replaceRecent([]);
+
+  const messages = listUserMessages(paths, "sess_messages");
+  assert.deepEqual(messages.map((m) => m.content), ["第一个问题", "第二个问题"]);
+  assert.equal(messages[0].time, "2026-06-07T08:00:00.000Z");
+});
+
+test("Session.load 跳过损坏 JSONL 行并裁剪未完成尾部", () => {
+  const paths = tempPaths();
+  fs.mkdirSync(paths.sessions, { recursive: true });
+  fs.writeFileSync(
+    path.join(paths.sessions, "sess_bad.jsonl"),
+    [
+      JSON.stringify({ type: "meta", key: "start", value: { model: "p/m" } }),
+      "{bad json",
+      JSON.stringify({ type: "message", message: { id: "u1", role: "user", content: "完成的问题", meta: {} } }),
+      JSON.stringify({ type: "message", message: { id: "a1", role: "assistant", content: "完成的回答", meta: {} } }),
+      JSON.stringify({ type: "message", message: { id: "u2", role: "user", content: "未完成的问题", meta: {} } }),
+      "",
+    ].join("\n"),
+  );
+
+  const loaded = Session.load(paths, new NullLogger(), "sess_bad");
+  assert.ok(loaded);
+  assert.equal(loaded.messages.length, 2);
+  assert.equal(loaded.messages.at(-1).role, "assistant");
+});
+
+test("latestSession 返回最近修改的会话，listSessions 正确统计消息数", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const older = new Session(paths, logger, { id: "sess_old", model: "p/a" }).start();
+  older.addMessage({ id: "u1", role: "user", content: "old", meta: {} });
+  const newer = new Session(paths, logger, { id: "sess_new", model: "p/b" }).start();
+  newer.addMessage({ id: "u2", role: "user", content: "new", meta: {} });
+  newer.addMessage({ id: "a2", role: "assistant", content: "ok", meta: {} });
+
+  fs.utimesSync(older.file, new Date(Date.now() - 10000), new Date(Date.now() - 10000));
+  fs.utimesSync(newer.file, new Date(), new Date());
+
+  const sessions = listSessions(paths);
+  assert.equal(sessions[0].id, "sess_new");
+  assert.equal(sessions[0].model, "p/b");
+  assert.equal(sessions[0].messageCount, 2);
+  assert.equal(latestSession(paths).id, "sess_new");
+});
+
+test("Session.resume 追加 resume meta", () => {
+  const paths = tempPaths();
+  paths.workspaceRoot = "/workspace/resume";
+  const s = new Session(paths, new NullLogger(), { id: "sess_resume", model: "p/m" }).start();
+  s.resume();
+  const text = fs.readFileSync(s.file, "utf8");
+  assert.match(text, /"key":"resume"/);
+  assert.equal(readSessionState(paths).latestSessionId, "sess_resume");
+  assert.equal(readSessionState(paths).workspaces["/workspace/resume"].latestSessionId, "sess_resume");
+});
+
+test("latestSession 优先使用 state.json 中的 latestSessionId", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const oldSession = new Session(paths, logger, { id: "sess_state_old", model: "p/old" }).start();
+  oldSession.addMessage({ id: "u1", role: "user", content: "old", meta: {} });
+  const newSession = new Session(paths, logger, { id: "sess_state_new", model: "p/new" }).start();
+  newSession.addMessage({ id: "u2", role: "user", content: "new", meta: {} });
+  fs.utimesSync(oldSession.file, new Date(Date.now() - 10000), new Date(Date.now() - 10000));
+  fs.utimesSync(newSession.file, new Date(), new Date());
+
+  saveLatestSessionId(paths, "sess_state_old");
+
+  const latest = latestSession(paths);
+  assert.equal(latest.id, "sess_state_old");
+  assert.equal(latest.model, "p/old");
+});
+
+test("latestSession 按 workspaceRoot 恢复对应会话", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const wsA = path.join(paths.root, "a");
+  const wsB = path.join(paths.root, "b");
+  const sessA = new Session({ ...paths, workspaceRoot: wsA }, logger, { id: "sess_ws_a", model: "p/a" }).start();
+  sessA.addMessage({ id: "u1", role: "user", content: "a", meta: {} });
+  const sessB = new Session({ ...paths, workspaceRoot: wsB }, logger, { id: "sess_ws_b", model: "p/b" }).start();
+  sessB.addMessage({ id: "u2", role: "user", content: "b", meta: {} });
+
+  assert.equal(latestSession(paths, wsA).id, "sess_ws_a");
+  assert.equal(latestSession(paths, wsB).id, "sess_ws_b");
+  assert.equal(readSessionState(paths).latestSessionId, "sess_ws_b"); // 全局兼容字段仍记录最后一次
+});
+
+test("latestSession 在 state 指向失效时回退扫描 sessions", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const s = new Session(paths, logger, { id: "sess_fallback", model: "p/m" }).start();
+  s.addMessage({ id: "u1", role: "user", content: "hi", meta: {} });
+  saveLatestSessionId(paths, "missing");
+
+  assert.equal(latestSession(paths).id, "sess_fallback");
+});
+
+test("createHarness 支持恢复最近会话", () => {
+  const paths = tempPaths();
+  fs.mkdirSync(paths.root, { recursive: true });
+  const logger = new NullLogger();
+  const s = new Session(paths, logger, { id: "sess_harness", model: "p/m" }).start();
+  s.addMessage({ id: "u1", role: "user", content: "继续这个任务", meta: {} });
+  s.addMessage({ id: "a1", role: "assistant", content: "好的", meta: {} });
+
+  const harness = createHarness({
+    paths,
+    logger,
+    restoreLatest: true,
+    config: {
+      llm: { defaultModel: "p/m", providers: { p: { type: "openai", baseURL: "http://x", apiKey: "k" } } },
+      logging: {},
+      memory: {},
+      agent: {},
+      security: { approval: "auto", workspaceRoot: paths.root },
+    },
+  });
+
+  assert.equal(harness.sessionRestored, true);
+  assert.equal(harness.session.id, "sess_harness");
+  assert.equal(harness.session.messages.length, 2);
+});
+
+test("createHarness 按当前工作区恢复对应会话", () => {
+  const paths = tempPaths();
+  const logger = new NullLogger();
+  const wsA = path.join(paths.root, "workspace-a");
+  const wsB = path.join(paths.root, "workspace-b");
+  new Session({ ...paths, workspaceRoot: wsA }, logger, { id: "sess_harness_a", model: "p/m" }).start();
+  new Session({ ...paths, workspaceRoot: wsB }, logger, { id: "sess_harness_b", model: "p/m" }).start();
+
+  const harnessA = createHarness({
+    paths,
+    logger,
+    restoreLatest: true,
+    config: {
+      llm: { defaultModel: "p/m", providers: { p: { type: "openai", baseURL: "http://x", apiKey: "k" } } },
+      logging: {},
+      memory: {},
+      agent: {},
+      security: { approval: "auto", workspaceRoot: wsA },
+    },
+  });
+
+  assert.equal(harnessA.sessionRestored, true);
+  assert.equal(harnessA.session.id, "sess_harness_a");
+});
+
+test("createHarness 支持热重载配置并更新运行时对象", () => {
+  const paths = tempPaths();
+  paths.config = path.join(paths.root, "config.json");
+  fs.mkdirSync(paths.root, { recursive: true });
+  const config1 = {
+    llm: { defaultModel: "p1/m1", providers: { p1: { type: "openai", baseURL: "http://one", apiKey: "k1" } } },
+    logging: {},
+    memory: {},
+    agent: { contextWindow: 100 },
+    security: { approval: "ask", workspaceRoot: paths.root },
+  };
+  const config2 = {
+    llm: { defaultModel: "p2/m2", providers: { p2: { type: "openai", baseURL: "http://two", apiKey: "k2" } } },
+    logging: { llmTrace: true },
+    memory: {},
+    agent: { contextWindow: 200 },
+    security: { approval: "auto", workspaceRoot: paths.root },
+  };
+  fs.writeFileSync(paths.config, JSON.stringify(config1));
+
+  const harness = createHarness({ paths, logger: new NullLogger(), config: config1 });
+  assert.equal(harness.model, "p1/m1");
+  assert.equal(harness.security.approval, "ask");
+  assert.equal(harness.config.agent.contextWindow, 100);
+
+  fs.writeFileSync(paths.config, JSON.stringify(config2));
+  const r = harness.reloadConfig({ force: true });
+  assert.equal(r.reloaded, true);
+  assert.equal(harness.model, "p2/m2");
+  assert.equal(harness.security.approval, "auto");
+  assert.equal(harness.config.agent.contextWindow, 200);
+  assert.doesNotThrow(() => harness.llm.resolveModel("p2/m2"));
+});
+
+test("createHarness 支持切换语言并写回配置", () => {
+  const paths = tempPaths();
+  paths.config = path.join(paths.root, "config.json");
+  fs.mkdirSync(paths.root, { recursive: true });
+  process.env.VANOR_TEST_KEY = "secret";
+  const config = {
+    llm: { defaultModel: "p/m", providers: { p: { type: "openai", baseURL: "http://one", apiKey: "env:VANOR_TEST_KEY" } } },
+    logging: {},
+    memory: {},
+    agent: {},
+    ui: { language: "en" },
+    security: { approval: "ask", workspaceRoot: paths.root },
+  };
+  fs.writeFileSync(paths.config, JSON.stringify(config));
+  const harness = createHarness({ paths, logger: new NullLogger(), config });
+
+  const next = harness.setLanguage("zh-CN");
+  const raw = JSON.parse(fs.readFileSync(paths.config, "utf8"));
+  assert.equal(next.language, "zh-CN");
+  assert.equal(harness.language, "zh-CN");
+  assert.equal(raw.ui.language, "zh-CN");
+  assert.equal(raw.llm.providers.p.apiKey, "env:VANOR_TEST_KEY");
+});
+
+test("热重载遇到无效配置时保留旧配置", () => {
+  const paths = tempPaths();
+  paths.config = path.join(paths.root, "config.json");
+  fs.mkdirSync(paths.root, { recursive: true });
+  const good = {
+    llm: { defaultModel: "p/m", providers: { p: { type: "openai", baseURL: "http://ok", apiKey: "k" } } },
+    logging: {},
+    memory: {},
+    agent: {},
+    security: { approval: "ask", workspaceRoot: paths.root },
+  };
+  fs.writeFileSync(paths.config, JSON.stringify(good));
+  const harness = createHarness({ paths, logger: new NullLogger(), config: good });
+
+  fs.writeFileSync(paths.config, JSON.stringify({ llm: { defaultModel: "missing/m", providers: {} } }));
+  const r = harness.reloadConfig({ force: true });
+  assert.ok(r.error);
+  assert.equal(harness.model, "p/m");
+  assert.equal(harness.config.llm.defaultModel, "p/m");
+});
+
+test("runTurn 前自动检测配置文件变更并热重载", async () => {
+  const paths = tempPaths();
+  paths.config = path.join(paths.root, "config.json");
+  fs.mkdirSync(paths.root, { recursive: true });
+  const config1 = {
+    llm: { defaultModel: "p1/m1", providers: { p1: { type: "openai", baseURL: "http://one", apiKey: "k1" } } },
+    logging: {},
+    memory: {},
+    agent: { maxIterations: 1 },
+    security: { approval: "auto", workspaceRoot: paths.root },
+  };
+  const config2 = {
+    llm: { defaultModel: "p2/m2", providers: { p2: { type: "openai", baseURL: "http://two", apiKey: "k2" } } },
+    logging: {},
+    memory: {},
+    agent: { maxIterations: 1 },
+    security: { approval: "auto", workspaceRoot: paths.root },
+  };
+  fs.writeFileSync(paths.config, JSON.stringify(config1));
+  const harness = createHarness({ paths, logger: new NullLogger(), config: config1 });
+
+  fs.writeFileSync(paths.config, JSON.stringify(config2));
+  fs.utimesSync(paths.config, new Date(Date.now() + 1000), new Date(Date.now() + 1000));
+
+  let requestedModel = "";
+  const oldFetch = globalThis.fetch;
+  globalThis.fetch = async (_url, req) => {
+    requestedModel = JSON.parse(req.body).model;
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode('data: {"choices":[{"delta":{"content":"ok"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n'));
+        controller.close();
+      },
+    });
+    return { ok: true, status: 200, body: stream, text: async () => "" };
+  };
+  try {
+    await harness.runTurn("hello", {}, new AbortController().signal);
+  } finally {
+    globalThis.fetch = oldFetch;
+  }
+  assert.equal(harness.model, "p2/m2");
+  assert.equal(requestedModel, "m2");
+});

package/base/test/skills.test.js

@@ -0,0 +1,236 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHarness } from "../core/harness.js";
+import { createSecurity } from "../security/index.js";
+import { createToolContext, runToolCall, ToolRegistry } from "../tools/index.js";
+import { createSkillsTool, defaultSkillDirs, loadSkills, renderSkills, summarizeSkills } from "../skills/loader.js";
+import { createI18n } from "../i18n/index.js";
+import { NullLogger } from "../logger.js";
+
+function tempPaths() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "vanor-skills-"));
+  return {
+    root,
+    skills: path.join(root, "skills"),
+    sessions: path.join(root, "sessions"),
+    memory: path.join(root, "memory"),
+    working: path.join(root, "memory", "working"),
+  };
+}
+
+function writeSkill(base, dir, name, description, body = "步骤说明") {
+  const skillDir = path.join(base, dir);
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(skillDir, "SKILL.md"),
+    ["---", `name: ${name}`, `description: ${description}`, "---", "", body, ""].join("\n"),
+  );
+}
+
+test("defaultSkillDirs 覆盖本机常见 skills 目录", () => {
+  const paths = tempPaths();
+  const workspace = path.join(paths.root, "workspace");
+  const dirs = defaultSkillDirs(paths, workspace);
+  assert.equal(dirs[0], paths.skills);
+  assert.equal(dirs[1], path.join(workspace, ".skills"));
+  assert.equal(dirs[2], path.join(workspace, "skills"));
+  assert.ok(dirs.includes(path.join(os.homedir(), ".cursor", "skills-cursor")));
+  assert.ok(dirs.includes(path.join(os.homedir(), ".claude", "skills")));
+  assert.ok(dirs.includes(path.join(os.homedir(), ".agents", "skills")));
+  assert.ok(dirs.includes(path.join(os.homedir(), ".codex", "skills")));
+  assert.ok(dirs.includes(path.join(os.homedir(), ".codex", "skills", ".archive")));
+});
+
+test("工作区 skills 优先于本机全局 skills", () => {
+  const paths = tempPaths();
+  const workspace = path.join(paths.root, "workspace");
+  const global = path.join(paths.root, "global");
+  writeSkill(path.join(workspace, ".skills"), "build", "build", "工作区隐藏技能");
+  writeSkill(path.join(workspace, "skills"), "test", "test", "工作区技能");
+  writeSkill(global, "build", "build", "全局同名技能");
+
+  const skills = loadSkills([...defaultSkillDirs(paths, workspace), global], new NullLogger());
+  assert.equal(skills.find((s) => s.name === "build").description, "工作区隐藏技能");
+  assert.equal(skills.find((s) => s.name === "test").description, "工作区技能");
+});
+
+test("loadSkills 按目录优先级去重并渲染到 prompt", () => {
+  const paths = tempPaths();
+  const shared = path.join(paths.root, "shared-skills");
+  writeSkill(shared, "deploy", "deploy", "共享部署流程");
+  writeSkill(paths.skills, "deploy", "deploy", "Vanor 本地部署流程");
+  writeSkill(paths.skills, "review", "review", "代码评审流程");
+
+  const skills = loadSkills([paths.skills, shared], new NullLogger());
+  assert.equal(skills.length, 2);
+  assert.equal(skills.find((s) => s.name === "deploy").description, "Vanor 本地部署流程");
+  const rendered = renderSkills(skills);
+  assert.match(rendered, /deploy/);
+  assert.match(rendered, /skills\.write\/edit/);
+  assert.match(rendered, /Available skills/);
+  const renderedZh = renderSkills(skills, createI18n("zh-CN"));
+  assert.match(renderedZh, /可用技能/);
+});
+
+test("summarizeSkills 统计总数和每个目录数量", () => {
+  const paths = tempPaths();
+  const shared = path.join(paths.root, "shared-skills");
+  writeSkill(paths.skills, "a", "a", "A");
+  writeSkill(paths.skills, "b", "b", "B");
+  writeSkill(shared, "c", "c", "C");
+
+  const skills = loadSkills([paths.skills, shared], new NullLogger());
+  const summary = summarizeSkills(skills);
+  assert.equal(summary.total, 3);
+  assert.deepEqual(
+    summary.byDir.map((x) => [x.dir, x.count]),
+    [
+      [paths.skills, 2],
+      [shared, 1],
+    ],
+  );
+});
+
+test("loadSkills 正确解析 YAML folded description", () => {
+  const paths = tempPaths();
+  const skillDir = path.join(paths.skills, "babysit");
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(skillDir, "SKILL.md"),
+    [
+      "---",
+      "name: babysit",
+      "description: >-",
+      "  Keep a PR merge-ready by triaging comments, resolving clear conflicts, and",
+      "  fixing CI in a loop.",
+      "---",
+      "# Babysit PR",
+      "",
+    ].join("\n"),
+  );
+
+  const skills = loadSkills([paths.skills], new NullLogger());
+  assert.equal(skills[0].name, "babysit");
+  assert.equal(
+    skills[0].description,
+    "Keep a PR merge-ready by triaging comments, resolving clear conflicts, and fixing CI in a loop.",
+  );
+});
+
+test("skills 工具支持 list/read/write/edit/remove，并按动作区分审批", async () => {
+  const paths = tempPaths();
+  let skills = [];
+  const reloadSkills = () => {
+    skills = loadSkills([paths.skills], new NullLogger());
+    return skills;
+  };
+  const reg = new ToolRegistry();
+  reg.register(createSkillsTool(paths, new NullLogger(), { getSkills: () => skills, reloadSkills }));
+  const security = createSecurity({ security: { approval: "ask", workspaceRoot: paths.root } });
+  let confirmCalls = 0;
+  const ctx = createToolContext({
+    security,
+    logger: new NullLogger(),
+    confirm: async () => {
+      confirmCalls++;
+      return true;
+    },
+  });
+
+  const empty = await runToolCall({ id: "1", name: "skills", arguments: { action: "list" } }, reg, ctx);
+  assert.equal(empty.content, "(no skills)");
+  assert.equal(confirmCalls, 0);
+
+  const written = await runToolCall(
+    {
+      id: "2",
+      name: "skills",
+      arguments: { action: "write", name: "测试技能", description: "用于测试", content: "# 使用方法\n先做 A" },
+    },
+    reg,
+    ctx,
+  );
+  assert.ok(!written.meta.isError);
+  assert.equal(confirmCalls, 1);
+  assert.equal(skills.length, 1);
+  assert.equal(skills[0].name, "测试技能");
+
+  const listed = await runToolCall({ id: "2b", name: "skills", arguments: { action: "list" } }, reg, ctx);
+  assert.match(listed.content, /Total: 1 skills/);
+  assert.match(listed.content, new RegExp(`${paths.skills.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}: 1`));
+
+  const read = await runToolCall({ id: "3", name: "skills", arguments: { action: "read", name: "测试技能" } }, reg, ctx);
+  assert.match(read.content, /先做 A/);
+  assert.equal(confirmCalls, 1);
+
+  const edited = await runToolCall(
+    { id: "4", name: "skills", arguments: { action: "edit", name: "测试技能", old_text: "先做 A", new_text: "先做 B" } },
+    reg,
+    ctx,
+  );
+  assert.ok(!edited.meta.isError);
+  assert.equal(confirmCalls, 2);
+  assert.match(
+    (await runToolCall({ id: "5", name: "skills", arguments: { action: "read", name: "测试技能" } }, reg, ctx)).content,
+    /先做 B/,
+  );
+
+  const removed = await runToolCall({ id: "6", name: "skills", arguments: { action: "remove", name: "测试技能" } }, reg, ctx);
+  assert.ok(!removed.meta.isError);
+  assert.equal(confirmCalls, 3);
+  assert.equal(skills.length, 0);
+});
+
+test("skills 工具支持中文 i18n 输出", async () => {
+  const paths = tempPaths();
+  const reg = new ToolRegistry();
+  reg.register(createSkillsTool(paths, new NullLogger(), { getSkills: () => [], getI18n: () => createI18n("zh-CN") }));
+  const security = createSecurity({ security: { approval: "auto", workspaceRoot: paths.root } });
+  const ctx = createToolContext({ security, logger: new NullLogger() });
+
+  const empty = await runToolCall({ id: "1", name: "skills", arguments: { action: "list" } }, reg, ctx);
+  assert.equal(empty.content, "（无技能）");
+});
+
+test("createHarness 每次请求前重新加载本地 skills 并注入 system prompt", async () => {
+  const paths = tempPaths();
+  let capturedSystem = "";
+  const oldFetch = globalThis.fetch;
+  globalThis.fetch = async (_url, req) => {
+    const parsed = JSON.parse(req.body);
+    capturedSystem = parsed.messages[0].content;
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(
+          encoder.encode('data: {"choices":[{"delta":{"content":"ok"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n'),
+        );
+        controller.close();
+      },
+    });
+    return { ok: true, status: 200, body: stream, text: async () => "" };
+  };
+
+  try {
+    const harness = createHarness({
+      paths,
+      logger: new NullLogger(),
+      config: {
+        llm: { defaultModel: "p/m", providers: { p: { type: "openai", baseURL: "http://example.test", apiKey: "k" } } },
+        logging: {},
+        memory: {},
+        agent: { maxIterations: 1 },
+        security: { approval: "auto", workspaceRoot: paths.root },
+      },
+    });
+    writeSkill(paths.skills, "late-skill", "late-skill", "创建 harness 后新增的技能");
+    await harness.runTurn("hello", {}, new AbortController().signal);
+    assert.match(capturedSystem, /late-skill/);
+    assert.match(capturedSystem, /创建 harness 后新增的技能/);
+  } finally {
+    globalThis.fetch = oldFetch;
+  }
+});