@qwen-code/channel-base 0.23.1-preview.1 → 0.23.1

package/dist/ChannelBase.js

@@ -7,8 +7,8 @@ import { DmGate } from './DmGate.js';
 import { GroupHistoryStore } from './group-history-store.js';
 import { SenderGate } from './SenderGate.js';
 import { PairingStore } from './PairingStore.js';
-import { SessionRouter } from './SessionRouter.js';
-import { NamedSessionManager, } from './named-session-manager.js';
+import { SessionRouter, readDaemonHttpErrorCode } from './SessionRouter.js';
+import { NamedSessionManager, NamedSessionTaskError, } from './named-session-manager.js';
 import { getGlobalQwenDir } from './paths.js';
 import { sanitizeSenderName, sanitizeQuotedText, sanitizePromptText, sanitizePromptPath, sanitizeLogText, sanitizeDisplayText, truncateCodePoints, PROMPT_UNSAFE_INVISIBLES, } from './sanitize.js';
 import { ChannelLoopSkippedError } from './ChannelLoopScheduler.js';
@@ -160,14 +160,17 @@ export class ChannelBase {
     bridgeToolCallListener = (event) => {
         this.dispatchToolCall(event);
     };
-    bridgeBackgroundResponseListener = (sessionId, text) => {
-        void this.dispatchBackgroundResponse(sessionId, text).catch((err) => {
+    bridgeBackgroundResponseListener = (sessionId, text, context) => {
+        void this.dispatchBackgroundResponse(sessionId, text, context).catch((err) => {
             process.stderr.write(`[${this.name}] background response delivery failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(err)}\n`);
         });
     };
     bridgeSessionDiedListener = (event) => {
         this.onSessionDied(event.sessionId);
     };
+    bridgeDisconnectedListener = () => {
+        this.onBridgeDisconnected();
+    };
     bridgePermissionRequestListener = (event) => {
         void this.dispatchPermissionRequest(event).catch((err) => {
             process.stderr.write(`[${this.name}] permission relay failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(err)}\n`);
@@ -209,13 +212,19 @@ export class ChannelBase {
         }
         this.onToolCall(chatId, event);
     }
-    async dispatchBackgroundResponse(sessionId, text) {
-        let target = this.router.getTarget(sessionId);
-        if (!target ||
-            target.channelName !== this.name ||
-            text.trim().length === 0) {
+    async dispatchBackgroundResponse(sessionId, text, _context) {
+        if (text.trim().length === 0)
+            return;
+        const delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+        if (!delivery || this.router.getTarget(sessionId) !== delivery.target) {
             return;
         }
+        await this.deliverBackgroundResponseToTarget(sessionId, text, delivery);
+    }
+    async resolveBackgroundResponseDelivery(sessionId) {
+        let target = this.router.getTarget(sessionId);
+        if (!target || target.channelName !== this.name)
+            return undefined;
         let sourceLabel;
         if (this.namedSessions) {
             const presentation = await this.namedSessions.resolvePresentation(sessionId);
@@ -235,6 +244,10 @@ export class ChannelBase {
             target = currentTarget;
             sourceLabel = this.createSourceLabel(presentation, target);
         }
+        return { target, sourceLabel };
+    }
+    async deliverBackgroundResponseToTarget(sessionId, text, delivery) {
+        const { target, sourceLabel } = delivery;
         if (this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
             if (sourceLabel) {
                 await this.pushProactive(target, text, sourceLabel);
@@ -1658,6 +1671,7 @@ export class ChannelBase {
             ]);
             if (!cancelled) {
                 this.cancelBtw(sessionId);
+                this.onSessionRetiring(sessionId);
                 this.router.removeSessionId(sessionId);
                 this.instructedSessions.delete(sessionId);
                 this.unattendedMemorySessions.delete(sessionId);
@@ -1796,10 +1810,19 @@ export class ChannelBase {
         this.unattendedMemorySessions.delete(sessionId);
         this.removePendingPermissionsForSession(sessionId);
     }
+    /**
+     * Called when the standalone ACP bridge process exits. Its in-flight turns
+     * never settle, but crash recovery restores the sessions on a fresh bridge,
+     * so overrides must clear only turn-scoped transient state (never session
+     * routing) and must not fabricate terminal outcomes for interrupted turns.
+     */
+    onBridgeDisconnected() { }
+    onSessionRetiring(_sessionId) { }
     attachBridgeEvents(bridge) {
         bridge.on('toolCall', this.bridgeToolCallListener);
         bridge.on('backgroundResponse', this.bridgeBackgroundResponseListener);
         bridge.on('sessionDied', this.bridgeSessionDiedListener);
+        bridge.on('disconnected', this.bridgeDisconnectedListener);
         bridge.on('permissionRequest', this.bridgePermissionRequestListener);
         bridge.on('permissionResolved', this.bridgePermissionResolvedListener);
     }
@@ -1807,6 +1830,7 @@ export class ChannelBase {
         bridge.off('toolCall', this.bridgeToolCallListener);
         bridge.off('backgroundResponse', this.bridgeBackgroundResponseListener);
         bridge.off('sessionDied', this.bridgeSessionDiedListener);
+        bridge.off('disconnected', this.bridgeDisconnectedListener);
         bridge.off('permissionRequest', this.bridgePermissionRequestListener);
         bridge.off('permissionResolved', this.bridgePermissionResolvedListener);
     }
@@ -2307,6 +2331,21 @@ export class ChannelBase {
         binding.released = true;
         this.releaseQueuedTurn(binding.sessionId);
     }
+    /**
+     * Follow a task onto the session its reload healed to (a superseded
+     * redirect). The queue reservation and the staleness generation are keyed
+     * by session id, so both must move with the binding: leaving them behind
+     * keeps the stale id "busy" forever and drops the turn on a generation the
+     * replacement never had.
+     */
+    moveNamedTurnBinding(binding, sessionId) {
+        if (binding.sessionId !== null) {
+            this.releaseQueuedTurn(binding.sessionId);
+        }
+        binding.sessionId = sessionId;
+        binding.generation = this.sessionGenerations.get(sessionId) ?? 0;
+        this.reserveQueuedTurn(sessionId);
+    }
     finishNamedTurnBinding(envelope) {
         const binding = this.namedTurnBindings.get(envelope);
         if (!binding)
@@ -2367,13 +2406,67 @@ export class ChannelBase {
             return true;
         }
     }
+    /**
+     * The actionable recovery message for a worktree task whose ownership state
+     * the daemon refused to restore. Both codes come from the load/resume route
+     * — the reset route resumes an interrupted transfer itself and reports a
+     * broken marker as invalid state — so they surface on selection and on a
+     * message, wrapped in the manager's generic load failure.
+     *
+     * Clearing always acts on the *selected* task, so pointing the user at a
+     * clear is only safe when the task that failed is the selected one. Aimed at
+     * any other task it would run a full ownership transfer against a healthy
+     * one and destroy that conversation, so the alternative points at the close
+     * that works on the broken task without loading it. Both name that task.
+     */
+    async worktreeRecoveryMessage(envelope, error) {
+        const code = readDaemonHttpErrorCode(error);
+        if (code !== 'worktree_reset_interrupted' &&
+            code !== 'worktree_marker_missing') {
+            return undefined;
+        }
+        const interrupted = code === 'worktree_reset_interrupted';
+        const failedTaskName = error instanceof NamedSessionTaskError ? error.taskName : undefined;
+        // This message bypasses the wrapper's sanitizeDisplayText, so bound the one
+        // piece of interpolated text it adds.
+        const safeTaskName = failedTaskName === undefined
+            ? undefined
+            : sanitizeDisplayText(failedTaskName, 32);
+        const subject = safeTaskName === undefined ? 'The task' : `Task "${safeTaskName}"`;
+        const problem = interrupted
+            ? 'was interrupted while being reset'
+            : 'cannot verify its worktree because its ownership marker is missing';
+        if (safeTaskName !== undefined &&
+            failedTaskName === (await this.selectedTaskName(envelope))) {
+            return `${subject} ${problem}. Its files were not changed. ${interrupted
+                ? 'Clear the task again to finish the reset.'
+                : 'Clear the task to restart it in the same worktree, or close it.'}`;
+        }
+        const remedy = safeTaskName === undefined
+            ? 'select this task first or close it'
+            : `select this task first or close it with ${this.prefixedCommand(`/session close ${safeTaskName}`)}`;
+        return `${subject} ${problem}. Its files were not changed. Clearing now would reset the selected task instead, so ${remedy}.`;
+    }
+    async selectedTaskName(envelope) {
+        const namedSessions = this.namedSessions;
+        if (!namedSessions)
+            return undefined;
+        try {
+            return (await namedSessions.current(this.namedSessionOwner(envelope)))
+                ?.name;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async sendNamedSessionError(envelope, error) {
         if (error instanceof Error && error.cause !== undefined) {
             process.stderr.write(`[${sanitizeLogText(this.name, 64)}] named-session operation failed: ${this.lifecycleError(error)} | cause: ${this.lifecycleError(error.cause)}\n`);
         }
-        const message = error instanceof Error
-            ? sanitizeDisplayText(error.message, 500)
-            : 'Named-session operation failed.';
+        const message = (await this.worktreeRecoveryMessage(envelope, error)) ??
+            (error instanceof Error
+                ? sanitizeDisplayText(error.message, 500)
+                : 'Named-session operation failed.');
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, message || 'Named-session operation failed.');
     }
     async handleNamedSessionsCommand(envelope, args) {
@@ -2424,7 +2517,8 @@ export class ChannelBase {
                         ? 'worktree'
                         : 'shared';
                     if ((isolation === 'shared' && parts.length !== 1) ||
-                        (isolation === 'worktree' && parts.length !== 2)) {
+                        (isolation === 'worktree' && parts.length !== 2) ||
+                        parts[0]?.startsWith('-')) {
                         break;
                     }
                     const created = await namedSessions.create(owner, parts[0], isolation);
@@ -2443,8 +2537,10 @@ export class ChannelBase {
                         break;
                     const closing = await namedSessions.lookup(owner, parts[0]);
                     const result = await namedSessions.close(owner, parts[0]);
-                    if (closing)
+                    if (closing) {
                         this.cancelBtw(closing.sessionId);
+                        this.onSessionRetiring(closing.sessionId);
+                    }
                     await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.active
                         ? `Closed task "${result.closed.name}". Selected "${result.active.name}".`
                         : `Closed task "${result.closed.name}". No task is selected.`);
@@ -2492,14 +2588,31 @@ export class ChannelBase {
     registerSharedCommands() {
         const doClear = async (envelope) => {
             let resetTaskName;
+            let resetWorktreeKept = false;
             let removedIds;
+            const retiringSessionId = this.namedSessions
+                ? undefined
+                : this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+            if (retiringSessionId)
+                this.onSessionRetiring(retiringSessionId);
             if (this.namedSessions) {
                 try {
                     const reset = await this.namedSessions.reset(this.namedSessionOwner(envelope));
                     resetTaskName = reset?.name;
+                    resetWorktreeKept = reset?.worktreeKept ?? false;
                     removedIds = reset ? [reset.previousSessionId] : [];
                 }
                 catch (error) {
+                    // The reset route's busy signal has its own wording; every other
+                    // typed failure goes through the shared named-session surface.
+                    const code = readDaemonHttpErrorCode(error);
+                    if (code !== undefined) {
+                        process.stderr.write(`[${sanitizeLogText(this.name, 64)}] worktree reset failed (${sanitizeLogText(code, 64)}): ${this.lifecycleError(error)}\n`);
+                    }
+                    if (code === 'worktree_reset_active') {
+                        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Task is busy. Wait for the running prompt to finish (or cancel it), then try again.');
+                        return;
+                    }
                     await this.sendNamedSessionError(envelope, error);
                     return;
                 }
@@ -2510,6 +2623,8 @@ export class ChannelBase {
             this.clearPendingGroupHistory(envelope);
             if (removedIds.length > 0) {
                 for (const id of removedIds) {
+                    if (id !== retiringSessionId)
+                        this.onSessionRetiring(id);
                     this.cancelBtw(id);
                     // Audit: clearing a SHARED session wipes the conversation for every
                     // participant, so record who triggered it (sanitized display name +
@@ -2600,7 +2715,9 @@ export class ChannelBase {
                     this.discardRetiredSession(this.bridge, id, 'cleared');
                 }
                 await this.sendThreadMessage(envelope.chatId, envelope.threadId, resetTaskName
-                    ? `Task "${resetTaskName}" reset with a fresh conversation.`
+                    ? resetWorktreeKept
+                        ? `Task "${resetTaskName}" reset with a fresh conversation; its worktree and files were kept.`
+                        : `Task "${resetTaskName}" reset with a fresh conversation.`
                     : 'Session cleared. The next message starts a fresh conversation.');
             }
             else {
@@ -4370,8 +4487,10 @@ export class ChannelBase {
                 return;
             }
             try {
-                const resumed = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
-                sessionId = resumed ? namedTurn.sessionId : undefined;
+                sessionId = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
+                if (sessionId && sessionId !== namedTurn.sessionId) {
+                    this.moveNamedTurnBinding(namedTurn, sessionId);
+                }
             }
             catch (error) {
                 await this.sendNamedSessionError(envelope, error);