@mnemonik/cli 7.140.1 → 7.140.3

package/dist/runtime/signers.js

@@ -469,8 +469,8 @@ var init_runtimeSigners = __esm({
       const result = promisify(execFile)(file, args);
       if (input === void 0)
         return result;
-      return new Promise((resolve5, reject2) => {
-        void result.then(resolve5, reject2);
+      return new Promise((resolve6, reject2) => {
+        void result.then(resolve6, reject2);
         result.child.stdin?.on("error", reject2);
         result.child.stdin?.end(input);
       });
@@ -503,8 +503,8 @@ var init_runtimeSigners = __esm({
       const options = hookOptions(file, args);
       if (treeListing)
         options.timeout = 3e4;
-      return new Promise((resolve5, reject2) => {
-        const child = execFile(file, args, options, (error, stdout2) => error ? reject2(error) : resolve5({ stdout: stdout2 }));
+      return new Promise((resolve6, reject2) => {
+        const child = execFile(file, args, options, (error, stdout2) => error ? reject2(error) : resolve6({ stdout: stdout2 }));
         if (input !== void 0) {
           child.stdin?.on("error", reject2);
           child.stdin?.end(input);
@@ -593,6 +593,14 @@ function parseIdentityFile(text) {
     }
   };
 }
+function isConfigurationOnly(text) {
+  try {
+    const value = JSON.parse(text);
+    return !!value && typeof value === "object" && !Array.isArray(value) && !("projectId" in value) && (!("schemaVersion" in value) || value.schemaVersion === 1);
+  } catch {
+    return false;
+  }
+}
 async function readIdentityFile(dir, options = {}) {
   const path = join2(dir, ".mnemonik.json");
   try {
@@ -602,14 +610,8 @@ async function readIdentityFile(dir, options = {}) {
     if (!stat2.isFile())
       return { kind: "malformed", detail: "identity path is not a regular file" };
     const text = await readFile2(path, "utf8");
-    if (options.selectedRoot) {
-      try {
-        const value = JSON.parse(text);
-        if (value && typeof value === "object" && !Array.isArray(value) && !("projectId" in value) && (!("schemaVersion" in value) || value.schemaVersion === 1))
-          return { kind: "absent" };
-      } catch {
-      }
-    }
+    if ((options.selectedRoot || options.configurationOnlyAbsent) && isConfigurationOnly(text))
+      return { kind: "absent" };
     return parseIdentityFile(text);
   } catch (error) {
     if (error.code === "ENOENT")
@@ -634,7 +636,7 @@ var init_projectIdentityFile = __esm({
 });
 
 // packages/shared/dist/repositoryRoot.js
-import { lstat as lstat2, readFile as readFile3 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile3, realpath } from "node:fs/promises";
 import { execFile as execFile2 } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
@@ -685,7 +687,7 @@ async function confirmedBoundaryAt(path) {
 async function boundariesBetween(cwd, root) {
   const boundaries = [];
   let directory = cwd;
-  while (directory !== root) {
+  while (!samePath(directory, root)) {
     const boundary = await confirmedBoundaryAt(directory);
     if (boundary)
       boundaries.push(boundary);
@@ -708,37 +710,31 @@ async function containingRepository(root) {
     directory = parent;
   }
 }
-async function canonicalBoundaryRoot(boundary) {
-  if (boundary.kind === "directory")
-    return boundary.path;
-  const pointer = /^gitdir:\s*(.+)\s*$/im.exec(await readFile3(join3(boundary.path, ".git"), "utf8"))?.[1];
-  if (!pointer)
-    return boundary.path;
-  const gitDir = resolve2(boundary.path, pointer);
-  try {
-    const commonDir = resolve2(gitDir, (await readFile3(join3(gitDir, "commondir"), "utf8")).trim());
-    return dirname2(commonDir);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return boundary.path;
-    throw error;
-  }
+async function canonicalPath(path) {
+  const absolute = resolve2(path);
+  return realpath(absolute).catch(() => absolute);
+}
+function samePath(left, right) {
+  return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
 async function resolveRepositoryRoot(cwd) {
-  const absoluteCwd = resolve2(cwd);
+  const absoluteCwd = await canonicalPath(cwd);
   try {
     const { stdout: stdout2 } = await runGit(absoluteCwd, [
       "rev-parse",
       "--show-toplevel",
+      "--git-dir",
       "--git-common-dir"
     ]);
-    const [rootLine, commonLine, ...extra] = stdout2.trim().split(/\r?\n/);
-    if (!rootLine || !commonLine || extra.length) {
+    const [rootLine, gitDirLine, commonLine, ...extra] = stdout2.trim().split(/\r?\n/);
+    if (!rootLine || !gitDirLine || !commonLine || extra.length) {
       return { kind: "git_unavailable", detail: "git rev-parse returned an unexpected response" };
     }
-    const root = resolve2(rootLine);
-    const commonDir = resolve2(root, commonLine);
-    const isLinkedWorktree = commonDir !== join3(root, ".git");
+    const fromGit = (line) => canonicalPath(resolve2(absoluteCwd, line));
+    const root = await fromGit(rootLine);
+    const gitDir = await fromGit(gitDirLine);
+    const commonDir = await fromGit(commonLine);
+    const isLinkedWorktree = !samePath(gitDir, commonDir);
     const nested = await boundariesBetween(absoluteCwd, root);
     if (!isLinkedWorktree && await containingRepository(root)) {
       const boundary = await boundaryAt(root);
@@ -760,14 +756,41 @@ async function resolveRepositoryRoot(cwd) {
     return { kind: "git_unavailable", detail: failure.message };
   }
 }
+async function linkedWorktreeCommonDir(dir) {
+  try {
+    if (!(await lstat2(join3(dir, ".git"))).isFile())
+      return void 0;
+    const pointer = /^gitdir:\s*(.+?)\s*$/im.exec(await readFile3(join3(dir, ".git"), "utf8"))?.[1];
+    if (!pointer)
+      return void 0;
+    const gitDir = resolve2(dir, pointer);
+    const common = (await readFile3(join3(gitDir, "commondir"), "utf8")).trim();
+    return common ? await canonicalPath(resolve2(gitDir, common)) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function mainCheckout(worktreeTop, commonDir) {
+  try {
+    const { stdout: stdout2 } = await runGit(worktreeTop, ["worktree", "list", "--porcelain"]);
+    const first = stdout2.split(/\r?\n\r?\n/)[0] ?? "";
+    const path = /^worktree (.+)$/m.exec(first)?.[1];
+    if (path) {
+      const main = await canonicalPath(resolve2(worktreeTop, path));
+      return /^bare$/m.test(first) ? dirname2(main) : main;
+    }
+  } catch {
+  }
+  return dirname2(commonDir);
+}
 async function readPlainIdentity(start) {
-  const home = resolve2(homedir());
+  const home = await canonicalPath(homedir());
   let directory = start;
   while (true) {
-    const result = await readIdentityFile(directory);
+    const result = await readIdentityFile(directory, { configurationOnlyAbsent: true });
     if (result.kind !== "absent")
       return { root: directory, result };
-    if (directory === home)
+    if (samePath(directory, home))
       break;
     const parent = dirname2(directory);
     if (parent === directory)
@@ -776,59 +799,59 @@ async function readPlainIdentity(start) {
   }
   return { root: start, result: { kind: "absent" } };
 }
-function withBase(repository, root, nested) {
-  return { root, repository, nested };
-}
-async function resolveProjectIdentity(cwd, options = {}) {
-  const resolved = await resolveRepositoryRoot(cwd);
-  const repository = resolved.kind === "git_unavailable" ? { kind: "plain", root: resolve2(cwd) } : resolved;
-  if (repository.kind === "plain") {
-    const { root, result } = options.selectedRoot ? { root: repository.root, result: await readIdentityFile(repository.root, options) } : await readPlainIdentity(repository.root);
-    const base2 = withBase(repository, root, []);
-    if (result.kind === "ok")
-      return { ...base2, ...result };
-    if (result.kind === "unknown_version")
-      return { ...base2, ...result, path: root };
-    if (result.kind === "malformed")
-      return { ...base2, ...result, path: root };
-    return { ...base2, kind: "absent" };
-  }
-  const ownRoot = repository.isLinkedWorktree ? dirname2(repository.commonDir) : repository.root;
-  const outer = repository.isLinkedWorktree ? void 0 : await containingRepository(repository.root);
-  const own = await readIdentityFile(ownRoot, options);
-  if (!outer || options.selectedRoot || own.kind === "ok") {
-    const base2 = withBase(repository, ownRoot, repository.nested);
-    if (own.kind === "ok")
-      return { ...base2, ...own };
-    if (own.kind === "unknown_version")
-      return { ...base2, ...own, path: ownRoot };
-    if (own.kind === "malformed")
-      return { ...base2, ...own, path: ownRoot };
-    return { ...base2, kind: "absent" };
-  }
-  const nested = repository.nested;
-  const parentRoot = await canonicalBoundaryRoot(outer);
-  const parent = await readIdentityFile(parentRoot);
-  const base = withBase(repository, parentRoot, nested);
-  if (own.kind === "unknown_version")
-    return { ...base, ...own, path: ownRoot };
-  if (own.kind === "malformed")
-    return { ...base, ...own, path: ownRoot };
-  if (parent.kind === "unknown_version")
-    return { ...base, ...parent, path: parentRoot };
-  if (parent.kind === "malformed")
-    return { ...base, ...parent, path: parentRoot };
-  if (!options.allowNestedInherit) {
-    return {
-      ...base,
-      kind: "nested",
-      ...parent.kind === "ok" ? { parentIdentity: parent.identity } : {}
-    };
+async function nearestIdentity(start) {
+  const home = await canonicalPath(homedir());
+  let directory = start;
+  while (true) {
+    const commonDir = await linkedWorktreeCommonDir(directory);
+    if (commonDir)
+      return { worktreeTop: directory, commonDir };
+    const result = await readIdentityFile(directory, { configurationOnlyAbsent: true });
+    if (result.kind !== "absent")
+      return { root: directory, result };
+    if (samePath(directory, home))
+      return void 0;
+    const parent = dirname2(directory);
+    if (parent === directory)
+      return void 0;
+    directory = parent;
   }
-  if (parent.kind === "ok")
-    return { ...base, kind: "ok", identity: parent.identity };
+}
+async function resolveNearestProjectIdentity(cwd) {
+  const start = await canonicalPath(cwd);
+  const resolved = await resolveRepositoryRoot(start);
+  const repository = resolved.kind === "git_unavailable" ? { kind: "plain", root: start } : resolved;
+  const nested = repository.kind === "git" ? repository.nested : [];
+  let found = await nearestIdentity(start);
+  if (found && "worktreeTop" in found) {
+    found = await readPlainIdentity(await mainCheckout(found.worktreeTop, found.commonDir));
+  }
+  if (found) {
+    return shapedIdentity(found, await projectFolderRepository(found.root, repository), nested);
+  }
+  return { ...withBase(repository, repository.root, nested), kind: "absent" };
+}
+function shapedIdentity(found, repository, nested) {
+  const base = withBase(repository, found.root, nested);
+  if (found.result.kind === "ok")
+    return { ...base, ...found.result };
+  if (found.result.kind === "unknown_version")
+    return { ...base, ...found.result, path: found.root };
+  if (found.result.kind === "malformed")
+    return { ...base, ...found.result, path: found.root };
   return { ...base, kind: "absent" };
 }
+async function projectFolderRepository(projectRoot, known) {
+  if (known.kind === "git" && samePath(known.root, projectRoot))
+    return known;
+  const repository = await resolveRepositoryRoot(projectRoot);
+  if (repository.kind === "git" && samePath(repository.root, projectRoot))
+    return repository;
+  return { kind: "plain", root: projectRoot };
+}
+function withBase(repository, root, nested) {
+  return { root, repository, nested };
+}
 var GIT_TIMEOUT_MS, GIT_ENV_KEYS;
 var init_repositoryRoot = __esm({
   "packages/shared/dist/repositoryRoot.js"() {
@@ -848,11 +871,564 @@ var init_repositoryRoot = __esm({
   }
 });
 
+// packages/shared/dist/protectedPaths.js
+import { homedir as homedir2 } from "node:os";
+import { posix, win32 as win322 } from "node:path";
+function mnemonikStateDirectory(platform = process.platform, env = process.env, home = homedir2()) {
+  if (env.MNEMONIK_STATE_DIR)
+    return env.MNEMONIK_STATE_DIR;
+  if (platform === "win32")
+    return win322.join(env.LOCALAPPDATA || win322.join(home, "AppData", "Local"), "Mnemonik");
+  if (platform === "darwin")
+    return posix.join(home, "Library", "Application Support", "Mnemonik");
+  return posix.join(env.XDG_STATE_HOME || posix.join(home, ".local", "state"), "mnemonik");
+}
+var init_protectedPaths = __esm({
+  "packages/shared/dist/protectedPaths.js"() {
+    "use strict";
+  }
+});
+
+// packages/shared/dist/secretPatterns.js
+function shannonEntropy(token) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of token)
+    counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  let bits = 0;
+  for (const count of counts.values()) {
+    const p = count / token.length;
+    bits -= p * Math.log2(p);
+  }
+  return bits;
+}
+function maxLowercaseRun(token) {
+  let max = 0;
+  let current = 0;
+  for (const ch of token) {
+    if (ch >= "a" && ch <= "z") {
+      current += 1;
+      if (current > max)
+        max = current;
+    } else {
+      current = 0;
+    }
+  }
+  return max;
+}
+function isHighEntropySecret(token) {
+  if (token.length < ENTROPY_MIN_LENGTH)
+    return false;
+  const stripped = token.replace(/[-_]/g, "");
+  if (stripped.length > 0 && ENTROPY_HEXISH_RE.test(stripped))
+    return false;
+  if (!/[a-z]/.test(token) || !/[A-Z]/.test(token) || !/[0-9]/.test(token))
+    return false;
+  if (ENTROPY_STRUCTURED_RE.test(token) && token.split(/[/_-]/).every((seg) => seg.length <= ENTROPY_MAX_STRUCTURED_SEGMENT)) {
+    return false;
+  }
+  if (maxLowercaseRun(token) > ENTROPY_MAX_LOWERCASE_RUN)
+    return false;
+  return shannonEntropy(token) >= ENTROPY_MIN_BITS_PER_CHAR;
+}
+function redactHighEntropyTokens(text) {
+  if (!text)
+    return text;
+  return text.replace(ENTROPY_CANDIDATE_RE, (match, offset) => {
+    const before = text.slice(Math.max(0, offset - 8), offset);
+    if (!ENTROPY_CONTEXT_RE.test(before))
+      return match;
+    const operatorContext = before.replace(/["'`]$/, "").trimEnd().slice(0, -1);
+    if (ENTROPY_OPERATOR_TAIL_RE.test(operatorContext))
+      return match;
+    if (ENV_READ_VALUE_RE.test(before + match))
+      return match;
+    return isHighEntropySecret(match) ? SECRET_REDACTION_PLACEHOLDER : match;
+  });
+}
+function scrubSecrets(text) {
+  if (!text)
+    return text;
+  let result = text;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(pattern, (match) => ENV_READ_VALUE_RE.test(match) ? match : SECRET_REDACTION_PLACEHOLDER);
+  }
+  return redactHighEntropyTokens(result);
+}
+var SECRET_REDACTION_PLACEHOLDER, SECRET_PATTERNS, ENV_READ_VALUE_RE, ENTROPY_MIN_LENGTH, ENTROPY_MIN_BITS_PER_CHAR, ENTROPY_MAX_STRUCTURED_SEGMENT, ENTROPY_MAX_LOWERCASE_RUN, ENTROPY_CANDIDATE_RE, ENTROPY_CONTEXT_RE, ENTROPY_OPERATOR_TAIL_RE, ENTROPY_HEXISH_RE, ENTROPY_STRUCTURED_RE;
+var init_secretPatterns = __esm({
+  "packages/shared/dist/secretPatterns.js"() {
+    "use strict";
+    SECRET_REDACTION_PLACEHOLDER = "[REDACTED]";
+    SECRET_PATTERNS = [
+      /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]\s*(?=\S*[A-Za-z0-9])\S+/gi,
+      // Stripe-shape: (sk|pk)_(live|test)_<24+ alphanumerics>. Catches modern
+      // Stripe keys whose body is split by an environment separator that
+      // breaks the contiguous-alphanum pattern below. Required `live|test`
+      // literal prevents false-positives on snake_case identifiers like
+      // pkg_install_helper_function_xyz_abc_def.
+      /(?:sk|pk)_(?:live|test)_[a-zA-Z0-9]{24,}/g,
+      /(?:sk|pk)[-_][a-zA-Z0-9]{20,}/g,
+      /ghp_[a-zA-Z0-9]{36}/g,
+      /glpat-[a-zA-Z0-9-]{20,}/g,
+      // PEM private keys. The BLOCK pattern runs first so header->footer (the
+      // actual key material) is redacted as one unit; the header-only pattern
+      // stays as the fallback for the case a chunk boundary lands between
+      // header and footer, where the block never closes inside the chunk.
+      // `[\s\S]*?` is lazy so two adjacent keys don't merge into one match.
+      /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g,
+      /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g,
+      // AWS access key IDs. The 16-char body must be uppercase-alphanumeric and
+      // \b-delimited, so prose ("AKIAMIA is a place name") cannot match.
+      /\bAKIA[0-9A-Z]{16}\b/g,
+      /\bASIA[0-9A-Z]{16}\b/g,
+      // AWS secret access key, labeled. The generic key=value pattern above does
+      // NOT cover this: its `secret` alternative must be followed immediately by
+      // `[:=]`, and here it is followed by `_access_key`.
+      /\baws_secret_access_key\s*[:=]\s*[A-Za-z0-9/+=]{40}\b/gi,
+      // JWT: three base64url segments. Length minimums keep dotted identifiers
+      // (`payload.header.signature`) out.
+      /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\b/g,
+      /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+      /\bAIza[0-9A-Za-z_-]{35}\b/g,
+      /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+      /\b(?:npm_|npms_)[A-Za-z0-9]{36,}\b/g,
+      // scheme://userinfo@: only the credential segment is consumed, so the
+      // host and path survive for anyone reading the code. Userinfo may contain
+      // empty fields or additional `:` / `@` characters; greediness selects its
+      // final `@`, while `/`, `?`, and `#` keep paths and queries out of the match.
+      /\b[a-z][a-z0-9+.-]*:\/\/(?=[^/\s?#]*[A-Za-z0-9][^/\s?#]*@)[^/\s?#]*@/gi,
+      // Authorization: Bearer <token>. The token class deliberately excludes
+      // `<` and `$`, so documentation placeholders (`Bearer <your-api-key>`,
+      // `Bearer $MNEMONIK_PROXY_TOKEN`) are left intact - redacting those would
+      // destroy the instruction without hiding a secret.
+      /Authorization\s*:\s*Bearer\s+(?=[._~+/-]*[A-Za-z0-9])[A-Za-z0-9._~+/-]+=*/gi,
+      // sshpass -p <password> (also -p'<password>' and -p"<password>"): only the
+      // password word is consumed, so the command stays readable. A shell
+      // expansion (`$PASS`, `"$PASS"`), a `<placeholder>`, an earlier redaction
+      // and quoted punctuation are left, and so is prose about the flag: a bare all-lower-case
+      // word counts only when the command sshpass runs (ssh, scp, ...) follows it.
+      // Eleven scanned chunks in production carried a root password this way
+      // (2026-10-12); the server's memory redactor (src/core/redactCredentials.ts)
+      // has the same rule.
+      /(?<=\bsshpass(?:[ \t]+-[a-oq-zA-Z]\S*)*[ \t]+-p[ \t]*)(?:'(?![$<]|\[REDACTED\])(?=[^'\n]*[A-Za-z0-9])[^'\n]+'|"(?![$<]|\[REDACTED\])(?=[^"\n]*[A-Za-z0-9])[^"\n]+"|(?![$<'"`(),[{\\]|\[REDACTED\]|[a-z]+[.,:;!?)]*(?![^\s'"`])(?![ \t]+(?:ssh|scp|sftp|rsync|ssh-copy-id|ansible[\w-]*)(?![\w-])))[^\s'"`;|&]+)/g
+    ];
+    ENV_READ_VALUE_RE = /[:=]\s*(?:await\s+)?(?:process\.env[.[]|import\.meta\.env[.[])/;
+    ENTROPY_MIN_LENGTH = 36;
+    ENTROPY_MIN_BITS_PER_CHAR = 4;
+    ENTROPY_MAX_STRUCTURED_SEGMENT = 16;
+    ENTROPY_MAX_LOWERCASE_RUN = 5;
+    ENTROPY_CANDIDATE_RE = /[A-Za-z0-9+/_-]{35}[A-Za-z0-9+/_-]+={0,2}/g;
+    ENTROPY_CONTEXT_RE = /(?:["'`]|[:=]\s*["'`]?)$/;
+    ENTROPY_OPERATOR_TAIL_RE = /[=!<>+\-*/%&|^]$/;
+    ENTROPY_HEXISH_RE = /^[0-9a-fA-F]+$/;
+    ENTROPY_STRUCTURED_RE = /^[A-Za-z0-9]+(?:[/_-][A-Za-z0-9]+)+$/;
+  }
+});
+
+// packages/shared/dist/hookTrace.js
+import { randomBytes } from "node:crypto";
+import { closeSync, constants, fstatSync, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync, renameSync as renameSync2, statSync, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
+function hookTraceEnabled(env = process.env) {
+  const value = env[HOOK_TRACE_ENV]?.trim().toLowerCase();
+  return !value || !["off", "0", "false", "no", "disabled"].includes(value);
+}
+function hookTraceDirectory(stateDir = mnemonikStateDirectory()) {
+  return join4(stateDir, "hook-trace");
+}
+function hookTraceFile(host, stateDir) {
+  return join4(hookTraceDirectory(stateDir), `${host}.jsonl`);
+}
+function ensurePrivateDirectory(directory) {
+  if (preparedDirectories.has(directory))
+    return;
+  if (process.platform === "win32")
+    ensureWindowsPrivateDirectorySync(directory);
+  else {
+    mkdirSync2(directory, { recursive: true, mode: 448 });
+    const stat2 = lstatSync2(directory);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink() || process.getuid && stat2.uid !== process.getuid() || stat2.mode & 63)
+      throw new Error("hook trace directory is not private");
+  }
+  preparedDirectories.add(directory);
+}
+function openTrace(file) {
+  return openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0), 384);
+}
+function sameFile(file, fd) {
+  try {
+    const opened = fstatSync(fd, { bigint: true });
+    const named = statSync(file, { bigint: true });
+    return opened.ino === named.ino && opened.dev === named.dev;
+  } catch {
+    return false;
+  }
+}
+function takeLock(lock) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      closeSync(openSync(lock, "wx", 384));
+      return true;
+    } catch {
+      try {
+        if (attempt > 0 || Date.now() - lstatSync2(lock).mtimeMs < STALE_LOCK_MS)
+          return false;
+        unlinkSync2(lock);
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function rotate(file, fd) {
+  const lock = `${file}.lock`;
+  if (!takeLock(lock))
+    return;
+  try {
+    if (sameFile(file, fd))
+      renameSync2(file, `${file}.1`);
+  } finally {
+    try {
+      unlinkSync2(lock);
+    } catch {
+    }
+  }
+}
+function appendHookTraceLine(file, record2) {
+  ensurePrivateDirectory(dirname3(file));
+  const line = `${JSON.stringify(record2)}
+`;
+  let fd = openTrace(file);
+  try {
+    const stat2 = fstatSync(fd);
+    if (!stat2.isFile() || process.getuid && stat2.uid !== process.getuid())
+      throw new Error("hook trace file is not ours");
+    if (stat2.size > 0 && stat2.size + Buffer.byteLength(line) > HOOK_TRACE_MAX_BYTES) {
+      try {
+        rotate(file, fd);
+      } finally {
+        closeSync(fd);
+        fd = -1;
+      }
+      fd = openTrace(file);
+    }
+    writeSync(fd, line);
+  } finally {
+    if (fd >= 0)
+      closeSync(fd);
+  }
+}
+function byteSize(value) {
+  if (typeof value === "string")
+    return Buffer.byteLength(value);
+  try {
+    return Buffer.byteLength(JSON.stringify(value) ?? "");
+  } catch {
+    return 0;
+  }
+}
+function safe(value, pattern) {
+  return typeof value === "string" && pattern.test(value) ? value : void 0;
+}
+function sizesOf(object, prefix = "") {
+  const sizes = {};
+  for (const key of Object.keys(object).slice(0, MAX_FIELDS))
+    if (SAFE_NAME.test(key))
+      sizes[prefix + key] = byteSize(object[key]);
+  return sizes;
+}
+function summarizeHookOutput(text) {
+  const output = { bytes: Buffer.byteLength(text), sizes: {} };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return output;
+  }
+  if (!isObject(value))
+    return output;
+  const nested = isObject(value.hookSpecificOutput) ? value.hookSpecificOutput : void 0;
+  const { hookSpecificOutput: _nested, ...top } = value;
+  output.sizes = { ...sizesOf(top), ...nested ? sizesOf(nested, "hookSpecificOutput.") : {} };
+  const permission = safe(value.permission ?? nested?.permissionDecision, SAFE_ENUM);
+  const decision = safe(value.decision, SAFE_ENUM);
+  if (permission)
+    output.permission = permission;
+  if (decision)
+    output.decision = decision;
+  if (typeof value.continue === "boolean")
+    output.continue = value.continue;
+  return output;
+}
+function routeOf(input) {
+  try {
+    const href = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    return new URL(String(href)).pathname.split("/").map((segment) => segment.length >= 16 && /\d/.test(segment) || /[%@]/.test(segment) ? ":id" : segment).join("/").slice(0, 200);
+  } catch {
+    return "unknown";
+  }
+}
+function errorKind(error) {
+  const failure = error;
+  if (failure?.name === "TimeoutError")
+    return "timeout";
+  if (failure?.name === "AbortError")
+    return "aborted";
+  const code = failure?.cause?.code ?? failure?.code;
+  if (typeof code === "string" && /^[A-Z0-9_]{2,40}$/.test(code))
+    return code;
+  return safe(failure?.name, /^\w{1,40}$/) ?? "error";
+}
+function scrubHookTraceMessage(error) {
+  const text = error instanceof Error ? error.message : String(error);
+  return scrubSecrets(text.replace(/\s+/g, " ").trim()).slice(0, MAX_ERROR_CHARS);
+}
+function noteHookTraceProject(projectId) {
+  active?.project(projectId);
+}
+function startHookTrace(options) {
+  if (active)
+    return active;
+  let file;
+  try {
+    if (hookTraceEnabled(options.env))
+      file = hookTraceFile(options.host, options.stateDir ?? mnemonikStateDirectory(process.platform, options.env ?? process.env));
+  } catch {
+    file = void 0;
+  }
+  const trace = new HookTrace(options.host, file, options.hookVersion);
+  active = trace;
+  if (!file)
+    return trace;
+  const original = globalThis.fetch;
+  if (typeof original === "function") {
+    globalThis.fetch = async (input, init) => {
+      const token = trace.callStarted(input);
+      try {
+        const response = await original.call(globalThis, input, init);
+        trace.settle(token, response.status);
+        return response;
+      } catch (error) {
+        trace.settle(token, void 0, error);
+        throw error;
+      }
+    };
+  }
+  process.once("exit", (code) => trace.finish(typeof code === "number" ? code : 0));
+  trace.open();
+  return trace;
+}
+var HOOK_TRACE_MAX_BYTES, HOOK_TRACE_ENV, MAX_FIELDS, MAX_CALLS, MAX_ERROR_CHARS, SAFE_ID, SAFE_NAME, SAFE_ENUM, preparedDirectories, STALE_LOCK_MS, isObject, HookTrace, active;
+var init_hookTrace = __esm({
+  "packages/shared/dist/hookTrace.js"() {
+    "use strict";
+    init_protectedPaths();
+    init_runtimeSigners();
+    init_secretPatterns();
+    HOOK_TRACE_MAX_BYTES = 2 * 1024 * 1024;
+    HOOK_TRACE_ENV = "MNEMONIK_HOOK_TRACE";
+    MAX_FIELDS = 64;
+    MAX_CALLS = 64;
+    MAX_ERROR_CHARS = 80;
+    SAFE_ID = /^[A-Za-z0-9@._+:-]{1,128}$/;
+    SAFE_NAME = /^[A-Za-z0-9@._+:/-]{1,120}$/;
+    SAFE_ENUM = /^[A-Za-z_]{1,24}$/;
+    preparedDirectories = /* @__PURE__ */ new Set();
+    STALE_LOCK_MS = 1e4;
+    isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+    HookTrace = class {
+      host;
+      file;
+      hookVersion;
+      id = randomBytes(8).toString("hex");
+      startedAt = performance.now();
+      opened = false;
+      started = false;
+      ended = false;
+      event = null;
+      outputSummary = null;
+      error;
+      errorKind;
+      projectId;
+      calls = [];
+      inFlight = /* @__PURE__ */ new Set();
+      constructor(host, file, hookVersion) {
+        this.host = host;
+        this.file = file;
+        this.hookVersion = hookVersion;
+      }
+      get enabled() {
+        return this.file !== void 0;
+      }
+      write(record2) {
+        if (!this.file)
+          return;
+        try {
+          appendHookTraceLine(this.file, record2);
+        } catch {
+        }
+      }
+      /**
+       * Write the `start` line: pid, run id and time since process start, nothing
+       * from the editor. Runs before stdin is read, so a run killed while the
+       * editor is still sending its event leaves this line.
+       */
+      open() {
+        if (!this.file || this.opened)
+          return;
+        this.opened = true;
+        this.write({
+          v: 1,
+          phase: "start",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          host: this.host,
+          ...this.hookVersion ? { hookVersion: this.hookVersion } : {},
+          pid: process.pid,
+          id: this.id,
+          processMs: Math.round(process.uptime() * 1e3)
+        });
+      }
+      /** Write the `input` line. `input` is the parsed payload, or null when none parsed. */
+      begin(input, event) {
+        if (!this.file || this.started)
+          return;
+        this.open();
+        this.started = true;
+        try {
+          const payload = isObject(input) ? input : {};
+          this.event = safe(event, SAFE_NAME) ?? safe(payload.hook_event_name, SAFE_NAME) ?? safe(payload.hookEventName, SAFE_NAME) ?? null;
+          const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots : [];
+          const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : typeof roots[0] === "string" ? roots[0] : process.cwd();
+          const record2 = {
+            v: 1,
+            phase: "input",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            host: this.host,
+            pid: process.pid,
+            id: this.id,
+            event: this.event,
+            inputBytes: isObject(input) ? byteSize(input) : 0,
+            fields: sizesOf(payload),
+            readMs: Math.round(performance.now() - this.startedAt)
+          };
+          const hostVersion = safe(payload.cursor_version ?? payload.version, /^[\w.+-]{1,40}$/);
+          if (hostVersion)
+            record2.hostVersion = hostVersion;
+          const ids = [
+            ["sessionId", "session_id"],
+            ["conversationId", "conversation_id"],
+            ["generationId", "generation_id"],
+            ["agentId", "agent_id"],
+            ["agentId", "subagent_id"],
+            ["turnId", "turn_id"]
+          ];
+          for (const [name, key] of ids) {
+            const id = safe(payload[key], SAFE_ID);
+            if (id && record2[name] === void 0)
+              record2[name] = id;
+          }
+          const tool = safe(payload.tool_name, SAFE_NAME);
+          if (tool)
+            record2.tool = tool;
+          if (cwd.length <= 1024)
+            record2.cwd = cwd;
+          this.write(record2);
+        } catch {
+        }
+      }
+      /** The exact text the hook wrote to stdout (or nothing). */
+      output(text) {
+        if (!this.file || text === null || text === void 0)
+          return;
+        try {
+          this.outputSummary = summarizeHookOutput(text);
+        } catch {
+        }
+      }
+      /** The error the hook failed open on. */
+      fail(error) {
+        if (!this.file)
+          return;
+        try {
+          this.errorKind = errorKind(error);
+          this.error = scrubHookTraceMessage(error);
+        } catch {
+          this.errorKind = "error";
+        }
+      }
+      project(projectId) {
+        if (projectId && !this.projectId && SAFE_ID.test(projectId))
+          this.projectId = projectId;
+      }
+      /** A call has gone out; {@link settle} records it, {@link finish} records it as pending. */
+      callStarted(input) {
+        const token = { input, startedAt: performance.now() };
+        if (this.file)
+          this.inFlight.add(token);
+        return token;
+      }
+      settle(token, status, error) {
+        this.inFlight.delete(token);
+        this.call(token.input, token.startedAt, status, error);
+      }
+      call(input, startedAt, status, error) {
+        if (!this.file || this.calls.length >= MAX_CALLS)
+          return;
+        try {
+          this.calls.push({
+            path: routeOf(input),
+            ...status !== void 0 ? { status } : { error: errorKind(error) },
+            ms: Math.round(performance.now() - startedAt)
+          });
+        } catch {
+        }
+      }
+      /** Write the `end` line once. Runs from the process `exit` event. */
+      finish(exitCode = 0) {
+        if (!this.file || this.ended)
+          return;
+        this.open();
+        this.ended = true;
+        for (const { input, startedAt } of this.inFlight) {
+          if (this.calls.length >= MAX_CALLS)
+            break;
+          try {
+            this.calls.push({
+              path: routeOf(input),
+              pending: true,
+              ms: Math.round(performance.now() - startedAt)
+            });
+          } catch {
+          }
+        }
+        this.inFlight.clear();
+        this.write({
+          v: 1,
+          phase: "end",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          host: this.host,
+          pid: process.pid,
+          id: this.id,
+          event: this.event,
+          ...this.projectId ? { projectId: this.projectId } : {},
+          output: this.outputSummary,
+          calls: this.calls,
+          durationMs: Math.round(performance.now() - this.startedAt),
+          processMs: Math.round(process.uptime() * 1e3),
+          exitCode,
+          ...this.errorKind ? { errorKind: this.errorKind } : {},
+          ...this.error ? { error: this.error } : {}
+        });
+      }
+    };
+  }
+});
+
 // packages/shared/dist/runtimeReader.js
 import { createHash as createHash2 } from "node:crypto";
-import { constants } from "node:fs";
+import { constants as constants2 } from "node:fs";
 import { lstat as lstat3, open, readdir } from "node:fs/promises";
-import { dirname as dirname3, join as join4, parse, resolve as resolve3, sep as sep2 } from "node:path";
+import { dirname as dirname4, join as join5, parse, resolve as resolve3, sep as sep2 } from "node:path";
 function safePath(path) {
   if (typeof path !== "string" || !/^[a-zA-Z0-9_@.+/-]+$/.test(path) || path.split("/").some((p) => !p || p === "." || p === "..") || path.includes(":"))
     throw new RuntimeError("permission");
@@ -903,7 +1479,7 @@ var init_runtimeReader = __esm({
       pointerPath(artifact) {
         if (!["cli", "scanner", "claude-code", "codex", "cursor", "grok"].includes(artifact))
           throw new RuntimeError("permission");
-        return join4(this.state, "runtimes", artifact, "current");
+        return join5(this.state, "runtimes", artifact, "current");
       }
       guardedPath(path) {
         const absolute = resolve3(path);
@@ -913,7 +1489,7 @@ var init_runtimeReader = __esm({
       }
       auditRoot(path) {
         const [area, artifact] = path.slice(this.state.length + 1).split(sep2);
-        return area === "runtimes" ? join4(this.state, area, ...artifact ? [artifact] : []) : path;
+        return area === "runtimes" ? join5(this.state, area, ...artifact ? [artifact] : []) : path;
       }
       traceAudit(event) {
         const level = process.env.MNEMONIK_AUDIT_TRACE;
@@ -930,7 +1506,7 @@ var init_runtimeReader = __esm({
       invalidateAudit(path) {
         const root = this.auditRoot(path);
         for (const key of this.windowsAudit.keys())
-          if (key === root || (!this.options.cacheDirectories || root.startsWith(join4(this.state, "runtimes") + sep2)) && key.startsWith(root + sep2))
+          if (key === root || (!this.options.cacheDirectories || root.startsWith(join5(this.state, "runtimes") + sep2)) && key.startsWith(root + sep2))
             this.windowsAudit.delete(key);
       }
       audit(paths) {
@@ -964,7 +1540,7 @@ var init_runtimeReader = __esm({
               pending.add(part);
             if (part === this.state)
               break;
-            part = dirname3(part);
+            part = dirname4(part);
           }
         }
         if (!pending.size)
@@ -974,7 +1550,7 @@ var init_runtimeReader = __esm({
           const ancestors = [...pending].filter((path) => path !== root && !path.startsWith(root + sep2));
           const tree = [...pending].filter((path) => !ancestors.includes(path));
           for (const part of [...ancestors, ...tree.length ? [root] : []]) {
-            const recursive = part === root && root.startsWith(join4(this.state, "runtimes") + sep2);
+            const recursive = part === root && root.startsWith(join5(this.state, "runtimes") + sep2);
             this.traceAudit({ event: "audit", root: part, recursive });
             const requested = part === root ? tree : [part];
             if (this.options.cacheDirectories && !this.windowsDirectories.has(part) && this.windowsAudit.get(part)?.verdict === "ok") {
@@ -1002,7 +1578,7 @@ var init_runtimeReader = __esm({
         const windowsPaths = [];
         let part = parse(absolute).root;
         for (const name of absolute.slice(part.length).split(sep2)) {
-          part = join4(part, name);
+          part = join5(part, name);
           const stat2 = await lstat3(part).catch((e) => {
             if (allowMissing && missing(e))
               return null;
@@ -1056,7 +1632,7 @@ var init_runtimeReader = __esm({
         if (process.platform !== "win32" || !this.options.cacheDirectories)
           return;
         const absolute = this.guardedPath(path);
-        const parent = dirname3(absolute);
+        const parent = dirname4(absolute);
         const stat2 = await lstat3(parent);
         if (!stat2.isDirectory() || stat2.isSymbolicLink() || !this.windowsStats.get(parent)?.startsWith(`${stat2.dev}:${stat2.ino}:`))
           throw new RuntimeError("permission");
@@ -1066,7 +1642,7 @@ var init_runtimeReader = __esm({
       }
       async bytes(path) {
         await this.inspect(path);
-        const fd = await open(path, constants.O_RDONLY | (process.platform === "win32" ? 0 : constants.O_NOFOLLOW));
+        const fd = await open(path, constants2.O_RDONLY | (process.platform === "win32" ? 0 : constants2.O_NOFOLLOW));
         try {
           return await fd.readFile();
         } finally {
@@ -1114,7 +1690,7 @@ var init_runtimeReader = __esm({
       async verifyOpen(artifact, ref, directory) {
         let bytes;
         try {
-          bytes = await this.bytes(join4(directory, "manifest.json"));
+          bytes = await this.bytes(join5(directory, "manifest.json"));
         } catch (e) {
           if (missing(e))
             throw new RuntimeError("manifest_missing");
@@ -1135,7 +1711,7 @@ var init_runtimeReader = __esm({
         if (artifact === "cli" && (m.source.kind !== "npm" || !Array.isArray(m.source.packages) || !m.source.packages.some((p) => p.name === "@mnemonik/cli" && p.version === m.version)))
           throw new RuntimeError("unsigned");
         if (process.platform === "win32")
-          await this.audit(Object.keys(m.files).map((name) => join4(directory, safePath(name))));
+          await this.audit(Object.keys(m.files).map((name) => join5(directory, safePath(name))));
         const actual = [];
         const walk = async (dir, prefix = "") => {
           await this.inspect(dir, true);
@@ -1143,7 +1719,7 @@ var init_runtimeReader = __esm({
             const key = prefix + name;
             if (!prefix && name === "manifest.json")
               continue;
-            const path = join4(dir, name);
+            const path = join5(dir, name);
             if ((await lstat3(path)).isDirectory())
               await walk(path, key + "/");
             else {
@@ -1159,7 +1735,7 @@ var init_runtimeReader = __esm({
         for (const [name, expected] of Object.entries(m.files)) {
           if (!expected || !/^[a-f0-9]{64}$/.test(expected.sha256) || !Number.isSafeInteger(expected.size) || expected.size < 0 || typeof expected.executable !== "boolean")
             throw new RuntimeError("digest_mismatch");
-          const path = join4(directory, safePath(name));
+          const path = join5(directory, safePath(name));
           const contents = await this.bytes(path);
           if (hash(contents) !== expected.sha256 || contents.length !== expected.size)
             throw new RuntimeError("digest_mismatch");
@@ -1170,11 +1746,11 @@ var init_runtimeReader = __esm({
         if (total !== m.totalSize)
           throw new RuntimeError("digest_mismatch");
         if (m.signer) {
-          const signer = m.signer.platform === "linux" ? { ...m.signer, signature: join4(directory, safePath(m.signer.signature)) } : m.signer;
+          const signer = m.signer.platform === "linux" ? { ...m.signer, signature: join5(directory, safePath(m.signer.signature)) } : m.signer;
           if (m.signer.platform === "linux" && !m.files[m.signer.signature])
             throw new RuntimeError("unsigned");
           try {
-            const entry = join4(directory, m.entry);
+            const entry = join5(directory, m.entry);
             if (signer.platform === "win32") {
               const key = JSON.stringify([entry, m.files[m.entry]?.sha256, signer.identity]);
               let verification = _RuntimeReader.windowsSignatures.get(key);
@@ -1192,18 +1768,18 @@ var init_runtimeReader = __esm({
             throw new RuntimeError("unsigned");
           }
         }
-        return { directory, manifest: m, entry: join4(directory, m.entry), reference: ref };
+        return { directory, manifest: m, entry: join5(directory, m.entry), reference: ref };
       }
       verifyRetainedRuntime(artifact, reference) {
         versionName(reference.version);
-        return this.verifyAt(artifact, reference, join4(dirname3(this.pointerPath(artifact)), reference.version));
+        return this.verifyAt(artifact, reference, join5(dirname4(this.pointerPath(artifact)), reference.version));
       }
       async verifyRuntime(artifact) {
         return this.operation(async () => {
           const p = await this.pointer(artifact);
           if (!p)
             throw new RuntimeError("manifest_missing");
-          return this.verifyOpen(artifact, p.current, join4(dirname3(this.pointerPath(artifact)), p.current.version));
+          return this.verifyOpen(artifact, p.current, join5(dirname4(this.pointerPath(artifact)), p.current.version));
         });
       }
     };
@@ -1212,10 +1788,10 @@ var init_runtimeReader = __esm({
 
 // packages/shared/dist/projectSetupHandoff.js
 import { spawn } from "node:child_process";
-import { constants as constants2 } from "node:fs";
-import { lstat as lstat4, mkdir, open as open2, readdir as readdir2, realpath, rename, rm } from "node:fs/promises";
+import { constants as constants3 } from "node:fs";
+import { lstat as lstat4, mkdir, open as open2, readdir as readdir2, realpath as realpath2, rename, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename as basename2, dirname as dirname4, join as join5, relative } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join6, relative } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function projectSetupActions(value) {
@@ -1255,7 +1831,7 @@ async function privateDirectory(path, session) {
   }
 }
 async function readPrivate(path) {
-  const file = await open2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  const file = await open2(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   try {
     const st = await file.stat();
     if (!st.isFile() || st.size > 64 * 1024 || process.getuid && (st.uid !== process.getuid() || st.mode & 63))
@@ -1266,8 +1842,8 @@ async function readPrivate(path) {
   }
 }
 async function writeDiagnostic(path, value) {
-  await privateDirectory(dirname4(dirname4(path)), dirname4(path));
-  await privateDirectory(dirname4(path), dirname4(path));
+  await privateDirectory(dirname5(dirname5(path)), dirname5(path));
+  await privateDirectory(dirname5(path), dirname5(path));
   const temp = `${path}.${randomUUID2()}`;
   try {
     const file = await open2(temp, "wx", 384);
@@ -1307,13 +1883,13 @@ async function waitForResult(path, waitMs) {
       return result;
     if (Date.now() >= deadline)
       return RUNNING;
-    await new Promise((resolve5) => setTimeout(resolve5, Math.min(50, deadline - Date.now())));
+    await new Promise((resolve6) => setTimeout(resolve6, Math.min(50, deadline - Date.now())));
   }
 }
 async function runEnsure(options) {
-  await privateDirectory(dirname4(options.directory), options.directory);
+  await privateDirectory(dirname5(options.directory), options.directory);
   await privateDirectory(options.directory, options.directory);
-  const runFile = join5(options.directory, "project-setup-run.json");
+  const runFile = join6(options.directory, "project-setup-run.json");
   let previous;
   try {
     previous = JSON.parse(await readPrivate(runFile));
@@ -1321,7 +1897,7 @@ async function runEnsure(options) {
     previous = void 0;
   }
   if (previous && previous.root === options.root && typeof previous.result === "string") {
-    const result2 = join5(options.directory, basename2(previous.result));
+    const result2 = join6(options.directory, basename2(previous.result));
     const finished = await readResult(result2).catch(() => ({ status: "failed" }));
     if (finished === void 0 && Date.now() - previous.startedAt < RUN_STALE_MS) {
       const outcome2 = await waitForResult(result2, options.waitMs);
@@ -1334,7 +1910,7 @@ async function runEnsure(options) {
     if (record(finished) && finished.status === "done")
       return finished;
   }
-  const result = join5(options.directory, `project-setup-${randomUUID2()}.result.json`);
+  const result = join6(options.directory, `project-setup-${randomUUID2()}.result.json`);
   const run = {
     requestId: options.requestId,
     root: options.root,
@@ -1402,28 +1978,28 @@ async function handoffProjectSetup(input) {
   try {
     if (!input.cwd)
       throw new Error("safe_cwd_unavailable");
-    const cache = JSON.parse(await readPrivate(join5(dirname4(input.stateFile), "bound-context.json")));
+    const cache = JSON.parse(await readPrivate(join6(dirname5(input.stateFile), "bound-context.json")));
     const [, family, body] = JSON.parse(cache.key);
     if (!input.familyId || family !== input.familyId || body.host !== input.host || body.hostSessionId !== input.hostSessionId || cache.expiresAt <= Date.now() || !cache.canonicalRoot)
       throw new Error("bound_context_unavailable");
-    root = await realpath(cache.canonicalRoot);
+    root = await realpath2(cache.canonicalRoot);
     const { findProjectIdentityDetailed: findProjectIdentityDetailed2 } = await Promise.resolve().then(() => (init_hookRuntime(), hookRuntime_exports));
-    const identity = await findProjectIdentityDetailed2(await realpath(input.cwd));
-    if (identity.kind === "git_unavailable" || root !== await realpath(identity.root))
+    const identity = await findProjectIdentityDetailed2(await realpath2(input.cwd));
+    if (identity.kind === "git_unavailable" || root !== await realpath2(identity.root))
       throw new Error("bound_root_changed");
     if (!requestId)
       throw new Error("manual_setup_required");
     const runtime = await new RuntimeReader(input.stateDir).verifyRuntime("cli").catch(() => {
       throw new Error("verified_cli_runtime_unavailable");
     });
-    const bin = join5(dirname4(runtime.entry), "bin.js");
+    const bin = join6(dirname5(runtime.entry), "bin.js");
     if (!runtime.manifest.files[relative(runtime.directory, bin).replaceAll("\\", "/")])
       throw new Error("verified_cli_bin_missing");
     const result = await runEnsure({
       bin,
       root,
       requestId,
-      directory: dirname4(input.stateFile),
+      directory: dirname5(input.stateFile),
       waitMs: input.waitMs ?? Math.max(0, hookDeadlineMs(input.host) - performance2.now())
     });
     if (result === RUNNING) {
@@ -1453,7 +2029,7 @@ async function handoffProjectSetup(input) {
       requestId,
       outcome,
       time: (/* @__PURE__ */ new Date()).toISOString(),
-      rootHash: root ? hash(root) : input.cwd ? hash(await realpath(input.cwd)) : null,
+      rootHash: root ? hash(root) : input.cwd ? hash(await realpath2(input.cwd)) : null,
       action,
       reason
     });
@@ -1463,11 +2039,11 @@ async function handoffProjectSetup(input) {
   return action;
 }
 async function pendingProjectSetup(root) {
-  const rootHash = hash(await realpath(root));
+  const rootHash = hash(await realpath2(root));
   const results = [];
   const uid = process.getuid?.() ?? "user";
   for (const host of ["credit", "cursor", "grok"]) {
-    const directory = join5(tmpdir(), `mnemonik-${host}-${uid}`);
+    const directory = join6(tmpdir(), `mnemonik-${host}-${uid}`);
     try {
       const stat2 = await lstat4(directory);
       if (stat2.isSymbolicLink() || !stat2.isDirectory())
@@ -1476,9 +2052,9 @@ async function pendingProjectSetup(root) {
         if (!/^[a-f0-9]{64}$/.test(name))
           continue;
         try {
-          if ((await lstat4(join5(directory, name))).isSymbolicLink())
+          if ((await lstat4(join6(directory, name))).isSymbolicLink())
             continue;
-          const diagnostic = JSON.parse(await readPrivate(join5(directory, name, "project-setup.json")));
+          const diagnostic = JSON.parse(await readPrivate(join6(directory, name, "project-setup.json")));
           if ((diagnostic.rootHash === rootHash || diagnostic.rootHash === null) && ["done", "ACTION_REQUIRED", "failed"].includes(diagnostic.outcome) && typeof diagnostic.action === "string" && diagnostic.action.length < 2e3 && Date.now() - Date.parse(diagnostic.time) < 24 * 60 * 60 * 1e3)
             results.push(diagnostic);
         } catch {
@@ -1530,9 +2106,9 @@ process.stdin.on('end', () => {
 });
 
 // packages/shared/dist/settingsIo.js
-import { createHash as createHash3, randomBytes } from "node:crypto";
-import { link, lstat as lstat5, mkdir as mkdir2, open as open3, readFile as readFile4, readdir as readdir3, realpath as realpath2, rename as rename2, rm as rm2, rmdir, stat, unlink } from "node:fs/promises";
-import { basename as basename3, dirname as dirname5, join as join6, resolve as resolve4 } from "node:path";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { link, lstat as lstat5, mkdir as mkdir2, open as open3, readFile as readFile4, readdir as readdir3, realpath as realpath3, rename as rename2, rm as rm2, rmdir, stat, unlink } from "node:fs/promises";
+import { basename as basename3, dirname as dirname6, join as join7, resolve as resolve4 } from "node:path";
 function errorCode(error) {
   return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
 }
@@ -1579,7 +2155,7 @@ async function removeStaleLock(lockPath, staleMs = LOCK_STALE_MS) {
   const [entry] = entries;
   if (entries.length !== 1 || entry === void 0 || !entry.startsWith("owner-"))
     return false;
-  const tokenPath = join6(lockPath, entry);
+  const tokenPath = join7(lockPath, entry);
   const owner = await readFile4(tokenPath, "utf8");
   if (lockOwnerIsAlive(owner))
     return false;
@@ -1600,13 +2176,13 @@ async function removeStaleLock(lockPath, staleMs = LOCK_STALE_MS) {
   }
 }
 async function acquireLock(lockPath, options = {}) {
-  await mkdir2(dirname5(lockPath), { recursive: true });
-  const owner = `${process.pid} ${Date.now()} ${randomBytes(12).toString("hex")}
+  await mkdir2(dirname6(lockPath), { recursive: true });
+  const owner = `${process.pid} ${Date.now()} ${randomBytes2(12).toString("hex")}
 `;
   for (let attempt = 0; attempt < (options.retries ?? LOCK_RETRIES); attempt += 1) {
     try {
       await mkdir2(lockPath, { mode: 448 });
-      const tokenPath = join6(lockPath, `owner-${process.pid}-${randomBytes(12).toString("hex")}`);
+      const tokenPath = join7(lockPath, `owner-${process.pid}-${randomBytes2(12).toString("hex")}`);
       const handle = await open3(tokenPath, "wx", 384);
       try {
         await handle.writeFile(owner, "utf8");
@@ -1615,7 +2191,7 @@ async function acquireLock(lockPath, options = {}) {
         await handle.close();
       }
       await syncDirectory(lockPath);
-      await syncDirectory(dirname5(lockPath));
+      await syncDirectory(dirname6(lockPath));
       return tokenPath;
     } catch (error) {
       if (errorCode(error) !== "EEXIST") {
@@ -1645,7 +2221,7 @@ async function withFileLock(lockPath, action, options) {
     try {
       await unlink(tokenPath);
       await rmdir(lockPath);
-      await syncDirectory(dirname5(lockPath));
+      await syncDirectory(dirname6(lockPath));
     } catch {
     }
   }
@@ -1661,30 +2237,30 @@ var init_settingsIo = __esm({
 });
 
 // packages/shared/dist/hookConversation.js
-import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
-import { constants as constants3 } from "node:fs";
+import { createHash as createHash4, randomBytes as randomBytes3 } from "node:crypto";
+import { constants as constants4 } from "node:fs";
 import { lstat as lstat6, mkdir as mkdir3, open as open4, rename as rename3, rm as rm3, utimes } from "node:fs/promises";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 function boundedHandle(value) {
   return typeof value === "string" && /^cv1\.[0-9a-f-]{36}\.[A-Za-z0-9_-]{43}$/.test(value);
 }
 async function configureHookConversation(input) {
-  active = new HookConversation(input);
-  await active.load();
+  active2 = new HookConversation(input);
+  await active2.load();
 }
 function currentConversationId() {
-  return active?.id;
+  return active2?.id;
 }
 function conversationMarker() {
-  return active?.id ? `<system-reminder>mnemonik-conversation: ${active.id}</system-reminder>` : void 0;
+  return active2?.id ? `<system-reminder>mnemonik-conversation: ${active2.id}</system-reminder>` : void 0;
 }
 async function adoptHookConversation(result) {
-  await active?.adopt(result);
+  await active2?.adopt(result);
 }
 function withHookConversation(url, init, post) {
-  return active ? active.request(url, init, post) : post(init);
+  return active2 ? active2.request(url, init, post) : post(init);
 }
-var RETENTION_MS, CONVERSATION_STATE_FILE, HookConversation, active;
+var RETENTION_MS, CONVERSATION_STATE_FILE, HookConversation, active2;
 var init_hookConversation = __esm({
   "packages/shared/dist/hookConversation.js"() {
     "use strict";
@@ -1712,10 +2288,10 @@ var init_hookConversation = __esm({
       async load() {
         this.conversationId = void 0;
         try {
-          const directory = await lstat6(dirname6(this.input.stateFile));
+          const directory = await lstat6(dirname7(this.input.stateFile));
           if (!directory.isDirectory() || directory.isSymbolicLink() || process.platform !== "win32" && (process.getuid && directory.uid !== process.getuid() || directory.mode & 63))
             return;
-          const file = await open4(this.input.stateFile, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+          const file = await open4(this.input.stateFile, constants4.O_RDONLY | constants4.O_NOFOLLOW);
           try {
             const stat2 = await file.stat();
             if (!stat2.isFile() || stat2.size > 4096 || process.platform !== "win32" && (process.getuid && stat2.uid !== process.getuid() || stat2.mode & 63))
@@ -1734,7 +2310,7 @@ var init_hookConversation = __esm({
         }
       }
       async locked(run) {
-        const directory = dirname6(this.input.stateFile);
+        const directory = dirname7(this.input.stateFile);
         await mkdir3(directory, { recursive: true, mode: 448 });
         const stat2 = await lstat6(directory);
         if (!stat2.isDirectory() || stat2.isSymbolicLink() || process.platform !== "win32" && (process.getuid && stat2.uid !== process.getuid() || stat2.mode & 63))
@@ -1747,8 +2323,8 @@ var init_hookConversation = __esm({
         });
       }
       async save(id) {
-        const temporary = `${this.input.stateFile}.${randomBytes2(8).toString("hex")}`;
-        const file = await open4(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY | constants3.O_NOFOLLOW, 384);
+        const temporary = `${this.input.stateFile}.${randomBytes3(8).toString("hex")}`;
+        const file = await open4(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY | constants4.O_NOFOLLOW, 384);
         try {
           await file.writeFile(JSON.stringify({ v: 1, scope: this.scope, conversationId: id, usedAt: Date.now() }));
         } finally {
@@ -2022,7 +2598,10 @@ var hookRuntime_exports = {};
 __export(hookRuntime_exports, {
   CONVERSATION_STATE_FILE: () => CONVERSATION_STATE_FILE,
   HOOK_STDIN_MAX_BYTES: () => HOOK_STDIN_MAX_BYTES,
+  HOOK_TRACE_ENV: () => HOOK_TRACE_ENV,
+  HOOK_TRACE_MAX_BYTES: () => HOOK_TRACE_MAX_BYTES,
   HookConversation: () => HookConversation,
+  HookTrace: () => HookTrace,
   PROJECT_ENSURE_TIMEOUT_MS: () => PROJECT_ENSURE_TIMEOUT_MS,
   PROJECT_SETUP_MANUAL: () => PROJECT_SETUP_MANUAL,
   PROJECT_SETUP_RUNNING: () => PROJECT_SETUP_RUNNING,
@@ -2031,6 +2610,7 @@ __export(hookRuntime_exports, {
   RuntimeReader: () => RuntimeReader,
   aclRecords: () => aclRecords,
   adoptHookConversation: () => adoptHookConversation,
+  appendHookTraceLine: () => appendHookTraceLine,
   auditWindowsPermissions: () => auditWindowsPermissions,
   bindHookContext: () => bindHookContext,
   clearProjectIdentityCache: () => clearProjectIdentityCache,
@@ -2038,21 +2618,31 @@ __export(hookRuntime_exports, {
   conversationMarker: () => conversationMarker,
   currentConversationId: () => currentConversationId,
   ensureWindowsPrivateDirectorySync: () => ensureWindowsPrivateDirectorySync,
+  errorKind: () => errorKind,
   execute: () => execute,
   findProjectIdentity: () => findProjectIdentity,
   findProjectIdentityDetailed: () => findProjectIdentityDetailed,
   handoffProjectSetup: () => handoffProjectSetup,
   hash: () => hash,
+  hookTraceDirectory: () => hookTraceDirectory,
+  hookTraceEnabled: () => hookTraceEnabled,
+  hookTraceFile: () => hookTraceFile,
   missing: () => missing,
+  modelTypedCwd: () => modelTypedCwd,
+  noteHookTraceProject: () => noteHookTraceProject,
   parseHookResponse: () => parseHookResponse,
   pendingProjectSetup: () => pendingProjectSetup,
   postHookBoundJson: () => postHookBoundJson,
   prepareWindowsAclDirectory: () => prepareWindowsAclDirectory,
+  projectScope: () => projectScope,
   projectSetupActions: () => projectSetupActions,
   protectWindowsDirectory: () => protectWindowsDirectory,
   readHookStdin: () => readHookStdin,
   safePath: () => safePath,
+  scrubHookTraceMessage: () => scrubHookTraceMessage,
   setupResponse: () => setupResponse,
+  startHookTrace: () => startHookTrace,
+  summarizeHookOutput: () => summarizeHookOutput,
   validHookSessionId: () => validHookSessionId,
   verifyMinisign: () => verifyMinisign,
   verifySigner: () => verifySigner,
@@ -2064,36 +2654,43 @@ __export(hookRuntime_exports, {
   withHookConversation: () => withHookConversation
 });
 import { stderr, stdin } from "node:process";
+import { homedir as homedir3 } from "node:os";
+import { join as join8, resolve as resolve5 } from "node:path";
+function modelTypedCwd(hostCwd, typed) {
+  const expanded = typed === "~" ? homedir3() : /^~[\\/]/.test(typed) ? join8(homedir3(), typed.slice(2)) : typed;
+  return resolve5(hostCwd, expanded);
+}
 function clearProjectIdentityCache() {
   identityCache.clear();
 }
-async function findProjectIdentity(startCwd, options = {}) {
+async function findProjectIdentity(startCwd) {
   if (!startCwd)
     return null;
-  const key = JSON.stringify([
-    startCwd,
-    options.allowNestedInherit ?? null,
-    options.maxDepth ?? null
-  ]);
+  const key = startCwd;
   let pending = identityCache.get(key);
   if (!pending) {
-    pending = findProjectIdentityDetailed(startCwd, options).then((result) => result.kind === "ok" ? {
+    pending = findProjectIdentityDetailed(startCwd).then((result) => result.kind === "ok" ? {
       projectId: result.identity.projectId,
       projectName: result.identity.projectName,
       projectRoot: result.root
     } : null);
     identityCache.set(key, pending);
     pending.catch(() => identityCache.delete(key));
+    pending.then((found) => noteHookTraceProject(found?.projectId), () => void 0);
   }
   return pending;
 }
-async function findProjectIdentityDetailed(startCwd, options = {}) {
-  return resolveProjectIdentity(startCwd, options);
+async function projectScope(startCwd) {
+  const identity = await findProjectIdentity(startCwd);
+  return identity ? { projectId: identity.projectId, projectRoot: identity.projectRoot } : {};
+}
+async function findProjectIdentityDetailed(startCwd) {
+  return resolveNearestProjectIdentity(startCwd);
 }
 function readHookStdin(options = {}) {
   const stream = options.stream ?? stdin;
   const maxBytes = options.maxBytes ?? HOOK_STDIN_MAX_BYTES;
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const chunks = [];
     let bytes = 0;
     let settled = false;
@@ -2109,7 +2706,7 @@ function readHookStdin(options = {}) {
         stream.pause();
         stream.destroy?.();
       }
-      resolve5(value);
+      resolve6(value);
     };
     const onData = (chunk) => {
       const buffer = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
@@ -2126,13 +2723,7 @@ function readHookStdin(options = {}) {
   });
 }
 async function parseHookResponse(response) {
-  const body = await response.json();
-  const result = body;
-  if (!mismatchEmitted && result?.ok === false && result.reason === "identity_mismatch") {
-    stderr.write("mnemonik-hook: project identity mismatch - .mnemonik.json points to one project, but this directory is registered to a different one on the server. Fix .mnemonik.json (delete it and let session_bootstrap rewrite it) or cd to the correct project root.\n");
-    mismatchEmitted = true;
-  }
-  return body;
+  return await response.json();
 }
 function validHookSessionId(value) {
   return typeof value === "string" && /^[a-zA-Z0-9@._+:-]{1,255}$/.test(value) && !["cursor-unknown-session", "codex-unknown-session"].includes(value);
@@ -2148,21 +2739,21 @@ async function postHookBoundJson(server, path, token, body) {
 }
 async function bindHookContext(input, familyId, hmac, post, options = {}) {
   const { execFile: execFile3 } = await import("node:child_process");
-  const { constants: constants4 } = await import("node:fs");
-  const { lstat: lstat7, mkdir: mkdir4, open: open5, realpath: realpath3 } = await import("node:fs/promises");
-  const { dirname: dirname7 } = await import("node:path");
+  const { constants: constants5 } = await import("node:fs");
+  const { lstat: lstat7, mkdir: mkdir4, open: open5, realpath: realpath4 } = await import("node:fs/promises");
+  const { dirname: dirname8 } = await import("node:path");
   const { selectRemote: selectRemote2 } = await Promise.resolve().then(() => (init_repositoryFingerprint(), repositoryFingerprint_exports));
-  const identity = await findProjectIdentityDetailed(await realpath3(input.cwd));
+  const identity = await findProjectIdentityDetailed(await realpath4(input.cwd));
   if (identity.kind === "git_unavailable")
     throw new Error("context unavailable");
-  const root = await realpath3(identity.root);
+  const root = await realpath4(identity.root);
   const binding = await hmac(root);
   const gitEnv = { LC_ALL: "C" };
   for (const key2 of ["PATH", "HOME", "LANG", "SYSTEMROOT", "TEMP", "TMP", "USERPROFILE"])
     if (process.env[key2] !== void 0)
       gitEnv[key2] = process.env[key2];
-  const git = (args) => new Promise((resolve5) => {
-    execFile3("git", args, { cwd: root, env: gitEnv, timeout: 2e3, encoding: "utf8" }, (error, stdout2) => resolve5(error ? [] : stdout2.trim().split(/\r?\n/).filter(Boolean)));
+  const git = (args) => new Promise((resolve6) => {
+    execFile3("git", args, { cwd: root, env: gitEnv, timeout: 2e3, encoding: "utf8" }, (error, stdout2) => resolve6(error ? [] : stdout2.trim().split(/\r?\n/).filter(Boolean)));
   });
   const remotes = identity.repository.kind === "git" ? await git(["remote"]) : [];
   const selection = selectRemote2(await Promise.all(remotes.map(async (name) => ({
@@ -2187,8 +2778,8 @@ async function bindHookContext(input, familyId, hmac, post, options = {}) {
     ...identity.kind === "ok" ? { projectId: identity.identity.projectId } : {}
   };
   const key = JSON.stringify([input.server, familyId, body]);
-  const directory = dirname7(input.stateFile);
-  for (const path of [dirname7(directory), directory]) {
+  const directory = dirname8(input.stateFile);
+  for (const path of [dirname8(directory), directory]) {
     const created = await mkdir4(path, { recursive: true, mode: 448 });
     const stat2 = await lstat7(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink() || (options.platform ?? process.platform) !== "win32" && (process.getuid && stat2.uid !== process.getuid() || stat2.mode & 63))
@@ -2197,7 +2788,7 @@ async function bindHookContext(input, familyId, hmac, post, options = {}) {
       await protectWindowsDirectory(path, created !== void 0, options.run, directory);
     }
   }
-  const file = await open5(input.stateFile, constants4.O_CREAT | constants4.O_RDWR | constants4.O_NOFOLLOW, 384);
+  const file = await open5(input.stateFile, constants5.O_CREAT | constants5.O_RDWR | constants5.O_NOFOLLOW, 384);
   try {
     let cache;
     try {
@@ -2227,20 +2818,21 @@ async function bindHookContext(input, familyId, hmac, post, options = {}) {
     await file.close();
   }
 }
-var identityCache, HOOK_STDIN_MAX_BYTES, mismatchEmitted;
+var identityCache, HOOK_STDIN_MAX_BYTES;
 var init_hookRuntime = __esm({
   "packages/shared/dist/hookRuntime.js"() {
     "use strict";
     init_runtimeSigners();
     init_hookTimeouts();
     init_repositoryRoot();
+    init_hookTrace();
     init_runtimeReader();
     init_runtimeSigners();
     init_projectSetupHandoff();
     init_hookConversation();
+    init_hookTrace();
     identityCache = /* @__PURE__ */ new Map();
     HOOK_STDIN_MAX_BYTES = 1048576;
-    mismatchEmitted = false;
   }
 });
 
@@ -2249,7 +2841,10 @@ init_hookRuntime();
 export {
   CONVERSATION_STATE_FILE,
   HOOK_STDIN_MAX_BYTES,
+  HOOK_TRACE_ENV,
+  HOOK_TRACE_MAX_BYTES,
   HookConversation,
+  HookTrace,
   PROJECT_ENSURE_TIMEOUT_MS,
   PROJECT_SETUP_MANUAL,
   PROJECT_SETUP_RUNNING,
@@ -2258,6 +2853,7 @@ export {
   RuntimeReader,
   aclRecords,
   adoptHookConversation,
+  appendHookTraceLine,
   auditWindowsPermissions,
   bindHookContext,
   clearProjectIdentityCache,
@@ -2265,21 +2861,31 @@ export {
   conversationMarker,
   currentConversationId,
   ensureWindowsPrivateDirectorySync,
+  errorKind,
   execute,
   findProjectIdentity,
   findProjectIdentityDetailed,
   handoffProjectSetup,
   hash,
+  hookTraceDirectory,
+  hookTraceEnabled,
+  hookTraceFile,
   missing,
+  modelTypedCwd,
+  noteHookTraceProject,
   parseHookResponse,
   pendingProjectSetup,
   postHookBoundJson,
   prepareWindowsAclDirectory,
+  projectScope,
   projectSetupActions,
   protectWindowsDirectory,
   readHookStdin,
   safePath,
+  scrubHookTraceMessage,
   setupResponse,
+  startHookTrace,
+  summarizeHookOutput,
   validHookSessionId,
   verifyMinisign,
   verifySigner,