opencode-acp 1.14.20 → 1.14.21-pr.317.34

package/README.md

@@ -235,13 +235,10 @@ ACP provides an `/acp` slash command (also accepts `/dcp` for backward compatibi
 
 | Command                 | Description                                                                                                                                |
 | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| `/acp`                  | Shows available ACP commands                                                                                                               |
+| `/acp`                  | Show compression status (same as `/acp stats`). Use `/acp help` for the command list                                                       |
 | `/acp context`          | Token usage breakdown by category (system, user, assistant, tools, etc.) and how much has been saved through pruning                       |
-| `/acp stats`            | Cumulative pruning statistics across all sessions                                                                                          |
-| `/acp manual [on\|off]` | Toggle manual mode. When on, the AI will not autonomously use context management tools                                                     |
-| `/acp compress [focus]` | Trigger a single compress tool execution. Optional focus text directs what content to compress, following the active `compress.mode`       |
-| `/acp decompress <n>`   | Restore a specific active compression by ID. Running without an argument shows available compression IDs, token sizes, and topics          |
-| `/acp recompress <n>`   | Re-apply a user-decompressed compression by ID. Running without an argument shows recompressible IDs, token sizes, and topics              |
+| `/acp stats`            | Compression status: blocks, context usage, ranges (same report as the `acp_status` tool)                                                   |
+| `/acp export`           | Export active compression blocks to a markdown file. Options: `--output <path>`, `--tier t1,t2,t3`, `--stdout`, `--append`                |
 
 ---
 
@@ -493,6 +490,21 @@ For the complete list with root cause analysis, see the [bug tracker](https://gi
 
 ## Changelog
 
+### v1.14.21 — /acp command fixes and completion (permission gate, export, help) (#286)
+
+**Problem**: Three gaps in the `/acp` command suite: (1) when the compress permission was `deny`, ALL `/acp` subcommands were silently swallowed (the gate is a pre-#233 leftover from when `/acp` triggered compression; every current subcommand is read-only or user-initiated); (2) bare `/acp` showed behavior inconsistent with the README and diverged from pi-acp (whose bare `/acp` shows the status report, same handler as `/acp-status`); (3) the requested `/acp export` command (#265) was unimplemented.
+
+**Fix**:
+- Removed the compress-permission `deny` gate from the command handler — `/acp` subcommands (context/stats/export) work regardless of compress permission; they are all read-only or user-initiated file writes.
+- Bare `/acp` (and `/dcp`) now shows the compression status report (same as `/acp stats`), aligned with pi-acp; `/acp help` shows the command list.
+- New `/acp export`: exports active compression blocks to markdown (`--output <path>`, `--tier t1,t2,t3`, `--stdout`, `--append`).
+
+Files: `lib/hooks.ts`, `lib/commands/export.ts`, `AGENTS.md`, `README.md`, `README.zh-CN.md`. Tests: `tests/hooks-permission.test.ts` updated.
+
+Closes: #285, #265.
+
+**Install**: `opencode plugin opencode-acp@latest --global`
+
 ### v1.14.20 — Post-v1.14.19 fix batch (modelContextLimit lifecycle, inactive-block decompress, logging)
 
 **Problem**: Five clusters of post-v1.14.19 issues: (1) `modelContextLimit` stayed stale after a model switch (#312) — within one LLM request the messages hook runs before the system hook refreshes the limit, and on a catalog miss (fresh instance + failed hydration) the previous model's window survived, so every percentage threshold misfired (#315); (2) `decompress` failed on standalone inactive blocks and inactive blocks were invisible in `acp_status` (#193); (3) a preemptive `acknowledgeRisk: true` (carried over from a non-quality error) hard-failed with "no quality gate rejection is pending" (#301); (4) debug nudge notifications used `sendIgnoredMessage` causing phantom turns, the debug recommendation-filter log spammed every turn, and ERROR/WARN lines only reached the daily log when debug was on (#311, #278, #279).

package/README.zh-CN.md

@@ -190,13 +190,10 @@ ACP 提供 `/acp` 斜杠命令（为向后兼容也接受 `/dcp`）：
 
 | 命令                    | 说明                                                                                                                |
 | ----------------------- | ------------------------------------------------------------------------------------------------------------------- |
-| `/acp`                  | 显示可用的 ACP 命令                                                                                                 |
+| `/acp`                  | 显示压缩状态（同 `/acp stats`）；`/acp help` 查看命令列表                                                                            |
 | `/acp context`          | 按类别（system、user、assistant、tools 等）显示 token 用量明细，以及通过剪枝节省的量                                |
-| `/acp stats`            | 跨所有会话的累计剪枝统计                                                                                            |
-| `/acp manual [on\|off]` | 切换手动模式。开启后，AI 不会自动使用上下文管理工具                                                                 |
-| `/acp compress [focus]` | 触发一次 `compress` 工具执行。可选的焦点文本指示要压缩的内容，遵循当前 `compress.mode`                              |
-| `/acp decompress <n>`   | 按 ID 恢复特定的活动压缩。不带参数运行时显示可用的压缩 ID、token 大小和主题                                         |
-| `/acp recompress <n>`   | 按 ID 重新应用用户解压的压缩。不带参数运行时显示可重新压缩的 ID、token 大小和主题                                   |
+| `/acp stats`            | 压缩状态：压缩块、上下文用量、推荐范围（与 `acp_status` 工具同一报告）                                                          |
+| `/acp export`           | 导出活动压缩块到 markdown 文件。选项：`--output <path>`、`--tier t1,t2,t3`、`--stdout`、`--append`                   |
 
 ---
 
@@ -447,6 +444,21 @@ ACP 是 DCP 的直接替代品。迁移步骤：
 
 ## 更新日志
 
+### v1.14.21 — /acp 命令修复与补全（权限门、export、help）(#286)
+
+**问题**：`/acp` 命令族的三个缺口：（1）压缩权限为 `deny` 时，**所有** `/acp` 子命令被静默吞掉（该门是 #233 之前 `/acp` 会触发压缩的残留；现在的子命令全是只读或用户发起的）；（2）无参 `/acp` 行为与 README 描述不一致，且与 pi-acp 不对齐（pi-acp 无参 `/acp` 显示状态报告，与 `/acp-status` 同一 handler）；（3）需求 `/acp export` 导出命令（#265）未实现。
+
+**修复**：
+- 从命令处理器移除压缩权限 `deny` 门——`/acp` 子命令（context/stats/export）现在无论压缩权限如何都能用，它们全部只读或用户发起的文件写入。
+- 无参 `/acp`（和 `/dcp`）现在显示压缩状态报告（同 `/acp stats`），对齐 pi-acp；`/acp help` 显示命令列表。
+- 新增 `/acp export`：将 active 压缩块导出为 markdown（`--output <path>`、`--tier t1,t2,t3`、`--stdout`、`--append`）。
+
+文件：`lib/hooks.ts`、`lib/commands/export.ts`、`AGENTS.md`、`README.md`、`README.zh-CN.md`。测试：`tests/hooks-permission.test.ts` 更新。
+
+关闭：#285、#265。
+
+**安装**：`opencode plugin opencode-acp@latest --global`
+
 ### v1.14.20 — v1.14.19 之后的修复批次（modelContextLimit 生命周期、inactive block 解压缩、日志）
 
 **问题**：五类 v1.14.19 之后发现的问题：（1）`modelContextLimit` 在模型切换后失效（#312）——同一次 LLM 请求内，messages hook 先于 system hook 刷新窗口值，而目录未命中时（新实例 + 水合失败），上一个模型的窗口值会一直残留，导致所有按百分比计算的阈值误触发（#315）；（2）`decompress` 对独立的 inactive block 报 `Block not found`，且 inactive block 在 `acp_status` 里完全不可见（#193）；（3）预防式 `acknowledgeRisk: true`（从非质量门禁错误里带过来的）直接报错 `no quality gate rejection is pending`（#301）；（4）debug nudge 通知用 `sendIgnoredMessage` 触发幽灵回合（#311），debug 推荐过滤日志每回合刷屏，ERROR/WARN 在 debug 关闭时不进日常日志（#311、#278、#279）。

package/dist/index.js

@@ -2900,14 +2900,14 @@ function applyCompressionState(state, input, selection, anchorMessageId, blockId
   block.directMessageIds = [...newlyCompressedMessageIds];
   block.directToolIds = [...newlyCompressedToolIds];
   block.compressedTokens = compressedTokens;
-  let effectiveTokens = compressedTokens;
+  let effectiveTokens2 = compressedTokens;
   for (const consumedBlockId of consumed) {
     const cb = messagesState.blocksById.get(consumedBlockId);
     if (cb && (cb.tier ?? 1) === targetTierForConsumption) {
-      effectiveTokens += cb.effectiveCompressedTokens ?? cb.compressedTokens;
+      effectiveTokens2 += cb.effectiveCompressedTokens ?? cb.compressedTokens;
     }
   }
-  block.effectiveCompressedTokens = effectiveTokens;
+  block.effectiveCompressedTokens = effectiveTokens2;
   state.stats.pruneTokenCounter += compressedTokens;
   state.stats.totalPruneTokens += state.stats.pruneTokenCounter;
   state.stats.pruneTokenCounter = 0;
@@ -8347,9 +8347,9 @@ function createDecompressTool(factoryCtx) {
         }
         const blockMessages = rawMessages.filter((m) => msgIdSet.has(extractMessageId(m)));
         const lines2 = blockMessages.map(extractMessageText2);
-        const { writeFile: writeFile3 } = await import("fs/promises");
+        const { writeFile: writeFile4 } = await import("fs/promises");
         const fileContent = lines2.length > 0 ? lines2.join("\n\n---\n\n") : targets[0]?.blocks[0]?.summary ?? "(no content available)";
-        await writeFile3(targetPath, fileContent, "utf-8");
+        await writeFile4(targetPath, fileContent, "utf-8");
         const displayIds2 = targets.map((t) => `b${t.displayId}`).join(", ");
         return `Block(s) ${displayIds2} content (${blockMessages.length} messages, ${fileContent.length} chars) written to ${targetPath}. Block(s) stay compressed \u2014 context unchanged. Use read tool to access specific parts.`;
       }
@@ -9025,7 +9025,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.14.20" : "dev";
+var LOG_VERSION = true ? "1.14.21-pr.317.34" : "dev";
 var Logger = class {
   logDir;
   enabled;
@@ -10089,6 +10089,308 @@ ${report}`;
   );
 }
 
+// lib/commands/export.ts
+import * as fs2 from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { dirname as dirname3, isAbsolute, join as join5, resolve } from "path";
+var ALL_TIERS = [1, 2, 3];
+var TIER_NAMES = {
+  1: "Tier 1 \u2014 Capture",
+  2: "Tier 2 \u2014 Distilled",
+  3: "Tier 3 \u2014 Condensed"
+};
+function parseExportArgs(rawArgs) {
+  const options = {
+    outputPath: "",
+    // "" sentinel => default path resolved later
+    tiers: /* @__PURE__ */ new Set(),
+    includeMetadata: true,
+    append: false
+  };
+  const tokens = tokenize2(rawArgs);
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    const [flag, inlineValue] = splitFlag(tok);
+    switch (flag) {
+      case "--output":
+      case "-o": {
+        const value = inlineValue ?? tokens[i + 1];
+        if (value === void 0) {
+          throw new Error("--output requires a path (use `-` for stdout)");
+        }
+        options.outputPath = value;
+        i += inlineValue !== void 0 ? 1 : 2;
+        break;
+      }
+      case "--tier":
+      case "-t": {
+        const value = inlineValue ?? tokens[i + 1];
+        if (value === void 0) {
+          throw new Error("--tier requires a value (e.g. t2,t3 or all)");
+        }
+        options.tiers = parseTiers(value);
+        i += inlineValue !== void 0 ? 1 : 2;
+        break;
+      }
+      case "--no-metadata":
+        if (inlineValue !== void 0) {
+          throw new Error("--no-metadata does not take a value");
+        }
+        options.includeMetadata = false;
+        i += 1;
+        break;
+      case "--metadata":
+        if (inlineValue !== void 0) {
+          throw new Error("--metadata does not take a value");
+        }
+        options.includeMetadata = true;
+        i += 1;
+        break;
+      case "--append":
+        if (inlineValue !== void 0) {
+          throw new Error("--append does not take a value");
+        }
+        options.append = true;
+        i += 1;
+        break;
+      case "--stdout":
+        if (inlineValue !== void 0) {
+          throw new Error("--stdout does not take a value");
+        }
+        options.outputPath = "-";
+        i += 1;
+        break;
+      default:
+        throw new Error(
+          `Unknown flag: ${tok}. Supported: --output, --tier, --no-metadata, --append, --stdout.`
+        );
+    }
+  }
+  return options;
+}
+function tokenize2(input) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(input)) !== null) {
+    tokens.push(m[1] ?? m[2] ?? m[3]);
+  }
+  return tokens;
+}
+function splitFlag(tok) {
+  const eq = tok.indexOf("=");
+  if (eq === -1) return [tok, void 0];
+  return [tok.slice(0, eq), tok.slice(eq + 1)];
+}
+function parseTiers(raw) {
+  const lower = raw.trim().toLowerCase();
+  if (lower === "all") return new Set(ALL_TIERS);
+  const parts = lower.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  const result = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    const digits = part.replace(/^t/i, "");
+    const n = Number(digits);
+    if (!Number.isInteger(n) || n < 1 || n > 3) {
+      throw new Error(
+        `Invalid tier "${part}". Expected t1, t2, t3, a combination (t2,t3), or "all".`
+      );
+    }
+    result.add(n);
+  }
+  if (result.size === 0) {
+    throw new Error(`Invalid tier "${raw}". Expected t1, t2, t3, or "all".`);
+  }
+  return result;
+}
+function resolveDefaultOutputPath(sessionId, cwd) {
+  const short = (sessionId || "session").slice(0, 8);
+  return join5(cwd, ".opencode", `acp-export-${short}.md`);
+}
+function formatTokens2(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+}
+function effectiveTokens(block) {
+  return block.effectiveCompressedTokens ?? block.compressedTokens ?? 0;
+}
+function collectActiveBlocks(state) {
+  const msgState = state.prune.messages;
+  const blocks = [];
+  for (const id of msgState.activeBlockIds) {
+    const block = msgState.blocksById.get(id);
+    if (block && block.active) {
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function filterByTier(blocks, tiers) {
+  if (tiers.size === 0) return blocks;
+  return blocks.filter((b) => tiers.has(b.tier ?? 1));
+}
+function tokenSpans(blocks) {
+  return {
+    effective: blocks.reduce((s, b) => s + effectiveTokens(b), 0),
+    summary: blocks.reduce((s, b) => s + (b.summaryTokens || 0), 0)
+  };
+}
+function tierCounts(blocks) {
+  const counts = {};
+  for (const b of blocks) {
+    const t = b.tier ?? 1;
+    counts[t] = (counts[t] || 0) + 1;
+  }
+  return ALL_TIERS.filter((t) => counts[t]).map((t) => `T${t}: ${counts[t]}`).join(", ");
+}
+function renderExportMarkdown(params) {
+  const { sessionId, generatedAt, blocks, tiers, includeMetadata } = params;
+  const out = [];
+  const tierFilterLabel = tiers.size === 0 ? "all" : ALL_TIERS.filter((t) => tiers.has(t)).map((t) => `T${t}`).join(", ");
+  out.push("# ACP Session Export");
+  out.push("");
+  out.push(`- **Session**: \`${(sessionId || "unknown").slice(0, 16)}\``);
+  out.push(`- **Generated**: ${generatedAt.toISOString()}`);
+  out.push(`- **Blocks exported**: ${blocks.length}`);
+  const breakdown = tierCounts(blocks);
+  if (breakdown) {
+    out.push(`  - ${breakdown}`);
+  }
+  out.push(`- **Tiers**: ${tierFilterLabel}`);
+  const span = tokenSpans(blocks);
+  if (blocks.length > 0) {
+    out.push(
+      `- **Coverage**: ${formatTokens2(span.effective)} original \u2192 ${formatTokens2(span.summary)} summary`
+    );
+  }
+  out.push("");
+  out.push("---");
+  out.push("");
+  if (blocks.length === 0) {
+    out.push("_No active compression blocks match the selected tiers._");
+    out.push("");
+    out.push(
+      "Tip: run `/acp export --tier all` to include every active tier, or trigger a compression first."
+    );
+    return out.join("\n");
+  }
+  for (const tier of [3, 2, 1]) {
+    const tierBlocks = blocks.filter((b) => (b.tier ?? 1) === tier).sort((a, b) => a.blockId - b.blockId);
+    if (tierBlocks.length === 0) continue;
+    out.push(`## ${TIER_NAMES[tier]}`);
+    out.push("");
+    for (const block of tierBlocks) {
+      const topic = block.topic || block.batchTopic || "(no topic)";
+      out.push(`### b${block.blockId} \u2014 ${topic}`);
+      out.push("");
+      if (includeMetadata) {
+        const mode = block.mode ?? "range";
+        const msgCount = block.effectiveMessageIds?.length ?? 0;
+        const created = new Date(block.createdAt).toISOString();
+        const age = block.survivedCount ?? 0;
+        out.push(`- **Tier**: T${tier} \xB7 **Mode**: ${mode}`);
+        out.push(`- **Messages**: ${msgCount} (effective)`);
+        out.push(
+          `- **Tokens**: ${formatTokens2(effectiveTokens(block))} \u2192 ${formatTokens2(block.summaryTokens || 0)} summary`
+        );
+        out.push(`- **Created**: ${created}`);
+        out.push(`- **Age**: survived ${age} transform${age === 1 ? "" : "s"}`);
+        out.push("");
+      }
+      const summary = (block.summary || "").trim() || "_(empty summary)_";
+      out.push(summary);
+      out.push("");
+      out.push("---");
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+async function handleExportCommand(ctx, args) {
+  const { client, state, logger, sessionId } = ctx;
+  let options;
+  try {
+    options = parseExportArgs(args);
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    logger.warn("export: argument parse failed", { error: msg, args });
+    await sendExportNotice(client, sessionId, ctx, `[ACP Export] ${msg}`);
+    return;
+  }
+  const tiers = options.tiers;
+  const allActive = collectActiveBlocks(state);
+  const blocks = filterByTier(allActive, tiers);
+  const generatedAt = /* @__PURE__ */ new Date();
+  const markdown = renderExportMarkdown({
+    sessionId,
+    generatedAt,
+    blocks,
+    tiers,
+    includeMetadata: options.includeMetadata
+  });
+  if (options.outputPath === "-") {
+    await sendExportNotice(client, sessionId, ctx, markdown);
+    return;
+  }
+  const cwd = ctx.workingDirectory || process.cwd();
+  const targetPath = options.outputPath !== "" ? isAbsolute(options.outputPath) ? options.outputPath : resolve(cwd, options.outputPath) : resolveDefaultOutputPath(sessionId, cwd);
+  try {
+    const dir = dirname3(targetPath);
+    if (!existsSync5(dir)) {
+      await fs2.mkdir(dir, { recursive: true });
+    }
+    const flag = options.append ? "a" : "w";
+    if (options.append && existsSync5(targetPath)) {
+      await fs2.appendFile(targetPath, `
+
+---
+
+${markdown}`, "utf-8");
+    } else {
+      await fs2.writeFile(targetPath, markdown, { flag, encoding: "utf-8" });
+    }
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    logger.warn("export: file write failed", { path: targetPath, error: msg });
+    await sendExportNotice(
+      client,
+      sessionId,
+      ctx,
+      `[ACP Export] Failed to write \`${targetPath}\`: ${msg}`
+    );
+    return;
+  }
+  logger.info("export: wrote markdown", {
+    path: targetPath,
+    blocks: blocks.length,
+    tiers: tiers.size ? [...tiers].sort().join(",") : "all"
+  });
+  const summary = formatExportSummary(targetPath, blocks, allActive, generatedAt);
+  await sendExportNotice(client, sessionId, ctx, summary);
+}
+function formatExportSummary(path, exported, allActive, generatedAt) {
+  const lines = [];
+  lines.push("[ACP Export]");
+  lines.push(`Wrote ${exported.length} block${exported.length === 1 ? "" : "s"} to:`);
+  lines.push(`  ${path}`);
+  if (exported.length === 0) {
+    lines.push("");
+    lines.push(
+      `No matching blocks (of ${allActive.length} active). Try \`/acp export --tier all\`.`
+    );
+  } else {
+    lines.push("");
+    lines.push(`Generated ${generatedAt.toISOString()}.`);
+    lines.push(
+      "Review, edit, and commit as a devlog / AGENTS.md supplement \u2014 export is user-driven, never auto-injected."
+    );
+  }
+  return lines.join("\n");
+}
+async function sendExportNotice(client, sessionId, ctx, text) {
+  await sendIgnoredMessage(client, sessionId, text, {}, ctx.logger);
+}
+
 // lib/messages/filter/registry.ts
 var registry3 = /* @__PURE__ */ new Map();
 function registerMessageFilter(filter) {
@@ -10744,6 +11046,20 @@ ${text}`);
     }
   };
 }
+function buildHelpText() {
+  return [
+    "[ACP] Available commands:",
+    "",
+    "  /acp              Show compression status (same as /acp stats)",
+    "  /acp context      Token usage breakdown (system, user, assistant, tools)",
+    "  /acp stats        Compression status: blocks, context usage, ranges",
+    "  /acp export       Export active compression blocks to markdown",
+    "                   Options: --output <path>, --tier t1,t2,t3, --stdout, --append",
+    "  /acp help         Show this help",
+    "",
+    "Also accepts /dcp for backward compatibility."
+  ].join("\n");
+}
 function createCommandExecuteHandler(client, registry4, logger, config, workingDirectory, hostPermissions) {
   return async (input, output) => {
     if (!config.commands.enabled) {
@@ -10761,23 +11077,35 @@ function createCommandExecuteHandler(client, registry4, logger, config, workingD
         config
       );
       syncCompressPermissionState(state, config, hostPermissions, messages);
-      const effectivePermission = compressPermission(state, config);
-      if (effectivePermission === "deny") {
-        return;
-      }
       const commandCtx = {
         client,
         state,
         config,
         logger,
         sessionId: input.sessionID,
-        messages
+        messages,
+        workingDirectory
       };
       const sub = input.arguments?.trim().toLowerCase();
-      if (sub === "stats" || sub === "status") {
+      if (sub === "stats" || sub === "status" || sub === "") {
         await handleStatsCommand(commandCtx);
         throw new Error("__DCP_CONTEXT_HANDLED__");
       }
+      if (sub === "export" || sub.startsWith("export ")) {
+        const exportArgs = input.arguments?.trim().slice("export".length).trim() || "";
+        await handleExportCommand(commandCtx, exportArgs);
+        throw new Error("__DCP_CONTEXT_HANDLED__");
+      }
+      if (sub === "help") {
+        await sendIgnoredMessage(
+          client,
+          input.sessionID,
+          buildHelpText(),
+          {},
+          logger
+        );
+        throw new Error("__DCP_CONTEXT_HANDLED__");
+      }
       await handleContextCommand(commandCtx);
       throw new Error("__DCP_CONTEXT_HANDLED__");
     }
@@ -10887,7 +11215,7 @@ function configureClientAuth(client) {
 
 // lib/update.ts
 import { readFile as readFile2, rm } from "fs/promises";
-import { basename, dirname as dirname3, join as join5 } from "path";
+import { basename, dirname as dirname4, join as join6 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "opencode-acp";
 function startAutoUpdate(ctx, enabled) {
@@ -10912,7 +11240,7 @@ function startAutoUpdate(ctx, enabled) {
 async function checkAutoUpdate(signal) {
   const packageDir = await findPackageDir(PACKAGE_NAME);
   if (!packageDir) return { updated: false };
-  const pkg = await readPackageJson(join5(packageDir, "package.json"));
+  const pkg = await readPackageJson(join6(packageDir, "package.json"));
   if (!pkg?.name || !pkg.version) return { updated: false };
   const latest = await fetchLatestVersion(pkg.name, signal);
   if (!latest || !isVersionNewer(latest, pkg.version)) return { updated: false };
@@ -10932,21 +11260,21 @@ async function checkAutoUpdate(signal) {
   return { updated: true, name: pkg.name, current: pkg.version, latest };
 }
 async function findPackageDir(name) {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const pkg = await readPackageJson(join5(dir, "package.json"));
+    const pkg = await readPackageJson(join6(dir, "package.json"));
     if (pkg?.name === name) return dir;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 async function updateRemoveDir(packageDir, name) {
-  const packageParent = dirname3(packageDir);
-  const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname3(packageParent) : packageParent;
+  const packageParent = dirname4(packageDir);
+  const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname4(packageParent) : packageParent;
   if (basename(nodeModulesDir) !== "node_modules") return void 0;
-  const wrapperDir = dirname3(nodeModulesDir);
-  const wrapperPkg = await readPackageJson(join5(wrapperDir, "package.json"));
+  const wrapperDir = dirname4(nodeModulesDir);
+  const wrapperPkg = await readPackageJson(join6(wrapperDir, "package.json"));
   const spec = wrapperSpec(wrapperDir, name) ?? wrapperPkg?.dependencies?.[name];
   if (!spec || !isAutoUpdatableSpec(spec)) return void 0;
   return wrapperDir;
@@ -10954,7 +11282,7 @@ async function updateRemoveDir(packageDir, name) {
 function wrapperSpec(wrapperDir, name) {
   if (name.startsWith("@")) {
     const [scope, pkg] = name.split("/");
-    if (!scope || !pkg || basename(dirname3(wrapperDir)) !== scope) return void 0;
+    if (!scope || !pkg || basename(dirname4(wrapperDir)) !== scope) return void 0;
     const prefix2 = `${pkg}@`;
     const base2 = basename(wrapperDir);
     return base2.startsWith(prefix2) ? base2.slice(prefix2.length) : void 0;