linkgravity 1.6.1 → 1.7.1

package/bin/cli.js

@@ -40,6 +40,22 @@ 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], {
@@ -392,6 +408,8 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
         require('../npm-scripts/ensure-env').ensureEnvironment();
     }
 
+    repairHookRegistration();
+
     info('Starting LinkGravity daemon...');
     runPm2([
         'start',
@@ -602,6 +620,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);
     }
@@ -624,6 +643,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/completion.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// bash and fish read these directories lazily, on the first completion attempt, so neither needs
+// an rc line. zsh's default fpath has no home-directory entry, so it gets three.
+const TARGETS = {
+    bash: { src: 'lgy.bash', dest: ['.local', 'share', 'bash-completion', 'completions', 'lgy'] },
+    zsh: { src: '_lgy', dest: ['.local', 'share', 'zsh', 'site-functions', '_lgy'], rc: '.zshrc' },
+    fish: { src: 'lgy.fish', dest: ['.config', 'fish', 'completions', 'lgy.fish'] },
+};
+
+const MARKER = '# linkgravity completion';
+
+function zshRcBlock(dir) {
+    return [
+        '',
+        MARKER,
+        `fpath+=("${dir}")`,
+        'autoload -Uz _lgy',
+        'whence compdef > /dev/null && compdef _lgy lgy linkgravity',
+        '',
+    ].join('\n');
+}
+
+function installCompletion(shell = path.basename(process.env.SHELL || '')) {
+    const target = TARGETS[shell];
+    if (!target) return null;
+
+    const dest = path.join(os.homedir(), ...target.dest);
+    let rcUpdated = false;
+    try {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.copyFileSync(path.join(__dirname, 'completions', target.src), dest);
+
+        if (target.rc) {
+            const rc = path.join(os.homedir(), target.rc);
+            const existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+            if (!existing.includes(MARKER)) {
+                fs.appendFileSync(rc, zshRcBlock(path.dirname(dest)));
+                rcUpdated = true;
+            }
+        }
+    } catch {
+        return null;
+    }
+    return { shell, file: dest, rc: rcUpdated ? path.join(os.homedir(), target.rc) : null };
+}
+
+module.exports = { installCompletion };

package/bin/completions/_lgy

@@ -0,0 +1,33 @@
+#compdef lgy linkgravity
+
+local -a commands
+commands=(
+    'version:Print the installed version'
+    'start:Start bot in the background'
+    'stop:Stop the background bot'
+    'restart:Restart the background bot'
+    'logs:View bot logs'
+    'status:Show daemon status'
+    'enable:Start automatically on system boot'
+    'disable:Remove bot from system boot'
+    'setup:Run the configuration wizard'
+    'update:Install a newer version if one exists'
+    'help:Show the help message'
+)
+
+if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+fi
+
+case "$words[2]" in
+    logs)
+        [[ "$words[CURRENT-1]" == (-n|--tail) ]] && return
+        _values 'flag' \
+            '-f[Follow the log output]' \
+            '-n[Number of lines to show]' \
+            '--tail[Number of lines to show]' \
+            '-t[Show timestamps]' \
+            '--timestamp[Show timestamps]'
+        ;;
+esac

package/bin/completions/lgy.bash

@@ -0,0 +1,18 @@
+_lgy_completion() {
+  local cur prev
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  prev="${COMP_WORDS[COMP_CWORD - 1]}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "version start stop restart logs status enable disable setup update help" -- "$cur"))
+    return
+  fi
+
+  if [ "${COMP_WORDS[1]}" = "logs" ]; then
+    case "$prev" in
+    -n | --tail) return ;;
+    esac
+    COMPREPLY=($(compgen -W "-f -n --tail -t --timestamp" -- "$cur"))
+  fi
+}
+complete -F _lgy_completion lgy linkgravity

package/bin/completions/lgy.fish

@@ -0,0 +1,32 @@
+complete -c lgy -n __fish_use_subcommand -a version -d 'Print the installed version'
+complete -c lgy -n __fish_use_subcommand -a start -d 'Start bot in the background'
+complete -c lgy -n __fish_use_subcommand -a stop -d 'Stop the background bot'
+complete -c lgy -n __fish_use_subcommand -a restart -d 'Restart the background bot'
+complete -c lgy -n __fish_use_subcommand -a logs -d 'View bot logs'
+complete -c lgy -n __fish_use_subcommand -a status -d 'Show daemon status'
+complete -c lgy -n __fish_use_subcommand -a enable -d 'Start automatically on system boot'
+complete -c lgy -n __fish_use_subcommand -a disable -d 'Remove bot from system boot'
+complete -c lgy -n __fish_use_subcommand -a setup -d 'Run the configuration wizard'
+complete -c lgy -n __fish_use_subcommand -a update -d 'Install a newer version if one exists'
+complete -c lgy -n __fish_use_subcommand -a help -d 'Show the help message'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s f -d 'Follow the log output'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s n -d 'Number of lines to show'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -l tail -d 'Number of lines to show'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s t -d 'Show timestamps'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -l timestamp -d 'Show timestamps'
+complete -c linkgravity -n __fish_use_subcommand -a version -d 'Print the installed version'
+complete -c linkgravity -n __fish_use_subcommand -a start -d 'Start bot in the background'
+complete -c linkgravity -n __fish_use_subcommand -a stop -d 'Stop the background bot'
+complete -c linkgravity -n __fish_use_subcommand -a restart -d 'Restart the background bot'
+complete -c linkgravity -n __fish_use_subcommand -a logs -d 'View bot logs'
+complete -c linkgravity -n __fish_use_subcommand -a status -d 'Show daemon status'
+complete -c linkgravity -n __fish_use_subcommand -a enable -d 'Start automatically on system boot'
+complete -c linkgravity -n __fish_use_subcommand -a disable -d 'Remove bot from system boot'
+complete -c linkgravity -n __fish_use_subcommand -a setup -d 'Run the configuration wizard'
+complete -c linkgravity -n __fish_use_subcommand -a update -d 'Install a newer version if one exists'
+complete -c linkgravity -n __fish_use_subcommand -a help -d 'Show the help message'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s f -d 'Follow the log output'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s n -d 'Number of lines to show'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -l tail -d 'Number of lines to show'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s t -d 'Show timestamps'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -l timestamp -d 'Show timestamps'

package/bin/setup.js

@@ -476,6 +476,8 @@ async function runSetup() {
             process.exit(0);
         }
         if (consent) registerHook({ allowFirstTimeCreate: true });
+    } else {
+        registerHook({ allowFirstTimeCreate: false, quiet: true });
     }
 
     while (true) {
@@ -494,6 +496,21 @@ async function runSetup() {
         await platformMenu(choice);
     }
 
+    const { installCompletion } = require('./completion');
+    const installed = installCompletion();
+    if (installed) {
+        p.note(
+            [
+                `Installed for ${installed.shell} at ${installed.file}.`,
+                installed.rc ? `Added a line to ${installed.rc}.` : null,
+                'Open a new shell to use it.',
+            ]
+                .filter(Boolean)
+                .join('\n'),
+            'Tab completion',
+        );
+    }
+
     p.outro('Setup complete.');
 }
 

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 } = 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() {
@@ -104,7 +129,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 +141,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 +164,11 @@ 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);
+        const command = `${NODE_CMD} "${scriptPath}"`;
         const hookEntry = findHookEntry(config, reg.eventType, reg.name, reg.wrapInMatcher);
         const isNew = !hookEntry.command;
 
@@ -146,9 +176,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 +187,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.6.1",
+  "version": "1.7.1",
   "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()