@co0ontty/wand 1.31.0 → 1.31.2

package/dist/server-session-routes.js

@@ -233,10 +233,13 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/structured-sessions/:id/messages", express.json(), async (req, res) => {
         const input = String(req.body?.input ?? "");
         const interrupt = !!req.body?.interrupt;
+        // preserveQueue: 仅在 interrupt 路径有意义。排队条「立即」会带这个 flag，
+        // 让退出 handler 不要把剩余 queuedMessages 清空（默认行为是清空）。
+        const preserveQueue = !!req.body?.preserveQueue;
         const idempotencyKey = typeof req.body?.idempotencyKey === "string" ? req.body.idempotencyKey : undefined;
-        console.log("[WAND] POST /api/structured-sessions/:id/messages id:", req.params.id, "input:", input.substring(0, 50), "interrupt:", interrupt, "idempotencyKey:", idempotencyKey);
+        console.log("[WAND] POST /api/structured-sessions/:id/messages id:", req.params.id, "input:", input.substring(0, 50), "interrupt:", interrupt, "preserveQueue:", preserveQueue, "idempotencyKey:", idempotencyKey);
         try {
-            const snapshot = await structured.sendMessage(req.params.id, input, { interrupt, idempotencyKey });
+            const snapshot = await structured.sendMessage(req.params.id, input, { interrupt, preserveQueue, idempotencyKey });
             res.json(snapshot);
         }
         catch (error) {
@@ -248,6 +251,46 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             });
         }
     });
+    // ── Structured queued-messages management ──
+    // 三个端点构成"排队消息条"的后端操作面：reorder（拖拽换序）、单条删除、全部清空。
+    // 全部走乐观更新模型，失败时前端会回滚到上一次 WS 推送的 queuedMessages。
+    app.patch("/api/structured-sessions/:id/queued", express.json(), (req, res) => {
+        const rawOrder = req.body?.order;
+        if (!Array.isArray(rawOrder)) {
+            res.status(400).json({ error: "缺少 order 数组。" });
+            return;
+        }
+        try {
+            const snapshot = structured.reorderQueuedMessages(req.params.id, rawOrder.map((v) => Number(v)));
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法调整排队顺序。") });
+        }
+    });
+    app.delete("/api/structured-sessions/:id/queued/:index", (req, res) => {
+        const index = Number(req.params.index);
+        if (!Number.isFinite(index)) {
+            res.status(400).json({ error: "下标无效。" });
+            return;
+        }
+        try {
+            const snapshot = structured.deleteQueuedMessage(req.params.id, index);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法删除排队消息。") });
+        }
+    });
+    app.delete("/api/structured-sessions/:id/queued", (req, res) => {
+        try {
+            const snapshot = structured.clearQueuedMessages(req.params.id);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法清空排队消息。") });
+        }
+    });
     // ── Tool content lazy-load endpoint ──
     app.get("/api/sessions/:id/tool-content/:toolUseId", (req, res) => {
         const snapshot = getSessionById(processes, structured, req.params.id);

package/dist/structured-session-manager.d.ts

@@ -41,6 +41,14 @@ export declare class StructuredSessionManager {
      */
     private readonly pendingSdkQueries;
     private readonly interruptedWith;
+    /**
+     * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
+     * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
+     * interrupt 语义是"算了，做这个"，把队列也作废。但 queue-promote 的语义是
+     * "先做这条，剩下的队列还要继续"，所以这里打个标记，让退出 handler 保留 queue。
+     * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
+     */
+    private readonly preserveQueueOnInterrupt;
     /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
     private readonly lastStreamSaveAt;
     /**
@@ -71,11 +79,25 @@ export declare class StructuredSessionManager {
     sendMessage(id: string, input: string, opts?: {
         interrupt?: boolean;
         idempotencyKey?: string;
+        preserveQueue?: boolean;
     }): Promise<SessionSnapshot>;
     /** Approve a pending permission request. */
     approvePermission(sessionId: string): SessionSnapshot;
     /** Deny a pending permission request. */
     denyPermission(sessionId: string): SessionSnapshot;
+    /**
+     * Reorder the pending queued messages. `order` is a permutation of the current
+     * indices, e.g. `[2, 0, 1]` means "move the third queued message to the front,
+     * push the original first to position #2". Throws if the permutation is
+     * malformed (length mismatch / duplicate / out-of-range). 不允许在 inFlight
+     * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
+     * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
+     */
+    reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
+    /** Remove a single queued message by index. */
+    deleteQueuedMessage(sessionId: string, index: number): SessionSnapshot;
+    /** Clear all queued messages. No-op when queue is already empty. */
+    clearQueuedMessages(sessionId: string): SessionSnapshot;
     /** Update the selected model for a structured session. Takes effect on the next spawn. */
     setSessionModel(sessionId: string, model: string | null): SessionSnapshot;
     /**

package/dist/structured-session-manager.js

@@ -390,8 +390,8 @@ function buildAppendSystemPromptParts(language, mode) {
     }
     if (trimmedLanguage) {
         parts.push(isChinese
-            ? "请使用中文回复。所有解释、注释和对话文本都使用中文。"
-            : `Please respond in ${trimmedLanguage}. Use ${trimmedLanguage} for all your explanations, comments, and conversational text.`);
+            ? "请使用中文回复。所有解释、注释和对话文本都使用中文。当你通过 Task 工具派发子代理（subagent）时，必须在传给子代理的 prompt 里明确要求它也使用中文回复，确保所有子代理的输出同样遵循该语言偏好。"
+            : `Please respond in ${trimmedLanguage}. Use ${trimmedLanguage} for all your explanations, comments, and conversational text. When you dispatch a subagent via the Task tool, you MUST explicitly instruct the subagent in its prompt to also respond in ${trimmedLanguage}, so every subagent's output follows the same language preference.`);
     }
     return parts;
 }
@@ -434,6 +434,14 @@ export class StructuredSessionManager {
      */
     pendingSdkQueries = new Map();
     interruptedWith = new Map();
+    /**
+     * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
+     * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
+     * interrupt 语义是"算了，做这个"，把队列也作废。但 queue-promote 的语义是
+     * "先做这条，剩下的队列还要继续"，所以这里打个标记，让退出 handler 保留 queue。
+     * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
+     */
+    preserveQueueOnInterrupt = new Set();
     /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
     lastStreamSaveAt = new Map();
     /**
@@ -637,6 +645,12 @@ export class StructuredSessionManager {
             }
             else if (opts?.interrupt) {
                 this.interruptedWith.set(id, prompt);
+                if (opts.preserveQueue) {
+                    this.preserveQueueOnInterrupt.add(id);
+                }
+                else {
+                    this.preserveQueueOnInterrupt.delete(id);
+                }
                 try {
                     child.kill("SIGTERM");
                 }
@@ -769,6 +783,60 @@ export class StructuredSessionManager {
     denyPermission(sessionId) {
         return this.resolvePermission(sessionId, false);
     }
+    /**
+     * Reorder the pending queued messages. `order` is a permutation of the current
+     * indices, e.g. `[2, 0, 1]` means "move the third queued message to the front,
+     * push the original first to position #2". Throws if the permutation is
+     * malformed (length mismatch / duplicate / out-of-range). 不允许在 inFlight
+     * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
+     * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
+     */
+    reorderQueuedMessages(sessionId, order) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Array.isArray(order) || order.length !== queue.length) {
+            throw new Error("排序长度与当前队列不一致，请刷新后重试。");
+        }
+        const seen = new Set();
+        for (const idx of order) {
+            if (!Number.isInteger(idx) || idx < 0 || idx >= queue.length || seen.has(idx)) {
+                throw new Error("排序参数无效。");
+            }
+            seen.add(idx);
+        }
+        const reordered = order.map((idx) => queue[idx]);
+        const updated = { ...session, queuedMessages: reordered };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
+    /** Remove a single queued message by index. */
+    deleteQueuedMessage(sessionId, index) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
+            throw new Error("队列中没有该条消息（可能已被处理）。");
+        }
+        const next = queue.slice(0, index).concat(queue.slice(index + 1));
+        const updated = { ...session, queuedMessages: next };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
+    /** Clear all queued messages. No-op when queue is already empty. */
+    clearQueuedMessages(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (!session.queuedMessages || session.queuedMessages.length === 0) {
+            return session;
+        }
+        const updated = { ...session, queuedMessages: [] };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
     /** Update the selected model for a structured session. Takes effect on the next spawn. */
     setSessionModel(sessionId, model) {
         const session = this.requireSession(sessionId);
@@ -850,6 +918,7 @@ export class StructuredSessionManager {
     stop(id) {
         const session = this.requireSession(id);
         this.interruptedWith.delete(id);
+        this.preserveQueueOnInterrupt.delete(id);
         const child = this.pendingChildren.get(id);
         if (child) {
             child.kill();
@@ -902,6 +971,8 @@ export class StructuredSessionManager {
         }
         this.sessions.delete(id);
         this.lastStreamSaveAt.delete(id);
+        this.interruptedWith.delete(id);
+        this.preserveQueueOnInterrupt.delete(id);
         this.storage.deleteSession(id);
         this.logger?.deleteSession(id);
     }
@@ -1292,7 +1363,7 @@ export class StructuredSessionManager {
                     output: turnState.result,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
-                    queuedMessages: interruptPrompt ? [] : current.queuedMessages,
+                    queuedMessages: interruptPrompt && !this.preserveQueueOnInterrupt.has(sessionId) ? [] : current.queuedMessages,
                     pendingEscalation: null,
                     permissionBlocked: false,
                     structuredState: {
@@ -1311,6 +1382,11 @@ export class StructuredSessionManager {
                 }
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
+                    // 把"保留队列"标记一并清掉——不属于本次 interrupt 的后续轮次会按
+                    // 默认（清空 queue）行为走，避免 stale flag 影响下一次普通 interrupt。
+                    // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
+                    // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
+                    this.preserveQueueOnInterrupt.delete(sessionId);
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((err) => {
@@ -1803,7 +1879,7 @@ export class StructuredSessionManager {
                     output: turnState.result,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
-                    queuedMessages: interruptPrompt ? [] : current.queuedMessages,
+                    queuedMessages: interruptPrompt && !this.preserveQueueOnInterrupt.has(sessionId) ? [] : current.queuedMessages,
                     pendingEscalation: null,
                     permissionBlocked: false,
                     structuredState: {
@@ -1828,6 +1904,11 @@ export class StructuredSessionManager {
                 // 用户中断当前回复：保存部分回复后立即发送新消息。
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
+                    // 把"保留队列"标记一并清掉——不属于本次 interrupt 的后续轮次会按
+                    // 默认（清空 queue）行为走，避免 stale flag 影响下一次普通 interrupt。
+                    // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
+                    // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
+                    this.preserveQueueOnInterrupt.delete(sessionId);
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((err) => {