linkgravity 1.7.0 → 1.7.2

package/bin/cli.js

@@ -32,30 +32,39 @@ function success(msg) {
     console.log(`${color.green}✔${color.reset} ${msg}`);
 }
 
-// Resolved rather than run through npx: pm2 is a direct dependency, and npx wraps it in
-// "npm exec" + "sh -c", which leaves the real process orphaned when we try to kill it.
-const PM2_BIN = require.resolve('pm2/bin/pm2');
+const { PM2_BIN, PM2_CWD, pm2Env } = require('./pm2');
+
+// `npm` is npm.cmd on Windows, and node refuses to spawn a .cmd without a shell.
+function runNpm(args, options = {}) {
+    return spawnSync('npm', args, { shell: isWin, ...options });
+}
 
 function info(msg) {
     console.log(`\n${color.cyan}▶${color.reset} ${msg}`);
 }
 
+// `fresh`: npm has swapped the package on disk since require time.
+function repairHookRegistration({ fresh = false } = {}) {
+    const modulePath = require.resolve('../npm-scripts/register-hook');
+    if (fresh) {
+        delete require.cache[modulePath];
+        delete require.cache[require.resolve('../npm-scripts/venv-paths')];
+    }
+    try {
+        require(modulePath)({ allowFirstTimeCreate: false, quiet: true });
+    } catch (err) {
+        console.log(
+            `${color.yellow}⚠${color.reset} Couldn't check the agy hook registration: ${err.message}`,
+        );
+    }
+}
+
 function runPm2(args, silent = true) {
     const stdioOpt = silent ? 'pipe' : 'inherit';
     const result = spawnSync(process.execPath, [PM2_BIN, ...args], {
         stdio: stdioOpt,
-        cwd: path.join(__dirname, '..'),
-        env: {
-            ...process.env,
-            // pm2 gives Python a pipe not a TTY, so it block-buffers stdout and can sit on log lines indefinitely - force line buffering.
-            PYTHONUNBUFFERED: '1',
-            // pm2 merges --update-env rather than replacing, so a LOG_LEVEL from an earlier run
-            // survives unless a value is passed every time.
-            LOG_LEVEL: process.env.LOG_LEVEL || 'INFO',
-            // Version managers (fnm, nvm) put node on PATH from a shell hook the daemon never runs,
-            // so the bot's own `node` lookup for voice-service would fail without this.
-            PATH: `${path.dirname(process.execPath)}${path.delimiter}${process.env.PATH || ''}`,
-        },
+        cwd: PM2_CWD,
+        env: pm2Env(),
     });
 
     if (result.error) {
@@ -132,7 +141,7 @@ function colorizeLevel(line) {
 }
 
 function runPm2LogsStream(args, printLine) {
-    const cp = spawn(process.execPath, [PM2_BIN, ...args], { cwd: path.join(__dirname, '..') });
+    const cp = spawn(process.execPath, [PM2_BIN, ...args], { cwd: PM2_CWD });
 
     const isNoise = (line) =>
         line.trim().length === 0 ||
@@ -191,7 +200,7 @@ function verifyStartup() {
         );
 
         let cp = spawn(process.execPath, [PM2_BIN, 'logs', LGY_PM2_NAME, '--raw', '--lines', '0'], {
-            cwd: path.join(__dirname, '..'),
+            cwd: PM2_CWD,
         });
 
         let settled = false;
@@ -343,10 +352,7 @@ function isAutostartEnabled() {
 }
 
 function checkLatestVersionFast(currentVersion) {
-    const view = spawnSync('npm', ['view', 'linkgravity', 'version'], {
-        stdio: 'pipe',
-        timeout: 3000,
-    });
+    const view = runNpm(['view', 'linkgravity', 'version'], { stdio: 'pipe', timeout: 3000 });
     if (view.error || view.status !== 0) return null;
     const latest = view.stdout.toString().trim();
     if (!latest) return null;
@@ -392,6 +398,8 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         require('../npm-scripts/ensure-env').ensureEnvironment();
     }
 
+    repairHookRegistration();
+
     info('Starting LinkGravity daemon...');
     runPm2([
         'start',
@@ -591,7 +599,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const currentVersion = pkg.version;
 
     info('Checking npm for the latest version...');
-    const viewResult = spawnSync('npm', ['view', 'linkgravity', 'version'], { stdio: 'pipe' });
+    const viewResult = runNpm(['view', 'linkgravity', 'version'], { stdio: 'pipe' });
     if (viewResult.error || viewResult.status !== 0) {
         console.error(
             (viewResult.stderr || '').toString().trim() ||
@@ -602,6 +610,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const latestVersion = viewResult.stdout.toString().trim();
 
     if (latestVersion === currentVersion) {
+        repairHookRegistration();
         success(`Already up to date (v${currentVersion}).\n`);
         process.exit(0);
     }
@@ -610,9 +619,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     const wasOnline = !!procBeforeUpdate && procBeforeUpdate.pm2_env.status === 'online';
 
     info(`Updating: v${currentVersion} -> v${latestVersion}...`);
-    const installResult = spawnSync('npm', ['install', '-g', 'linkgravity@latest'], {
-        stdio: 'inherit',
-    });
+    const installResult = runNpm(['install', '-g', 'linkgravity@latest'], { stdio: 'inherit' });
     if (installResult.status !== 0) {
         console.error('npm install failed - update aborted, still on the old version.');
         process.exit(1);
@@ -624,6 +631,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     // replaced this package on disk, and the copy required at startup is the pre-update one.
     delete require.cache[require.resolve('../npm-scripts/ensure-env')];
     require('../npm-scripts/ensure-env').ensureEnvironment();
+    repairHookRegistration({ fresh: true });
 
     if (!procBeforeUpdate) {
         info("Daemon wasn't running - starting it fresh...");

package/bin/pm2.js

@@ -0,0 +1,22 @@
+const path = require('path');
+
+// Not `npx pm2`: its `npm exec` + `sh -c` wrapping survives cp.kill() as a zombie, and LPM
+// Firewall reads it as a runtime package install.
+const PM2_BIN = require.resolve('pm2/bin/pm2');
+const PM2_CWD = path.join(__dirname, '..');
+
+function pm2Env() {
+    return {
+        ...process.env,
+        // pm2 gives Python a pipe not a TTY, so it block-buffers stdout and can sit on log lines indefinitely - force line buffering.
+        PYTHONUNBUFFERED: '1',
+        // pm2 merges --update-env rather than replacing, so a LOG_LEVEL from an earlier run
+        // survives unless a value is passed every time.
+        LOG_LEVEL: process.env.LOG_LEVEL || 'INFO',
+        // Version managers (fnm, nvm) put node on PATH from a shell hook the daemon never runs,
+        // so the bot's own `node` lookup for voice-service would fail without this.
+        PATH: `${path.dirname(process.execPath)}${path.delimiter}${process.env.PATH || ''}`,
+    };
+}
+
+module.exports = { PM2_BIN, PM2_CWD, pm2Env };

package/bin/setup.js

@@ -1,6 +1,7 @@
 const p = require('@clack/prompts');
 const { spawnSync } = require('child_process');
 const { python: pythonExe } = require('../npm-scripts/venv-paths');
+const { PM2_BIN, PM2_CWD, pm2Env } = require('./pm2');
 const {
     getSettings,
     updateSettings,
@@ -178,11 +179,19 @@ async function collectUserIds(existingIds, platformLabel, required = false) {
     return ids;
 }
 
+function runPm2(args) {
+    return spawnSync(process.execPath, [PM2_BIN, ...args], {
+        stdio: 'pipe',
+        cwd: PM2_CWD,
+        env: pm2Env(),
+    });
+}
+
 function stopDaemon(pm2Name, label) {
     console.log(`${color.cyan}▶${color.reset} Stopping ${label} daemon...`);
-    spawnSync('npx', ['-y', 'pm2', 'delete', pm2Name], { stdio: 'pipe' });
+    runPm2(['delete', pm2Name]);
 
-    const jlist = spawnSync('npx', ['-y', 'pm2', 'jlist'], { stdio: 'pipe' });
+    const jlist = runPm2(['jlist']);
     let stillRunning = false;
     if (jlist.status === 0) {
         try {
@@ -194,17 +203,14 @@ function stopDaemon(pm2Name, label) {
         p.outro(`${label} daemon stopped.`);
     } else {
         p.outro(
-            `${color.yellow}⚠${color.reset} ${label} daemon is still running - run \`npx pm2 delete ${pm2Name}\` manually and check \`npx pm2 list\`.`,
+            `${color.yellow}⚠${color.reset} ${label} daemon is still running - run \`lgy stop\` manually and check \`lgy status\`.`,
         );
     }
 }
 
 function startOrRestartDaemon(pm2Name, scriptPath, label) {
     console.log(`${color.cyan}▶${color.reset} Restarting ${label} daemon to apply changes...`);
-    const restartResult = spawnSync('npx', ['-y', 'pm2', 'restart', pm2Name, '--update-env'], {
-        stdio: 'pipe',
-        env: { ...process.env, PYTHONUNBUFFERED: '1' },
-    });
+    const restartResult = runPm2(['restart', pm2Name, '--update-env']);
 
     if (restartResult.status === 0) {
         p.outro(`${label} daemon restarted.`);
@@ -214,11 +220,14 @@ function startOrRestartDaemon(pm2Name, scriptPath, label) {
     const stderr = (restartResult.stderr || '').toString();
     if (stderr.includes('not found')) {
         // Nothing to restart yet - start it instead of a false "restarted".
-        const startResult = spawnSync(
-            'npx',
-            ['-y', 'pm2', 'start', scriptPath, '--interpreter', pythonExe, '--name', pm2Name],
-            { stdio: 'pipe', env: { ...process.env, PYTHONUNBUFFERED: '1' } },
-        );
+        const startResult = runPm2([
+            'start',
+            scriptPath,
+            '--interpreter',
+            pythonExe,
+            '--name',
+            pm2Name,
+        ]);
         if (startResult.status === 0) {
             p.outro(`${label} daemon wasn't running yet - started it fresh instead.`);
         } else {
@@ -476,6 +485,8 @@ async function runSetup() {
             process.exit(0);
         }
         if (consent) registerHook({ allowFirstTimeCreate: true });
+    } else {
+        registerHook({ allowFirstTimeCreate: false, quiet: true });
     }
 
     while (true) {

package/hooks/hook.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('fs');
+const http = require('http');
+const os = require('os');
+const path = require('path');
+
+const LGY_CONFIG_FILE = path.join(os.homedir(), '.gemini', 'linkgravity', 'lgy.json');
+// Not "localhost" - the server binds 127.0.0.1 and node resolves localhost to ::1 first.
+const APPROVE_HOST = '127.0.0.1';
+const APPROVE_PORT = 18080;
+const TIMEOUT_MS = 3600 * 1000;
+
+function emit(payload) {
+    process.stdout.write(JSON.stringify(payload));
+}
+
+function loadApproveToken() {
+    try {
+        return JSON.parse(fs.readFileSync(LGY_CONFIG_FILE, 'utf8')).approve_token || '';
+    } catch {
+        return '';
+    }
+}
+
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+
+function requestDecision(body) {
+    return new Promise((resolve, reject) => {
+        const req = http.request(
+            {
+                host: APPROVE_HOST,
+                port: APPROVE_PORT,
+                path: '/approve',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': body.length,
+                    'X-LGY-Token': loadApproveToken(),
+                },
+            },
+            (res) => {
+                const parts = [];
+                res.on('data', (chunk) => parts.push(chunk));
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(Buffer.concat(parts).toString('utf8')));
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            },
+        );
+        req.on('error', reject);
+        req.setTimeout(TIMEOUT_MS, () => req.destroy(new Error('timed out waiting for approval')));
+        req.end(body);
+    });
+}
+
+async function main() {
+    if (process.env.LGY_APPROVAL_HOOK !== '1') {
+        emit({ decision: 'allow' });
+        return;
+    }
+
+    let hookInput;
+    try {
+        hookInput = JSON.parse(await readStdin());
+    } catch {
+        emit({ decision: 'deny', reason: 'Failed to parse hook input.' });
+        return;
+    }
+
+    const toolCall = hookInput.toolCall || {};
+    const body = Buffer.from(
+        JSON.stringify({
+            conversation_id: hookInput.conversationId || 'unknown',
+            tool_name: toolCall.name || 'unknown_tool',
+            tool_input: toolCall.args || {},
+            thread_id: process.env.LGY_THREAD_ID || null,
+        }),
+        'utf8',
+    );
+
+    try {
+        const result = await requestDecision(body);
+        if ((result.decision || 'allow') === 'allow') {
+            const out = { decision: 'allow' };
+            // Print mode requires a matching allow rule even when this hook says "allow", or it soft-denies anyway.
+            if (result.permissionOverrides) out.permissionOverrides = result.permissionOverrides;
+            emit(out);
+        } else {
+            emit({ decision: 'deny', reason: result.reason || 'User rejected the action.' });
+        }
+    } catch (err) {
+        process.stderr.write(`Hook error: ${err.message}\n`);
+        emit({ decision: 'deny', reason: `Connection to webhook failed: ${err.message}` });
+    }
+}
+
+main();

package/hooks/stop_hook.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+'use strict';
+// Stop-event hook (https://antigravity.google/docs/hooks).
+// `fullyIdle: false` means a run_command that detached to async is still in flight; "continue"
+// keeps the turn alive so agy picks that result up instead of losing it.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_CONTINUE_ATTEMPTS = 20;
+// Its own process, so it never reaches `lgy logs`.
+const DEBUG_LOG = path.join(os.homedir(), '.gemini', 'linkgravity', 'logs', 'stop_hook_debug.log');
+
+function log(line) {
+    try {
+        fs.mkdirSync(path.dirname(DEBUG_LOG), { recursive: true });
+        fs.appendFileSync(DEBUG_LOG, `${new Date().toISOString()} ${line}\n`);
+    } catch {}
+}
+
+function emit(payload) {
+    process.stdout.write(JSON.stringify(payload));
+}
+
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+
+async function main() {
+    const raw = await readStdin();
+    let hookInput;
+    try {
+        hookInput = JSON.parse(raw);
+    } catch (err) {
+        log(`[PARSE ERROR] ${err.message} raw=${JSON.stringify(raw)}`);
+        emit({});
+        return;
+    }
+
+    const fullyIdle = hookInput.fullyIdle ?? true;
+    const executionNum = hookInput.executionNum ?? 0;
+    log(
+        `[STOP HOOK] fullyIdle=${fullyIdle} executionNum=${executionNum} ` +
+            `terminationReason=${JSON.stringify(hookInput.terminationReason)} ` +
+            `conv=${JSON.stringify(hookInput.conversationId)}`,
+    );
+
+    if (!fullyIdle && executionNum < MAX_CONTINUE_ATTEMPTS) {
+        const response = {
+            decision: 'continue',
+            reason:
+                'A background command is still running. Wait for it to finish, ' +
+                'then report its actual result to the user before ending your turn.',
+        };
+        log(`[STOP HOOK] -> continue: ${JSON.stringify(response)}`);
+        emit(response);
+    } else {
+        log('[STOP HOOK] -> {} (fullyIdle true or attempt cap reached)');
+        emit({});
+    }
+}
+
+main();

package/npm-scripts/register-hook.js

@@ -3,30 +3,55 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { repoRoot, python: venvPython } = require('./venv-paths');
+const { repoRoot, workspaceDir, isWin } = require('./venv-paths');
 
 const hooksJsonPath = path.join(os.homedir(), '.gemini', 'config', 'hooks.json');
 
-// PreToolUse/Stop meanings are agy's own hook contract: Stop fires when agy is about to
-// end a turn, and if fullyIdle is false (an async run_command still in flight), stop_hook.py
-// tells agy to keep going instead of losing that result.
+// Not process.execPath: this runs on every agy tool call machine-wide, and an absolute
+// interpreter path dies the moment a version manager moves it.
+const NODE_CMD = 'node';
+
+// A copy, never this package: npm has had no uninstall lifecycle since v7, so an entry pointing
+// into node_modules would 127 every agy tool call once linkgravity is removed.
+const installedHooksDir = path.join(workspaceDir, 'hooks');
+
 const HOOK_REGISTRATIONS = [
     {
         eventType: 'PreToolUse',
         name: 'discord-approval',
-        scriptPath: path.join(repoRoot, 'hooks', 'hook.py'),
+        fileName: 'hook.js',
         defaultTimeout: 3600,
         wrapInMatcher: true,
     },
     {
         eventType: 'Stop',
         name: 'discord-approval-stop',
-        scriptPath: path.join(repoRoot, 'hooks', 'stop_hook.py'),
+        fileName: 'stop_hook.js',
         defaultTimeout: 30,
         wrapInMatcher: false,
     },
 ];
 
+function installHookScripts() {
+    for (const reg of HOOK_REGISTRATIONS) {
+        const source = fs.readFileSync(path.join(repoRoot, 'hooks', reg.fileName), 'utf8');
+        const installedPath = path.join(installedHooksDir, reg.fileName);
+        let installed = null;
+        try {
+            installed = fs.readFileSync(installedPath, 'utf8');
+        } catch {}
+        if (installed === source) continue;
+        try {
+            fs.mkdirSync(installedHooksDir, { recursive: true });
+            fs.writeFileSync(installedPath, source);
+        } catch (err) {
+            // A stale copy still answers agy, so only a missing one is fatal.
+            if (installed === null) throw err;
+            console.log(`⚠️  Couldn't refresh ${installedPath}: ${err.message}`);
+        }
+    }
+}
+
 const RETIRED_HOOKS = [{ eventType: 'PreInvocation', name: 'wait-ms-before-async-reminder' }];
 
 function loadHooksConfig() {
@@ -34,12 +59,13 @@ function loadHooksConfig() {
         return { hooks: {} };
     }
     try {
-        return JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8'));
+        // Windows tools write a BOM, which JSON.parse rejects.
+        return JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8').replace(/^\uFEFF/, ''));
     } catch (err) {
         const backupPath = `${hooksJsonPath}.corrupted-${Date.now()}`;
         fs.copyFileSync(hooksJsonPath, backupPath);
         console.warn(
-            `⚠️  ${hooksJsonPath} was invalid JSON - backed up to ${backupPath} and starting fresh.`,
+            `⚠️  ${hooksJsonPath} was invalid JSON - copied to ${backupPath}. Any hooks it held, including other tools', are about to be replaced.`,
         );
         return { hooks: {} };
     }
@@ -104,7 +130,7 @@ function removeRetiredHooks(config) {
     return removedAny;
 }
 
-function registerHook({ allowFirstTimeCreate = true } = {}) {
+function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
     const config = loadHooksConfig();
     config.hooks = config.hooks || {};
 
@@ -116,9 +142,11 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
     });
 
     if (isFirstTime && !allowFirstTimeCreate) {
-        console.log(
-            "ℹ️  LinkGravity's Discord/Telegram/Slack approval hook isn't registered with agy yet - run `lgy setup` to enable it.",
-        );
+        if (!quiet) {
+            console.log(
+                "ℹ️  LinkGravity's Discord/Telegram/Slack approval hook isn't registered with agy yet - run `lgy setup` to enable it.",
+            );
+        }
         return;
     }
 
@@ -137,8 +165,12 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
         wroteChange = true;
     }
 
+    installHookScripts();
+
     for (const reg of HOOK_REGISTRATIONS) {
-        const command = `"${venvPython}" "${reg.scriptPath}"`;
+        const scriptPath = path.join(installedHooksDir, reg.fileName);
+        // Windows agy takes everything after the first token as one argument; POSIX agy uses a shell.
+        const command = isWin ? `${NODE_CMD} ${scriptPath}` : `${NODE_CMD} "${scriptPath}"`;
         const hookEntry = findHookEntry(config, reg.eventType, reg.name, reg.wrapInMatcher);
         const isNew = !hookEntry.command;
 
@@ -146,9 +178,7 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
             hookEntry.type = 'command';
             hookEntry.timeout = reg.defaultTimeout;
             hookEntry.command = command;
-            console.log(
-                `🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${reg.scriptPath}`,
-            );
+            console.log(`🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${scriptPath}`);
             wroteChange = true;
         } else if (hookEntry.command !== command) {
             backupBeforeFirstChange();
@@ -159,9 +189,9 @@ function registerHook({ allowFirstTimeCreate = true } = {}) {
             );
             hookEntry.command = command;
             wroteChange = true;
-        } else {
+        } else if (!quiet) {
             console.log(
-                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${reg.scriptPath}`,
+                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
             );
         }
     }

package/npm-scripts/venv-paths.js

@@ -35,7 +35,7 @@ function venvBin(name) {
 }
 
 module.exports = {
-    repoRoot, // where the CODE lives (this checkout/install) - hooks/hook.py, src/main.py, etc.
+    repoRoot, // where the CODE lives (this checkout/install) - hooks/hook.js, src/main.py, etc.
     workspaceDir, // where generated/user DATA lives (venv, logs, lgy.json, wake_refs, ...)
     isWin,
     venvBinDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/hooks/hook.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-import json
-import os
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-LGY_CONFIG_FILE = Path.home() / ".gemini" / "linkgravity" / "lgy.json"
-
-
-def _load_approve_token():
-    try:
-        with open(LGY_CONFIG_FILE, encoding="utf-8") as f:
-            return json.load(f).get("approve_token", "")
-    except Exception:
-        return ""
-
-
-def main():
-    if os.environ.get("LGY_APPROVAL_HOOK") != "1":
-        print(json.dumps({"decision": "allow"}))
-        return
-
-    try:
-        raw_input = sys.stdin.read()
-        hook_input = json.loads(raw_input)
-    except Exception:
-        print(json.dumps({"decision": "deny", "reason": "Failed to parse hook input."}))
-        return
-
-    tool_call = hook_input.get("toolCall", {})
-    tool_name = tool_call.get("name", "unknown_tool")
-
-    tool_input_data = tool_call.get("args", {})
-    conv_id = hook_input.get("conversationId", "unknown")
-
-    payload = json.dumps(
-        {
-            "conversation_id": conv_id,
-            "tool_name": tool_name,
-            "tool_input": tool_input_data,
-            "thread_id": os.environ.get("LGY_THREAD_ID"),
-        }
-    ).encode("utf-8")
-
-    req = urllib.request.Request(
-        "http://localhost:18080/approve",
-        data=payload,
-        headers={"Content-Type": "application/json", "X-LGY-Token": _load_approve_token()},
-    )
-
-    try:
-        with urllib.request.urlopen(req, timeout=3600) as response:
-            res_data = json.loads(response.read().decode("utf-8"))
-            decision = res_data.get("decision", "allow")
-            if decision == "allow":
-                out = {"decision": "allow"}
-                # Print mode requires a matching allow rule even when this hook says "allow", or it soft-denies anyway.
-                if res_data.get("permissionOverrides"):
-                    out["permissionOverrides"] = res_data["permissionOverrides"]
-                print(json.dumps(out))
-            else:
-                reason = res_data.get("reason", "User rejected the action.")
-                print(json.dumps({"decision": "deny", "reason": reason}))
-    except Exception as e:
-        sys.stderr.write(f"Hook error: {e}\n")
-        print(json.dumps({"decision": "deny", "reason": f"Connection to webhook failed: {e}"}))
-
-
-if __name__ == "__main__":
-    main()

package/hooks/stop_hook.py

@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-"""Stop-event hook (https://antigravity.google/docs/hooks#stop).
-
-`fullyIdle: false` means a run_command call detached to async (its
-WaitMsBeforeAsync budget ran out) is still in flight. Returning
-{"decision": "continue"} keeps the turn alive so agy can pick up that
-result instead of ending the turn with it lost. Capped by executionNum
-so a genuinely stuck command doesn't loop forever.
-"""
-
-import json
-import sys
-from datetime import datetime
-from pathlib import Path
-
-MAX_CONTINUE_ATTEMPTS = 20
-# This runs as its own process, invoked directly by agy - not visible in
-# `lgy logs`. Plain-file logging is the only way to inspect it.
-DEBUG_LOG = Path.home() / ".gemini" / "linkgravity" / "logs" / "stop_hook_debug.log"
-
-
-def log(line: str):
-    try:
-        DEBUG_LOG.parent.mkdir(parents=True, exist_ok=True)
-        with open(DEBUG_LOG, "a", encoding="utf-8") as f:
-            f.write(f"{datetime.now().isoformat()} {line}\n")
-    except Exception:
-        pass
-
-
-def main():
-    try:
-        raw = sys.stdin.read()
-        hook_input = json.loads(raw)
-    except Exception as e:
-        log(f"[PARSE ERROR] {e} raw={raw!r}")
-        print(json.dumps({}))
-        return
-
-    fully_idle = hook_input.get("fullyIdle", True)
-    execution_num = hook_input.get("executionNum", 0)
-    termination_reason = hook_input.get("terminationReason")
-    log(
-        f"[STOP HOOK] fullyIdle={fully_idle!r} executionNum={execution_num!r} "
-        f"terminationReason={termination_reason!r} conv={hook_input.get('conversationId')!r}"
-    )
-
-    if not fully_idle and execution_num < MAX_CONTINUE_ATTEMPTS:
-        response = {
-            "decision": "continue",
-            "reason": (
-                "A background command is still running. Wait for it to finish, "
-                "then report its actual result to the user before ending your turn."
-            ),
-        }
-        log(f"[STOP HOOK] -> continue: {response}")
-        print(json.dumps(response))
-    else:
-        log("[STOP HOOK] -> {} (fullyIdle true or attempt cap reached)")
-        print(json.dumps({}))
-
-
-if __name__ == "__main__":
-    main()