@qwen-code/qwen-code 0.19.11 → 0.19.12-preview.0

package/chunks/{chunk-6Y6ORE2G.js → chunk-WACI4VES.js}

@@ -3,30 +3,39 @@
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-CF5VJRGC.js";
+} from "./chunk-7LMAKIWE.js";
 import {
   sanitizeTerminalText
-} from "./chunk-SUARMD4Q.js";
+} from "./chunk-J6NT5YTN.js";
+import {
+  isGoalStatusKind,
+  isTerminalGoalStatusKind
+} from "./chunk-76BFY7AF.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
 import {
-  writeStderrLine
-} from "./chunk-YUZI3WAC.js";
+  writeStderrLine,
+  writeStderrLineSafe
+} from "./chunk-OWAK7LMW.js";
 import {
-  getActiveGoal
-} from "./chunk-NJOFRXTM.js";
+  getActiveGoal,
+  registerGoalHook,
+  setGoalTerminalObserver,
+  setLastGoalTerminal,
+  unregisterGoalHook
+} from "./chunk-6TDA4EVC.js";
 import {
   apiActivityTracker,
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-MQOVXZAF.js";
+} from "./chunk-YN2I5I42.js";
 import {
   ToolNames
-} from "./chunk-JGUT3LWZ.js";
+} from "./chunk-ANRANWVE.js";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -35,6 +44,195 @@ import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/cli/src/ui/utils/restoreGoal.ts
+init_esbuild_shims();
+function findGoalToRestore(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const item = history[i];
+    if (item?.type !== "goal_status" /* GOAL_STATUS */) continue;
+    const goal = item;
+    if (goal.kind !== "set" && goal.kind !== "checking") return null;
+    const setAt = goal.setAt ?? findSetAtOfRun(history, i);
+    return {
+      condition: goal.condition,
+      iterations: goal.iterations ?? 0,
+      ...setAt !== void 0 ? { setAt } : {}
+    };
+  }
+  return null;
+}
+__name(findGoalToRestore, "findGoalToRestore");
+function findSetAtOfRun(history, startIndex) {
+  const start = history[startIndex];
+  const condition = start?.condition;
+  for (let i = startIndex - 1; i >= 0; i--) {
+    const item = history[i];
+    if (item?.type !== "goal_status" /* GOAL_STATUS */) continue;
+    const goal = item;
+    if (goal.kind !== "set" && goal.kind !== "checking") return void 0;
+    if (goal.condition !== condition) return void 0;
+    if (goal.setAt !== void 0) return goal.setAt;
+  }
+  return void 0;
+}
+__name(findSetAtOfRun, "findSetAtOfRun");
+function findLastTerminalGoal(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const item = history[i];
+    if (item?.type !== "goal_status" /* GOAL_STATUS */) continue;
+    const goal = item;
+    if (!isTerminalGoalStatusKind(goal.kind)) continue;
+    return {
+      kind: goal.kind,
+      condition: goal.condition,
+      iterations: goal.iterations ?? 0,
+      durationMs: goal.durationMs ?? 0,
+      lastReason: goal.lastReason
+    };
+  }
+  return null;
+}
+__name(findLastTerminalGoal, "findLastTerminalGoal");
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(finiteNumber, "finiteNumber");
+function isTranscriptItemRecord(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+__name(isTranscriptItemRecord, "isTranscriptItemRecord");
+function parseGoalStatusItem(item) {
+  if (!isTranscriptItemRecord(item)) return null;
+  if (item["type"] !== "goal_status" /* GOAL_STATUS */) return null;
+  const kind = item["kind"];
+  const condition = item["condition"];
+  if (!isGoalStatusKind(kind) || typeof condition !== "string") return null;
+  const iterations = finiteNumber(item["iterations"]);
+  const setAt = finiteNumber(item["setAt"]);
+  const durationMs = finiteNumber(item["durationMs"]);
+  const lastReason = typeof item["lastReason"] === "string" ? item["lastReason"] : void 0;
+  return {
+    type: "goal_status" /* GOAL_STATUS */,
+    kind,
+    condition,
+    ...iterations !== void 0 ? { iterations } : {},
+    ...setAt !== void 0 ? { setAt } : {},
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...lastReason !== void 0 ? { lastReason } : {}
+  };
+}
+__name(parseGoalStatusItem, "parseGoalStatusItem");
+function collectGoalStatusItemsFromRecords(records) {
+  const items = [];
+  for (const record of records) {
+    if (record.type !== "system" || record.subtype !== "slash_command") {
+      continue;
+    }
+    const payload = record.systemPayload;
+    if (payload?.phase !== "result") continue;
+    const raws = payload.outputHistoryItems;
+    if (!Array.isArray(raws)) continue;
+    for (const raw of raws) {
+      const item = parseGoalStatusItem(raw);
+      if (item) items.push(item);
+    }
+  }
+  return items;
+}
+__name(collectGoalStatusItemsFromRecords, "collectGoalStatusItemsFromRecords");
+function goalTerminalEventToHistoryItem(event) {
+  return {
+    type: "goal_status" /* GOAL_STATUS */,
+    kind: event.kind,
+    condition: event.condition,
+    iterations: event.iterations,
+    durationMs: event.durationMs,
+    lastReason: event.lastReason ?? event.systemMessage
+  };
+}
+__name(goalTerminalEventToHistoryItem, "goalTerminalEventToHistoryItem");
+function recordGoalStatusItem(config, item, rawCommand = "/goal") {
+  try {
+    const recording = config.getChatRecordingService?.();
+    if (!recording) {
+      writeStderrLineSafe(
+        `qwen: no chat recording service; goal_status (kind=${item.kind}) will not survive a resume.`
+      );
+      return;
+    }
+    recording.recordSlashCommand({
+      phase: "result",
+      rawCommand,
+      outputHistoryItems: [{ ...item }]
+    });
+  } catch (error) {
+    writeStderrLineSafe(
+      `qwen: failed to record goal_status (kind=${item.kind}): ${error}`
+    );
+  }
+}
+__name(recordGoalStatusItem, "recordGoalStatusItem");
+function installGoalTerminalObserver(args) {
+  const { sessionId, config, addItem } = args;
+  setGoalTerminalObserver(sessionId, (event) => {
+    const item = goalTerminalEventToHistoryItem(event);
+    addItem(item, Date.now());
+    recordGoalStatusItem(config, item);
+  });
+}
+__name(installGoalTerminalObserver, "installGoalTerminalObserver");
+function goalRestoreBlockedBy(config) {
+  if (!config.isTrustedFolder()) return "untrusted-folder";
+  if (config.getDisableAllHooks()) return "hooks-disabled";
+  if (!config.getHookSystem()) return "no-hook-system";
+  return null;
+}
+__name(goalRestoreBlockedBy, "goalRestoreBlockedBy");
+function goalConditionBlockedBy(condition) {
+  if (condition.length === 0) return "condition-invalid";
+  return null;
+}
+__name(goalConditionBlockedBy, "goalConditionBlockedBy");
+function restoreGoalFromHistory(history, config, addItem) {
+  const sessionId = config.getSessionId();
+  const lastTerminal = findLastTerminalGoal(history);
+  setLastGoalTerminal(sessionId, lastTerminal ?? void 0);
+  const restorable = findGoalToRestore(history);
+  if (restorable === null) {
+    unregisterGoalHook(config, sessionId);
+    return { restored: false };
+  }
+  const blockedBy = goalRestoreBlockedBy(config);
+  if (blockedBy) {
+    unregisterGoalHook(config, sessionId);
+    return { restored: false, blockedBy };
+  }
+  if (goalConditionBlockedBy(restorable.condition)) {
+    writeStderrLineSafe(
+      `qwen: refusing to restore a goal for session ${sessionId}: the condition is empty.`
+    );
+    unregisterGoalHook(config, sessionId);
+    return { restored: false, blockedBy: "condition-invalid" };
+  }
+  registerGoalHook({
+    config,
+    sessionId,
+    condition: restorable.condition,
+    tokensAtStart: 0,
+    // Resume the iteration count so MAX_GOAL_ITERATIONS is a cross-resume cap,
+    // not a per-resume one.
+    initialIterations: restorable.iterations,
+    // Likewise the start time: without it every reload restarts the clock, and
+    // `GET /goals` reports a long-running goal as freshly started.
+    ...restorable.setAt !== void 0 ? { initialSetAt: restorable.setAt } : {}
+  });
+  if (addItem) {
+    installGoalTerminalObserver({ sessionId, config, addItem });
+  }
+  return { restored: true, condition: restorable.condition };
+}
+__name(restoreGoalFromHistory, "restoreGoalFromHistory");
+
 // packages/cli/src/services/setup-github.ts
 init_esbuild_shims();
 var import_undici2 = __toESM(require_undici(), 1);
@@ -1212,6 +1410,11 @@ function extractFunctionResponseId(record) {
 __name(extractFunctionResponseId, "extractFunctionResponseId");
 
 // packages/cli/src/acp-integration/session/history-replayer.ts
+var GOAL_NOT_RESTORED_REASON = {
+  "untrusted-folder": "Goal not restored: this folder is not trusted, so its Stop hook cannot run.",
+  "hooks-disabled": "Goal not restored: hooks are disabled for this session.",
+  "no-hook-system": "Goal not restored: the hook system is unavailable."
+};
 var MISSING_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
 var HistoryReplayer = class {
   static {
@@ -1220,9 +1423,11 @@ var HistoryReplayer = class {
   ctx;
   messageEmitter;
   toolCallEmitter;
+  options;
   pendingReplayToolCalls = /* @__PURE__ */ new Map();
-  constructor(ctx) {
+  constructor(ctx, options = {}) {
     this.ctx = ctx;
+    this.options = options;
     this.messageEmitter = new MessageEmitter(ctx);
     this.toolCallEmitter = new ToolCallEmitter(ctx);
   }
@@ -1237,6 +1442,7 @@ var HistoryReplayer = class {
   async replay(records, gaps) {
     try {
       await this.replayPage(records, { finalizeDangling: true, gaps });
+      await this.supersedeUnrestorableGoal(records);
     } finally {
       this.pendingReplayToolCalls.clear();
       this.setActiveRecordId(null);
@@ -1509,14 +1715,33 @@ var HistoryReplayer = class {
    * Replays a slash_command system record by re-emitting its output as an
    * agent message chunk. This allows Zed to reconstruct the correct turn
    * structure (user → agent) on session resume without polluting model context.
+   *
+   * Goal cards are re-emitted as `_meta.goalStatus` rather than text: they carry
+   * no `text` field, so the plain-text path below would silently drop them and
+   * the client would lose the goal card (and its status pill) on every reload.
+   * Per-iteration `checking` cards are skipped — a TUI transcript persists one
+   * per stop-hook turn, and clients suppress them as noise. Skipping costs no
+   * fidelity: goal restore reads the records directly, not this replay.
    */
   async replaySlashCommandResult(record) {
     const payload = record.systemPayload;
-    if (payload?.phase !== "result" || !payload.outputHistoryItems?.length) {
-      return;
-    }
-    for (const item of payload.outputHistoryItems) {
-      const text = typeof item["text"] === "string" ? item["text"] : "";
+    if (payload?.phase !== "result") return;
+    const items = payload.outputHistoryItems;
+    if (!Array.isArray(items) || items.length === 0) return;
+    for (const item of items) {
+      const goalStatus = parseGoalStatusItem(item);
+      if (goalStatus) {
+        if (goalConditionBlockedBy(goalStatus.condition)) {
+          writeStderrLineSafe(
+            "qwen: skipping replay of a goal card whose condition is empty."
+          );
+        } else if (goalStatus.kind !== "checking") {
+          const { type: _type, ...status } = goalStatus;
+          await this.messageEmitter.emitGoalStatus(status);
+        }
+        continue;
+      }
+      const text = isTranscriptItemRecord(item) && typeof item["text"] === "string" ? item["text"] : "";
       if (text) {
         await this.messageEmitter.emitSlashCommandOutput(
           text.replace(/\n/g, "  \n"),
@@ -1525,6 +1750,42 @@ var HistoryReplayer = class {
       }
     }
   }
+  /**
+   * Emits a trailing `cleared` card when the transcript ends on an active goal
+   * that `restoreGoalFromHistory` is about to refuse.
+   *
+   * A client reads "there is an active goal" off the newest goal card it has
+   * seen, so replaying a `set` card that no Stop hook will drive leaves the UI
+   * claiming a goal is running when the loop is dead. The gates are pure
+   * functions of `config`, so the answer is known here, before restore runs.
+   *
+   * This card is emitted, not recorded: the transcript keeps its `set` card, so
+   * a later resume in a trusted folder (or with hooks re-enabled) restores the
+   * goal instead of finding it destroyed. Emitting from inside replay is also
+   * what puts the card *after* the `set` card — `loadSession` batches replay
+   * updates into its response, and a notification sent afterwards would reach
+   * the client first.
+   *
+   * Gated on `supersedeUnrestorableGoal`: only a resume registers a hook, and
+   * only a resume has a `config` that answers trust and hook-policy questions.
+   */
+  async supersedeUnrestorableGoal(records) {
+    if (!this.options.supersedeUnrestorableGoal) return;
+    const active = findGoalToRestore(
+      collectGoalStatusItemsFromRecords(records)
+    );
+    if (!active || goalConditionBlockedBy(active.condition)) return;
+    if (!hasFullSessionContext(this.ctx)) return;
+    const blockedBy = goalRestoreBlockedBy(this.ctx.config);
+    if (!blockedBy) return;
+    await this.messageEmitter.emitGoalStatus({
+      kind: "cleared",
+      condition: active.condition,
+      iterations: active.iterations,
+      ...active.setAt !== void 0 ? { setAt: active.setAt } : {},
+      lastReason: GOAL_NOT_RESTORED_REASON[blockedBy]
+    });
+  }
   /**
    * Extracts tool name from a chat record's function response.
    */
@@ -1539,10 +1800,7 @@ var HistoryReplayer = class {
     return "";
   }
   setActiveRecordId(recordId, timestamp) {
-    const context = this.ctx;
-    if (typeof context.setActiveRecordId === "function") {
-      context.setActiveRecordId(recordId, timestamp);
-    }
+    this.ctx.setActiveRecordId?.(recordId, timestamp);
   }
 };
 
@@ -1735,7 +1993,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-XPKFZ3RN.js");
+    const { getGitRepoName } = await import("./src-ADLNIPHD.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -2579,6 +2837,11 @@ export {
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter,
+  collectGoalStatusItemsFromRecords,
+  goalTerminalEventToHistoryItem,
+  recordGoalStatusItem,
+  installGoalTerminalObserver,
+  restoreGoalFromHistory,
   HistoryReplayer,
   collectSessionData,
   normalizeSessionData,
@@ -2590,6 +2853,11 @@ export {
   toJsonl,
   generateExportFilename
 };
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Google LLC

package/chunks/{chunk-WTNZ6DXB.js → chunk-WEPXQKGP.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-JGUT3LWZ.js";
+} from "./chunk-ANRANWVE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4BJVSIS3.js → chunk-WHQNBBWW.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-FEOZBUMT.js";
 import {
   TextTokenizer
-} from "./chunk-VRR65QYW.js";
+} from "./chunk-V4PCIS25.js";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QDJ2R4CM.js → chunk-WTHRMVKB.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-THXDQSTA.js";
+} from "./chunk-IQRQVPGN.js";
 import {
   parseAndFormatApiError
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-MQOVXZAF.js";
+} from "./chunk-YN2I5I42.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-L4Y55KIS.js → chunk-X6YQWCIJ.js}

@@ -169,7 +169,7 @@ var WorkspaceMismatchError = class extends Error {
   constructor(bound, requested) {
     const safeRequested = requested.length > MAX_WORKSPACE_PATH_LENGTH ? `${requested.slice(0, MAX_WORKSPACE_PATH_LENGTH)}\u2026[truncated]` : requested;
     super(
-      `Workspace mismatch: daemon is bound to "${bound}" but request asked for "${safeRequested}". Each \`qwen serve\` daemon binds to exactly one workspace; start a separate daemon for "${safeRequested}" (or route the request to one via an orchestrator).`
+      `Workspace mismatch: runtime is bound to "${bound}" but request asked for "${safeRequested}". Select a registered runtime for "${safeRequested}" or register it before retrying; this bridge will not fall back to the primary workspace.`
     );
     this.name = "WorkspaceMismatchError";
     this.bound = bound;

package/chunks/{chunk-Q6TUALBE.js → chunk-XAAEDML2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RKUWKYED.js";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-BUAXJVNP.js → chunk-XACBIZJB.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-3M75MSVA.js";
+} from "./chunk-SMASS3CY.js";
 import {
   resolvePath
-} from "./chunk-FSA7ERJ2.js";
+} from "./chunk-F2RR4HO2.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2OG646IN.js → chunk-XFJU7SVP.js}

@@ -10,18 +10,18 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine
-} from "./chunk-YUZI3WAC.js";
+} from "./chunk-OWAK7LMW.js";
 import {
   ideContextStore
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
 import {
   atomicWriteFileSync
-} from "./chunk-WIEO4CWB.js";
+} from "./chunk-VAJS2E2D.js";
 import {
   FatalConfigError,
   Storage,
   getErrorMessage
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-KKRTYONM.js → chunk-XSPFQQRE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getTasksDir
-} from "./chunk-TV6K2FB4.js";
+} from "./chunk-4RPARQ5D.js";
 import {
   require_proper_lockfile
 } from "./chunk-E2UVIFI2.js";
@@ -11,11 +11,11 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-WIEO4CWB.js";
+} from "./chunk-VAJS2E2D.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-V2DXTLUE.js → chunk-Y5UDBQYF.js}

@@ -8,13 +8,13 @@ import {
 } from "./chunk-L573Z2QZ.js";
 import {
   t
-} from "./chunk-4AGTGMCQ.js";
+} from "./chunk-3PE7OY2G.js";
 import {
   So
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";