@quantiya/codevibe-antigravity-plugin 2.0.63 → 2.0.64

package/README.md

@@ -57,6 +57,18 @@ Approval prompts and multi-choice questions aren't in the transcript at the mome
 
 A single launch session covers the entire wrapper lifetime, so `/resume` commands continue under the same backend session and your phone sees one continuous conversation.
 
+### Several agy sessions at once
+
+All agy sessions on a computer write to the same folders. CodeVibe tells them apart with two agy hooks:
+- **`PreInvocation`** reports which conversation a session is running.
+- **`PostToolUse`** reports which tool just ran. When that tool was waiting on an approval you answered at the desktop, the prompt on your phone closes.
+
+On each launch, `codevibe --agent agy` registers one named entry, `codevibe-antigravity`, in `~/.gemini/config/hooks.json`, and keeps the hook scripts in `~/.codevibe/codevibe-agy/hooks/`:
+- Other entries in that file are left as they are.
+- A file that is not valid JSON, or is a symlink, is never changed. CodeVibe then falls back to agy's log files, which cannot tell concurrent sessions apart.
+- The hook does nothing for agy sessions that CodeVibe did not start.
+- To switch it off, add `"enabled": false` to the `codevibe-antigravity` entry. CodeVibe leaves a switched-off entry alone. Deleting the entry only lasts until the next `codevibe --agent agy` launch, which writes it again. After uninstalling CodeVibe you can delete the entry; see INSTALLATION.md.
+
 ## What gets synced
 
 | Direction | What |
@@ -86,6 +98,9 @@ ls -la ~/.gemini/antigravity-cli/brain/
 # Verify tmux session
 tmux list-sessions | grep codevibe-agy
 
+# Verify the session hooks are registered (needed to keep concurrent sessions apart)
+grep -c codevibe-antigravity ~/.gemini/config/hooks.json
+
 # Reinstall if needed
 codevibe update
 ```

package/antigravity-plugin.json

@@ -6,6 +6,6 @@
   "implementation": {
     "architecture": "transcript+tmux+approval-heuristic",
     "schema_version": "v1.0",
-    "note": "v1.0 ships without JSON hooks (agy backend gate `enable_json_hooks` is OFF for our account). Monitors `~/.gemini/antigravity-cli/brain/<UUID>/.system_generated/logs/transcript.jsonl` + mirrors the tmux pane for approval-UI detection. v1.1 will add hook handlers when the backend gate flips."
+    "note": "Monitors ~/.gemini/antigravity-cli/brain/<UUID>/.system_generated/logs/transcript.jsonl and the tmux pane. Where agy JSON hooks fire (agy 1.3.1+, hook gate on), the companion launcher registers a `codevibe-antigravity` entry in ~/.gemini/config/hooks.json (PreInvocation + PostToolUse) so each session routes only its own conversations; otherwise it falls back to agy's CLI log."
   }
 }

package/dist/agy-hook.js

@@ -0,0 +1,247 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agy-hook.ts
+var agy_hook_exports = {};
+__export(agy_hook_exports, {
+  FORWARDED_TOOL_ARG_KEYS: () => FORWARDED_TOOL_ARG_KEYS,
+  HARD_DEADLINE_MS: () => HARD_DEADLINE_MS,
+  REQUEST_TIMEOUT_MS: () => REQUEST_TIMEOUT_MS,
+  buildBody: () => buildBody,
+  isPidAlive: () => isPidAlive,
+  postHook: () => postHook,
+  readConn: () => readConn,
+  readStdin: () => readStdin,
+  runHook: () => runHook
+});
+module.exports = __toCommonJS(agy_hook_exports);
+var fs = __toESM(require("fs"));
+var http = __toESM(require("http"));
+var path2 = __toESM(require("path"));
+
+// src/agy-hook-paths.ts
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var HOOK_ROUTE_PREFIX = "/agy-hook/v1/";
+var HOOK_EVENTS = ["PreInvocation", "PostToolUse"];
+var HOOK_OWNER_ENV = "CODEVIBE_AGY_HOOK_OWNER";
+function isHookEvent(value) {
+  return typeof value === "string" && HOOK_EVENTS.includes(value);
+}
+function codevibeAgyDir(home = os.homedir()) {
+  return path.join(home, ".codevibe", "codevibe-agy");
+}
+function runtimeBaseDir(home = os.homedir()) {
+  return path.join(codevibeAgyDir(home), "runtime");
+}
+
+// src/agy-hook.ts
+var HARD_DEADLINE_MS = 2500;
+var REQUEST_TIMEOUT_MS = 1500;
+var MAX_STDIN_BYTES = 1024 * 1024;
+var MAX_CONN_FILE_BYTES = 4096;
+var MAX_TOOL_ARG_CHARS = 4096;
+var FORWARDED_TOOL_ARG_KEYS = [
+  "CommandLine",
+  "Command",
+  "command",
+  "AbsolutePath",
+  "TargetFile",
+  "FilePath",
+  "file_path",
+  "filePath",
+  "path",
+  "DirectoryPath"
+];
+function buildBody(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const payload = raw;
+  if (typeof payload.conversationId !== "string" || payload.conversationId.length === 0) return null;
+  const body = { conversationId: payload.conversationId };
+  if (Number.isInteger(payload.invocationNum)) body.invocationNum = payload.invocationNum;
+  if (Number.isInteger(payload.initialNumSteps)) body.initialNumSteps = payload.initialNumSteps;
+  if (Number.isInteger(payload.stepIdx)) body.stepIdx = payload.stepIdx;
+  const toolCall = payload.toolCall;
+  if (toolCall && typeof toolCall === "object" && !Array.isArray(toolCall)) {
+    const call = toolCall;
+    if (typeof call.name === "string") body.toolName = call.name.slice(0, 128);
+    const args = call.args;
+    if (args && typeof args === "object" && !Array.isArray(args)) {
+      const source = args;
+      const kept = {};
+      for (const key of FORWARDED_TOOL_ARG_KEYS) {
+        const value = source[key];
+        if (typeof value === "string") kept[key] = value.slice(0, MAX_TOOL_ARG_CHARS);
+      }
+      body.toolArgs = kept;
+    }
+  }
+  if ("error" in payload) {
+    const error = payload.error;
+    body.hasError = !(error === null || error === void 0 || error === "" || error === false);
+  }
+  return body;
+}
+function readConn(runtimeBase, owner, uid = process.getuid?.()) {
+  const file = path2.join(runtimeBase, owner, "conn.json");
+  let stat;
+  try {
+    stat = fs.lstatSync(file);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile() || stat.size > MAX_CONN_FILE_BYTES) return null;
+  if (uid !== void 0 && stat.uid !== uid) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const conn = parsed;
+  const port = conn.port;
+  const token = conn.token;
+  const pid = conn.pid;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  if (typeof token !== "string" || token.length < 16) return null;
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  return { port, token, pid };
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function postHook(conn, event, body) {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify(body);
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve(ok);
+    };
+    try {
+      const request2 = http.request(
+        {
+          host: "127.0.0.1",
+          port: conn.port,
+          method: "POST",
+          path: `${HOOK_ROUTE_PREFIX}${event}`,
+          headers: {
+            Authorization: `Bearer ${conn.token}`,
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(payload)
+          },
+          timeout: REQUEST_TIMEOUT_MS
+        },
+        (response) => {
+          response.resume();
+          response.on("end", () => finish((response.statusCode ?? 0) >= 200 && (response.statusCode ?? 0) < 300));
+          response.on("error", () => finish(false));
+        }
+      );
+      request2.on("timeout", () => {
+        request2.destroy();
+        finish(false);
+      });
+      request2.on("error", () => finish(false));
+      request2.end(payload);
+    } catch {
+      finish(false);
+    }
+  });
+}
+function readStdin(stream) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let size = 0;
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      resolve(value);
+    };
+    stream.on("data", (chunk) => {
+      const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+      size += buffer.length;
+      if (size > MAX_STDIN_BYTES) {
+        finish(null);
+        return;
+      }
+      chunks.push(buffer);
+    });
+    stream.on("end", () => finish(Buffer.concat(chunks).toString("utf8")));
+    stream.on("error", () => finish(null));
+  });
+}
+async function runHook(options) {
+  const owner = options.env[HOOK_OWNER_ENV] ?? "";
+  const raw = await readStdin(options.stdin);
+  if (!/^[0-9]{1,10}$/.test(owner) || !isHookEvent(options.event) || raw === null) return "skipped";
+  const conn = readConn(options.runtimeBase ?? runtimeBaseDir(), owner);
+  if (!conn || !(options.isPidAlive ?? isPidAlive)(conn.pid)) return "skipped";
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return "skipped";
+  }
+  const body = buildBody(parsed);
+  if (!body) return "skipped";
+  const ok = await (options.post ?? postHook)(conn, options.event, body);
+  return ok ? "sent" : "failed";
+}
+function finishProcess() {
+  try {
+    fs.writeSync(1, "{}");
+  } catch {
+  }
+  process.exit(0);
+}
+if (require.main === module) {
+  setTimeout(finishProcess, HARD_DEADLINE_MS);
+  runHook({ event: process.argv[2], env: process.env, stdin: process.stdin }).then(finishProcess, finishProcess);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FORWARDED_TOOL_ARG_KEYS,
+  HARD_DEADLINE_MS,
+  REQUEST_TIMEOUT_MS,
+  buildBody,
+  isPidAlive,
+  postHook,
+  readConn,
+  readStdin,
+  runHook
+});

package/dist/installer-cli.js

@@ -34,25 +34,43 @@ __export(installer_cli_exports, {
   isInstallerVerbose: () => isInstallerVerbose
 });
 module.exports = __toCommonJS(installer_cli_exports);
-var path2 = __toESM(require("path"));
+var path3 = __toESM(require("path"));
 
 // src/installer.ts
 var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
 var crypto = __toESM(require("crypto"));
+
+// src/agy-hook-paths.ts
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var HOOK_ENTRY_NAME = "codevibe-antigravity";
+var HOOK_SHELL_BASENAME = "agy-hook.sh";
+var HOOK_SCRIPT_BASENAME = "agy-hook.js";
+function codevibeAgyDir(home = os.homedir()) {
+  return path.join(home, ".codevibe", "codevibe-agy");
+}
+function hooksDir(home = os.homedir()) {
+  return path.join(codevibeAgyDir(home), "hooks");
+}
+function globalHooksConfigPath(home = os.homedir()) {
+  return path.join(home, ".gemini", "config", "hooks.json");
+}
+
+// src/installer.ts
 var MANIFEST_FILENAME = "antigravity-plugin.json";
 var SENTINEL_FILENAME = ".codevibe-manifest-hash";
 var MCP_SERVERS_KEY = "codevibe-antigravity";
 var LOCK_ACQUIRE_TIMEOUT_MS = 5e3;
 var LOCK_RETRY_INTERVAL_MS = 50;
 function resolveInstallerPaths(opts) {
-  const home = opts.homedir ?? os.homedir();
+  const home = opts.homedir ?? os2.homedir();
   return {
-    pluginJsonSourcePath: path.join(opts.pluginPkgDir, MANIFEST_FILENAME),
-    installDir: path.join(home, ".gemini", "antigravity-cli", "plugins", "codevibe-antigravity"),
-    mcpConfigPath: path.join(home, ".gemini", "config", "mcp_config.json"),
-    serverScriptPath: path.join(opts.pluginPkgDir, "dist", "server.js")
+    pluginJsonSourcePath: path2.join(opts.pluginPkgDir, MANIFEST_FILENAME),
+    installDir: path2.join(home, ".gemini", "antigravity-cli", "plugins", "codevibe-antigravity"),
+    mcpConfigPath: path2.join(home, ".gemini", "config", "mcp_config.json"),
+    serverScriptPath: path2.join(opts.pluginPkgDir, "dist", "server.js")
   };
 }
 async function ensureInstalled(options) {
@@ -88,7 +106,7 @@ async function ensureInstalled(options) {
     }
   }
   const expectedManifestHash = sha256Hex(manifestContent);
-  const lockPath = path.join(path.dirname(installDir), ".codevibe-install.lock");
+  const lockPath = path2.join(path2.dirname(installDir), ".codevibe-install.lock");
   const releaseLock = await acquireLock(lockPath, LOCK_ACQUIRE_TIMEOUT_MS, logger, "install");
   try {
     await crashRecoverySweep(installDir, logger);
@@ -124,14 +142,14 @@ async function stageAndInstall(args) {
   const { installDir, manifestContent, expectedManifestHash, pid } = args;
   const stagingDir = `${installDir}.new.${pid}`;
   const oldDir = `${installDir}.old.${pid}`;
-  await fs.promises.mkdir(path.dirname(installDir), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(installDir), { recursive: true });
   await rmRecursive(stagingDir);
   await fs.promises.mkdir(stagingDir, { recursive: true, mode: 493 });
-  const manifestDest = path.join(stagingDir, MANIFEST_FILENAME);
+  const manifestDest = path2.join(stagingDir, MANIFEST_FILENAME);
   const manifestTmp = `${manifestDest}.partial`;
   await fs.promises.writeFile(manifestTmp, manifestContent, { mode: 420 });
   await fs.promises.rename(manifestTmp, manifestDest);
-  const sentinelDest = path.join(stagingDir, SENTINEL_FILENAME);
+  const sentinelDest = path2.join(stagingDir, SENTINEL_FILENAME);
   await fs.promises.writeFile(sentinelDest, expectedManifestHash + "\n", { mode: 420 });
   const installExists = await lstatExists(installDir);
   if (installExists) {
@@ -159,8 +177,8 @@ async function stageAndInstall(args) {
   }
 }
 async function crashRecoverySweep(installDir, logger) {
-  const parent = path.dirname(installDir);
-  const baseName = path.basename(installDir);
+  const parent = path2.dirname(installDir);
+  const baseName = path2.basename(installDir);
   let entries;
   try {
     entries = await fs.promises.readdir(parent, { withFileTypes: true });
@@ -170,8 +188,8 @@ async function crashRecoverySweep(installDir, logger) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (!entry.name.startsWith(`${baseName}.new.`)) continue;
-    const dir = path.join(parent, entry.name);
-    const sentinel = path.join(dir, SENTINEL_FILENAME);
+    const dir = path2.join(parent, entry.name);
+    const sentinel = path2.join(dir, SENTINEL_FILENAME);
     if (await pathExists(sentinel)) {
       if (!await lstatExists(installDir)) {
         try {
@@ -195,19 +213,19 @@ async function crashRecoverySweep(installDir, logger) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (!entry.name.startsWith(`${baseName}.old.`)) continue;
-    const dir = path.join(parent, entry.name);
+    const dir = path2.join(parent, entry.name);
     logger.info("Crash-recovery: deleting orphan .old dir", { dir });
     await rmRecursive(dir);
   }
 }
 async function ensureMcpConfigCourtesy(mcpConfigPath, logger) {
   try {
-    await fs.promises.mkdir(path.dirname(mcpConfigPath), { recursive: true });
+    await fs.promises.mkdir(path2.dirname(mcpConfigPath), { recursive: true });
   } catch (err) {
     const code = err.code;
     if (code === "ENOTDIR" || code === "EEXIST") {
       throw new Error(
-        `mcp_config.json parent path exists as a file, expected a directory: ${path.dirname(mcpConfigPath)}`
+        `mcp_config.json parent path exists as a file, expected a directory: ${path2.dirname(mcpConfigPath)}`
       );
     }
     throw err;
@@ -291,12 +309,186 @@ async function doEnsureMcpConfigCourtesy(mcpConfigPath, logger) {
     { mcpConfigPath, removedStaleEntry: hadStaleEntry }
   );
 }
+var HOOK_TIMEOUT_SECONDS = 5;
+function resolveHookInstallPaths(opts) {
+  const home = opts.homedir ?? os2.homedir();
+  return {
+    hookShellSourcePath: path2.join(opts.pluginPkgDir, "libexec", HOOK_SHELL_BASENAME),
+    hookScriptSourcePath: path2.join(opts.pluginPkgDir, "dist", HOOK_SCRIPT_BASENAME),
+    hooksDir: hooksDir(home),
+    hooksConfigPath: globalHooksConfigPath(home)
+  };
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function buildHookEntry(hooksFolder) {
+  const shell = shellQuote(path2.join(hooksFolder, HOOK_SHELL_BASENAME));
+  return {
+    PreInvocation: [
+      { type: "command", command: `${shell} PreInvocation`, timeout: HOOK_TIMEOUT_SECONDS }
+    ],
+    PostToolUse: [
+      {
+        matcher: "*",
+        hooks: [
+          { type: "command", command: `${shell} PostToolUse`, timeout: HOOK_TIMEOUT_SECONDS }
+        ]
+      }
+    ]
+  };
+}
+function readHooksConfigSync(hooksConfigPath) {
+  let stat;
+  try {
+    stat = fs.lstatSync(hooksConfigPath);
+  } catch (err) {
+    if (err.code === "ENOENT") return { kind: "absent" };
+    return { kind: "unsupported", reason: `cannot stat: ${err.message}` };
+  }
+  if (stat.isSymbolicLink()) return { kind: "unsupported", reason: "is a symlink" };
+  if (!stat.isFile()) return { kind: "unsupported", reason: "is not a regular file" };
+  let raw;
+  try {
+    raw = fs.readFileSync(hooksConfigPath, "utf8");
+  } catch (err) {
+    return { kind: "unsupported", reason: `cannot read: ${err.message}` };
+  }
+  if (raw.trim().length === 0) return { kind: "object", config: {}, mode: stat.mode & 511 };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { kind: "unsupported", reason: "is not valid JSON" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { kind: "unsupported", reason: "is not a JSON object" };
+  }
+  return { kind: "object", config: parsed, mode: stat.mode & 511 };
+}
+function sameJson(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isUserDisabled(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const named = entry;
+  if (named.enabled === false) return true;
+  const visit = (value) => {
+    if (Array.isArray(value)) return value.some(visit);
+    if (!value || typeof value !== "object") return false;
+    const obj = value;
+    return obj.enabled === false || visit(obj.hooks);
+  };
+  return Object.entries(named).some(([key, value]) => key !== "enabled" && visit(value));
+}
+async function installHookFile(source, dest, mode) {
+  const wanted = await fs.promises.readFile(source);
+  try {
+    const current = await fs.promises.readFile(dest);
+    const currentMode = (await fs.promises.stat(dest)).mode & 511;
+    if (current.equals(wanted) && currentMode === mode) return;
+  } catch {
+  }
+  const tmp = `${dest}.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+  const handle = await fs.promises.open(tmp, "wx", mode);
+  try {
+    await handle.chmod(mode);
+    await handle.writeFile(wanted);
+    await handle.close();
+  } catch (err) {
+    try {
+      await handle.close();
+    } catch {
+    }
+    try {
+      await fs.promises.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    await fs.promises.rename(tmp, dest);
+  } catch (err) {
+    try {
+      await fs.promises.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureHookRegistration(paths, logger = defaultLogger()) {
+  try {
+    await fs.promises.mkdir(paths.hooksDir, { recursive: true, mode: 448 });
+    await fs.promises.mkdir(path2.dirname(paths.hooksConfigPath), { recursive: true });
+    const releaseLock = await acquireLock(
+      `${paths.hooksConfigPath}.lock`,
+      LOCK_ACQUIRE_TIMEOUT_MS,
+      logger,
+      "hooks-config"
+    );
+    try {
+      await installHookFile(paths.hookScriptSourcePath, path2.join(paths.hooksDir, HOOK_SCRIPT_BASENAME), 420);
+      await installHookFile(paths.hookShellSourcePath, path2.join(paths.hooksDir, HOOK_SHELL_BASENAME), 493);
+      const read = readHooksConfigSync(paths.hooksConfigPath);
+      if (read.kind === "unsupported") {
+        const reason = `${paths.hooksConfigPath} ${read.reason}; left untouched`;
+        logger.warn(`agy session hooks not registered: ${reason}`);
+        return { status: "unsupported", reason };
+      }
+      const config = read.kind === "object" ? read.config : {};
+      if (isUserDisabled(config[HOOK_ENTRY_NAME])) {
+        logger.info('agy session hooks are switched off in hooks.json ("enabled": false); leaving them off', {
+          hooksConfigPath: paths.hooksConfigPath
+        });
+        return { status: "disabled" };
+      }
+      const desired = buildHookEntry(paths.hooksDir);
+      if (sameJson(config[HOOK_ENTRY_NAME], desired)) return { status: "current" };
+      config[HOOK_ENTRY_NAME] = desired;
+      const existingMode = read.kind === "object" ? read.mode : null;
+      const tmp = `${paths.hooksConfigPath}.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+      const handle = await fs.promises.open(tmp, "wx", existingMode ?? 420);
+      try {
+        if (existingMode !== null) await handle.chmod(existingMode);
+        await handle.writeFile(JSON.stringify(config, null, 2) + "\n", "utf8");
+        await handle.close();
+      } catch (err) {
+        try {
+          await handle.close();
+        } catch {
+        }
+        try {
+          await fs.promises.unlink(tmp);
+        } catch {
+        }
+        throw err;
+      }
+      try {
+        await fs.promises.rename(tmp, paths.hooksConfigPath);
+      } catch (err) {
+        try {
+          await fs.promises.unlink(tmp);
+        } catch {
+        }
+        throw err;
+      }
+      logger.info("Registered the CodeVibe agy session hooks", { hooksConfigPath: paths.hooksConfigPath });
+      return { status: "written" };
+    } finally {
+      await releaseLock();
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger.warn(`agy session hooks not registered: ${reason}`);
+    return { status: "failed", reason };
+  }
+}
 function sha256Hex(s) {
   return crypto.createHash("sha256").update(s, "utf8").digest("hex");
 }
 async function tryReadCurrentHash(installDir) {
   try {
-    const sentinel = await fs.promises.readFile(path.join(installDir, SENTINEL_FILENAME), "utf8");
+    const sentinel = await fs.promises.readFile(path2.join(installDir, SENTINEL_FILENAME), "utf8");
     return sentinel.trim();
   } catch {
     return null;
@@ -319,7 +511,7 @@ async function lstatExists(p) {
   }
 }
 async function acquireLock(lockPath, timeoutMs, logger, label = "install") {
-  await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
+  await fs.promises.mkdir(path2.dirname(lockPath), { recursive: true });
   const myPidLine = `${process.pid}
 `;
   const deadline = Date.now() + timeoutMs;
@@ -437,21 +629,19 @@ function isInstallerVerbose(env = process.env, argv = process.argv) {
 }
 async function main() {
   const isVerbose = isInstallerVerbose();
-  const pkgDir = path2.resolve(__dirname, "..");
+  const pkgDir = path3.resolve(__dirname, "..");
   const paths = resolveInstallerPaths({ pluginPkgDir: pkgDir });
-  try {
-    const result = await ensureInstalled({
-      ...paths,
-      logger: {
-        info: (msg, meta) => {
-          if (isVerbose) {
-            console.log(`[installer] ${msg}`, meta ?? "");
-          }
-        },
-        warn: (msg, meta) => console.warn(`[installer] WARN: ${msg}`, meta ?? ""),
-        error: (msg, meta) => console.error(`[installer] ERROR: ${msg}`, meta ?? "")
+  const logger = {
+    info: (msg, meta) => {
+      if (isVerbose) {
+        console.log(`[installer] ${msg}`, meta ?? "");
       }
-    });
+    },
+    warn: (msg, meta) => console.warn(`[installer] WARN: ${msg}`, meta ?? ""),
+    error: (msg, meta) => console.error(`[installer] ERROR: ${msg}`, meta ?? "")
+  };
+  try {
+    const result = await ensureInstalled({ ...paths, logger });
     if (isVerbose) {
       if (result.installed) {
         console.log(`[installer] Installed fresh manifest hash=${result.manifestHash}`);
@@ -459,12 +649,14 @@ async function main() {
         console.log(`[installer] Up to date (manifest hash=${result.manifestHash})`);
       }
     }
-    process.exit(0);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[installer] FATAL: ${msg}`);
     process.exit(1);
   }
+  const hooks = await ensureHookRegistration(resolveHookInstallPaths({ pluginPkgDir: pkgDir }), logger);
+  if (isVerbose) console.log(`[installer] agy session hooks: ${hooks.status}`);
+  process.exit(0);
 }
 if (require.main === module) {
   void main();