easy-coding-harness 0.5.0 → 0.5.2-beta.0

package/CHANGELOG.md

@@ -6,6 +6,13 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.5.2-beta.0
+
+- 修复 Claude Code hook 命令使用直接相对路径导致在子目录 cwd 下找不到 `.claude/hooks/*.py` 的问题；Claude、Codex、Qoder 的 hook 配置现在使用可共享的 portable relative launcher，并绑定 `.easy-coding/config.yaml` 的 `project.id`，避免把本机仓库绝对路径写入可提交配置，同时防止 supermodule 父仓 hook 被子仓 cwd 错路由。
+- `easy-coding upgrade` 可直接刷新存量 0.5.0 项目和已安装 0.5.1 beta 绝对路径配置；同版本也会修复缺失、重复、事件错位或 stale 的托管 hook 注册。
+- `easy-coding clear` 和 `install-manifest.json` 兼容 portable launcher、旧直接相对命令和旧绝对 hook 命令，清理时仍按项目相对 hook 路径识别托管注册项。
+- npm `0.5.1` 已发布不可覆盖，本版本作为 beta 修复包发布，用于替代原 `0.5.1` beta。
+
 ## 0.5.0
 
 - 新增 supermodule 支持：`easy-coding init` 会识别 `.gitmodules`，父仓必装，已检出的一级子仓可按交互或参数选择分层安装。

package/dist/cli.js

@@ -61,6 +61,7 @@ function colorizeBanner(art) {
 }
 
 // src/utils/config-yaml.ts
+import { randomUUID } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
 import YAML, { isScalar, isSeq, parseDocument } from "yaml";
 
@@ -108,6 +109,7 @@ function createDefaultConfig(params) {
     harness_version: params.harnessVersion,
     agents: params.agents,
     project: {
+      id: params.projectId ?? createProjectId(),
       name: params.projectName
     },
     memory: {
@@ -138,6 +140,14 @@ async function readConfigYaml(filePath) {
   const content = await readFile2(filePath, "utf8");
   return YAML.parse(content);
 }
+async function readProjectIdIfExists(filePath) {
+  try {
+    const config = await readConfigYaml(filePath);
+    return typeof config.project?.id === "string" && config.project.id.trim() ? config.project.id : null;
+  } catch {
+    return null;
+  }
+}
 async function updateConfigYaml(filePath, updater) {
   const content = await readFile2(filePath, "utf8");
   const document = parseDocument(content);
@@ -160,11 +170,27 @@ async function updateHarnessVersion(filePath, version) {
     config.harness_version = version;
   });
 }
+async function ensureProjectId(filePath) {
+  let projectId = "";
+  await updateConfigYaml(filePath, (config) => {
+    if (!config.project || typeof config.project !== "object") {
+      config.project = { id: createProjectId(), name: "" };
+    }
+    if (typeof config.project.id !== "string" || !config.project.id.trim()) {
+      config.project.id = createProjectId();
+    }
+    projectId = config.project.id;
+  });
+  return projectId;
+}
 async function updateSupermoduleConfig(filePath, supermodule) {
   return updateConfigYaml(filePath, (config) => {
     config.supermodule = supermodule;
   });
 }
+function createProjectId() {
+  return `ec-${randomUUID()}`;
+}
 
 // src/utils/gitignore.ts
 import path3 from "path";
@@ -350,7 +376,7 @@ async function writeInstallManifest(cwd, params) {
       const registration = {
         config_path: configPath2,
         command: artifact.command,
-        hook_path: artifact.hookPath,
+        hook_path: artifact.hookPath ? normalizeHookPath(cwd, artifact.hookPath) : null,
         platform: artifact.platform
       };
       hookRegistrations.set(`${configPath2}\0${normalizeCommand(artifact.command)}`, registration);
@@ -465,9 +491,75 @@ function collectHookCommands(hooks) {
   return commands;
 }
 function extractHookPathFromCommand(command) {
-  const match = normalizeCommand(command).match(/(?:^|\s)(\S+\/hooks\/\S+\.py)(?:\s|$)/);
+  return extractQuotedHookPath(command) ?? extractUnquotedHookPath(command);
+}
+function extractQuotedHookPath(command) {
+  for (let index = 0; index < command.length; index += 1) {
+    const quote = command[index];
+    if (quote !== '"' && quote !== "'") {
+      continue;
+    }
+    if (index > 0 && !/\s/.test(command[index - 1])) {
+      continue;
+    }
+    const parsed = parseQuotedToken(command, index, quote);
+    if (!parsed) {
+      continue;
+    }
+    const suffix = readPathSuffix(command, parsed.endIndex);
+    for (const candidate of [parsed.value + suffix, parsed.value]) {
+      if (isHookPythonPath(candidate)) {
+        return candidate;
+      }
+    }
+    index = parsed.endIndex;
+  }
+  return null;
+}
+function parseQuotedToken(command, startIndex, quote) {
+  let value = "";
+  for (let index = startIndex + 1; index < command.length; index += 1) {
+    const char = command[index];
+    if (quote === '"' && char === "\\" && index + 1 < command.length) {
+      value += command[index + 1];
+      index += 1;
+      continue;
+    }
+    if (char === quote) {
+      return { value, endIndex: index + 1 };
+    }
+    value += char;
+  }
+  return null;
+}
+function readPathSuffix(command, startIndex) {
+  if (command[startIndex] !== "/") {
+    return "";
+  }
+  let suffix = "";
+  for (let index = startIndex; index < command.length; index += 1) {
+    const char = command[index];
+    if (/\s/.test(char)) {
+      break;
+    }
+    suffix += char;
+  }
+  return suffix;
+}
+function extractUnquotedHookPath(command) {
+  const match = command.match(/(?:^|\s)(\S+\/hooks\/\S+\.py)(?:\s|$)/);
   return match?.[1] ?? null;
 }
+function isHookPythonPath(candidate) {
+  return /\/hooks\/\S+\.py$/.test(candidate);
+}
+function normalizeHookPath(cwd, hookPath) {
+  const normalized = hookPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (path4.isAbsolute(hookPath) || path4.posix.isAbsolute(normalized) || path4.win32.isAbsolute(hookPath)) {
+    return toProjectPath(cwd, hookPath);
+  }
+  return normalized;
+}
 function byPath(a, b) {
   return a.path.localeCompare(b.path);
 }
@@ -502,17 +594,21 @@ async function writeRuntimeScaffold(cwd, agents, opts = {}) {
   const easyCodingDir = path6.join(cwd, EASY_CODING_DIR);
   await ensureDir(easyCodingDir);
   const configPath2 = path6.join(easyCodingDir, CONFIG_FILE);
+  let projectId = opts.projectId ?? createProjectId();
   if (!await pathExists(configPath2)) {
     const projectName = path6.basename(cwd);
     await writeConfigYaml(
       configPath2,
       createDefaultConfig({
         projectName,
+        projectId,
         harnessVersion: VERSION,
         agents,
         supermodule: opts.supermodule
       })
     );
+  } else {
+    projectId = await ensureProjectId(configPath2);
   }
   await ensureDir(path6.join(easyCodingDir, "tasks"));
   await ensureDir(path6.join(easyCodingDir, SESSIONS_DIR));
@@ -520,6 +616,7 @@ async function writeRuntimeScaffold(cwd, agents, opts = {}) {
   await ensureDir(path6.join(easyCodingDir, SPEC_DIR, DEV_SPEC_DIR));
   await writeMemoryScaffold(easyCodingDir);
   await writeTemplatesScaffold(easyCodingDir);
+  return projectId;
 }
 async function writeTemplatesScaffold(easyCodingDir) {
   const templatesDir = path6.join(easyCodingDir, TEMPLATES_DIR);
@@ -696,6 +793,89 @@ function resolvePlaceholders(content, ctx, contentName = "template") {
   }
   return resolved;
 }
+async function withProjectInstallPaths(cwd, ctx, projectId) {
+  const resolvedProjectId = projectId ?? await readProjectIdIfExists(path8.join(cwd, EASY_CODING_DIR, CONFIG_FILE));
+  return withInstallPaths(cwd, ctx, resolvedProjectId ?? void 0);
+}
+function withInstallPaths(cwd, ctx, projectId) {
+  return {
+    ...ctx,
+    platform_hook_session_start_command: jsonStringContent(
+      renderHookCommand(cwd, ctx, "session-start.py", process.platform, projectId)
+    ),
+    platform_hook_inject_workflow_state_command: jsonStringContent(
+      renderHookCommand(cwd, ctx, "inject-workflow-state.py", process.platform, projectId)
+    ),
+    platform_hook_inject_subagent_context_command: jsonStringContent(
+      renderHookCommand(cwd, ctx, "inject-subagent-context.py", process.platform, projectId)
+    )
+  };
+}
+function renderHookCommand(_cwd, ctx, scriptName, platform = process.platform, projectId) {
+  const launcher = `import base64;exec(base64.b64decode('${Buffer.from(HOOK_LAUNCHER_PYTHON).toString("base64")}').decode())`;
+  const rootIdArg = projectId ? ` ${shellDoubleQuoteArg(projectId, platform)}` : "";
+  return `${ctx.python_cmd} -c ${shellDoubleQuoteArg(launcher, platform)}${rootIdArg} ${ctx.platform_config_dir}/hooks/${scriptName}`;
+}
+function shellDoubleQuoteArg(value, platform = process.platform) {
+  if (platform === "win32") {
+    if (value.includes('"')) {
+      throw new Error("Windows hook paths cannot contain double quotes.");
+    }
+    return `"${value}"`;
+  }
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function jsonStringContent(value) {
+  return JSON.stringify(value).slice(1, -1);
+}
+var HOOK_LAUNCHER_PYTHON = [
+  "import io,json,os,re,runpy,sys",
+  "from pathlib import Path",
+  "payload=sys.stdin.read()",
+  "try:",
+  "    data=json.loads(payload or '{}')",
+  "except Exception:",
+  "    data={}",
+  "expected_id=sys.argv[1] if len(sys.argv) > 2 else None",
+  "script_arg=sys.argv[2] if len(sys.argv) > 2 else (sys.argv[1] if len(sys.argv) > 1 else None)",
+  "def project_id(root):",
+  "    try:",
+  "        lines=(root / '.easy-coding' / 'config.yaml').read_text(encoding='utf-8').splitlines()",
+  "    except Exception:",
+  "        return None",
+  "    in_project=False",
+  "    for line in lines:",
+  "        if not in_project:",
+  "            if re.match(r'^project\\s*:\\s*(?:#.*)?$', line):",
+  "                in_project=True",
+  "            continue",
+  "        if not line.strip() or line.lstrip().startswith('#'):",
+  "            continue",
+  "        if not line.startswith((' ', '\\t')):",
+  "            return None",
+  `        match=re.match(r"\\s+id\\s*:\\s*['\\"]?([^'\\"#\\s]+)", line)`,
+  "        if match:",
+  "            return match.group(1)",
+  "    return None",
+  "def roots_from(raw):",
+  "    if not raw:",
+  "        return []",
+  "    start=Path(raw).resolve()",
+  "    return [candidate for candidate in (start, *start.parents) if (candidate / '.easy-coding').is_dir()]",
+  "sources=[os.environ.get('CLAUDE_PROJECT_DIR'), os.environ.get('QODER_PROJECT_DIR'), data.get('cwd'), os.getcwd()]",
+  "root=None",
+  "if expected_id:",
+  "    root=next((candidate for raw in sources for candidate in roots_from(raw) if project_id(candidate) == expected_id), None)",
+  "else:",
+  "    root=next((candidate for raw in sources for candidate in roots_from(raw)), None)",
+  "target=(root / script_arg) if root and script_arg else None",
+  "if target and target.is_file():",
+  "    os.chdir(root)",
+  "    data['cwd']=str(root)",
+  "    sys.stdin=io.StringIO(json.dumps(data))",
+  "    sys.path.insert(0, str(target.parent))",
+  "    runpy.run_path(str(target), run_name='__main__')"
+].join("\n");
 async function resolveSkills(ctx) {
   const skillsRoot = getTemplatePath("common", "skills");
   const entries = await readdir2(skillsRoot);
@@ -851,7 +1031,7 @@ function stripTemplateExtension(fileName) {
 async function configureClaude(cwd, opts = {}) {
   const platform = "claude-code";
   const meta = PLATFORM_META[platform];
-  const ctx = meta.templateContext;
+  const ctx = await withProjectInstallPaths(cwd, meta.templateContext, opts.projectId);
   const dest = path9.join(cwd, ".claude");
   const hookConfigPath = path9.join(cwd, meta.hookConfigFile);
   const artifacts = [];
@@ -889,7 +1069,7 @@ import path10 from "path";
 async function configureCodex(cwd, opts = {}) {
   const platform = "codex";
   const meta = PLATFORM_META[platform];
-  const ctx = meta.templateContext;
+  const ctx = await withProjectInstallPaths(cwd, meta.templateContext, opts.projectId);
   const hookConfigPath = path10.join(cwd, meta.hookConfigFile);
   const artifacts = [];
   artifacts.push(
@@ -1005,7 +1185,7 @@ async function existingManagedSkillArtifacts(skillsDir, skillNames, platform) {
 async function configureQoder(cwd, opts = {}) {
   const platform = "qoder";
   const meta = resolvePlatformMeta(cwd, platform);
-  const ctx = meta.templateContext;
+  const ctx = await withProjectInstallPaths(cwd, meta.templateContext, opts.projectId);
   const dest = path12.join(cwd, ctx.platform_config_dir);
   const hookConfigPath = path12.join(cwd, meta.hookConfigFile);
   const artifacts = [];
@@ -1056,17 +1236,22 @@ var CONFIGURATORS = {
 };
 
 // src/commands/install-harness.ts
-async function configurePlatformsForDir(targetDir, platforms, boundary) {
+async function configurePlatformsForDir(targetDir, platforms, opts = {}) {
   const artifacts = [];
   for (const platform of platforms) {
-    artifacts.push(...await CONFIGURATORS[platform](targetDir, { supermodule: boundary }));
+    artifacts.push(...await CONFIGURATORS[platform](targetDir, opts));
   }
   return artifacts;
 }
 async function installHarnessToDir(targetDir, platforms, ctx) {
-  const artifacts = await configurePlatformsForDir(targetDir, platforms, boundaryFromContext(ctx));
+  const projectId = createProjectId();
+  const artifacts = await configurePlatformsForDir(targetDir, platforms, {
+    supermodule: boundaryFromContext(ctx),
+    projectId
+  });
   await writeRuntimeScaffold(targetDir, platforms, {
-    supermodule: supermoduleConfigFromContext(ctx)
+    supermodule: supermoduleConfigFromContext(ctx),
+    projectId
   });
   await writeInstallManifest(targetDir, {
     harnessVersion: VERSION,
@@ -1560,14 +1745,13 @@ async function addAgent(opts) {
     const toInstall = platforms.filter((platform) => !config.agents.includes(platform));
     const agents = [...config.agents, ...toInstall];
     if (toInstall.length > 0) {
-      const artifacts = await configurePlatformsForDir(
-        target.dir,
-        toInstall,
-        target.boundary
-      );
-      await writeRuntimeScaffold(target.dir, agents, {
+      const projectId = await writeRuntimeScaffold(target.dir, agents, {
         supermodule: target.supermodule
       });
+      const artifacts = await configurePlatformsForDir(target.dir, toInstall, {
+        supermodule: target.boundary,
+        projectId
+      });
       await writeInstallManifest(target.dir, {
         harnessVersion: VERSION,
         agents: toInstall,
@@ -1770,11 +1954,12 @@ async function buildManifestClearPlan(cwd, agents, manifest) {
     if (!agentSet.has(registration.platform)) {
       continue;
     }
+    const managedHookPaths = registration.hook_path ? managedHookPathsForRegistration(cwd, registration.hook_path) : [];
     addHookConfigPrune(
       plan.pruneHookConfigs,
       plan.pruneHookCommands,
       manifestPath(cwd, registration.config_path),
-      registration.hook_path ? [registration.hook_path] : [],
+      managedHookPaths,
       [registration.command]
     );
   }
@@ -1822,7 +2007,7 @@ async function addTemplateClearEntries(plan, cwd, platform, metas, managedSkills
       plan.pruneHookConfigs,
       plan.pruneHookCommands,
       path16.join(cwd, meta.hookConfigFile),
-      hookFileNames.map((name) => `${meta.templateContext.platform_config_dir}/hooks/${name}`),
+      managedHookPathsForTemplate(cwd, meta, hookFileNames),
       []
     );
     plan.constraints.add(path16.join(cwd, meta.mainConstraint));
@@ -1873,6 +2058,51 @@ function addHookConfigPrune(pruneHookConfigs, pruneHookCommands, filePath, manag
   }
   pruneHookCommands.set(filePath, existingCommands);
 }
+function managedHookPathsForRegistration(cwd, hookPath) {
+  const paths = [hookPath];
+  try {
+    paths.push(...managedHookPathTokens(manifestPath(cwd, hookPath)));
+  } catch {
+    if (path16.isAbsolute(hookPath)) {
+      paths.push(...managedHookPathTokens(hookPath));
+    }
+  }
+  return paths;
+}
+function managedHookPathsForTemplate(cwd, meta, hookFileNames) {
+  const relativePaths = hookFileNames.map(
+    (name) => `${meta.templateContext.platform_config_dir}/hooks/${name}`
+  );
+  const absolutePaths = hookFileNames.flatMap(
+    (name) => managedHookPathTokens(path16.join(cwd, meta.hooksDir, name))
+  );
+  return [...relativePaths, ...absolutePaths];
+}
+function managedHookPathTokens(filePath) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const equivalentPath of equivalentAbsolutePaths(filePath)) {
+    const normalized = equivalentPath.replace(/\\/g, "/");
+    const dir = path16.posix.dirname(normalized);
+    const basename = path16.posix.basename(normalized);
+    tokens.add(normalized);
+    tokens.add(shellDoubleQuoteArg2(normalized));
+    tokens.add(`${shellDoubleQuoteArg2(dir)}/${basename}`);
+  }
+  return [...tokens];
+}
+function equivalentAbsolutePaths(filePath) {
+  const normalized = path16.resolve(filePath).replace(/\\/g, "/");
+  const equivalents = [normalized];
+  if (normalized.startsWith("/private/var/")) {
+    equivalents.push(normalized.replace(/^\/private\/var\//, "/var/"));
+  } else if (normalized.startsWith("/var/")) {
+    equivalents.push(normalized.replace(/^\/var\//, "/private/var/"));
+  }
+  return equivalents;
+}
+function shellDoubleQuoteArg2(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
 function createClearPlan() {
   return {
     remove: /* @__PURE__ */ new Set(),
@@ -2057,7 +2287,7 @@ function isManagedHook(hook, managedHookPaths, managedHookCommands) {
   if (normalizedManagedCommands.includes(normalizeCommand(command))) {
     return true;
   }
-  const normalizedCommand = command.replace(/\\/g, "/");
+  const normalizedCommand = command;
   return managedHookPaths.some(
     (hookPath) => commandContainsPathToken(normalizedCommand, hookPath.replace(/\\/g, "/"))
   );
@@ -2543,8 +2773,35 @@ async function update(opts) {
 }
 
 // src/commands/upgrade.ts
+import path22 from "path";
 import { cancel as cancel5, confirm as confirm4, outro as outro5 } from "@clack/prompts";
 import chalk7 from "chalk";
+var EXPECTED_HOOK_REGISTRATION_SCRIPTS = {
+  "claude-code": [
+    { event: "SessionStart", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" },
+    { event: "PreToolUse", scriptName: "inject-subagent-context.py" }
+  ],
+  codex: [
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" }
+  ],
+  qoder: [
+    { event: "UserPromptSubmit", scriptName: "session-start.py" },
+    { event: "UserPromptSubmit", scriptName: "inject-workflow-state.py" },
+    { event: "PreToolUse", scriptName: "inject-subagent-context.py" }
+  ]
+};
+var MANAGED_HOOK_SCRIPT_NAMES = {
+  "claude-code": [
+    ...new Set(
+      EXPECTED_HOOK_REGISTRATION_SCRIPTS["claude-code"].map(({ scriptName }) => scriptName)
+    )
+  ],
+  codex: [...new Set(EXPECTED_HOOK_REGISTRATION_SCRIPTS.codex.map(({ scriptName }) => scriptName))],
+  qoder: [...new Set(EXPECTED_HOOK_REGISTRATION_SCRIPTS.qoder.map(({ scriptName }) => scriptName))]
+};
 async function upgrade(opts) {
   renderBanner();
   const cwd = process.cwd();
@@ -2591,14 +2848,13 @@ async function upgrade(opts) {
     }
   }
   for (const { target, config } of pending) {
-    const artifacts = await configurePlatformsForDir(
-      target.dir,
-      config.agents,
-      target.boundary
-    );
-    await writeRuntimeScaffold(target.dir, config.agents, {
+    const projectId = await writeRuntimeScaffold(target.dir, config.agents, {
       supermodule: target.supermodule
     });
+    const artifacts = await configurePlatformsForDir(target.dir, config.agents, {
+      supermodule: target.boundary,
+      projectId
+    });
     await writeInstallManifest(target.dir, {
       harnessVersion: VERSION,
       agents: config.agents,
@@ -2645,12 +2901,153 @@ async function resolvePendingUpgradeTargets(targets) {
         `${target.label} harness version ${installedVersion} is newer than CLI ${VERSION}. Update the CLI first.`
       );
     }
-    if (relation === -1) {
+    if (relation === -1 || relation === 0 && await needsHookConfigRefresh(target, config)) {
       pending.push({ target, config });
     }
   }
   return pending;
 }
+async function needsHookConfigRefresh(target, config) {
+  const projectId = typeof config.project?.id === "string" ? config.project.id.trim() : "";
+  if (!projectId) {
+    return true;
+  }
+  const manifest = await readInstallManifest(target.dir);
+  for (const agent of config.agents) {
+    const meta = resolvePlatformMeta(target.dir, agent);
+    const configPath2 = path22.join(target.dir, meta.hookConfigFile);
+    const content = await readTextIfExists(configPath2);
+    if (content === null) {
+      return true;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return true;
+    }
+    const commandsByEvent = collectHookCommandsByEvent(parsed.hooks);
+    const commands = [...commandsByEvent.values()].flat();
+    const expectedRegistrations = expectedHookRegistrations(target.dir, meta, agent, projectId);
+    const expectedCommandSet = new Set(
+      expectedRegistrations.map((registration) => registration.command)
+    );
+    if (!hasExpectedHookRegistrations(commandsByEvent, expectedRegistrations)) {
+      return true;
+    }
+    const manifestManagedCommands = new Set(
+      manifest?.hook_registrations.filter((registration) => registration.platform === agent).map((registration) => registration.command) ?? []
+    );
+    if (commands.some(
+      (command) => isUnexpectedManagedHookCommand(
+        command,
+        expectedCommandSet,
+        target.dir,
+        meta,
+        agent,
+        manifestManagedCommands
+      )
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function expectedHookRegistrations(cwd, meta, platform, projectId) {
+  return EXPECTED_HOOK_REGISTRATION_SCRIPTS[platform].map(({ event, scriptName }) => ({
+    event,
+    command: renderHookCommand(cwd, meta.templateContext, scriptName, process.platform, projectId)
+  }));
+}
+function hasExpectedHookRegistrations(commandsByEvent, expectedRegistrations) {
+  const actualCounts = countRegistrations(
+    [...commandsByEvent.entries()].flatMap(
+      ([event, commands]) => commands.map((command) => ({ event, command }))
+    )
+  );
+  const expectedCounts = countRegistrations(expectedRegistrations);
+  return [...expectedCounts.entries()].every(
+    ([registrationKey, expectedCount]) => (actualCounts.get(registrationKey) ?? 0) >= expectedCount
+  );
+}
+function countRegistrations(registrations) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const registration of registrations) {
+    const key = hookRegistrationKey(registration);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function hookRegistrationKey(registration) {
+  return `${registration.event}\0${registration.command}`;
+}
+function collectHookCommandsByEvent(hooks) {
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return /* @__PURE__ */ new Map();
+  }
+  const commandsByEvent = /* @__PURE__ */ new Map();
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    for (const group of value) {
+      if (!group || typeof group !== "object") {
+        continue;
+      }
+      const hookItems = group.hooks;
+      if (!Array.isArray(hookItems)) {
+        continue;
+      }
+      for (const hook of hookItems) {
+        if (!hook || typeof hook !== "object") {
+          continue;
+        }
+        const command = hook.command;
+        if (typeof command === "string") {
+          const eventCommands = commandsByEvent.get(event) ?? [];
+          eventCommands.push(command);
+          commandsByEvent.set(event, eventCommands);
+        }
+      }
+    }
+  }
+  return commandsByEvent;
+}
+function isUnexpectedManagedHookCommand(command, expectedCommands, cwd, meta, platform, manifestManagedCommands) {
+  if (expectedCommands.has(command)) {
+    return false;
+  }
+  if (manifestManagedCommands.has(command)) {
+    return true;
+  }
+  const hookPath = extractHookPathFromCommand(command);
+  return hookPath === null ? false : isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform);
+}
+function isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform) {
+  const normalizedHookPath = normalizePathForHookComparison(hookPath);
+  const configDir = normalizePathForHookComparison(meta.templateContext.platform_config_dir);
+  return MANAGED_HOOK_SCRIPT_NAMES[platform].some((scriptName) => {
+    const relativeHookPath = `${configDir}/hooks/${scriptName}`;
+    if (normalizedHookPath === relativeHookPath) {
+      return true;
+    }
+    return pathAliases(
+      normalizePathForHookComparison(path22.resolve(cwd, relativeHookPath))
+    ).includes(normalizedHookPath);
+  });
+}
+function normalizePathForHookComparison(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function pathAliases(value) {
+  const aliases = /* @__PURE__ */ new Set([value]);
+  if (value.startsWith("/private/var/")) {
+    aliases.add(value.replace(/^\/private\/var\//, "/var/"));
+  } else if (value.startsWith("/var/")) {
+    aliases.add(`/private${value}`);
+  }
+  return [...aliases];
+}
 async function resolveParentTopologyRefresh(targets, pending) {
   const parent = targets.find(
     (target) => target.label === "." && target.supermodule.role === "super-parent"