@downcity/agent 1.1.437 → 1.1.445

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

@@ -0,0 +1,202 @@
+/**
+ * @file 验证 Interaction 嵌套在所属 Tool Part 内，而不是作为独立 Part 平级存在。
+ *
+ * Interaction 与 Tool 是归属关系：Tool 在等待响应时阻塞，因此一次 Interaction 的
+ * 完整生命周期落在所属 Tool 的执行区间内，归属即结构，需求顺序由数组顺序表达。
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionAgentMessageState } from "../bin/session/messages/SessionAgentMessageState.js";
+import { SessionMessageCache } from "../bin/session/messages/SessionMessageCache.js";
+import { SessionMessages } from "../bin/session/messages/SessionMessages.js";
+
+/** 构造一条含 ready 状态 Tool Part 的流式 Assistant Message fixture。 */
+function create_writer_fixture() {
+  let message = {
+    message_id: "agent:session-1:1",
+    session_id: "session-1",
+    turn_id: "turn-1",
+    sequence: 1,
+    revision: 1,
+    visibility: "visible",
+    created_at: 1,
+    updated_at: 1,
+    role: "agent",
+    state: "streaming",
+    parts: [
+      {
+        part_id: "tool:call-9",
+        sequence: 1,
+        step_id: "step-1",
+        type: "tool",
+        tool_call_id: "call-9",
+        tool_name: "ask_question",
+        state: "ready",
+      },
+    ],
+  };
+  // 缓存与 State 都是真实实例：Interaction 变更依赖“读取当前快照 → 替换 Tool”的
+  // 串行语义，用桩会绕过被验证的部分。
+  const cache = new SessionMessageCache({
+    session_id: "session-1",
+    publish: () => {},
+  });
+  cache.set_held(message.message_id);
+  cache.accept(message, false);
+  const store = {
+    read_message: async (message_id) =>
+      message_id === message.message_id ? structuredClone(message) : null,
+    update_message: async (input) => {
+      message = structuredClone(input.message);
+      cache.accept(message, false);
+    },
+  };
+  const state = new SessionAgentMessageState({
+    session_id: "session-1",
+    store,
+    cache,
+  });
+  return {
+    state,
+    read_parts: () => message.parts,
+    read_tool: () => message.parts.find((part) => part.type === "tool"),
+  };
+}
+
+/** 构造一次属于 call-9 的提问请求。 */
+function create_question_request(interaction_id = "interaction-1") {
+  return {
+    interaction_id,
+    turn_id: "turn-1",
+    type: "question",
+    source: { type: "tool", tool_call_id: "call-9", tool_name: "ask_question" },
+    payload: { questions: [] },
+    created_at: 1,
+  };
+}
+
+test("Interaction 创建后嵌套在所属 Tool Part 内，不再平级存在", async () => {
+  const fixture = create_writer_fixture();
+
+  const interaction = await fixture.state.request_interaction(create_question_request());
+
+  assert.equal(interaction.status, "pending");
+  // 关键断言：Message 只有一个 Part，Interaction 不是其中之一。
+  assert.deepEqual(fixture.read_parts().map((part) => part.type), ["tool"]);
+  const tool = fixture.read_tool();
+  assert.equal(tool.state, "waiting-user");
+  assert.deepEqual(
+    tool.interactions.map((item) => item.interaction_id),
+    ["interaction-1"],
+  );
+});
+
+test("用户响应后 Tool 恢复运行，Interaction 就地终结", async () => {
+  const fixture = create_writer_fixture();
+  await fixture.state.request_interaction(create_question_request());
+
+  await fixture.state.resolve_interaction("interaction-1", {
+    type: "question",
+    outcome: "resolved",
+    payload: { answers: [{ question_id: "q1", value: "main" }] },
+  });
+
+  assert.deepEqual(fixture.read_parts().map((part) => part.type), ["tool"]);
+  const tool = fixture.read_tool();
+  assert.equal(tool.state, "running");
+  assert.equal(tool.interactions[0].status, "resolved");
+  assert.deepEqual(fixture.state.list_pending_interactions(), []);
+});
+
+test("拒绝响应会把所属 Tool 标记为失败", async () => {
+  const fixture = create_writer_fixture();
+  await fixture.state.request_interaction(create_question_request());
+
+  await fixture.state.resolve_interaction("interaction-1", {
+    type: "question",
+    outcome: "denied",
+    payload: {},
+  });
+
+  const tool = fixture.read_tool();
+  assert.equal(tool.state, "failed");
+  assert.equal(tool.interactions[0].status, "denied");
+  assert.equal(tool.error, "Interaction denied");
+});
+
+test("取消未响应交互会把所属 Tool 标记为失败并保留原因", async () => {
+  const fixture = create_writer_fixture();
+  await fixture.state.request_interaction(create_question_request());
+
+  await fixture.state.close_interaction("interaction-1", {
+    reason: "turn_stopped",
+  });
+
+  const tool = fixture.read_tool();
+  assert.equal(tool.state, "failed");
+  assert.equal(tool.error, "Interaction cancelled");
+  assert.equal(tool.interactions[0].status, "cancelled");
+  assert.equal(tool.interactions[0].cancel_reason, "turn_stopped");
+});
+
+test("等待中的 Interaction 可以按 Tool 归属查询", async () => {
+  const fixture = create_writer_fixture();
+  await fixture.state.request_interaction(create_question_request("interaction-1"));
+  await fixture.state.request_interaction(create_question_request("interaction-2"));
+
+  assert.deepEqual(
+    fixture.state.list_pending_interactions().map((item) => item.interaction_id),
+    ["interaction-1", "interaction-2"],
+  );
+  // 同一 Tool 内部按发生顺序保留。
+  assert.deepEqual(
+    fixture.read_tool().interactions.map((item) => item.interaction_id),
+    ["interaction-1", "interaction-2"],
+  );
+});
+
+test("Message 收口仍然整条发布，消费方才能收敛 state", async () => {
+  const stored_messages = [];
+  const publications = [];
+  const store = {
+    initialize: async () => {},
+    list_messages: async () => structuredClone(stored_messages),
+    list_recoverable_agent_messages: async () => [],
+    read_message: async (message_id) => structuredClone(
+      stored_messages.find((message) => message.message_id === message_id) ?? null,
+    ),
+    message_stats: async () => ({ message_count: 0, storage_bytes: 0, latest_message: null }),
+    create_message: async (build_message) => {
+      const message = build_message({ message_sequence: 1 });
+      stored_messages.push(structuredClone(message));
+      return structuredClone(message);
+    },
+    update_message: async ({ message, expected_revision }) => {
+      const index = stored_messages.findIndex(
+        (candidate) => candidate.message_id === message.message_id,
+      );
+      if (stored_messages[index]?.revision !== expected_revision) {
+        throw new Error("revision conflict");
+      }
+      stored_messages[index] = structuredClone(message);
+    },
+  };
+  const messages = new SessionMessages({
+    session_id: "session-1",
+    store,
+    publish: (mutation) => publications.push(mutation),
+  });
+  await messages.initialize();
+  const writer = await messages.open_agent_message({ turn_id: "turn-1" });
+  await writer.append_result_parts([{ type: "text", text: "处理中" }]);
+
+  publications.length = 0;
+  await writer.complete();
+
+  assert.deepEqual(
+    publications.map((mutation) => mutation.variant),
+    ["message"],
+  );
+  assert.equal(publications[0].message.state, "done");
+});

package/scripts/session-messages-error-part.test.mjs

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SessionMessages } from "../bin/session/SessionMessages.js";
+import { SessionMessages } from "../bin/session/messages/SessionMessages.js";
 
 /** 创建支持聚合创建和 expected revision 更新的最小内存 SessionStorage。 */
 function create_fixture(initial_messages = []) {

package/scripts/session-messages-error.test.mjs

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SessionMessages } from "../bin/session/SessionMessages.js";
+import { SessionMessages } from "../bin/session/messages/SessionMessages.js";
 
 function create_messages(store) {
   return new SessionMessages({

package/scripts/session-prompt-idempotency.test.mjs

@@ -5,8 +5,8 @@
 import { createHash } from "node:crypto";
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SessionLoop } from "../bin/session/SessionLoop.js";
-import { SessionQueue } from "../bin/session/SessionQueue.js";
+import { SessionLoop } from "../bin/session/loop/SessionLoop.js";
+import { SessionQueue } from "../bin/session/loop/SessionQueue.js";
 
 /** 创建只覆盖已完成幂等请求读取路径的最小 SessionLoop。 */
 function create_loop(request_id) {
@@ -52,7 +52,9 @@ function create_loop(request_id) {
         execute_count += 1;
         return { text: "unexpected", success: true };
       },
+      is_executing: () => false,
     },
+    advance_context: async () => false,
     maintain_context: async () => {},
     state: { ensure_runnable: async () => {} },
     messages: {

package/scripts/session-queue.test.mjs

@@ -4,7 +4,7 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { SessionQueue } from "../bin/session/SessionQueue.js";
+import { SessionQueue } from "../bin/session/loop/SessionQueue.js";
 
 function create_command(name, executed, cancel) {
   return {
@@ -98,3 +98,23 @@ test("SessionQueue 保留 Command 的类别与完成信息", async () => {
   assert.equal(command.kind, "maintenance");
   assert.deepEqual(command.completion, completion);
 });
+
+test("SessionQueue drain_maintenance 只取出 Maintenance 并保留 Prompt", async () => {
+  const queue = new SessionQueue();
+  const executed = [];
+  const prompt = create_command("prompt", executed, () => {});
+  const first_maintenance = create_command("config-1", executed);
+  const second_maintenance = create_command("config-2", executed);
+  queue.enqueue_command(prompt);
+  queue.enqueue_command(first_maintenance);
+  queue.enqueue_command(second_maintenance);
+
+  const drained = queue.drain_maintenance();
+  assert.deepEqual(drained, [first_maintenance, second_maintenance]);
+  for (const command of drained) await command.execute();
+  assert.deepEqual(executed, ["config-1", "config-2"]);
+
+  // Prompt 必须留在队列里由后续 Turn 消费。
+  assert.equal(queue.take_next(), prompt);
+  assert.equal(queue.has_command(), false);
+});

package/scripts/session-storage-sqlite.test.mjs

@@ -1,4 +1,4 @@
-/** @file 验证 SessionStorage 的 SQLite 事务、投影、恢复与 Policy 隔离边界。 */
+/** @file 验证 SessionStorage 的 SQLite 事务、投影、恢复与派生 namespace 隔离边界。 */
 
 import assert from "node:assert/strict";
 import fs from "node:fs/promises";
@@ -121,11 +121,11 @@ test("Storage 只查询中断状态，不擅自解释领域恢复语义", async
   await reopened.dispose();
 });
 
-test("Composer Policy 只能写自己的派生 namespace，clear 触发 FK 清理", async () => {
+test("Composer 只能写自己的派生 namespace，clear 触发 FK 清理", async () => {
   const directory_path = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-session-storage-"));
   const storage = await create_storage(directory_path);
   await storage.create_message(create_user_message);
-  const policy = storage.composer_storage("sequence");
+  const policy = storage.derived_store("sequence");
   await policy.transaction((transaction) => {
     transaction.execute("CREATE TABLE composer_sequence_test (message_id TEXT REFERENCES messages(message_id) ON DELETE CASCADE)");
     transaction.execute("INSERT INTO composer_sequence_test (message_id) VALUES (?)", ["user-1"]);

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

@@ -3,40 +3,58 @@
  *
  * 关键点（中文）
  * - 测试编译后的 bin 输出，避免测试文件依赖 TS 源码加载器。
- * - 自定义 instruction 不能替代 Downcity core；core 必须包含 Shell 与 plugin 总规则。
+ * - Agent 身份与 Downcity core 由 SDK 注入，不能被调用方 instruction 替代。
+ * - 身份块必须同时给出 agent name 与 id，且不携带项目路径。
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
 
 import { create_instruction_system_blocks } from "../bin/agent/AgentInstructions.js";
-import { build_session_system_blocks } from "../bin/session/SessionSystem.js";
+import { build_session_system_blocks } from "../bin/session/input/SessionSystem.js";
 
-test("instruction blocks keep Downcity core after custom instruction", () => {
-  const blocks = create_instruction_system_blocks(
-    ["你是这个项目的工程 agent。"],
-    "/tmp/downcity-project",
+test("instruction blocks keep identity, custom instruction, and Downcity core in order", () => {
+  const blocks = create_instruction_system_blocks({
+    agent_id: "reviewer",
+    agent_name: "Code Reviewer",
+    instruction: ["你是这个项目的工程 agent。"],
+  });
+
+  assert.deepEqual(
+    blocks.map((block) => `${block.source}:${block.name}`),
+    ["instruction:identity", "instruction:agent", "core:default"],
   );
+  assert.match(blocks[0].content, /^# Agent Identity/);
+  assert.match(blocks[0].content, /You are "Code Reviewer" \(agent id: reviewer\)\./);
+  assert.equal(blocks[1].content, "你是这个项目的工程 agent。");
+  assert.match(blocks[2].content, /# Harness Design/);
+  assert.match(blocks[2].content, /human-owned workspace/);
+  assert.match(blocks[2].content, /project structure is the control surface/);
+  assert.match(blocks[2].content, /# Shell Commands/);
+  assert.match(blocks[2].content, /# Power System/);
+  assert.doesNotMatch(blocks[2].content, /\/tmp\/downcity-project/);
+  assert.doesNotMatch(blocks[2].content, /current year/i);
+  assert.doesNotMatch(blocks[2].content, /# Project Runtime/);
+  assert.doesNotMatch(blocks[2].content, /\.downcity\/agents/);
+  assert.doesNotMatch(blocks[2].content, /\.downcity\/memory/);
+  assert.doesNotMatch(blocks[2].content, /\.downcity\/public/);
+});
+
+test("identity block falls back to agent id when name is empty", () => {
+  const blocks = create_instruction_system_blocks({
+    agent_id: "reviewer",
+    agent_name: "  ",
+    instruction: [],
+  });
 
   assert.deepEqual(
     blocks.map((block) => `${block.source}:${block.name}`),
-    ["instruction:agent", "core:default"],
+    ["instruction:identity", "core:default"],
   );
-  assert.match(blocks[1].content, /# Harness Design/);
-  assert.match(blocks[1].content, /# Harness Design/);
-  assert.match(blocks[1].content, /human-owned workspace/);
-  assert.match(blocks[1].content, /project structure is the control surface/);
-  assert.match(blocks[1].content, /# Shell Commands/);
-  assert.match(blocks[1].content, /# Plugin System/);
-  assert.doesNotMatch(blocks[1].content, /\/tmp\/downcity-project/);
-  assert.doesNotMatch(blocks[1].content, /current year/i);
-  assert.doesNotMatch(blocks[1].content, /# Project Runtime/);
-  assert.doesNotMatch(blocks[1].content, /\.downcity\/agents/);
-  assert.doesNotMatch(blocks[1].content, /\.downcity\/memory/);
-  assert.doesNotMatch(blocks[1].content, /\.downcity\/public/);
+  assert.match(blocks[0].content, /You are "reviewer" \(agent id: reviewer\)\./);
 });
 
-test("session system blocks are ordered as instruction, core, plugin, session", async () => {
+test("session system blocks are ordered as identity, instruction, core, power, session", async () => {
   const blocks = await build_session_system_blocks({
     agent_id: "agent-test",
     project_root: "/tmp/downcity-project",
@@ -44,16 +62,17 @@ test("session system blocks are ordered as instruction, core, plugin, session",
     created_at: Date.UTC(2026, 6, 9, 8, 0, 0),
     timezone: "Asia/Shanghai",
     get_instruction_system_blocks: () =>
-      create_instruction_system_blocks(
-        ["使用中文回复。"],
-        "/tmp/downcity-project",
-      ),
-    get_managed_plugin_system_blocks: async () => [],
-    get_plugin_system_blocks: async () => [
+      create_instruction_system_blocks({
+        agent_id: "agent-test",
+        agent_name: "Agent Test",
+        instruction: ["使用中文回复。"],
+      }),
+    get_managed_power_system_blocks: async () => [],
+    get_power_system_blocks: async () => [
       {
-        source: "plugin",
+        source: "power",
         name: "task",
-        content: "# Task Plugin\n\n任务插件说明。",
+        content: "# Task Power\n\n任务插件说明。",
       },
     ],
   });
@@ -61,26 +80,29 @@ test("session system blocks are ordered as instruction, core, plugin, session",
   assert.deepEqual(
     blocks.map((block) => `${block.source}:${block.name}`),
     [
+      "instruction:identity",
       "instruction:agent",
       "core:default",
-      "plugin:task",
+      "power:task",
       "session:context",
     ],
   );
-  assert.equal(blocks[0].content, "使用中文回复。");
-  assert.match(blocks[1].content, /plugin_call/);
-  assert.match(blocks[3].content, /^Current session context:/);
-  assert.match(
-    blocks[3].content,
-    /You are serving agent "agent-test" in session "session-test"\./,
-  );
+  assert.match(blocks[0].content, /You are "Agent Test" \(agent id: agent-test\)\./);
+  assert.equal(blocks[1].content, "使用中文回复。");
+  assert.match(blocks[2].content, /# Power System/);
+  assert.equal(blocks[3].content, "# Task Power\n\n任务插件说明。");
+  assert.match(blocks[4].content, /^Current session context:/);
+  assert.match(blocks[4].content, /This session is "session-test"\./);
   assert.match(
-    blocks[3].content,
+    blocks[4].content,
     /The current project root is "\/tmp\/downcity-project"\./,
   );
   assert.match(
-    blocks[3].content,
+    blocks[4].content,
     /This session was created at 2026-07-09T08:00:00\.000Z, with Asia\/Shanghai as its reference timezone\./,
   );
-  assert.doesNotMatch(blocks[3].content, /[\u3400-\u9fff]/u);
+  // session block 只描述 session 自身，不得重复 agent 身份。
+  assert.doesNotMatch(blocks[4].content, /agent-test/);
+  assert.doesNotMatch(blocks[4].content, /Agent Test/);
+  assert.doesNotMatch(blocks[4].content, /[\u3400-\u9fff]/u);
 });

package/scripts/session-turn-context.test.mjs

@@ -3,14 +3,14 @@
  *
  * 关键点（中文）
  * - 动态输入和输出只能通过领域行为读写。
- * - Step 切换和 Context dispose 都会闭合 Plugin Hook 作用域。
- * - Plugin 只获得独立的只读快照，不能访问根上下文能力。
+ * - Step 切换和 Context dispose 都会闭合 Power Hook 作用域。
+ * - Power 只获得独立的只读快照，不能访问根上下文能力。
  */
 
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { create_session_turn_context } from "../bin/session/runtime/SessionTurnContext.js";
+import { create_session_turn_context } from "../bin/session/loop/SessionTurnContext.js";
 
 test("SessionTurnContext 在检查点消费输入并封装输出缓冲", async () => {
   let commit_count = 0;
@@ -74,53 +74,50 @@ test("SessionTurnContext 只按顺序收集当前 Turn 的 Tool effects", () =>
   );
 });
 
-test("SessionTurnContext 负责 Plugin Hook 作用域与只读投影生命周期", async () => {
-  const released = [];
-  const create_scope = (name) => ({
-    system_blocks: async () => [],
-    pipeline: async (_point_name, value) => value,
-    effect: async () => {},
-    close: async () => released.push(name),
-  });
+test("SessionTurnContext 把 Workspace env 与 Agent systems 固化为只读快照", () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
     session_origin: { type: "group", group_id: "group-1" },
     turn_id: "turn-context-test",
     project_root: "/workspace",
   });
+  // commit 前是初始空值（尚未采集），commit 后是冻结快照。
+  assert.equal(context.step.workspace_env, undefined);
+  assert.deepEqual(context.step.agent_systems, []);
+
   context.step.commit({
     workspace_env: { REGION: "cn" },
     agent_systems: ["system"],
   });
-  await context.step.replace_hooks(create_scope("first"));
-  await context.step.replace_hooks(create_scope("second"));
 
-  const plugin_execution_context = context.step.hook_context("call-context-test");
-  assert.deepEqual(Object.keys(plugin_execution_context).sort(), [
-    "abort_signal",
-    "agent_systems",
-    "call_id",
-    "project_root",
-    "session_id",
-    "session_origin",
-    "turn_id",
-    "workspace_env",
-  ]);
-  assert.equal(Object.isFrozen(plugin_execution_context), true);
-  assert.equal(plugin_execution_context.call_id, "call-context-test");
-  assert.deepEqual(plugin_execution_context.session_origin, {
-    type: "group",
-    group_id: "group-1",
-  });
-  assert.deepEqual(plugin_execution_context.workspace_env, { REGION: "cn" });
-  assert.deepEqual(released, ["first"]);
+  assert.deepEqual(context.step.workspace_env, { REGION: "cn" });
+  assert.deepEqual(context.step.agent_systems, ["system"]);
+  // 快照必须冻结：Power 拿到的是值，不是可以回写内核的引用。
+  assert.equal(Object.isFrozen(context.step.workspace_env), true);
+  assert.equal(Object.isFrozen(context.step.agent_systems), true);
+});
 
-  await context.lifecycle.dispose();
-  await context.lifecycle.dispose();
-  assert.deepEqual(released, ["first", "second"]);
+/**
+ * Power hook 不再经 SessionTurnContext 装配。
+ *
+ * 旧实现里 Step 通过 `step.replace_hooks()` 打开 hook 作用域、通过
+ * `step.hook_context()` 取执行上下文。重构后 Power 产物由 City 编译并推送给 Agent，
+ * 这两个入口连同作用域类一起被删了（见 063d6cd1e）。
+ *
+ * 这条断言守的是「别再把它们长回来」：Session 层不再认识 hook 作用域。
+ */
+test("SessionTurnContext 不再承担 Power hook 装配", () => {
+  const context = create_session_turn_context({
+    session_id: "session-context-test",
+    session_origin: { type: "chat" },
+    turn_id: "turn-context-test",
+  });
+  for (const removed of ["replace_hooks", "hook_context", "release_extensions", "hooks"]) {
+    assert.equal(removed in context.step, false, `SessionTurnContext.step 又长回了 ${removed}`);
+  }
 });
 
-test("SessionTurnContext 在整个 Turn 中只解析一次 Plugin Context", async () => {
+test("SessionTurnContext 在整个 Turn 中只解析一次 Power Context", async () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
     session_origin: { type: "chat" },
@@ -130,7 +127,7 @@ test("SessionTurnContext 在整个 Turn 中只解析一次 Plugin Context", asyn
   const resolver = async () => {
     resolve_count += 1;
     return [{
-      source_plugin: "memory",
+      source_power: "memory",
       name: "recall",
       content: "stable recall",
       trust_level: "reference",
@@ -138,12 +135,12 @@ test("SessionTurnContext 在整个 Turn 中只解析一次 Plugin Context", asyn
     }];
   };
 
-  const first = await context.step.resolve_plugin_context_blocks(resolver);
-  const second = await context.step.resolve_plugin_context_blocks(resolver);
+  const first = await context.step.resolve_power_context_blocks(resolver);
+  const second = await context.step.resolve_power_context_blocks(resolver);
 
   assert.equal(resolve_count, 1);
   assert.equal(first, second);
-  assert.equal(first, context.step.plugin_context_blocks);
+  assert.equal(first, context.step.power_context_blocks);
   assert.equal(Object.isFrozen(first), true);
   assert.equal(Object.isFrozen(first[0]), true);
   assert.equal(Object.isFrozen(first[0].citations), true);

package/scripts/verify-build-aliases.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const bin_root = path.resolve(__dirname, "../bin");
-const alias_pattern = /(?:from\s+["'](?:@\/|@executor\/)|import\s*\(\s*["'](?:@\/|@executor\/)|["'](?:@\/|@executor\/))/;
+const alias_pattern = /(?:from\s+["']@\/|import\s*\(\s*["']@\/|["']@\/)/;
 
 async function collect_files(dir_path) {
   const entries = await fs.readdir(dir_path, { withFileTypes: true });