@mnemonik/cli 7.127.1 → 7.127.3

package/dist/runtime/signers.js

@@ -187,8 +187,8 @@ function privateEntries(entries, user, directory) {
 function* prepareAclDirectory(state) {
   const directory = join(state, "audit-tmp");
   if (auditDirectories.has(directory)) {
-    const stat2 = lstatSync(directory);
-    if (!stat2.isDirectory() || stat2.isSymbolicLink())
+    const stat3 = lstatSync(directory);
+    if (!stat3.isDirectory() || stat3.isSymbolicLink())
       throw new Error("acl_permissions");
     return directory;
   }
@@ -200,8 +200,8 @@ function* prepareAclDirectory(state) {
     if (error.code !== "EEXIST")
       throw error;
   }
-  const stat = lstatSync(directory);
-  if (!stat.isDirectory() || stat.isSymbolicLink())
+  const stat2 = lstatSync(directory);
+  if (!stat2.isDirectory() || stat2.isSymbolicLink())
     throw new Error("acl_permissions");
   if (!auditDirectories.has(directory)) {
     currentIdentity ??= yield* readWindowsIdentity();
@@ -291,8 +291,8 @@ function ownerSids(output) {
   return owners;
 }
 function* hookPermission(path, created, session, directory = true) {
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink() || (directory ? !stat.isDirectory() : !stat.isFile()))
+  const stat2 = lstatSync(path);
+  if (stat2.isSymbolicLink() || (directory ? !stat2.isDirectory() : !stat2.isFile()))
     throw new Error("cache unavailable");
   const marker = join(session, ".windows-acl.json");
   let receipt = receipts.get(session);
@@ -469,8 +469,8 @@ var init_runtimeSigners = __esm({
       const result = promisify(execFile)(file, args);
       if (input === void 0)
         return result;
-      return new Promise((resolve4, reject2) => {
-        void result.then(resolve4, reject2);
+      return new Promise((resolve5, reject2) => {
+        void result.then(resolve5, 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((resolve4, reject2) => {
-        const child = execFile(file, args, options, (error, stdout2) => error ? reject2(error) : resolve4({ stdout: stdout2 }));
+      return new Promise((resolve5, reject2) => {
+        const child = execFile(file, args, options, (error, stdout2) => error ? reject2(error) : resolve5({ stdout: stdout2 }));
         if (input !== void 0) {
           child.stdin?.on("error", reject2);
           child.stdin?.end(input);
@@ -596,10 +596,10 @@ function parseIdentityFile(text) {
 async function readIdentityFile(dir, options = {}) {
   const path = join2(dir, ".mnemonik.json");
   try {
-    const stat = await lstat(path);
-    if (stat.isSymbolicLink())
+    const stat2 = await lstat(path);
+    if (stat2.isSymbolicLink())
       return { kind: "malformed", detail: "symlink" };
-    if (!stat.isFile())
+    if (!stat2.isFile())
       return { kind: "malformed", detail: "identity path is not a regular file" };
     const text = await readFile2(path, "utf8");
     if (options.selectedRoot) {
@@ -659,10 +659,10 @@ function runGit(cwd, args) {
 }
 async function boundaryAt(path) {
   try {
-    const stat = await lstat2(join3(path, ".git"));
-    if (stat.isDirectory())
+    const stat2 = await lstat2(join3(path, ".git"));
+    if (stat2.isDirectory())
       return { path, kind: "directory" };
-    if (stat.isFile())
+    if (stat2.isFile())
       return { path, kind: "file" };
   } catch (error) {
     const code = error.code;
@@ -879,7 +879,7 @@ var init_runtimeReader = __esm({
         throw new RuntimeError("permission");
       return v;
     };
-    statIdentity = (stat) => [stat.dev, stat.ino, stat.mode, stat.uid, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+    statIdentity = (stat2) => [stat2.dev, stat2.ino, stat2.mode, stat2.uid, stat2.size, stat2.mtimeMs, stat2.ctimeMs].join(":");
     RuntimeReader = class _RuntimeReader {
       run;
       options;
@@ -1003,14 +1003,14 @@ var init_runtimeReader = __esm({
         let part = parse(absolute).root;
         for (const name of absolute.slice(part.length).split(sep2)) {
           part = join4(part, name);
-          const stat = await lstat3(part).catch((e) => {
+          const stat2 = await lstat3(part).catch((e) => {
             if (allowMissing && missing(e))
               return null;
             throw e;
           });
-          if (!stat)
+          if (!stat2)
             break;
-          if (stat.isSymbolicLink() || (part === absolute ? directory ? !stat.isDirectory() : !stat.isFile() : !stat.isDirectory()))
+          if (stat2.isSymbolicLink() || (part === absolute ? directory ? !stat2.isDirectory() : !stat2.isFile() : !stat2.isDirectory()))
             throw new RuntimeError("permission");
           if (part !== this.state && !part.startsWith(this.state + sep2))
             continue;
@@ -1021,11 +1021,11 @@ var init_runtimeReader = __esm({
               await prepareWindowsAclDirectory(this.state, this.run).catch((error) => {
                 throw new RuntimeError(error instanceof Error && error.message === "acl_permissions" ? "permission" : "acl_unavailable");
               });
-              Object.assign(stat, await lstat3(part));
+              Object.assign(stat2, await lstat3(part));
             }
-            if (stat.isDirectory())
+            if (stat2.isDirectory())
               this.windowsDirectories.add(part);
-            const identity = statIdentity(stat);
+            const identity = statIdentity(stat2);
             const previous = this.windowsStats.get(part);
             if (previous !== void 0 && previous !== identity) {
               this.traceAudit({
@@ -1041,7 +1041,7 @@ var init_runtimeReader = __esm({
             }
             this.windowsStats.set(part, identity);
             windowsPaths.push(part);
-          } else if (stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+          } else if (stat2.uid !== process.getuid?.() || (stat2.mode & 63) !== 0)
             throw new RuntimeError("permission");
         }
         await this.audit(windowsPaths);
@@ -1057,10 +1057,10 @@ var init_runtimeReader = __esm({
           return;
         const absolute = this.guardedPath(path);
         const parent = dirname3(absolute);
-        const stat = await lstat3(parent);
-        if (!stat.isDirectory() || stat.isSymbolicLink() || !this.windowsStats.get(parent)?.startsWith(`${stat.dev}:${stat.ino}:`))
+        const stat2 = await lstat3(parent);
+        if (!stat2.isDirectory() || stat2.isSymbolicLink() || !this.windowsStats.get(parent)?.startsWith(`${stat2.dev}:${stat2.ino}:`))
           throw new RuntimeError("permission");
-        this.windowsStats.set(parent, statIdentity(stat));
+        this.windowsStats.set(parent, statIdentity(stat2));
         this.windowsAudit.delete(absolute);
         this.windowsStats.delete(absolute);
       }
@@ -1307,7 +1307,7 @@ async function waitForResult(path, waitMs) {
       return result;
     if (Date.now() >= deadline)
       return RUNNING;
-    await new Promise((resolve4) => setTimeout(resolve4, Math.min(50, deadline - Date.now())));
+    await new Promise((resolve5) => setTimeout(resolve5, Math.min(50, deadline - Date.now())));
   }
 }
 async function runEnsure(options) {
@@ -1469,8 +1469,8 @@ async function pendingProjectSetup(root) {
   for (const host of ["credit", "cursor", "grok"]) {
     const directory = join5(tmpdir(), `mnemonik-${host}-${uid}`);
     try {
-      const stat = await lstat4(directory);
-      if (stat.isSymbolicLink() || !stat.isDirectory())
+      const stat2 = await lstat4(directory);
+      if (stat2.isSymbolicLink() || !stat2.isDirectory())
         continue;
       for (const name of await readdir2(directory)) {
         if (!/^[a-f0-9]{64}$/.test(name))
@@ -1529,6 +1529,319 @@ 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";
+function errorCode(error) {
+  return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+}
+async function syncDirectory(path) {
+  try {
+    const handle = await open3(path, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch {
+  }
+}
+function lockOwnerIsAlive(raw) {
+  const pid = Number.parseInt(raw.split(/\s+/, 1)[0] ?? "", 10);
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) === "EPERM";
+  }
+}
+async function removeStaleLock(lockPath, staleMs = LOCK_STALE_MS) {
+  const info = await lstat5(lockPath);
+  if (!info.isDirectory()) {
+    throw new Error(`Refusing unsafe non-directory installer lock ${lockPath}`);
+  }
+  if (Date.now() - info.mtimeMs <= staleMs)
+    return false;
+  const entries = await readdir3(lockPath);
+  if (entries.length === 0) {
+    try {
+      await rmdir(lockPath);
+      return true;
+    } catch (error) {
+      if (["ENOENT", "ENOTEMPTY"].includes(errorCode(error) ?? ""))
+        return false;
+      throw error;
+    }
+  }
+  const [entry] = entries;
+  if (entries.length !== 1 || entry === void 0 || !entry.startsWith("owner-"))
+    return false;
+  const tokenPath = join6(lockPath, entry);
+  const owner = await readFile4(tokenPath, "utf8");
+  if (lockOwnerIsAlive(owner))
+    return false;
+  try {
+    await unlink(tokenPath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return false;
+    throw error;
+  }
+  try {
+    await rmdir(lockPath);
+    return true;
+  } catch (error) {
+    if (["ENOENT", "ENOTEMPTY"].includes(errorCode(error) ?? ""))
+      return false;
+    throw error;
+  }
+}
+async function acquireLock(lockPath, options = {}) {
+  await mkdir2(dirname5(lockPath), { recursive: true });
+  const owner = `${process.pid} ${Date.now()} ${randomBytes(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 handle = await open3(tokenPath, "wx", 384);
+      try {
+        await handle.writeFile(owner, "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await syncDirectory(lockPath);
+      await syncDirectory(dirname5(lockPath));
+      return tokenPath;
+    } catch (error) {
+      if (errorCode(error) !== "EEXIST") {
+        await rmdir(lockPath).catch(() => void 0);
+        if (errorCode(error) === "ENOENT")
+          continue;
+        throw error;
+      }
+      try {
+        if (await removeStaleLock(lockPath, options.staleMs))
+          continue;
+      } catch (inspectError) {
+        if (errorCode(inspectError) === "ENOENT")
+          continue;
+        throw inspectError;
+      }
+      await new Promise((resolveDelay) => setTimeout(resolveDelay, options.retryMs ?? LOCK_RETRY_MS));
+    }
+  }
+  throw new Error(`Timed out waiting for installer lock ${lockPath}`);
+}
+async function withFileLock(lockPath, action, options) {
+  const tokenPath = await acquireLock(lockPath, options);
+  try {
+    return await action();
+  } finally {
+    try {
+      await unlink(tokenPath);
+      await rmdir(lockPath);
+      await syncDirectory(dirname5(lockPath));
+    } catch {
+    }
+  }
+}
+var LOCK_STALE_MS, LOCK_RETRIES, LOCK_RETRY_MS;
+var init_settingsIo = __esm({
+  "packages/shared/dist/settingsIo.js"() {
+    "use strict";
+    LOCK_STALE_MS = 12e4;
+    LOCK_RETRIES = 100;
+    LOCK_RETRY_MS = 20;
+  }
+});
+
+// packages/shared/dist/hookConversation.js
+import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
+import { constants as constants3 } 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";
+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();
+}
+function currentConversationId() {
+  return active?.id;
+}
+function conversationMarker() {
+  return active?.id ? `<system-reminder>mnemonik-conversation: ${active.id}</system-reminder>` : void 0;
+}
+async function adoptHookConversation(result) {
+  await active?.adopt(result);
+}
+function withHookConversation(url, init, post) {
+  return active ? active.request(url, init, post) : post(init);
+}
+var RETENTION_MS, CONVERSATION_STATE_FILE, HookConversation, active;
+var init_hookConversation = __esm({
+  "packages/shared/dist/hookConversation.js"() {
+    "use strict";
+    init_settingsIo();
+    init_runtimeSigners();
+    RETENTION_MS = 24 * 60 * 60 * 1e3;
+    CONVERSATION_STATE_FILE = "conversation.json";
+    HookConversation = class {
+      input;
+      conversationId;
+      scope;
+      constructor(input) {
+        this.input = input;
+        this.scope = createHash4("sha256").update(JSON.stringify([
+          input.server.replace(/\/$/, ""),
+          input.account,
+          input.host,
+          input.nativeSessionId,
+          input.agentId ?? ""
+        ])).digest("hex");
+      }
+      get id() {
+        return this.conversationId;
+      }
+      async load() {
+        this.conversationId = void 0;
+        try {
+          const directory = await lstat6(dirname6(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);
+          try {
+            const stat2 = await file.stat();
+            if (!stat2.isFile() || stat2.size > 4096 || process.platform !== "win32" && (process.getuid && stat2.uid !== process.getuid() || stat2.mode & 63))
+              return;
+            const cache = JSON.parse(await file.readFile("utf8"));
+            if (cache.scope !== this.scope || !boundedHandle(cache.conversationId) || typeof cache.usedAt !== "number" || Date.now() - stat2.mtimeMs >= RETENTION_MS)
+              return;
+            this.conversationId = cache.conversationId;
+          } finally {
+            await file.close();
+          }
+          await utimes(this.input.stateFile, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+          return this.conversationId;
+        } catch {
+          return void 0;
+        }
+      }
+      async locked(run) {
+        const directory = dirname6(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))
+          throw new Error("conversation cache unavailable");
+        ensureWindowsPrivateDirectorySync(directory);
+        return withFileLock(`${this.input.stateFile}.lock`, run, {
+          staleMs: 1e4,
+          retries: 150,
+          retryMs: 20
+        });
+      }
+      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);
+        try {
+          await file.writeFile(JSON.stringify({ v: 1, scope: this.scope, conversationId: id, usedAt: Date.now() }));
+        } finally {
+          await file.close();
+        }
+        try {
+          await rename3(temporary, this.input.stateFile);
+          this.conversationId = id;
+        } finally {
+          await rm3(temporary, { force: true });
+        }
+      }
+      /** Existing authenticated response is the acquisition; no additional endpoint. */
+      async request(url, init, post) {
+        if (typeof init.body !== "string" || !url.startsWith(`${this.input.server.replace(/\/$/, "")}/api/v1/`))
+          return post(init);
+        let body;
+        try {
+          body = JSON.parse(init.body);
+        } catch {
+          return post(init);
+        }
+        const acquisition = this.input.acquire !== false && (url.endsWith("/hooks/mcp-precheck") || url.endsWith("/hooks/injections") && ["SessionStart", "SubagentStart", "UserPromptSubmit"].includes(String(body.event)));
+        const send = async () => {
+          await this.load();
+          const response = await post({
+            ...init,
+            body: JSON.stringify({
+              ...body,
+              ...this.conversationId ? { conversationId: this.conversationId } : {}
+            })
+          });
+          if (acquisition && response.ok) {
+            const result = await response.clone().json().catch(() => null);
+            if (boundedHandle(result?.conversationId)) {
+              if (this.conversationId && this.conversationId !== result.conversationId)
+                throw new Error("conversation response mismatch");
+              await this.save(result.conversationId);
+            }
+          } else if (this.conversationId)
+            await this.save(this.conversationId);
+          return response;
+        };
+        return acquisition ? this.locked(send) : send();
+      }
+      /** Grok adopts only an authenticated explicit-bootstrap tool result. */
+      async adopt(result) {
+        const walk = (value, depth) => {
+          if (depth > 5 || !value)
+            return;
+          if (typeof value === "string" && value.length < 65536) {
+            const marker = value.match(/(?:^|[\s>])mnemonik-conversation:\s*(cv1\.[0-9a-f-]{36}\.[A-Za-z0-9_-]{43})(?=$|[\s<])/);
+            if (marker && boundedHandle(marker[1]))
+              return marker[1];
+            try {
+              return walk(JSON.parse(value), depth + 1);
+            } catch {
+              return;
+            }
+          }
+          if (typeof value !== "object")
+            return;
+          const object = value;
+          if (boundedHandle(object.conversationId))
+            return object.conversationId;
+          if (typeof object.text === "string" && object.text.length < 65536) {
+            const id2 = walk(object.text, depth + 1);
+            if (id2)
+              return id2;
+          }
+          for (const key of ["structuredContent", "result", "content"]) {
+            const nested = object[key];
+            for (const child of Array.isArray(nested) ? nested : [nested]) {
+              const id2 = walk(child, depth + 1);
+              if (id2)
+                return id2;
+            }
+          }
+          return;
+        };
+        const id = walk(result, 0);
+        if (id)
+          await this.locked(async () => {
+            await this.load();
+            if (this.conversationId && this.conversationId !== id)
+              throw new Error("conversation response mismatch");
+            await this.save(id);
+          });
+      }
+    };
+  }
+});
+
 // packages/shared/dist/repositoryFingerprint.js
 var repositoryFingerprint_exports = {};
 __export(repositoryFingerprint_exports, {
@@ -1536,7 +1849,7 @@ __export(repositoryFingerprint_exports, {
   canonicalizeRemote: () => canonicalizeRemote,
   selectRemote: () => selectRemote
 });
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { domainToASCII } from "node:url";
 function canonicalizeRemote(url, { providerRules = REPOSITORY_PROVIDER_RULES } = {}) {
   if (controls.test(url))
@@ -1646,7 +1959,7 @@ function canonicalizeRemote(url, { providerRules = REPOSITORY_PROVIDER_RULES } =
   const canonical = `repo-v1:${prefix}/${parsed.path}`;
   return {
     canonical,
-    hash: createHash3("sha256").update(canonical, "utf8").digest("hex"),
+    hash: createHash5("sha256").update(canonical, "utf8").digest("hex"),
     algorithmVersion: 1
   };
 }
@@ -1690,7 +2003,9 @@ var init_repositoryFingerprint = __esm({
 // packages/shared/dist/hookRuntime.js
 var hookRuntime_exports = {};
 __export(hookRuntime_exports, {
+  CONVERSATION_STATE_FILE: () => CONVERSATION_STATE_FILE,
   HOOK_STDIN_MAX_BYTES: () => HOOK_STDIN_MAX_BYTES,
+  HookConversation: () => HookConversation,
   PROJECT_ENSURE_TIMEOUT_MS: () => PROJECT_ENSURE_TIMEOUT_MS,
   PROJECT_SETUP_MANUAL: () => PROJECT_SETUP_MANUAL,
   PROJECT_SETUP_RUNNING: () => PROJECT_SETUP_RUNNING,
@@ -1698,9 +2013,13 @@ __export(hookRuntime_exports, {
   RuntimeError: () => RuntimeError,
   RuntimeReader: () => RuntimeReader,
   aclRecords: () => aclRecords,
+  adoptHookConversation: () => adoptHookConversation,
   auditWindowsPermissions: () => auditWindowsPermissions,
   bindHookContext: () => bindHookContext,
   clearProjectIdentityCache: () => clearProjectIdentityCache,
+  configureHookConversation: () => configureHookConversation,
+  conversationMarker: () => conversationMarker,
+  currentConversationId: () => currentConversationId,
   ensureWindowsPrivateDirectorySync: () => ensureWindowsPrivateDirectorySync,
   execute: () => execute,
   findProjectIdentity: () => findProjectIdentity,
@@ -1724,7 +2043,8 @@ __export(hookRuntime_exports, {
   verifyWindowsPermission: () => verifyWindowsPermission,
   verifyWindowsPermissionSync: () => verifyWindowsPermissionSync,
   versionName: () => versionName,
-  windowsCurrentAccountSync: () => windowsCurrentAccountSync
+  windowsCurrentAccountSync: () => windowsCurrentAccountSync,
+  withHookConversation: () => withHookConversation
 });
 import { stderr, stdin } from "node:process";
 function clearProjectIdentityCache() {
@@ -1756,7 +2076,7 @@ async function findProjectIdentityDetailed(startCwd, options = {}) {
 function readHookStdin(options = {}) {
   const stream = options.stream ?? stdin;
   const maxBytes = options.maxBytes ?? HOOK_STDIN_MAX_BYTES;
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const chunks = [];
     let bytes = 0;
     let settled = false;
@@ -1772,7 +2092,7 @@ function readHookStdin(options = {}) {
         stream.pause();
         stream.destroy?.();
       }
-      resolve4(value);
+      resolve5(value);
     };
     const onData = (chunk) => {
       const buffer = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
@@ -1811,21 +2131,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: constants3 } = await import("node:fs");
-  const { lstat: lstat5, mkdir: mkdir2, open: open3, realpath: realpath2 } = await import("node:fs/promises");
-  const { dirname: dirname5 } = await import("node:path");
+  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 { selectRemote: selectRemote2 } = await Promise.resolve().then(() => (init_repositoryFingerprint(), repositoryFingerprint_exports));
-  const identity = await findProjectIdentityDetailed(await realpath2(input.cwd));
+  const identity = await findProjectIdentityDetailed(await realpath3(input.cwd));
   if (identity.kind === "git_unavailable")
     throw new Error("context unavailable");
-  const root = await realpath2(identity.root);
+  const root = await realpath3(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((resolve4) => {
-    execFile3("git", args, { cwd: root, env: gitEnv, timeout: 2e3, encoding: "utf8" }, (error, stdout2) => resolve4(error ? [] : stdout2.trim().split(/\r?\n/).filter(Boolean)));
+  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 remotes = identity.repository.kind === "git" ? await git(["remote"]) : [];
   const selection = selectRemote2(await Promise.all(remotes.map(async (name) => ({
@@ -1850,17 +2170,17 @@ 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 = dirname5(input.stateFile);
-  for (const path of [dirname5(directory), directory]) {
-    const created = await mkdir2(path, { recursive: true, mode: 448 });
-    const stat = await lstat5(path);
-    if (!stat.isDirectory() || stat.isSymbolicLink() || (options.platform ?? process.platform) !== "win32" && (process.getuid && stat.uid !== process.getuid() || stat.mode & 63))
+  const directory = dirname7(input.stateFile);
+  for (const path of [dirname7(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))
       throw new Error("cache unavailable");
     if ((options.platform ?? process.platform) === "win32") {
       await protectWindowsDirectory(path, created !== void 0, options.run, directory);
     }
   }
-  const file = await open3(input.stateFile, constants3.O_CREAT | constants3.O_RDWR | constants3.O_NOFOLLOW, 384);
+  const file = await open5(input.stateFile, constants4.O_CREAT | constants4.O_RDWR | constants4.O_NOFOLLOW, 384);
   try {
     let cache;
     try {
@@ -1900,6 +2220,7 @@ var init_hookRuntime = __esm({
     init_runtimeReader();
     init_runtimeSigners();
     init_projectSetupHandoff();
+    init_hookConversation();
     identityCache = /* @__PURE__ */ new Map();
     HOOK_STDIN_MAX_BYTES = 1048576;
     mismatchEmitted = false;
@@ -1909,7 +2230,9 @@ var init_hookRuntime = __esm({
 // packages/cli/src/runtime/signers.ts
 init_hookRuntime();
 export {
+  CONVERSATION_STATE_FILE,
   HOOK_STDIN_MAX_BYTES,
+  HookConversation,
   PROJECT_ENSURE_TIMEOUT_MS,
   PROJECT_SETUP_MANUAL,
   PROJECT_SETUP_RUNNING,
@@ -1917,9 +2240,13 @@ export {
   RuntimeError,
   RuntimeReader,
   aclRecords,
+  adoptHookConversation,
   auditWindowsPermissions,
   bindHookContext,
   clearProjectIdentityCache,
+  configureHookConversation,
+  conversationMarker,
+  currentConversationId,
   ensureWindowsPrivateDirectorySync,
   execute,
   findProjectIdentity,
@@ -1943,5 +2270,6 @@ export {
   verifyWindowsPermission,
   verifyWindowsPermissionSync,
   versionName,
-  windowsCurrentAccountSync
+  windowsCurrentAccountSync,
+  withHookConversation
 };

package/dist/runtime/store.js

@@ -824,6 +824,24 @@ process.stdin.on('end', () => {
   }
 });
 
+// packages/shared/dist/settingsIo.js
+var init_settingsIo = __esm({
+  "packages/shared/dist/settingsIo.js"() {
+    "use strict";
+  }
+});
+
+// packages/shared/dist/hookConversation.js
+var RETENTION_MS;
+var init_hookConversation = __esm({
+  "packages/shared/dist/hookConversation.js"() {
+    "use strict";
+    init_settingsIo();
+    init_runtimeSigners();
+    RETENTION_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // packages/shared/dist/hookRuntime.js
 var init_hookRuntime = __esm({
   "packages/shared/dist/hookRuntime.js"() {
@@ -834,6 +852,7 @@ var init_hookRuntime = __esm({
     init_runtimeReader();
     init_runtimeSigners();
     init_projectSetupHandoff();
+    init_hookConversation();
   }
 });