@co0ontty/wand 1.60.5 → 1.61.0-beta.g5043a45

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "0c8dc16285dd049afbc98eb8a17204ed37cb33d4",
-  "builtAt": "2026-06-13T10:07:33.053Z",
-  "version": "1.60.5",
-  "channel": "stable"
+  "commit": "5043a45750e7229c7f3567c971edfd10beccbce8",
+  "builtAt": "2026-06-13T23:53:44.046Z",
+  "version": "1.61.0-beta.g5043a45",
+  "channel": "beta"
 }

package/dist/process-manager.js

@@ -165,7 +165,10 @@ function isClaudeSessionFileAvailable(cwd, claudeSessionId) {
  * interpretations and validate with existsSync, falling back to naive replacement.
  */
 function invertNormalizedProjectDir(dirName) {
-    // The normalization is: path.resolve(cwd).replace(/\//g, "-")
+    // The normalization replaces every non-alphanumeric char with "-", so this
+    // inversion is best-effort: "-" most often maps back to "/", but may also be
+    // a literal "-", ".", or "_". We try "/" vs "-" per position and validate with
+    // existsSync; dots/underscores in the original path can't be recovered here.
     const naive = dirName.replace(/-/g, "/");
     if (existsSync(naive))
         return naive;
@@ -494,7 +497,11 @@ function listClaudeTaskIds() {
     }
 }
 function getClaudeProjectDir(cwd) {
-    const normalized = path.resolve(cwd).replace(/\//g, "-");
+    // Claude Code encodes the project dir by replacing every non-alphanumeric
+    // character (slash, dot, underscore, etc.) with "-", not just "/". Mirroring
+    // only "/" misses paths like ".../vibe_coding/wand" → the scan looks in a
+    // directory Claude never wrote to, so the session ID is never discovered.
+    const normalized = path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
     return path.join(os.homedir(), ".claude", "projects", normalized);
 }
 function getLatestClaudeTaskId(excludeIds) {

package/dist/server-session-routes.js

@@ -252,7 +252,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
     });
     // ── Structured queued-messages management ──
-    // 三个端点构成"排队消息条"的后端操作面：reorder（拖拽换序）、单条删除、全部清空。
+    // 这些端点构成"排队消息条"的后端操作面：reorder、立即发送、单条删除、全部清空。
     // 全部走乐观更新模型，失败时前端会回滚到上一次 WS 推送的 queuedMessages。
     app.patch("/api/structured-sessions/:id/queued", express.json(), (req, res) => {
         const rawOrder = req.body?.order;
@@ -282,6 +282,27 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "无法删除排队消息。") });
         }
     });
+    app.post("/api/structured-sessions/:id/queued/:index/promote", express.json(), async (req, res) => {
+        const index = Number(req.params.index);
+        if (!Number.isInteger(index)) {
+            res.status(400).json({ error: "下标无效。" });
+            return;
+        }
+        const expectedText = typeof req.body?.expectedText === "string" ? req.body.expectedText : undefined;
+        const idempotencyKey = typeof req.body?.idempotencyKey === "string" ? req.body.idempotencyKey : undefined;
+        try {
+            const snapshot = await structured.promoteQueuedMessage(req.params.id, index, expectedText, idempotencyKey);
+            res.json(snapshot);
+        }
+        catch (error) {
+            const errorCode = error?.code;
+            const status = errorCode === "duplicate_idempotency_key" ? 409 : 400;
+            res.status(status).json({
+                error: getErrorMessage(error, "无法立即发送排队消息。"),
+                errorCode,
+            });
+        }
+    });
     app.delete("/api/structured-sessions/:id/queued", (req, res) => {
         try {
             const snapshot = structured.clearQueuedMessages(req.params.id);

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

@@ -90,6 +90,7 @@ export declare class StructuredSessionManager {
         interrupt?: boolean;
         idempotencyKey?: string;
         preserveQueue?: boolean;
+        queueAlreadyRemoved?: boolean;
     }): Promise<SessionSnapshot>;
     /**
      * Reorder the pending queued messages. `order` is a permutation of the current
@@ -102,6 +103,12 @@ export declare class StructuredSessionManager {
     reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
     /** Remove a single queued message by index. */
     deleteQueuedMessage(sessionId: string, index: number): SessionSnapshot;
+    /**
+     * Remove one queued message by index before sending it. Keeping this operation
+     * on the server prevents clients from re-sending the text while the original
+     * queue entry remains available for the automatic flush path.
+     */
+    promoteQueuedMessage(sessionId: string, index: number, expectedText?: string, idempotencyKey?: string): Promise<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. */
@@ -119,8 +126,6 @@ export declare class StructuredSessionManager {
     stop(id: string): SessionSnapshot;
     delete(id: string): void;
     private requireSession;
-    private buildQueuedPlaceholderTurns;
-    private buildRenderableMessages;
     private emitStructuredSnapshot;
     private flushNextQueuedMessage;
     private emit;

package/dist/structured-session-manager.js

@@ -629,6 +629,22 @@ export class StructuredSessionManager {
                 this.interruptedWith.set(id, prompt);
                 if (opts.preserveQueue) {
                     this.preserveQueueOnInterrupt.add(id);
+                    // 「立即发送」排队条某一条：interrupt 把它作为新输入重发，但该条仍留在
+                    // queuedMessages 里。必须在这里把它从队列摘掉一次，否则 preserveQueue 会
+                    // 原样保留整条队列，待 interruptPrompt 跑完 flushNextQueuedMessage 会把它
+                    // 当成普通排队再发一遍（重复发送）。旧客户端没有走 promote endpoint，
+                    // 服务端只能按文本删第一处匹配；新客户端会带 queueAlreadyRemoved 跳过这里。
+                    if (!opts.queueAlreadyRemoved) {
+                        const queue = session.queuedMessages ?? [];
+                        const removeAt = queue.indexOf(prompt);
+                        if (removeAt !== -1) {
+                            const trimmedQueue = queue.slice(0, removeAt).concat(queue.slice(removeAt + 1));
+                            session = { ...session, queuedMessages: trimmedQueue };
+                            this.sessions.set(id, session);
+                            this.storage.saveSession(session);
+                            this.emitStructuredSnapshot(session);
+                        }
+                    }
                 }
                 else {
                     this.preserveQueueOnInterrupt.delete(id);
@@ -796,6 +812,44 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /**
+     * Remove one queued message by index before sending it. Keeping this operation
+     * on the server prevents clients from re-sending the text while the original
+     * queue entry remains available for the automatic flush path.
+     */
+    async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey) {
+        const session = this.requireSession(sessionId);
+        if (idempotencyKey && this.seenIdempotencyKeys.has(`${sessionId}:${idempotencyKey}`)) {
+            return session;
+        }
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
+            throw new Error("队列中没有该条消息（可能已被处理）。");
+        }
+        if (expectedText !== undefined && queue[index] !== expectedText) {
+            throw new Error("排队消息已变化，请按最新顺序重试。");
+        }
+        const prompt = queue[index];
+        const remaining = queue.slice(0, index).concat(queue.slice(index + 1));
+        const inFlight = session.status === "running" && session.structuredState?.inFlight === true;
+        const updated = { ...session, queuedMessages: remaining };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        try {
+            return await this.sendMessage(sessionId, prompt, {
+                interrupt: inFlight,
+                preserveQueue: inFlight,
+                queueAlreadyRemoved: true,
+                idempotencyKey,
+            });
+        }
+        catch {
+            // Once the item has been promoted it must not return to the queue: the
+            // send path may have already persisted its user turn before a runner error.
+            return this.requireSession(sessionId);
+        }
+    }
     /** Clear all queued messages. No-op when queue is already empty. */
     clearQueuedMessages(sessionId) {
         const session = this.requireSession(sessionId);
@@ -957,23 +1011,13 @@ export class StructuredSessionManager {
         }
         return session;
     }
-    buildQueuedPlaceholderTurns(session) {
-        return (session.queuedMessages ?? []).map((text) => ({
-            role: "user",
-            content: [{ type: "text", text, __queued: true }],
-        }));
-    }
-    buildRenderableMessages(session) {
-        return [
-            ...(session.messages ?? []),
-            ...this.buildQueuedPlaceholderTurns(session),
-        ];
-    }
     emitStructuredSnapshot(session, eventType = "output") {
+        // 排队消息只通过 payload.queuedMessages 单独下发，由各端在消息卡片外的「排队条」
+        // 里纵向渲染——绝不再把它们当成 __queued 占位 turn 混进 messages 消息流里，否则会
+        // 和排队条重复显示（旧的「显示异常」根因）。
         const payload = buildStructuredOutputPayload(session);
         const data = {
             ...payload,
-            messages: this.buildRenderableMessages(session),
             status: session.status,
             exitCode: session.exitCode,
         };