linkgravity 1.8.1 → 1.9.1

package/hooks/hook.js

@@ -9,7 +9,7 @@ const LGY_CONFIG_FILE = path.join(os.homedir(), '.gemini', 'linkgravity', 'lgy.j
 // 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;
+const TIMEOUT_MS = 86400 * 1000;
 
 function emit(payload) {
     // Exits explicitly: the keep-alive socket and its hour-long timer stay open after the

package/npm-scripts/register-hook.js

@@ -20,7 +20,7 @@ const HOOK_REGISTRATIONS = [
         eventType: 'PreToolUse',
         name: 'discord-approval',
         fileName: 'hook.js',
-        defaultTimeout: 3600,
+        defaultTimeout: 86400,
         wrapInMatcher: true,
     },
     {
@@ -130,7 +130,7 @@ function removeRetiredHooks(config) {
     return removedAny;
 }
 
-function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
+function registerHook({ allowFirstTimeCreate = true, quiet = false, resetTimeouts = false } = {}) {
     const config = loadHooksConfig();
     config.hooks = config.hooks || {};
 
@@ -180,19 +180,34 @@ function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
             hookEntry.command = command;
             console.log(`🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${scriptPath}`);
             wroteChange = true;
-        } else if (hookEntry.command !== command) {
-            backupBeforeFirstChange();
-            console.log(
-                `🔗 Fixing agy ${reg.eventType} hook '${reg.name}' in ${hooksJsonPath}` +
-                    (backedUp ? ` (previous version backed up to ${hooksJsonPath}.bak)` : '') +
-                    `:\n   was: ${hookEntry.command}\n   now: ${command}`,
-            );
-            hookEntry.command = command;
-            wroteChange = true;
-        } else if (!quiet) {
-            console.log(
-                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
-            );
+        } else {
+            let changedThisEntry = false;
+            if (hookEntry.command !== command) {
+                backupBeforeFirstChange();
+                console.log(
+                    `🔗 Fixing agy ${reg.eventType} hook '${reg.name}' in ${hooksJsonPath}` +
+                        (backedUp ? ` (previous version backed up to ${hooksJsonPath}.bak)` : '') +
+                        `:\n   was: ${hookEntry.command}\n   now: ${command}`,
+                );
+                hookEntry.command = command;
+                changedThisEntry = true;
+            }
+            // Only setup resets timeout - a passive `update` must not clobber a user-customized value.
+            if (resetTimeouts && hookEntry.timeout !== reg.defaultTimeout) {
+                backupBeforeFirstChange();
+                console.log(
+                    `🔗 Resetting agy ${reg.eventType} hook '${reg.name}' timeout: ${hookEntry.timeout}s -> ${reg.defaultTimeout}s`,
+                );
+                hookEntry.timeout = reg.defaultTimeout;
+                changedThisEntry = true;
+            }
+            if (changedThisEntry) {
+                wroteChange = true;
+            } else if (!quiet) {
+                console.log(
+                    `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
+                );
+            }
         }
     }
 

package/package.json

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

package/src/core/agy_runner.py

@@ -208,13 +208,6 @@ async def run_agy(
                             stdout_chunks.append(clean)
                             if stream_queue is not None:
                                 await stream_queue.put((clean, False))
-                                if (
-                                    "(Calls tool:" in clean
-                                    or "Tool Output:" in clean
-                                    or "Tool Execute:" in clean
-                                    or clean.startswith("● ")
-                                ):
-                                    await stream_queue.put(("__SPLIT__", True))
 
                 async def read_stderr():
                     while True:
@@ -229,7 +222,7 @@ async def run_agy(
                 gather_task = asyncio.create_task(_gather_pipes())
                 wait_task = asyncio.create_task(proc.wait())
 
-                # Slices let the timeout pause indefinitely while any approval is pending (hooks/hook.js waits up to 24h).
+                # Slices let the timeout pause while an approval is pending (hook.js waits up to 24h).
                 from config import session_manager as _sm
 
                 poll_slice = 5.0
@@ -351,7 +344,7 @@ async def agy_new_conversation(
     args = ["--dangerously-skip-permissions", "--print", content, "--print-timeout", "24h"]
     if model:
         args.extend(["--model", clean_model_name(model)])
-    result_text = await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
+    result_text = await run_agy(*args, timeout=86400, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
     conv_id = await _get_latest_conversation_id()
     return result_text, conv_id
 
@@ -367,7 +360,7 @@ async def agy_send_message(
     args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id, "--print-timeout", "24h"]
     if model:
         args.extend(["--model", clean_model_name(model)])
-    return await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
+    return await run_agy(*args, timeout=86400, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
 
 
 def get_current_model() -> str:

package/src/core/session_manager.py

@@ -14,6 +14,7 @@ class SessionManager:
         self.sessions: dict[str, dict] = self._load_sessions()
         self.active_queues: dict[str, asyncio.Queue] = {}
         self.active_tts_tasks: dict[str, asyncio.Task] = {}
+        self.active_handler_tasks: dict[str, asyncio.Task] = {}
         self.pending_approvals: dict[str, asyncio.Future] = {}
         self.pending_approval_types: dict[str, str] = {}
         self.pending_approval_messages: dict[str, Any] = {}
@@ -121,6 +122,15 @@ class SessionManager:
     def remove_tts_task(self, thread_id: str):
         self.active_tts_tasks.pop(str(thread_id), None)
 
+    def get_handler_task(self, thread_id: str) -> asyncio.Task | None:
+        return self.active_handler_tasks.get(str(thread_id))
+
+    def set_handler_task(self, thread_id: str, task: asyncio.Task):
+        self.active_handler_tasks[str(thread_id)] = task
+
+    def remove_handler_task(self, thread_id: str):
+        self.active_handler_tasks.pop(str(thread_id), None)
+
     def set_pending_approval(
         self,
         approval_key: str,

package/src/handlers/thread_reply.py

@@ -133,6 +133,17 @@ async def handle_existing_session(
         cleanup_images(image_paths)
 
 
+async def _run_tracked(thread_id: str, coro) -> None:
+    # Registered so /stop can cancel the whole turn, not just the agy process.
+    task = asyncio.current_task()
+    session_manager.set_handler_task(thread_id, task)
+    try:
+        await coro
+    finally:
+        if session_manager.get_handler_task(thread_id) is task:
+            session_manager.remove_handler_task(thread_id)
+
+
 async def handle_thread_reply(bot, incoming: IncomingMessage):
     session = session_manager.get_session(incoming.conversation_id)
     if not session:
@@ -202,10 +213,16 @@ async def handle_thread_reply(bot, incoming: IncomingMessage):
 
     if not conv_id:
         if session.get("status") == "pending":
-            await handle_pending_session(bot, incoming, session, agy_content, content, image_paths)
+            await _run_tracked(
+                incoming.conversation_id,
+                handle_pending_session(bot, incoming, session, agy_content, content, image_paths),
+            )
             return
         else:
             await adapter.send_message(thread, "⚠️ Session ID not found. Start a new session with `/new`.")
             return
 
-    await handle_existing_session(bot, incoming, session, conv_id, agy_content, image_paths)
+    await _run_tracked(
+        incoming.conversation_id,
+        handle_existing_session(bot, incoming, session, conv_id, agy_content, image_paths),
+    )