qz-browser-agent 0.1.2 → 0.1.3

package/README.md

@@ -94,7 +94,7 @@ CLI and MCP share the same browser connection. The MCP tool list is in the
 | `qz send TASK_ID "MESSAGE"` | Send a follow-up, or `--steer` the current run |
 | `qz tasks` | List tasks |
 | `qz show TASK_ID` | Read a task's status, response, or pending question |
-| `qz watch TASK_ID` | Follow a running task until it finishes |
+| `qz watch TASK_ID` | Follow a task until its work and queued messages finish |
 | `qz submit` / `approve` / `reject` | Answer a question or permission request |
 | `qz cancel TASK_ID` | Stop a task |
 | `qz data` | List, export, or delete data tables |
@@ -107,6 +107,12 @@ CLI and MCP share the same browser connection. The MCP tool list is in the
 With several browser profiles connected, choose one with `--client NAME|UUID` (or `-c`).
 Run `qz COMMAND --help` for options. Interactive terminals show readable text; pipes receive JSON.
 
+`watch`, `--wait`, and `--stream` follow the same task across runs until its current work and
+accepted follow-ups and steering messages have completed and its queues are empty. Questions
+and permission requests keep observation open. Task failure or stopping ends observation.
+Timeout or Ctrl-C ends observation while the browser task continues; execute the returned
+`watch` command with the same task ID and browser UUID to resume. Observation never resends messages.
+
 ## Privacy and local access
 
 The service accepts connections only on your computer, and ordinary websites cannot use its MCP

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qz-browser-agent",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local browser tools and MCP access for the qz extension",
   "type": "module",
   "engines": { "node": ">=22" },

package/src/catalog.json

@@ -62,10 +62,10 @@
   },
   {
     "name": "qingzhou_create_session",
-    "description": "Create a task with an optional first message. Set wait=true to return its completed snapshot, or stream=true for progress events. User-input waits keep observation open. Cancellation stops observing; the browser task continues.",
+    "description": "Create a task with an optional first message. Set wait=true to follow the same task across runs until its current work and accepted follow-ups and steering messages have completed and its queues are empty. stream=true adds progress events. User-input waits keep observation open. Task failure or stopping ends observation. Timeout or cancellation ends observation while the browser task continues; use the returned watch recovery call without resubmitting.",
     "inputSchema": {
       "properties": {
-        "wait": {"type": "boolean", "default": false, "description": "Keep observing until the task finishes, including user-input waits."},
+        "wait": {"type": "boolean", "default": false, "description": "Follow the same task across runs until its work completes and its accepted follow-up and steering queues are empty. User-input waits keep observation open; task failure or stopping ends it."},
         "stream": {"type": "boolean", "default": false, "description": "Implies wait. Send task text, status, and input events through MCP progress notifications when a progressToken is supplied."},
         "waitTimeoutSeconds": {"type": ["number", "null"], "exclusiveMinimum": 0, "maximum": 86400, "default": null, "description": "Optional total observation deadline; null waits indefinitely. timeoutSeconds bounds each browser request."},
         "title": {"default": "", "title": "Title", "type": "string"},
@@ -80,10 +80,10 @@
   },
   {
     "name": "qingzhou_send_message",
-    "description": "Send a message to the specified task. By default, a busy task queues a follow-up for its next run. Set steer=true to guide its current run at the next safe boundary. An idle task starts with either mode. Returns deliveryMode, disposition, and clientMessageId for tracking. Set wait=true to observe the submitted message through completion, including queued follow-ups and user-input waits. stream=true also emits text through MCP progress notifications.",
+    "description": "Send a message to the specified task. By default, a busy task queues a follow-up for its next run. Set steer=true to guide its current run at the next safe boundary. An idle task starts with either mode. Returns deliveryMode, disposition, and clientMessageId to confirm acceptance. Set wait=true to follow the same task across runs until its work completes and its follow-up and steering queues are empty. A queued message removed before execution no longer blocks completion. stream=true emits text from the submitted message onward through MCP progress notifications. Timeout or cancellation ends observation; use the returned watch recovery call without resubmitting.",
     "inputSchema": {
       "properties": {
-        "wait": {"type": "boolean", "default": false, "description": "Keep observing until the task finishes, including user-input waits."},
+        "wait": {"type": "boolean", "default": false, "description": "Follow the same task across runs until its work completes and its accepted follow-up and steering queues are empty. User-input waits keep observation open; task failure or stopping ends it."},
         "stream": {"type": "boolean", "default": false, "description": "Implies wait. Send task text, status, and input events through MCP progress notifications when a progressToken is supplied."},
         "waitTimeoutSeconds": {"type": ["number", "null"], "exclusiveMinimum": 0, "maximum": 86400, "default": null, "description": "Optional total observation deadline; null waits indefinitely. timeoutSeconds bounds each browser request."},
         "text": {"title": "Text", "type": "string"},
@@ -150,7 +150,7 @@
     "description": "Respond using the pending input's responseTemplate: fill answers keyed by field IDs with option values for choices (arrays for multi_choice), then submit; approve a completed action or application consent, or reject. Show location disclosures and obtain explicit user consent before approving with consentVersion. Native Chrome permissions require the user's click in qz. Invalid or stale replies return the current input for correction and keep the request pending.",
     "inputSchema": {
       "properties": {
-        "wait": {"type": "boolean", "default": false, "description": "Keep observing until the task finishes, including user-input waits."},
+        "wait": {"type": "boolean", "default": false, "description": "Follow the same task across runs until its work completes and its accepted follow-up and steering queues are empty. User-input waits keep observation open; task failure or stopping ends it."},
         "stream": {"type": "boolean", "default": false, "description": "Implies wait. Send task text, status, and input events through MCP progress notifications when a progressToken is supplied."},
         "waitTimeoutSeconds": {"type": ["number", "null"], "exclusiveMinimum": 0, "maximum": 86400, "default": null, "description": "Optional total observation deadline; null waits indefinitely. timeoutSeconds bounds each browser request."},
         "sessionId": {"type": "string", "minLength": 1},
@@ -357,7 +357,7 @@
   },
   {
     "name": "qingzhou_watch_task",
-    "description": "Observe an existing task until it finishes without resubmitting it. Questions and Chrome permission requests keep observation open; MCP progress notifications include their full input and responseTemplate. stream=true includes text updates. Cancellation stops observing while the task continues.",
+    "description": "Observe an existing task across runs until its current work and accepted follow-ups and steering messages have completed and its queues are empty, without resubmitting anything. Questions and Chrome permission requests keep observation open; MCP progress notifications include their full input and responseTemplate. stream=true includes text updates. Task failure or stopping ends observation. Timeout or cancellation ends observation while the browser task continues; resume with the returned recovery call using the same sessionId and clientId.",
     "inputSchema": {
       "type": "object",
       "properties": {

package/src/cli.mjs

@@ -213,14 +213,14 @@ async function dispatchCommand(parsed, dependencies) {
       throw error;
     }
   };
-  const observe = async (sessionId, { runId = "", expectedMessageId = "", previousRunId = "", ignoreWaitId = "", allowIdle = false } = {}) => {
+  const observe = async (sessionId, { runId = "", expectedMessageId = "", messageWasQueued = false, ignoreWaitId = "", allowIdle = false } = {}) => {
     try {
       const remaining = waitTimeoutSeconds == null ? null : waitTimeoutSeconds - (Date.now() - startedAt) / 1000;
       if (remaining !== null && remaining <= 0) throw new DOMException("Stopped watching after the configured --timeout. The browser task may still be running.", "TimeoutError");
       return await waitForTask({
         sessionId, clientId: common.clientId, timeoutSeconds: remaining, signal: dependencies.signal,
         requestTimeoutSeconds: timeoutSeconds,
-        expectedRunId: runId, expectedMessageId, previousRunId, ignoreWaitId, allowIdle,
+        expectedRunId: runId, expectedMessageId, messageWasQueued, ignoreWaitId, allowIdle,
         onUpdate: dependencies.onTaskUpdate,
         getSnapshot: ({ timeoutSeconds: seconds, signal }) => readSnapshot(sessionId, seconds, signal),
       });
@@ -245,7 +245,9 @@ async function dispatchCommand(parsed, dependencies) {
           sessionId: id, hint: "Continue watching the same task:", command: recoveryCommand("watch", id, clientId, true),
         });
       }
-      result = { ...result, snapshot: await observe(id, { expectedMessageId: result.clientMessageId }) };
+      result = { ...result, snapshot: await observe(id, {
+        expectedMessageId: result.clientMessageId, messageWasQueued: result.disposition === "queued",
+      }) };
     }
     return { result };
   }

package/src/commands.mjs

@@ -14,7 +14,7 @@ export const COMMANDS = {
   create: { options: [...waiting, "title", "parent"], summary: "Start a task",
     help: ['qz create "PROMPT" [--title TITLE] [--wait | --stream]', "Start a browser task. The title is optional.",
       "--title, -t  Set the task title. --parent TASK_ID creates a child task.",
-      "--wait    Wait for completion, including pauses for user input.", "--stream  Show responses as they arrive; also wait.",
+      "--wait    Follow the task across runs until its work completes and accepted message queues are empty; user-input pauses keep waiting.", "--stream  Show responses as they arrive; also wait.",
       "Use - as the prompt to read stdin.",
       'qz create "Compare these two pages." --stream', 'qz create "Summarize this page." --title Research --wait'],
   },
@@ -22,7 +22,8 @@ export const COMMANDS = {
     help: ['qz send TASK_ID "MESSAGE" [--steer] [--wait | --stream]', "Send a follow-up or steer a specific task.",
       "A busy task queues a follow-up for its next run. --steer delivers the message to the current run at its next safe boundary.",
       "Both start a new run when the task is idle. Pending questions and permissions still require a response.",
-      "Use - as the message to read stdin. --wait follows the submitted message; --stream also shows its responses.",
+      "Use - as the message to read stdin. --wait follows the task until its work completes and queues are empty; removed queued messages no longer block completion.",
+      "--stream also shows responses from this message onward, including later runs.",
       'qz send TASK_ID "Add the source links." --stream', 'qz send TASK_ID "Focus on open-source options." --steer --stream'],
   },
   tasks: { options: [...request, "limit"], summary: "List tasks",
@@ -32,19 +33,20 @@ export const COMMANDS = {
     help: ["qz show TASK_ID", "Show task status, the latest response, and any pending form or permission request.", "Pending input includes field IDs, option values, and a submission template. Use --json for the complete snapshot.", "qz show TASK_ID --json"],
   },
   watch: { options: [...request, "stream"], summary: "Wait for a task",
-    help: ["qz watch TASK_ID [--stream]", "Wait for an existing task to finish, including pauses for user input.", "--stream  Show assistant responses as they arrive.", "Timeout or Ctrl-C ends watching without cancelling the task."],
+    help: ["qz watch TASK_ID [--stream]", "Follow an existing task across runs until its work completes and accepted message queues are empty; user-input pauses keep waiting.", "--stream  Show assistant responses as they arrive.", "Task failure or stopping ends observation. Timeout or Ctrl-C ends watching without cancelling the task.", "Resume with the returned watch command for the same task and browser; observation never resends messages."],
   },
   submit: { options: [...waiting, "wait-id"], summary: "Answer a form",
     help: ["qz submit TASK_ID JSON [--wait | --stream]", "Submit answers to the current form. Use - to read JSON from stdin.",
       "--wait-id ID  Bind the response to a previously read wait. Otherwise qz reads the current wait before submitting.",
+      "--wait and --stream follow the task across runs until its work completes and accepted message queues are empty.",
       'qz submit TASK_ID \'{"selectedIds":["option-a"]}\' --stream'],
   },
   approve: { options: [...waiting, "wait-id"], summary: "Continue a waiting task",
     help: ["qz approve TASK_ID [--wait | --stream]", "Continue after completing a requested action.",
-      "Review app consent notices with qz show before approving. Native browser permissions require a click in the qz side panel.", "--wait-id ID  Respond only to this wait."],
+      "Review app consent notices with qz show before approving. Native browser permissions require a click in the qz side panel.", "--wait-id ID  Respond only to this wait.", "--wait and --stream follow the task across runs until its work completes and accepted message queues are empty."],
   },
   reject: { options: [...waiting, "wait-id"], summary: "Decline a pending request",
-    help: ["qz reject TASK_ID [--wait-id ID] [--wait | --stream]", "Decline the pending request and optionally follow the task's next step. Use qz cancel TASK_ID to stop the whole task."],
+    help: ["qz reject TASK_ID [--wait-id ID] [--wait | --stream]", "Decline the pending request. --wait and --stream follow the task across runs until its work completes and accepted message queues are empty. Use qz cancel TASK_ID to stop the whole task."],
   },
   cancel: { options: request, summary: "Stop a task",
     help: ["qz cancel TASK_ID", "Stop a task's active run.", "qz stop stops the local service instead."],

package/src/task-stream.mjs

@@ -1,8 +1,9 @@
 import { setTimeout as delay } from "node:timers/promises";
 
-const STOP_STATUSES = new Set(["completed", "error", "failed", "aborted", "cancelled", "interrupted"]);
+const FAILURE_STATUSES = new Set(["error", "failed", "aborted", "cancelled", "interrupted"]);
 const ACTIVE_STATUSES = new Set(["pending", "running", "waiting_user", "paused"]);
 const INPUT_STATUSES = new Set(["waiting_user", "paused"]);
+const QUEUE_FIELDS = ["pendingFollowUps", "pendingFollowUpMessages", "pendingSteerings", "pendingSteeringMessages"];
 const record = value => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 
 export const TASK_NOT_FOUND_MESSAGE = "The task was not found in the selected browser. It may have been deleted, the task ID may be incorrect, or a different browser may be selected.";
@@ -13,6 +14,11 @@ function taskStatus(snapshot) {
   return status.toLowerCase() === "canceled" ? "cancelled" : status.toLowerCase();
 }
 
+function hasPendingWork(runtime) {
+  return runtime.running === true || runtime.pendingStart === true
+    || QUEUE_FIELDS.some(key => Array.isArray(runtime[key]) && runtime[key].length > 0);
+}
+
 function assistantText(content) {
   if (typeof content === "string") return content;
   return Array.isArray(content) ? content.filter(part => part?.type === "text")
@@ -37,12 +43,13 @@ function abortable(operation, signal) {
 }
 
 /** Observe snapshots only: timeout, interruption, and polling failures never cancel or restart a browser task.
+ * Follow one Session across runs until execution and its accepted queues are finished.
  * User input pauses execution, not observation; input events expose each pending request.
  * Total observation is unlimited by default; each snapshot request has its own finite deadline.
  * getSnapshot must request compact:false and tail:false so transcript identities and streaming text survive.
  */
 export async function waitForTask({ sessionId, clientId, timeoutSeconds = null, requestTimeoutSeconds = 180, signal, getSnapshot, onUpdate,
-  pollIntervalMs = 750, expectedRunId = "", expectedMessageId = "", previousRunId = "", ignoreWaitId = "", allowIdle = false } = {}) {
+  pollIntervalMs = 750, expectedRunId = "", expectedMessageId = "", messageWasQueued = false, ignoreWaitId = "", allowIdle = false } = {}) {
   if (!String(sessionId || "").trim()) throw new TypeError("sessionId is required");
   if (typeof getSnapshot !== "function") throw new TypeError("getSnapshot is required");
   if (timeoutSeconds !== null && (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0)) throw new TypeError("timeoutSeconds must be positive or null");
@@ -86,12 +93,11 @@ export async function waitForTask({ sessionId, clientId, timeoutSeconds = null,
     }
   };
   const messages = new Map();
-  let selectedRunId = String(expectedRunId || "");
-  let observedRun = false;
+  let firstRunId = String(expectedRunId || "");
+  let trackingReady = false;
   let observedActivity = false;
   let awaitingMessage = Boolean(expectedMessageId);
-  let messageRunId = "";
-  let awaitingResume = Boolean(ignoreWaitId);
+  let observedQueuedMessage = messageWasQueued;
   let lastStatus = "";
   let lastInput = "";
   const emit = async update => {
@@ -137,67 +143,63 @@ export async function waitForTask({ sessionId, clientId, timeoutSeconds = null,
       const transcript = Array.isArray(snapshot.transcript) ? snapshot.transcript : Array.isArray(snapshot.tail) ? snapshot.tail : [];
       const submittedMessageIndex = expectedMessageId
         ? transcript.findIndex(entry => entry?.type === "user" && entry.clientMessageId === expectedMessageId) : -1;
-      if (awaitingMessage) {
-        const message = transcript[submittedMessageIndex];
-        if (message?.runId) {
-          messageRunId = String(message.runId);
-          selectedRunId = messageRunId;
-          awaitingMessage = false;
-        } else {
-          // A queued message may wait behind an earlier run's question or permission.
-          // Keep that input actionable, but never mistake its answer for this message's result.
-          if (status !== "completed") await emitStatus(status, runId, runtime);
-          await emitInput(status, runId, runtime, canonicalInput);
-          if (STOP_STATUSES.has(status) && status !== "completed") return snapshot;
-          await pollingDelay();
-          continue;
-        }
+      if (awaitingMessage && QUEUE_FIELDS.some(key => Array.isArray(runtime[key])
+        && runtime[key].some(message => message?.clientMessageId === expectedMessageId))) observedQueuedMessage = true;
+      const submittedMessage = transcript[submittedMessageIndex];
+      if (awaitingMessage && submittedMessage?.runId) {
+        firstRunId = String(submittedMessage.runId);
+        awaitingMessage = false;
       }
-      const previous = previousRunId && (!runId || runId === previousRunId);
-      const awaitedRunId = messageRunId || expectedRunId;
-      const awaitingExpected = awaitedRunId && runId !== awaitedRunId;
       const targetIndex = submittedMessageIndex >= 0 ? submittedMessageIndex
-        : awaitedRunId ? transcript.findIndex(entry => entry?.runId === awaitedRunId) : -1;
-      // A fast queued run can finish before the first poll. A later accepted user message
-      // distinguishes that replacement from an older runtime snapshot still catching up.
-      const passedTarget = awaitingExpected && runId && targetIndex >= 0
+        : firstRunId ? transcript.findIndex(entry => entry?.runId === firstRunId) : -1;
+      // The runtime can lag the transcript or skip whole runs between polls. Admit the
+      // target run or a proven successor once, then follow the Session without a run fence.
+      const passedTarget = runId && targetIndex >= 0
         && transcript.slice(targetIndex + 1).some(entry => entry?.type === "user" && entry.runId === runId);
-      if ((observedRun && runId && selectedRunId !== runId) || passedTarget) {
-        throw Object.assign(new Error("A different run replaced the task being watched. Use qz show to inspect its conversation."), {
-          code: "task_changed", details: { expectedRunId: selectedRunId || awaitedRunId, actualRunId: runId },
-        });
+      // Resolving a wait and persisting its updated snapshot are separate operations.
+      // Ignore that exact old wait even while its runtime lags the acknowledged run.
+      const oldWait = !trackingReady && ignoreWaitId && status === "waiting_user" && String(canonicalInput?.waitId || runtime.waitId || "") === ignoreWaitId;
+      if (oldWait) {
+        await pollingDelay();
+        continue;
       }
-      if (!previous && !awaitingExpected) {
-        if (runId) { selectedRunId = runId; observedRun = true; }
-        // Resolving a wait and persisting its updated snapshot are separate operations.
-        // Ignore that exact old wait until the resumed run or its next wait is visible.
-        const oldWait = awaitingResume && status === "waiting_user" && String(canonicalInput?.waitId || runtime.waitId || "") === ignoreWaitId;
-        if (oldWait) {
-          await pollingDelay();
-          continue;
-        }
-        awaitingResume = false;
-        if (ACTIVE_STATUSES.has(status)) observedActivity = true;
-        await emitStatus(status, runId, runtime);
-        for (const [index, entry] of transcript.entries()) {
-          // Steering can continue the same run. Only stream responses after this submitted message.
-          if (expectedMessageId && (submittedMessageIndex < 0 || index <= submittedMessageIndex)) continue;
-          if (entry?.type !== "assistant" || (entry.runId && selectedRunId && entry.runId !== selectedRunId)) continue;
-          const messageId = messageIdentity(entry, index, selectedRunId);
-          const fullText = assistantText(entry.content);
-          const seen = messages.has(messageId);
-          const previousText = messages.get(messageId) || "";
-          if (fullText === previousText) continue;
-          messages.set(messageId, fullText);
-          const append = fullText.startsWith(previousText);
-          await emit({ type: append ? "text" : "replace", sessionId, runId: String(entry.runId || runId), messageId,
-            text: append ? fullText.slice(previousText.length) : fullText, fullText,
-            newMessage: !seen, streaming: entry.streaming === true });
-        }
+      if (!trackingReady && (awaitingMessage || (firstRunId && runId !== firstRunId && !passedTarget))) {
+        // Queue acceptance precedes these reads; pending precedes dequeue. A settled
+        // task with no trace of an accepted queued message means it was removed.
+        const removedMessage = awaitingMessage && observedQueuedMessage && submittedMessageIndex < 0
+          && status === "completed" && !hasPendingWork(runtime);
+        // A queued message can wait behind another run's question. Keep it actionable,
+        // but do not emit its earlier answer or accept its successful completion.
+        if (status !== "completed" || removedMessage) await emitStatus(status, runId, runtime);
         await emitInput(status, runId, runtime, canonicalInput);
-        // A newly created session can report idle before its first run starts.
-        if (STOP_STATUSES.has(status) || (status === "idle" && (observedActivity || allowIdle))) return snapshot;
+        if (FAILURE_STATUSES.has(status) || removedMessage) return snapshot;
+        await pollingDelay();
+        continue;
+      }
+      trackingReady = true;
+      if (!firstRunId && runId) firstRunId = runId;
+      if (ACTIVE_STATUSES.has(status)) observedActivity = true;
+      await emitStatus(status, runId, runtime);
+      for (const [index, entry] of transcript.entries()) {
+        // Steering can continue the same run. Only stream responses after this submitted message.
+        if (expectedMessageId && (submittedMessageIndex < 0 || index <= submittedMessageIndex)) continue;
+        if (entry?.type !== "assistant") continue;
+        if (!expectedMessageId && (targetIndex >= 0 ? index < targetIndex : entry.runId && entry.runId !== runId)) continue;
+        const messageId = messageIdentity(entry, index, firstRunId);
+        const fullText = assistantText(entry.content);
+        const seen = messages.has(messageId);
+        const previousText = messages.get(messageId) || "";
+        if (fullText === previousText) continue;
+        messages.set(messageId, fullText);
+        const append = fullText.startsWith(previousText);
+        await emit({ type: append ? "text" : "replace", sessionId, runId: String(entry.runId || runId), messageId,
+          text: append ? fullText.slice(previousText.length) : fullText, fullText,
+          newMessage: !seen, streaming: entry.streaming === true });
       }
+      await emitInput(status, runId, runtime, canonicalInput);
+      // A newly created session can report idle before its first run starts.
+      if (FAILURE_STATUSES.has(status) || (!hasPendingWork(runtime)
+        && (status === "completed" || (status === "idle" && (observedActivity || allowIdle))))) return snapshot;
       await pollingDelay();
     }
   } catch (error) {

package/src/tools.mjs

@@ -78,7 +78,7 @@ async function executeBrowserTool(state, name, args, { signal, connectionSignal,
       if (remaining !== null && remaining <= 0) throw new DOMException("Stopped watching after waitTimeoutSeconds. The browser task may still be running.", "TimeoutError");
       return await waitForTask({ sessionId, clientId: args.clientId, signal, timeoutSeconds: remaining,
         requestTimeoutSeconds: args.timeoutSeconds || state.requestTimeoutSeconds || 180,
-        expectedRunId: tracking.runId, expectedMessageId: tracking.clientMessageId,
+        expectedRunId: tracking.runId, expectedMessageId: tracking.clientMessageId, messageWasQueued: tracking.disposition === "queued",
         ignoreWaitId: tracking.ignoreWaitId, allowIdle: tracking.allowIdle,
         onUpdate: onTaskUpdate && (event => args.stream || !["text", "replace"].includes(event.type) ? onTaskUpdate(event) : undefined),
         getSnapshot: async ({ signal: requestSignal, timeoutSeconds }) => bindInputClient("qingzhou_get_session_snapshot",
@@ -140,9 +140,11 @@ async function executeBrowserTool(state, name, args, { signal, connectionSignal,
       result = { ...result, snapshot: await watch(sessionId, { allowIdle: !args.firstMessage.trim() }) };
     } else if (name === "qingzhou_send_message" && result?.accepted === true) {
       if (typeof result.clientMessageId !== "string" || !result.clientMessageId.trim()) {
-        throw new BridgeError("invalid_response", "The message was accepted without a tracking ID. Inspect the task before sending it again.");
+        throw Object.assign(new BridgeError("invalid_response", "The message was accepted without a tracking ID. Continue watching the same task before sending it again."), {
+          details: { sessionId, clientId, recovery: { tool: "qingzhou_watch_task", arguments: { sessionId, clientId } } },
+        });
       }
-      result = { ...result, snapshot: await watch(sessionId, { clientMessageId: result.clientMessageId }) };
+      result = { ...result, snapshot: await watch(sessionId, { clientMessageId: result.clientMessageId, disposition: result.disposition }) };
     } else if (name === "qingzhou_respond_to_user_input" && (result?.accepted === true || result?.requiresUserAction)) {
       const snapshot = await watch(sessionId, { runId: result.runId || "", ignoreWaitId: result.requiresUserAction ? "" : args.waitId });
       result = result.requiresUserAction ? { sessionId, waitId: args.waitId, snapshot } : { ...result, snapshot };