paseo-acp-agy 1.2.5 → 1.2.7

package/dist/acp-server.d.ts

@@ -1,6 +1,7 @@
 import { Readable, Writable } from "node:stream";
+import { EventEmitter } from "node:events";
 import { SessionManager } from "./session.js";
-export declare class ACPServer {
+export declare class ACPServer extends EventEmitter {
     private sessionManager;
     private input;
     private output;

package/dist/acp-server.js

@@ -1,10 +1,12 @@
 import readline from "node:readline";
+import { EventEmitter } from "node:events";
 import { logger } from "./logger.js";
 import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, mapToolNameToKind, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
 import { SessionManager } from "./session.js";
 import { executeSlashCommand, AVAILABLE_SLASH_COMMANDS } from "./slash-commands.js";
 import { getShortVersion } from "./version.js";
 import { resolveDefaultAgyBinary } from "./antigravity-process.js";
+import { loadConversationTranscript } from "./transcript.js";
 function splitModelAndEffort(modelInput) {
     if (!modelInput)
         return {};
@@ -16,7 +18,7 @@ function splitModelAndEffort(modelInput) {
     }
     return { model: modelInput };
 }
-export class ACPServer {
+export class ACPServer extends EventEmitter {
     sessionManager;
     input;
     output;
@@ -25,6 +27,7 @@ export class ACPServer {
     rl = null;
     isRunning = false;
     constructor(options = {}) {
+        super();
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
         this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
@@ -37,6 +40,14 @@ export class ACPServer {
         if (this.isRunning)
             return;
         this.isRunning = true;
+        this.output.on("error", (err) => {
+            if (err.code === "EPIPE" || err.code === "ERR_STREAM_DESTROYED") {
+                logger.debug("ACP output stream closed", { code: err.code });
+            }
+            else {
+                logger.error("ACP output stream error", { error: err.message, code: err.code });
+            }
+        });
         this.rl = readline.createInterface({
             input: this.input,
             output: undefined,
@@ -49,14 +60,23 @@ export class ACPServer {
         });
         this.rl.on("close", () => {
             logger.info("ACP input stream closed, shutting down server");
-            this.stop().catch((err) => {
+            this.stop()
+                .catch((err) => {
                 logger.error("Error stopping ACP server on close", { error: err.message });
+            })
+                .finally(() => {
+                this.emit("close");
             });
         });
         logger.info("ACP Server started");
     }
     send(msg) {
-        this.output.write(JSON.stringify(msg) + "\n");
+        try {
+            this.output.write(JSON.stringify(msg) + "\n");
+        }
+        catch (err) {
+            logger.warn("Failed to write to ACP output stream", { error: err.message });
+        }
     }
     sendNotification(method, params) {
         const notification = { jsonrpc: "2.0", method, params };
@@ -186,8 +206,12 @@ export class ACPServer {
                             agentInfo: { name: "agy-acp", version: shortVersion },
                             serverInfo: { name: "agy-acp", version: shortVersion },
                             agentCapabilities: {
-                                loadSession: false,
-                                sessionCapabilities: { resume: {} },
+                                loadSession: true,
+                                sessionCapabilities: {
+                                    resume: {},
+                                    list: {},
+                                    fork: {},
+                                },
                             },
                         });
                     }
@@ -234,7 +258,6 @@ export class ACPServer {
                         break;
                     }
                     let session = this.sessionManager.getSession(sessionId);
-                    let created = false;
                     try {
                         if (!session) {
                             session = this.sessionManager.createSession({
@@ -242,10 +265,79 @@ export class ACPServer {
                                 cwd,
                                 binaryPath: this.binaryPath,
                             });
-                            created = true;
                         }
-                        if (!created && session.process.currentConversationId) {
-                            await session.ensureReadyForResume();
+                        const conversationId = session.process.currentConversationId;
+                        if (conversationId) {
+                            try {
+                                const replayItems = await loadConversationTranscript(conversationId);
+                                if (!session.title && replayItems.length > 0) {
+                                    const firstUser = replayItems.find((item) => item.type === "user_message");
+                                    if (firstUser && firstUser.text) {
+                                        session.setTitle(firstUser.text.slice(0, 80).replace(/\r?\n/g, " ").trim());
+                                    }
+                                }
+                                for (const item of replayItems) {
+                                    switch (item.type) {
+                                        case "user_message":
+                                            this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                sessionId: session.id,
+                                                update: {
+                                                    sessionUpdate: "user_message_chunk",
+                                                    content: { type: "text", text: item.text },
+                                                },
+                                            });
+                                            break;
+                                        case "agent_thought":
+                                            this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                sessionId: session.id,
+                                                update: {
+                                                    sessionUpdate: "agent_thought_chunk",
+                                                    content: { type: "text", text: item.text },
+                                                },
+                                            });
+                                            break;
+                                        case "tool_call":
+                                            this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                sessionId: session.id,
+                                                update: {
+                                                    sessionUpdate: "tool_call",
+                                                    toolCallId: item.toolCallId,
+                                                    title: item.title,
+                                                    kind: item.kind,
+                                                    rawInput: item.rawInput,
+                                                },
+                                            });
+                                            break;
+                                        case "tool_call_update":
+                                            this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                sessionId: session.id,
+                                                update: {
+                                                    sessionUpdate: "tool_call_update",
+                                                    toolCallId: item.toolCallId,
+                                                    status: item.status,
+                                                    rawOutput: item.rawOutput,
+                                                },
+                                            });
+                                            break;
+                                        case "agent_message":
+                                            this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                                sessionId: session.id,
+                                                update: {
+                                                    sessionUpdate: "agent_message_chunk",
+                                                    content: { type: "text", text: item.text },
+                                                },
+                                            });
+                                            break;
+                                    }
+                                }
+                            }
+                            catch (replayErr) {
+                                logger.warn("Failed to replay conversation transcript during session load", {
+                                    sessionId,
+                                    conversationId,
+                                    error: replayErr.message,
+                                });
+                            }
                         }
                         if (!isNotification) {
                             this.sendSuccess(id, await this.sessionState(session));
@@ -309,6 +401,40 @@ export class ACPServer {
                     }
                     break;
                 }
+                case ACP_METHODS.SESSION_LIST:
+                case ACP_METHODS.SESSION_LIST_CAMEL:
+                case ACP_METHODS.SESSION_LIST_ALIAS: {
+                    const cwd = typeof params.cwd === "string" ? params.cwd : undefined;
+                    const sessions = this.sessionManager.listSessions(cwd);
+                    if (!isNotification) {
+                        this.sendSuccess(id, { sessions });
+                    }
+                    break;
+                }
+                case ACP_METHODS.SESSION_FORK:
+                case ACP_METHODS.SESSION_FORK_ALIAS: {
+                    const sourceSessionId = String(params.sessionId || "");
+                    const cwd = typeof params.cwd === "string" ? params.cwd : undefined;
+                    const sourceSession = sourceSessionId ? this.sessionManager.getSession(sourceSessionId) : undefined;
+                    const newSession = this.sessionManager.createSession({
+                        cwd: cwd || sourceSession?.cwd,
+                        model: sourceSession?.model,
+                        effort: sourceSession?.effort,
+                        mode: sourceSession?.mode,
+                        permission: sourceSession?.permission,
+                        conversationId: sourceSession?.process.currentConversationId,
+                        binaryPath: this.binaryPath,
+                    });
+                    if (sourceSession?.title) {
+                        newSession.setTitle(`${sourceSession.title} (fork)`);
+                    }
+                    if (!isNotification) {
+                        this.sendSuccess(id, await this.sessionState(newSession));
+                        this.publishCommands(newSession.id);
+                        this.publishUsageUpdate(newSession);
+                    }
+                    break;
+                }
                 case ACP_METHODS.SESSION_PROMPT:
                 case ACP_METHODS.SESSION_PROMPT_ALIAS: {
                     const sessionId = String(params.sessionId || "");
@@ -331,6 +457,9 @@ export class ACPServer {
                     try {
                         session.touch();
                         const promptText = extractPromptText(params.prompt);
+                        if (!session.title && promptText) {
+                            session.setTitle(promptText.slice(0, 80).replace(/\r?\n/g, " ").trim());
+                        }
                         logger.info("Processing ACP prompt", {
                             sessionId,
                             promptLength: promptText.length,
@@ -444,31 +573,38 @@ export class ACPServer {
                             if (step.usage) {
                                 const inputTokens = step.usage.input_tokens ?? 0;
                                 const outputTokens = step.usage.output_tokens ?? 0;
-                                if (inputTokens > 0) {
-                                    latestStepContextTokens = inputTokens + outputTokens;
-                                }
-                                const turnCost = calculateUsageCostUsd(executingModel, inputTokens, outputTokens, step.usage.cache_read_tokens || 0);
                                 const cachedReadTokens = step.usage.cache_read_tokens ?? 0;
+                                if (inputTokens > 0 || cachedReadTokens > 0) {
+                                    latestStepContextTokens = inputTokens + cachedReadTokens + outputTokens;
+                                }
+                                const turnCost = calculateUsageCostUsd(executingModel, inputTokens, outputTokens, cachedReadTokens);
                                 const thoughtTokens = step.usage.thinking_tokens;
-                                const totalTokens = step.usage.total_tokens ?? (inputTokens + outputTokens);
                                 const totalCostUsd = roundUsageCostUsd(session.usage.totalCostUsd + turnCost);
                                 const contextWindowMaxTokens = getModelContextWindow(executingModel);
-                                const contextWindowUsedTokens = Math.min(inputTokens + outputTokens, contextWindowMaxTokens);
+                                const stepContextUsed = Math.min(latestStepContextTokens ?? (inputTokens + cachedReadTokens + outputTokens), contextWindowMaxTokens);
+                                session.usage.contextWindowUsedTokens = stepContextUsed;
+                                const cumulativeInputTokens = session.usage.inputTokens + inputTokens;
+                                const cumulativeOutputTokens = session.usage.outputTokens + outputTokens;
+                                const cumulativeCachedTokens = session.usage.cachedInputTokens + cachedReadTokens;
+                                const cumulativeTotalTokens = cumulativeInputTokens + cumulativeOutputTokens;
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
                                         sessionUpdate: "usage_update",
                                         size: contextWindowMaxTokens,
-                                        used: contextWindowUsedTokens,
+                                        used: stepContextUsed,
                                         cost: { amount: totalCostUsd, currency: "USD" },
-                                        inputTokens,
-                                        outputTokens,
-                                        cachedReadTokens,
+                                        inputTokens: cumulativeInputTokens,
+                                        outputTokens: cumulativeOutputTokens,
+                                        cachedReadTokens: cumulativeCachedTokens,
+                                        cachedInputTokens: cumulativeCachedTokens,
                                         ...(thoughtTokens !== undefined ? { thoughtTokens } : {}),
-                                        totalTokens,
+                                        totalTokens: cumulativeTotalTokens,
                                         totalCostUsd,
                                         contextWindowMaxTokens,
-                                        contextWindowUsedTokens,
+                                        contextWindowUsedTokens: stepContextUsed,
+                                        stepInputTokens: inputTokens,
+                                        stepOutputTokens: outputTokens,
                                     },
                                 });
                             }

package/dist/antigravity-process.d.ts

@@ -1,3 +1,4 @@
+import { ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { AgyInitEvent, AgyStepUpdateEvent, AgyResultEvent } from "./protocol.js";
 import { PermissionSettings } from "./permissions.js";
@@ -15,6 +16,12 @@ export interface AntigravityProcessOptions {
     permissions?: PermissionSettings;
     env?: Record<string, string>;
 }
+interface ActiveTurn {
+    child: ChildProcess | null;
+    cancelled: boolean;
+    resolve: (result: AgyResultEvent) => void;
+    reject: (err: Error) => void;
+}
 export declare class AntigravityProcess extends EventEmitter {
     private child;
     private binaryPath;
@@ -51,8 +58,10 @@ export declare class AntigravityProcess extends EventEmitter {
     private applyPendingRestart;
     start(): Promise<void>;
     private handleEvent;
-    ensureReady(expectedConversationId?: string, timeoutMs?: number): Promise<void>;
+    ensureReady(expectedConversationId?: string, timeoutMs?: number, forTurn?: ActiveTurn, allowAutoHeal?: boolean): Promise<void>;
+    private ensureReadyInternal;
     sendPrompt(text: string, onStepUpdate?: (event: AgyStepUpdateEvent) => void): Promise<AgyResultEvent>;
     cancelCurrentTurn(): boolean;
     close(): Promise<void>;
 }
+export {};

package/dist/antigravity-process.js

@@ -400,6 +400,7 @@ export class AntigravityProcess extends EventEmitter {
         let stdoutBuffer = "";
         let stderrBuffer = "";
         child.stdout.on("data", (chunk) => {
+            this.emit("activity");
             stdoutBuffer += chunk;
             const lines = stdoutBuffer.split("\n");
             stdoutBuffer = lines.pop() || "";
@@ -453,6 +454,7 @@ export class AntigravityProcess extends EventEmitter {
             }
             else if (this.child === child) {
                 this.child = null;
+                this.initialInfo = null;
             }
             this.emit("exit", { code, signal, pid: child.pid });
         });
@@ -485,27 +487,49 @@ export class AntigravityProcess extends EventEmitter {
                 break;
             }
             case "result": {
-                if (!ownsTurn || !this.currentTurnPromise)
-                    break;
                 const resultEvent = event;
                 if (resultEvent.result?.conversation_id) {
                     this.conversationId = resultEvent.result.conversation_id;
                 }
-                this.emit("result", resultEvent);
-                const active = this.currentTurnPromise;
-                this.currentTurnPromise = null;
-                active.resolve(resultEvent);
+                if (ownsProcess) {
+                    this.emit("result", resultEvent);
+                }
+                if (ownsTurn && this.currentTurnPromise) {
+                    const active = this.currentTurnPromise;
+                    this.currentTurnPromise = null;
+                    active.resolve(resultEvent);
+                }
                 break;
             }
             default:
                 logger.warn("Unknown agy event received", { raw: event });
         }
     }
-    async ensureReady(expectedConversationId, timeoutMs = 10_000) {
-        if (this.currentTurnPromise) {
-            throw new Error("Cannot validate an Antigravity session while a prompt turn is active");
+    async ensureReady(expectedConversationId, timeoutMs = 15_000, forTurn, allowAutoHeal = true) {
+        try {
+            await this.ensureReadyInternal(expectedConversationId, timeoutMs, forTurn);
+        }
+        catch (err) {
+            if (allowAutoHeal && this.conversationId) {
+                logger.warn("Failed to start/resume agy process with conversation ID; auto-healing by clearing conversation ID and starting fresh", { conversationId: this.conversationId, error: err.message });
+                const failedChild = this.child;
+                this.conversationId = undefined;
+                this.initialInfo = null;
+                if (failedChild) {
+                    await this.terminateChild(failedChild).catch(() => { });
+                }
+                await this.ensureReadyInternal(undefined, timeoutMs, forTurn);
+                this.emit("conversation_healed", { previousConversationId: expectedConversationId });
+                return;
+            }
+            throw err;
         }
-        await this.applyPendingRestart();
+    }
+    async ensureReadyInternal(expectedConversationId, timeoutMs = 15_000, forTurn) {
+        if (this.currentTurnPromise && this.currentTurnPromise !== forTurn) {
+            throw new Error("Cannot validate an Antigravity session while another prompt turn is active");
+        }
+        await this.applyPendingRestart(forTurn);
         if (!this.isRunning)
             await this.start();
         const child = this.child;
@@ -524,8 +548,10 @@ export class AntigravityProcess extends EventEmitter {
             let settled = false;
             const cleanup = () => {
                 this.off("init", onInit);
+                this.off("result", onResult);
                 child.off("error", onError);
                 child.off("close", onClose);
+                child.off("exit", onExit);
                 clearTimeout(timer);
             };
             const finishReject = (err) => {
@@ -557,8 +583,16 @@ export class AntigravityProcess extends EventEmitter {
                 }
                 finishResolve();
             };
+            const onResult = (event) => {
+                if (this.child !== child)
+                    return;
+                if (event.result?.status === "ERROR") {
+                    finishReject(new Error(event.result.error || "Antigravity failed before initialization"));
+                }
+            };
             const onError = (err) => finishReject(err);
             const onClose = (code, signal) => finishReject(new Error(`Antigravity exited before initialization: code=${code} signal=${signal}`));
+            const onExit = (code, signal) => finishReject(new Error(`Antigravity exited before initialization: code=${code} signal=${signal}`));
             const timer = setTimeout(() => {
                 if (settled)
                     return;
@@ -571,8 +605,10 @@ export class AntigravityProcess extends EventEmitter {
                 });
             }, timeoutMs);
             this.on("init", onInit);
+            this.on("result", onResult);
             child.once("error", onError);
             child.once("close", onClose);
+            child.once("exit", onExit);
             if (this.initialInfo !== null) {
                 onInit({
                     event: "init",
@@ -602,49 +638,88 @@ export class AntigravityProcess extends EventEmitter {
         // turn while the child is still starting or restarting.
         this.currentTurnPromise = active;
         let stepListener = null;
-        const failBeforeWrite = (err) => {
-            if (stepListener)
+        let activityListener = null;
+        let inactivityTimer = null;
+        const turnTimeoutMs = Number(process.env.AGY_ACP_TURN_TIMEOUT_MS) > 0
+            ? Number(process.env.AGY_ACP_TURN_TIMEOUT_MS)
+            : 15 * 60 * 1000; // 15 minutes default turn inactivity timeout
+        const resetInactivityTimer = () => {
+            if (inactivityTimer)
+                clearTimeout(inactivityTimer);
+            inactivityTimer = setTimeout(() => {
+                logger.error("Turn timed out due to lack of activity from agy", {
+                    timeoutMs: turnTimeoutMs,
+                    conversationId: this.conversationId,
+                });
+                if (active.child) {
+                    const childToKill = active.child;
+                    this.signalProcessTree(childToKill, "SIGINT");
+                    setTimeout(() => {
+                        if (this.isProcessTreeAlive(childToKill)) {
+                            this.signalProcessTree(childToKill, "SIGKILL");
+                        }
+                    }, 3000);
+                }
+                cleanupAndSettle(() => active.reject(new Error(`Turn timed out after ${turnTimeoutMs / 1000}s of inactivity`)));
+            }, turnTimeoutMs);
+        };
+        const cleanupAndSettle = (settleFn) => {
+            if (inactivityTimer) {
+                clearTimeout(inactivityTimer);
+                inactivityTimer = null;
+            }
+            if (stepListener) {
                 this.off("step_update", stepListener);
-            if (this.currentTurnPromise === active)
+                stepListener = null;
+            }
+            if (activityListener) {
+                this.off("activity", activityListener);
+                activityListener = null;
+            }
+            if (this.currentTurnPromise === active) {
                 this.currentTurnPromise = null;
-            active.reject(err);
+            }
+            settleFn();
         };
         try {
             await this.applyPendingRestart(active);
             if (active.cancelled) {
-                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                cleanupAndSettle(() => active.reject(new Error("Prompt turn cancelled before execution")));
                 return turnPromise;
             }
-            if (!this.isRunning)
-                await this.start();
+            // Synchronize readiness & auto-heal if conversation resume was broken
+            await this.ensureReady(this.conversationId, 15_000, active, true);
             if (active.cancelled) {
-                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                cleanupAndSettle(() => active.reject(new Error("Prompt turn cancelled before execution")));
                 return turnPromise;
             }
             const child = this.child;
             if (!child || !child.stdin || !child.stdin.writable) {
-                failBeforeWrite(new Error("Cannot send prompt: agy process stdin is not writable"));
+                cleanupAndSettle(() => active.reject(new Error("Cannot send prompt: agy process stdin is not writable")));
                 return turnPromise;
             }
             active.child = child;
+            const origResolve = active.resolve;
+            const origReject = active.reject;
+            active.resolve = (result) => {
+                cleanupAndSettle(() => origResolve(result));
+            };
+            active.reject = (err) => {
+                cleanupAndSettle(() => origReject(err));
+            };
             if (onStepUpdate) {
-                stepListener = onStepUpdate;
-                this.on("step_update", stepListener);
-                const originalResolve = active.resolve;
-                const originalReject = active.reject;
-                active.resolve = (result) => {
-                    if (stepListener)
-                        this.off("step_update", stepListener);
-                    originalResolve(result);
-                };
-                active.reject = (err) => {
-                    if (stepListener)
-                        this.off("step_update", stepListener);
-                    originalReject(err);
+                stepListener = (event) => {
+                    resetInactivityTimer();
+                    onStepUpdate(event);
                 };
+                this.on("step_update", stepListener);
             }
+            activityListener = () => resetInactivityTimer();
+            this.on("activity", activityListener);
+            // Start initial inactivity timer
+            resetInactivityTimer();
             if (active.cancelled) {
-                failBeforeWrite(new Error("Prompt turn cancelled before execution"));
+                cleanupAndSettle(() => active.reject(new Error("Prompt turn cancelled before execution")));
                 return turnPromise;
             }
             const payload = {
@@ -655,7 +730,7 @@ export class AntigravityProcess extends EventEmitter {
             child.stdin.write(JSON.stringify(payload) + "\n");
         }
         catch (err) {
-            failBeforeWrite(err);
+            cleanupAndSettle(() => active.reject(err));
         }
         return turnPromise;
     }
@@ -665,8 +740,26 @@ export class AntigravityProcess extends EventEmitter {
             return false;
         active.cancelled = true;
         logger.info("Cancelling active agy turn", { hasChild: Boolean(active.child) });
-        if (active.child)
-            this.signalProcessTree(active.child, "SIGINT");
+        if (active.child) {
+            const child = active.child;
+            this.signalProcessTree(child, "SIGINT");
+            setTimeout(() => {
+                if (this.isProcessTreeAlive(child)) {
+                    logger.warn("agy process did not exit after SIGINT cancellation; sending SIGTERM", {
+                        pid: child.pid,
+                    });
+                    this.signalProcessTree(child, "SIGTERM");
+                    setTimeout(() => {
+                        if (this.isProcessTreeAlive(child)) {
+                            logger.warn("agy process did not exit after SIGTERM; sending SIGKILL", {
+                                pid: child.pid,
+                            });
+                            this.signalProcessTree(child, "SIGKILL");
+                        }
+                    }, 1500);
+                }
+            }, 3000);
+        }
         return true;
     }
     async close() {

package/dist/index.js

@@ -160,7 +160,7 @@ if (args.includes("doctor") || args.includes("--doctor")) {
             process.stdout.write("      Then launch Paseo again.\n");
         }
         else {
-            process.stdout.write("      Tip: Run 'paseo daemon restart' or close the Paseo app to reload.\n");
+            process.stdout.write("      Tip: Run 'paseo restart' or close the Paseo app/daemon to reload with updated patches.\n");
         }
     }
     else {
@@ -238,11 +238,15 @@ if (args.includes("setup") ||
                 process.stdout.write("Paseo is already up-to-date and configured for Antigravity telemetry.\n");
             }
             if (isPaseoRunning()) {
+                const isWin = process.platform === "win32";
                 process.stdout.write(`\n⚠️  IMPORTANT: Paseo is currently running in the background!\n` +
-                    `   Windows caches running executables in memory, so changes will only take effect after restarting Paseo.\n` +
-                    `   In PowerShell, run:\n` +
-                    `     Stop-Process -Name "Paseo" -Force -ErrorAction SilentlyContinue\n` +
-                    `   Then launch Paseo again.\n\n`);
+                    (isWin
+                        ? `   Windows caches running executables in memory, so changes will only take effect after restarting Paseo.\n` +
+                            `   In PowerShell, run:\n` +
+                            `     Stop-Process -Name "Paseo" -Force -ErrorAction SilentlyContinue\n` +
+                            `   Then launch Paseo again.\n\n`
+                        : `   Changes will only take effect after restarting the Paseo daemon/app.\n` +
+                            `   Run 'paseo restart' or close the Paseo app to reload.\n\n`));
             }
             else {
                 process.stdout.write(`Please start Paseo to apply changes.\n\n`);
@@ -262,6 +266,19 @@ void ensurePaseoIntegration().catch(() => { });
 const skipNarration = args.includes("--skip-naration") ||
     args.includes("--skip-narration") ||
     process.env.AGY_ACP_SKIP_NARRATION === "true";
+process.on("uncaughtException", (err) => {
+    if (err.code === "EPIPE") {
+        logger.debug("Suppressed EPIPE in uncaughtException");
+        return;
+    }
+    logger.error("Uncaught exception in agy-acp process", { error: err.message, stack: err.stack });
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled rejection in agy-acp process", {
+        reason: reason instanceof Error ? reason.message : String(reason),
+        stack: reason instanceof Error ? reason.stack : undefined,
+    });
+});
 const server = new ACPServer({ skipNarration });
 const cleanup = async () => {
     try {
@@ -275,4 +292,7 @@ const cleanup = async () => {
 };
 process.on("SIGINT", cleanup);
 process.on("SIGTERM", cleanup);
+server.on("close", () => {
+    process.exit(0);
+});
 server.start();