opencode-plugin-teleprompt 0.1.4 → 0.2.0

package/dist/runtime/controller.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { getCurrentSessionID } from "../opencode/binding.js";
+import { appendFileSync } from "node:fs";
+import { getCurrentOrCreateSessionID } from "../opencode/binding.js";
 import { replyPermission, toPendingPermission, formatPermissionRequestMessage } from "../opencode/permissions.js";
 import { createTelegramUserMessageID, submitPrompt } from "../opencode/submit.js";
 import { formatSummaryForTelegram } from "../summary/format.js";
@@ -10,12 +11,12 @@ import { TelegramApi } from "../telegram/api.js";
 import { TelegramPoller } from "../telegram/poller.js";
 import { SessionEventStream } from "../opencode/events.js";
 import { createShutdownGuard } from "./shutdown.js";
+import { PLUGIN_VERSION } from "../version.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_DEPS = {
     now: () => Date.now(),
     randomID: () => `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
 };
-const BRIDGE_USER_MESSAGE_GRACE_MS = 10_000;
 function formatAgeMs(ms) {
     if (ms < 1000)
         return `${ms}ms`;
@@ -119,6 +120,7 @@ function resolvePresetModel(preset, models) {
 export class BridgeController {
     api;
     config;
+    storePath;
     deps;
     instanceID;
     client;
@@ -135,9 +137,12 @@ export class BridgeController {
     processingQueue = false;
     lastEscAt = 0;
     sessionCredentials;
+    activePromptCheckInFlight = false;
+    completionInFlight = false;
     constructor(api, config, storePath, deps) {
         this.api = api;
         this.config = config;
+        this.storePath = storePath;
         this.deps = { ...DEFAULT_DEPS, ...deps };
         this.instanceID = this.deps.randomID();
         this.client = api.client;
@@ -145,6 +150,16 @@ export class BridgeController {
         this.store = new BridgeStore(storePath, config.channelID ?? "");
         this.lease = new LeaseManager(this.instanceID, this.deps.now, config.leaseTtlMs);
     }
+    log(message) {
+        try {
+            const logPath = this.storePath.replace(/\.json$/, ".log");
+            const timestamp = new Date().toISOString();
+            appendFileSync(logPath, `[${timestamp}] ${message}\n`, "utf8");
+        }
+        catch {
+            // ignore
+        }
+    }
     async init() {
         this.data = await this.store.load();
     }
@@ -155,17 +170,26 @@ export class BridgeController {
         this.config.botToken = resolvedCredentials.botToken;
         this.config.channelID = resolvedCredentials.channelID;
         this.store.setChannelID(resolvedCredentials.channelID);
-        const sessionID = getCurrentSessionID(this.api);
+        this.log(`bindCurrent: api.route.current = ${JSON.stringify(this.api.route.current)}`);
+        try {
+            const listResponse = await this.client.session.list({ directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+            const sessions = Array.isArray(listResponse) ? listResponse : (listResponse?.sessions || listResponse?.items || listResponse?.data || []);
+            this.log(`bindCurrent: available sessions: ${JSON.stringify(sessions.map((s) => ({ id: s.id, title: s.title })))}`);
+        }
+        catch (e) {
+            this.log(`bindCurrent: failed to list sessions: ${String(e)}`);
+        }
+        const sessionID = await getCurrentOrCreateSessionID(this.api, this.client);
+        this.log(`bindCurrent: getCurrentOrCreateSessionID returned ${sessionID}`);
         const state = await this.syncState();
         const claimed = this.lease.claim(state);
-        claimed.bound.sessionID = sessionID;
-        claimed.bound.status = "online";
-        claimed.bound.model = undefined;
-        claimed.bound.channelID = resolvedCredentials.channelID;
-        await this.persist(claimed);
+        const next = this.resetBoundSessionState(claimed, sessionID, resolvedCredentials.channelID);
+        await this.persist(next);
+        await this.skipTelegramBacklog();
         this.startHeartbeat();
         await this.startEventStream(sessionID);
         this.startPolling();
+        await this.clearTuiPrompt();
         if (this.config.onlineNotice) {
             await this.getTelegramApi().sendMessage(this.requireChannelID(), `OpenCode Telegram bridge online.\nsession_id: ${sessionID}`);
         }
@@ -222,10 +246,12 @@ export class BridgeController {
         return lines.join("\n");
     }
     async handleTelegramCommand(command) {
+        this.log(`handleTelegramCommand: kind=${command.command.kind}, updateID=${command.updateID}, messageID=${command.messageID}`);
         const state = await this.syncState();
         const isOwner = this.lease.isOwner(state);
-        const alwaysAllowed = new Set(["status", "who", "health", "reclaim"]);
+        const alwaysAllowed = new Set(["status", "who", "health", "reclaim", "version"]);
         if (!isOwner && !alwaysAllowed.has(command.command.kind)) {
+            this.log(`handleTelegramCommand: rejected because not owner (isOwner=${isOwner}, kind=${command.command.kind})`);
             await this.telegram.sendMessage(this.config.channelID, "Bridge is currently owned by another OpenCode instance. Use /tp:reclaim first.", { replyToMessageID: command.messageID });
             return;
         }
@@ -233,6 +259,10 @@ export class BridgeController {
             await this.telegram.sendMessage(this.config.channelID, await this.statusLine(), { replyToMessageID: command.messageID });
             return;
         }
+        if (command.command.kind === "version") {
+            await this.telegram.sendMessage(this.config.channelID, this.versionLine(), { replyToMessageID: command.messageID });
+            return;
+        }
         if (command.command.kind === "disconnect") {
             const state = await this.requireState();
             if (state.bound.status !== "online") {
@@ -304,9 +334,11 @@ export class BridgeController {
             return;
         }
         if (state.bound.status !== "online" || !state.bound.sessionID) {
+            this.log(`handleTelegramCommand: rejected because offline or missing session ID (status=${state.bound.status}, sessionID=${state.bound.sessionID})`);
             await this.telegram.sendMessage(this.config.channelID, "Bridge is offline. Run /tp:start in OpenCode first.", { replyToMessageID: command.messageID });
             return;
         }
+        this.log(`handleTelegramCommand: accepting prompt, sending accepted to Telegram`);
         await this.telegram.sendMessage(this.config.channelID, "accepted", { replyToMessageID: command.messageID });
         const job = {
             telegramUpdateID: command.updateID,
@@ -359,12 +391,20 @@ export class BridgeController {
         const startWithCredentials = this.parseStartWithCredentials(command);
         if (startWithCredentials) {
             const sessionID = await this.bindCurrent(startWithCredentials);
+            await this.clearTuiPrompt();
             this.api.ui.toast({
                 variant: "success",
                 message: `Telegram bridge bound to session ${sessionID}`,
             });
             return;
         }
+        if (this.isVersionCommand(command)) {
+            this.api.ui.toast({
+                variant: "info",
+                message: this.versionLine(),
+            });
+            return;
+        }
         const credentialOnly = this.parseCredentialCommand(command);
         if (credentialOnly) {
             this.sessionCredentials = credentialOnly;
@@ -402,19 +442,32 @@ export class BridgeController {
         });
     }
     async processPromptQueue() {
-        if (this.processingQueue)
+        if (this.processingQueue) {
+            this.log("processPromptQueue: queue processing already in progress");
             return;
+        }
         this.processingQueue = true;
+        this.log("processPromptQueue: started processing queue");
         try {
             while (true) {
                 const state = await this.syncState();
-                if (!this.lease.isOwner(state))
+                if (!this.lease.isOwner(state)) {
+                    this.log(`processPromptQueue: stopped - not owner of lease`);
                     return;
-                if (state.activePrompt || state.promptQueue.length === 0)
+                }
+                if (state.activePrompt) {
+                    this.log(`processPromptQueue: stopped - another prompt is active (activePromptID=${state.activePrompt.userMessageID})`);
                     return;
+                }
+                if (state.promptQueue.length === 0) {
+                    this.log(`processPromptQueue: queue is empty`);
+                    return;
+                }
                 const job = state.promptQueue[0];
-                if (!state.bound.sessionID)
+                if (!state.bound.sessionID) {
+                    this.log(`processPromptQueue: error - missing sessionID in state`);
                     return;
+                }
                 const startedAt = this.deps.now();
                 const activeJob = {
                     ...job,
@@ -426,11 +479,20 @@ export class BridgeController {
                     promptQueue: state.promptQueue.slice(1),
                 };
                 await this.persist(next);
-                await this.telegram.sendMessage(this.config.channelID, "running", { replyToMessageID: activeJob.telegramMessageID });
+                this.log(`processPromptQueue: activeJob set to userMessageID=${activeJob.userMessageID}`);
+                this.api.ui.toast({
+                    variant: "info",
+                    message: `Teleprompt: sending prompt to session ${state.bound.sessionID}...`,
+                });
                 try {
-                    await submitPrompt(this.client, state.bound.sessionID, job.prompt, job.telegramUpdateID, state.bound.model);
+                    this.log(`processPromptQueue: submitting to client: prompt="${job.prompt}"`);
+                    const submitted = await submitPrompt(this.client, state.bound.sessionID, job.prompt, job.telegramUpdateID, this.api.state.path.directory, state.bound.model);
+                    this.log(`processPromptQueue: submitted successfully. userMessageID=${submitted.userMessageID}, assistantMessageID=${submitted.assistantMessageID}. Waiting for completion...`);
+                    await this.waitForPromptCompletion(state.bound.sessionID, submitted.userMessageID, submitted.assistantMessageID);
+                    this.log(`processPromptQueue: completed successfully`);
                 }
                 catch (error) {
+                    this.log(`processPromptQueue: execution failed: ${String(error)}`);
                     const latest = await this.requireState();
                     if (latest.activePrompt?.userMessageID === activeJob.userMessageID) {
                         await this.persist(this.appendPromptHistory({
@@ -451,36 +513,52 @@ export class BridgeController {
         }
         finally {
             this.processingQueue = false;
+            this.log("processPromptQueue: finished processing queue");
         }
     }
-    async onAssistantCompleted(sessionID, assistantMessageID, parentUserMessageID) {
-        const state = await this.syncState();
-        if (!this.lease.isOwner(state))
-            return;
-        if (!state.activePrompt)
-            return;
-        if (state.activePrompt.userMessageID !== parentUserMessageID)
-            return;
-        if (state.bound.sessionID !== sessionID)
+    async onAssistantCompleted(_sessionID, _assistantMessageID, _parentUserMessageID) {
+        // Intentionally a no-op. Completion is handled by waitForPromptCompletion
+        // polling. The event stream fires for EVERY completed assistant message,
+        // including intermediate ones during the agent tool-call loop, so reacting
+        // here would prematurely abort the agent before the final answer arrives.
+    }
+    async completeActivePrompt(sessionID, assistantMessageID, diffMessageID, directParts) {
+        // Guard against duplicate completion from event stream + polling race
+        if (this.completionInFlight)
             return;
-        const summary = await this.buildSummary(sessionID, assistantMessageID, state.activePrompt.userMessageID);
-        const completedAt = this.deps.now();
-        const elapsed = completedAt - (state.activePrompt.startedAt ?? state.activePrompt.createdAt);
-        const message = formatSummaryForTelegram(summary, this.config.summaryMaxChars);
-        await this.telegram.sendMessage(this.config.channelID, `completed in ${formatAgeMs(Math.max(0, elapsed))}`, { replyToMessageID: state.activePrompt.telegramMessageID });
-        await this.telegram.sendMessage(this.config.channelID, message, { replyToMessageID: state.activePrompt.telegramMessageID });
-        await this.persist(this.appendPromptHistory({
-            ...state,
-            activePrompt: undefined,
-        }, {
-            jobID: state.activePrompt.userMessageID,
-            prompt: state.activePrompt.prompt,
-            summary: summary.text,
-            changedFiles: summary.changedFiles,
-            status: "completed",
-            at: completedAt,
-        }));
-        await this.processPromptQueue();
+        this.completionInFlight = true;
+        try {
+            const state = await this.syncState();
+            if (!this.lease.isOwner(state))
+                return;
+            if (!state.activePrompt)
+                return;
+            if (state.bound.sessionID !== sessionID)
+                return;
+            // Removed session.abort() because we want the agent to finish its turn naturally,
+            // avoiding "interrupted" UI states.
+            const summary = await this.buildSummary(sessionID, assistantMessageID, diffMessageID, directParts);
+            const completedAt = this.deps.now();
+            const elapsed = completedAt - (state.activePrompt.startedAt ?? state.activePrompt.createdAt);
+            const resultText = formatSummaryForTelegram(summary, this.config.summaryMaxChars);
+            const combinedMessage = `✅ completed in ${formatAgeMs(Math.max(0, elapsed))}\n\n${resultText}`;
+            await this.telegram.sendMessage(this.config.channelID, combinedMessage, { replyToMessageID: state.activePrompt.telegramMessageID });
+            await this.persist(this.appendPromptHistory({
+                ...state,
+                activePrompt: undefined,
+            }, {
+                jobID: state.activePrompt.userMessageID,
+                prompt: state.activePrompt.prompt,
+                summary: summary.text,
+                changedFiles: summary.changedFiles,
+                status: "completed",
+                at: completedAt,
+            }));
+            await this.processPromptQueue();
+        }
+        finally {
+            this.completionInFlight = false;
+        }
     }
     async onUserMessage(sessionID, userMessageID) {
         const state = await this.syncState();
@@ -490,18 +568,12 @@ export class BridgeController {
             return;
         if (state.bound.sessionID !== sessionID)
             return;
-        if (userMessageID.startsWith("tg-"))
+        if (userMessageID.startsWith("msg_tg_"))
             return;
-        const activeStartedAt = state.activePrompt?.startedAt ?? state.activePrompt?.createdAt;
-        if (activeStartedAt && this.deps.now() - activeStartedAt < BRIDGE_USER_MESSAGE_GRACE_MS) {
+        if (state.activePrompt)
             return;
-        }
-        try {
-            await this.client.session.abort({ sessionID });
-        }
-        catch { }
         try {
-            await this.client.session.deleteMessage({ sessionID, messageID: userMessageID });
+            await this.client.session.abort({ sessionID, directory: this.api.state.path.directory });
         }
         catch { }
         this.api.ui.toast({
@@ -539,7 +611,7 @@ export class BridgeController {
             await this.telegram.sendMessage(this.config.channelID, `Permission request not found: ${requestID}`, replyToMessageID ? { replyToMessageID } : undefined);
             return;
         }
-        await replyPermission(this.client, requestID, action);
+        await replyPermission(this.client, pending.sessionID, requestID, action);
         const { [requestID]: _removed, ...rest } = state.pendingPermissions;
         await this.persist({
             ...state,
@@ -598,7 +670,10 @@ export class BridgeController {
     }
     async fetchAvailableModels() {
         try {
-            const response = await this.client.config.providers({}, { responseStyle: "data", throwOnError: true });
+            const response = await this.client.config.providers({
+                responseStyle: "data",
+                throwOnError: true,
+            });
             const providers = response?.providers;
             if (!Array.isArray(providers))
                 return [];
@@ -627,8 +702,8 @@ export class BridgeController {
             return [];
         }
     }
-    async buildSummary(sessionID, assistantMessageID, userMessageID) {
-        const parts = this.api.state.part(assistantMessageID);
+    async buildSummary(sessionID, assistantMessageID, userMessageID, directParts) {
+        const parts = directParts ?? this.api.state.part(assistantMessageID);
         const text = parts
             .filter((part) => {
             return part.type === "text" && typeof part.text === "string";
@@ -638,11 +713,8 @@ export class BridgeController {
             .trim();
         let changedFiles = [];
         try {
-            const diffResponse = await this.client.session.diff({
-                sessionID,
-                messageID: userMessageID,
-            }, { responseStyle: "data", throwOnError: true });
-            const diff = diffResponse.diff;
+            const diffResponse = await this.client.session.message({ sessionID, messageID: userMessageID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+            const diff = diffResponse?.diff;
             changedFiles = (diff || []).map((item) => item.file);
         }
         catch {
@@ -785,7 +857,7 @@ export class BridgeController {
             return;
         }
         try {
-            await this.client.session.summarize({ sessionID: state.bound.sessionID }, { responseStyle: "data", throwOnError: true });
+            await this.client.session.summarize({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
             await this.telegram.sendMessage(this.config.channelID, `Compaction requested for session ${state.bound.sessionID}.`, { replyToMessageID });
         }
         catch (error) {
@@ -799,8 +871,11 @@ export class BridgeController {
             return;
         }
         try {
-            const response = await this.client.session.create({}, { responseStyle: "data", throwOnError: true });
-            const nextSessionID = response?.session?.id ?? response?.id;
+            const response = await this.client.session.create({
+                responseStyle: "data",
+                throwOnError: true,
+            });
+            const nextSessionID = response?.id ?? response?.session?.id;
             if (!nextSessionID || typeof nextSessionID !== "string") {
                 throw new Error("Could not resolve new session id.");
             }
@@ -906,7 +981,7 @@ export class BridgeController {
             return;
         }
         try {
-            await this.client.session.abort({ sessionID: state.bound.sessionID });
+            await this.client.session.abort({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory });
             const latest = await this.requireState();
             if (latest.activePrompt?.userMessageID === state.activePrompt.userMessageID) {
                 await this.persist(this.appendPromptHistory({
@@ -980,8 +1055,8 @@ export class BridgeController {
         if (!sessionID)
             return undefined;
         try {
-            const response = await this.client.session.get({ sessionID }, { responseStyle: "data", throwOnError: true });
-            const title = response?.session?.title;
+            const response = await this.client.session.get({ sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+            const title = response?.title ?? response?.session?.title;
             if (typeof title === "string" && title.trim().length > 0)
                 return title.trim();
             return undefined;
@@ -992,18 +1067,9 @@ export class BridgeController {
     }
     async switchBoundSession(sessionID) {
         const state = await this.syncState();
-        const next = {
-            ...state,
-            bound: {
-                ...state.bound,
-                sessionID,
-                status: "online",
-            },
-            activePrompt: undefined,
-            promptQueue: [],
-            pendingPermissions: {},
-        };
+        const next = this.resetBoundSessionState(state, sessionID, state.bound.channelID || this.requireChannelID());
         await this.persist(next);
+        await this.skipTelegramBacklog();
         await this.startEventStream(sessionID);
     }
     startHeartbeat() {
@@ -1013,7 +1079,9 @@ export class BridgeController {
                 const state = await this.syncState();
                 if (!this.lease.isOwner(state))
                     return;
-                await this.persist(this.lease.refresh(state));
+                const refreshed = this.lease.refresh(state);
+                await this.persist(refreshed);
+                await this.reconcileActivePrompt(refreshed);
             }
             catch (error) {
                 this.api.ui.toast({
@@ -1042,6 +1110,12 @@ export class BridgeController {
                     return;
                 await this.persist({ ...state, pollingOffset: offset });
             },
+            onUpdates: (count) => {
+                this.api.ui.toast({
+                    variant: "info",
+                    message: `Teleprompt: received ${count} Telegram updates`,
+                });
+            },
             onError: (error) => {
                 this.api.ui.toast({
                     variant: "warning",
@@ -1139,6 +1213,13 @@ export class BridgeController {
         }
         return this.parseCredentialArgs(parts);
     }
+    isVersionCommand(command) {
+        const parts = this.splitCommandArgs(command);
+        return this.isLocalCommand(parts, "version");
+    }
+    versionLine() {
+        return `opencode-plugin-teleprompt ${PLUGIN_VERSION}`;
+    }
     resolveCredentials(credentials) {
         const botToken = credentials?.botToken?.trim()
             || this.sessionCredentials?.botToken?.trim()
@@ -1198,5 +1279,176 @@ export class BridgeController {
         this.data = latest;
         return latest;
     }
+    resetBoundSessionState(state, sessionID, channelID) {
+        return {
+            ...state,
+            bound: {
+                sessionID,
+                channelID,
+                status: "online",
+                model: undefined,
+            },
+            activePrompt: undefined,
+            promptQueue: [],
+            pendingPermissions: {},
+            promptHistory: [],
+            recentPrompts: [],
+        };
+    }
+    async skipTelegramBacklog() {
+        const latestOffset = await this.getTelegramApi().getLatestUpdateOffset();
+        if (latestOffset === undefined)
+            return;
+        const state = await this.requireState();
+        if (latestOffset <= state.pollingOffset)
+            return;
+        await this.persist({
+            ...state,
+            pollingOffset: latestOffset,
+        });
+    }
+    async reconcileActivePrompt(state) {
+        if (this.activePromptCheckInFlight)
+            return;
+        if (!state.activePrompt)
+            return;
+        if (state.bound.status !== "online" || !state.bound.sessionID)
+            return;
+        this.activePromptCheckInFlight = true;
+        try {
+            const response = await this.client.session.messages({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+            const messages = Array.isArray(response) ? response : (response?.messages || response?.items || response?.data || []);
+            const threshold = (state.activePrompt.startedAt ?? state.activePrompt.createdAt) - 1_000;
+            const latestCompletedAssistant = [...messages]
+                .reverse()
+                .find((entry) => {
+                const info = entry?.info;
+                return (info?.role === "assistant"
+                    && typeof info?.id === "string"
+                    && typeof info?.time?.completed === "number"
+                    && info.time.completed >= threshold);
+            });
+            if (!latestCompletedAssistant)
+                return;
+            await this.completeActivePrompt(state.bound.sessionID, latestCompletedAssistant.info.id, state.activePrompt.userMessageID, latestCompletedAssistant.parts);
+        }
+        catch { }
+        finally {
+            this.activePromptCheckInFlight = false;
+        }
+    }
+    async clearTuiPrompt() {
+        try {
+            await this.client.tui.clearPrompt({}, { responseStyle: "data", throwOnError: true });
+        }
+        catch { }
+    }
+    async waitForPromptCompletion(sessionID, userMessageID, _assistantMessageID) {
+        const startedAt = this.deps.now();
+        const timeoutMs = 10 * 60 * 1000;
+        const pollEveryMs = 2000;
+        const stableDelayMs = 3000; // Wait 3s of no new messages before declaring done
+        let lastSeenAssistantID;
+        let stableSince;
+        while (this.deps.now() - startedAt < timeoutMs) {
+            const state = await this.syncState();
+            if (!this.lease.isOwner(state))
+                return;
+            if (state.bound.sessionID !== sessionID)
+                return;
+            if (!state.activePrompt || state.activePrompt.userMessageID !== userMessageID)
+                return;
+            try {
+                // 1. Poll the session status
+                let isIdle = false;
+                try {
+                    const statusResponse = await this.client.session.status({ query: { directory: this.api.state.path.directory } }, { responseStyle: "data", throwOnError: true });
+                    const statusType = statusResponse?.type || statusResponse?.data?.type;
+                    isIdle = statusType === "idle";
+                }
+                catch (statusErr) {
+                    this.log(`waitForPromptCompletion: failed to get session status: ${String(statusErr)}`);
+                }
+                const response = await this.client.session.messages({ sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+                const messages = Array.isArray(response) ? response : (response?.messages || response?.items || response?.data || []);
+                // 2. Find the user message created after we started
+                const userMessage = [...messages]
+                    .reverse()
+                    .find((entry) => {
+                    const info = entry?.info;
+                    if (info?.role !== "user")
+                        return false;
+                    const created = info?.time?.created || 0;
+                    if (created > 0 && created < startedAt - 5000)
+                        return false;
+                    return true;
+                });
+                const actualUserMessageID = userMessage?.info?.id || userMessageID;
+                // Find the LATEST completed assistant message created after we started
+                const completedAssistant = [...messages]
+                    .reverse()
+                    .find((entry) => {
+                    const info = entry?.info;
+                    if (info?.role !== "assistant")
+                        return false;
+                    if (!info?.time?.completed)
+                        return false;
+                    const created = info?.time?.created || 0;
+                    if (created > 0 && created < startedAt - 5000)
+                        return false;
+                    return true;
+                });
+                if (completedAssistant?.info?.id) {
+                    if (completedAssistant.info.error) {
+                        throw new Error(`Assistant error: ${JSON.stringify(completedAssistant.info.error)}`);
+                    }
+                    // If the session status is idle, we can fast-path immediately
+                    if (isIdle) {
+                        this.log(`waitForPromptCompletion: session is idle, fast-path completing`);
+                        await this.completeActivePrompt(sessionID, completedAssistant.info.id, actualUserMessageID, completedAssistant.parts);
+                        return;
+                    }
+                    // Stable-state detection: wait until no NEW assistant messages appear
+                    if (completedAssistant.info.id !== lastSeenAssistantID) {
+                        // New message appeared — reset the stability timer
+                        lastSeenAssistantID = completedAssistant.info.id;
+                        stableSince = this.deps.now();
+                        this.log(`waitForPromptCompletion: new assistant message ${completedAssistant.info.id}, resetting stability timer`);
+                    }
+                    else if (stableSince && (this.deps.now() - stableSince >= stableDelayMs)) {
+                        // Same message for stableDelayMs — model has stopped, we're done
+                        this.log(`waitForPromptCompletion: stable for ${stableDelayMs}ms, completing`);
+                        await this.completeActivePrompt(sessionID, completedAssistant.info.id, actualUserMessageID, completedAssistant.parts);
+                        return;
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.startsWith("Assistant error:")) {
+                    throw err;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollEveryMs));
+        }
+        const state = await this.syncState();
+        if (!this.lease.isOwner(state))
+            return;
+        if (state.bound.sessionID !== sessionID)
+            return;
+        if (state.activePrompt?.userMessageID !== userMessageID)
+            return;
+        await this.telegram.sendMessage(this.config.channelID, "failed: prompt timed out waiting for completion", { replyToMessageID: state.activePrompt.telegramMessageID });
+        await this.persist(this.appendPromptHistory({
+            ...state,
+            activePrompt: undefined,
+        }, {
+            jobID: userMessageID,
+            prompt: state.activePrompt.prompt,
+            summary: "Timed out waiting for assistant completion.",
+            changedFiles: [],
+            status: "failed",
+            at: this.deps.now(),
+        }));
+    }
 }
 //# sourceMappingURL=controller.js.map