@qwen-code/qwen-code 0.23.5-dev.codemode-responses.20260915.f024b37689 → 0.23.5-preview.0

package/chunks/{chunk-NJ2OFVUX.js → chunk-P42KMMU6.js}

@@ -6,6 +6,10 @@ import {
 import {
   stringifyGenAiJson
 } from "./chunk-KFFCDLKV.js";
+import {
+  GOAL_STATE_EVENT_CAUSES,
+  makeGoalStateEvent
+} from "./chunk-CDDP4ONL.js";
 import {
   atomicWriteJSON
 } from "./chunk-XFFRI3WM.js";
@@ -16,7 +20,7 @@ import {
   getMeter,
   isTelemetrySdkInitialized,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-4Y2I3CI3.js";
+} from "./chunk-6USYH3EU.js";
 import {
   FatalConfigError,
   QWEN_DIR,
@@ -7615,6 +7619,801 @@ init_esbuild_shims();
 // packages/core/src/telemetry/index.ts
 init_esbuild_shims();
 
+// packages/core/src/telemetry/goal-events.ts
+init_esbuild_shims();
+
+// packages/core/src/goals/goal-reducer.ts
+init_esbuild_shims();
+
+// packages/core/src/goals/goal-protocol.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/terminalSafe.ts
+init_esbuild_shims();
+var TERMINAL_OSC_REGEX = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+var TERMINAL_CSI_REGEX = /\x1b\[[\d;?]*[a-zA-Z]/g;
+var TERMINAL_SHIFT_DCS_REGEX = /\x1b[NOP]/g;
+function stripTerminalControlSequences(s) {
+  return s.replace(TERMINAL_OSC_REGEX, " ").replace(TERMINAL_CSI_REGEX, " ").replace(TERMINAL_SHIFT_DCS_REGEX, " ").replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+}
+__name(stripTerminalControlSequences, "stripTerminalControlSequences");
+function isBidiControlChar(code) {
+  return code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297;
+}
+__name(isBidiControlChar, "isBidiControlChar");
+function stripDisplayControlChars(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 9) {
+      out += text[i];
+      continue;
+    }
+    if (code < 32) continue;
+    if (code >= 128 && code <= 159) continue;
+    if (isBidiControlChar(code)) continue;
+    out += text[i];
+  }
+  return out;
+}
+__name(stripDisplayControlChars, "stripDisplayControlChars");
+var NOTIFICATION_LABEL_MAX_LENGTH = 80;
+function truncateNotificationLabel(label) {
+  const normalized = stripDisplayControlChars(label).replace(/\s+/g, " ").trim();
+  const codePoints = [...normalized];
+  if (codePoints.length <= NOTIFICATION_LABEL_MAX_LENGTH) {
+    return normalized;
+  }
+  return codePoints.slice(0, NOTIFICATION_LABEL_MAX_LENGTH - 3).join("") + "...";
+}
+__name(truncateNotificationLabel, "truncateNotificationLabel");
+
+// packages/core/src/goals/goal-protocol.ts
+var GOAL_STATE_VERSION = 2;
+var GOAL_PROPOSAL_REASON_MAX_CHARACTERS = 8e3;
+var GOAL_PROPOSAL_REASON_MAX_BYTES = 16e3;
+var GOAL_CHECKPOINT_CLAIM_LIMIT = 32;
+var GOAL_CHECKPOINT_CLAIM_MAX_CHARACTERS = 2e3;
+var GOAL_CHECKPOINT_CLAIM_MAX_BYTES = 16e3;
+var GOAL_CHECKPOINT_SOURCE_REFERENCE_LIMIT = 32;
+var GOAL_EVIDENCE_CATALOG_EXHAUSTED_REASON = "The current Goal revision exceeded the bounded evidence catalog. Automatic retries cannot recover. Edit or replace the Goal before resuming it.";
+var GOAL_CHECKPOINT_REQUEST_TOO_LARGE_REASON = "The current Goal revision exceeded the checkpoint verifier request limit. Automatic retries cannot recover. Edit or replace the Goal before resuming it.";
+var GOAL_CHECKPOINT_STALL_LIMIT = 3;
+var GOAL_NO_PROGRESS_TURN_LIMIT = 3;
+var GOAL_CHECKPOINT_STALLED_REASON = "The current Goal revision ran three consecutive evidence checkpoints without relief: the evidence window overflowed every time, and the last check could not fit it within the checkpoint claim bounds, so every turn paid a checkpoint call and lost uncatalogued evidence. Automatic retries cannot recover. Edit or replace the Goal with a narrower objective before resuming it.";
+var GOAL_CHECKPOINT_UNUSABLE_REASON = "The current Goal revision ran three consecutive evidence checkpoints without relief: the evidence window overflowed every time, and the last check answered with output that could not be folded into claims. Narrowing the objective does not fix this. Check that the checkpoint model returns the structured JSON it is asked for, or switch models, then resume the Goal; resuming starts a fresh evidence window.";
+var GOAL_CHECKPOINT_UNREACHABLE_REASON = "The current Goal revision ran three consecutive evidence checkpoints without relief: the evidence window overflowed every time, and the last check failed before the checkpoint verifier returned an answer. The recorded checkpoint failure says why: an unreachable or rate-limited provider, a check that did not finish within model.goalCheckpointTimeoutSeconds, or an error in the check itself. Fix the provider, raise that timeout, or narrow the objective so the window checkpoints in time, then resume the Goal; resuming starts a fresh evidence window.";
+function goalCheckpointStalledReason(shape) {
+  switch (shape) {
+    case "capacity":
+      return GOAL_CHECKPOINT_STALLED_REASON;
+    case "unusable":
+      return GOAL_CHECKPOINT_UNUSABLE_REASON;
+    case "unreachable":
+      return GOAL_CHECKPOINT_UNREACHABLE_REASON;
+    default: {
+      const exhaustive = shape;
+      return exhaustive;
+    }
+  }
+}
+__name(goalCheckpointStalledReason, "goalCheckpointStalledReason");
+var GOAL_CHECKPOINT_FAILURE_MAX_CHARACTERS = 500;
+function capGoalCheckpointFailure(text) {
+  const oneLine = stripDisplayControlChars(stripTerminalControlSequences(text)).replace(/\s+/g, " ").trim();
+  const codePoints = [...oneLine];
+  return codePoints.length <= GOAL_CHECKPOINT_FAILURE_MAX_CHARACTERS ? oneLine : `${codePoints.slice(0, GOAL_CHECKPOINT_FAILURE_MAX_CHARACTERS - 1).join("")}\u2026`;
+}
+__name(capGoalCheckpointFailure, "capGoalCheckpointFailure");
+function goalCheckpointHealthVisible(goal) {
+  if (goal.status === "complete") return false;
+  if ((goal.checkpointStalls ?? 0) > 0) return true;
+  const failed = Boolean(goal.lastCheckpointFailure?.trim());
+  if (goal.limitKind === "checkpoint_request") return failed;
+  return (goal.status ?? "active") === "active" && failed;
+}
+__name(goalCheckpointHealthVisible, "goalCheckpointHealthVisible");
+function goalCheckpointHealthLine(goal, clean = (text) => text) {
+  if (!goalCheckpointHealthVisible(goal)) return void 0;
+  const stalls = goal.checkpointStalls ?? 0;
+  return [
+    stalls > 0 ? `${stalls}/${GOAL_CHECKPOINT_STALL_LIMIT} stalled` : "last check failed",
+    clean(goal.lastCheckpointFailure ?? "").trim()
+  ].filter(Boolean).join(" \xB7 ");
+}
+__name(goalCheckpointHealthLine, "goalCheckpointHealthLine");
+var GOAL_DEFAULT_TOKEN_BUDGET = 3e7;
+function goalTokenBudgetReason(tokenBudget) {
+  return `The Goal spent its autonomous token budget (${tokenBudget.toLocaleString("en-US")} tokens). Resume the Goal to authorize another budget window, or clear it.`;
+}
+__name(goalTokenBudgetReason, "goalTokenBudgetReason");
+function isGoalTokenBudgetSpent(goal) {
+  return goal.tokenBudget !== void 0 && goal.tokensUsed >= goal.tokenBudget;
+}
+__name(isGoalTokenBudgetSpent, "isGoalTokenBudgetSpent");
+function goalTurnBudgetReason(turnBudget) {
+  return `The Goal ran its Goal-turn budget (${turnBudget.toLocaleString("en-US")} ${turnBudget === 1 ? "turn" : "turns"}). Resume the Goal to authorize another window of turns, or clear it.`;
+}
+__name(goalTurnBudgetReason, "goalTurnBudgetReason");
+function isGoalTurnBudgetSpent(goal) {
+  return goal.turnBudget !== void 0 && goal.turnCount >= goal.turnBudget;
+}
+__name(isGoalTurnBudgetSpent, "isGoalTurnBudgetSpent");
+function formatGoalActiveTimeBudget(activeTimeBudgetMs) {
+  const minutes = activeTimeBudgetMs / 6e4;
+  if (minutes >= 1) {
+    const rounded = Math.round(minutes);
+    return `${rounded.toLocaleString("en-US")} ${rounded === 1 ? "minute" : "minutes"}`;
+  }
+  const seconds = Math.max(1, Math.round(activeTimeBudgetMs / 1e3));
+  return `${seconds.toLocaleString("en-US")} ${seconds === 1 ? "second" : "seconds"}`;
+}
+__name(formatGoalActiveTimeBudget, "formatGoalActiveTimeBudget");
+function goalActiveTimeBudgetReason(activeTimeBudgetMs) {
+  return `The Goal ran its active-time budget (${formatGoalActiveTimeBudget(activeTimeBudgetMs)}). Resume the Goal to authorize another window of time, or clear it.`;
+}
+__name(goalActiveTimeBudgetReason, "goalActiveTimeBudgetReason");
+function isGoalActiveTimeBudgetSpent(goal, elapsedActiveMs) {
+  return goal.activeTimeBudgetMs !== void 0 && elapsedActiveMs >= goal.activeTimeBudgetMs;
+}
+__name(isGoalActiveTimeBudgetSpent, "isGoalActiveTimeBudgetSpent");
+function isGoalLimitKind(value) {
+  return value === "evidence_catalog" || value === "checkpoint_request" || isGoalBudgetLimitKind(value);
+}
+__name(isGoalLimitKind, "isGoalLimitKind");
+function isGoalBudgetLimitKind(value) {
+  return value === "token_budget" || value === "turn_budget" || value === "time_budget";
+}
+__name(isGoalBudgetLimitKind, "isGoalBudgetLimitKind");
+function goalLimitKindForReason(reason) {
+  if (reason === GOAL_EVIDENCE_CATALOG_EXHAUSTED_REASON) {
+    return "evidence_catalog";
+  }
+  if (reason === GOAL_CHECKPOINT_REQUEST_TOO_LARGE_REASON) {
+    return "checkpoint_request";
+  }
+  return void 0;
+}
+__name(goalLimitKindForReason, "goalLimitKindForReason");
+var PAUSED_GOAL_SYSTEM_REMINDER = "<system-reminder>\nThe Goal is paused. Do not continue its objective unless the user resumes it. Treat this message as ordinary conversation.\n</system-reminder>";
+function isGoalEvidenceProofKind(value) {
+  return value === "user_input" || value === "delivered_output" || value === "external_fact";
+}
+__name(isGoalEvidenceProofKind, "isGoalEvidenceProofKind");
+function emptyGoalSnapshot() {
+  return { v: GOAL_STATE_VERSION, goal: null, activity: "idle" };
+}
+__name(emptyGoalSnapshot, "emptyGoalSnapshot");
+function goalRequiresExactPermit(snapshot) {
+  return snapshot.goal !== null && (snapshot.goal.status === "active" || snapshot.activity === "running");
+}
+__name(goalRequiresExactPermit, "goalRequiresExactPermit");
+function isRepeatedBlockerProposal(proposal) {
+  return proposal.status === "blocked" && proposal.blockerKind !== "authority" && proposal.blockerKind !== "external" && proposal.blockerKind !== "infeasible";
+}
+__name(isRepeatedBlockerProposal, "isRepeatedBlockerProposal");
+var GOAL_INFEASIBLE_NEXT_STEP = "The objective cannot be satisfied as written; edit or replace the Goal with an objective the evidence allows before resuming it.";
+function validateGoalProposalReason(reason) {
+  if (!reason.trim()) return "Goal proposal reason must not be empty";
+  if ([...reason].length > GOAL_PROPOSAL_REASON_MAX_CHARACTERS) {
+    return `Goal proposal reason exceeds ${GOAL_PROPOSAL_REASON_MAX_CHARACTERS} characters`;
+  }
+  if (new TextEncoder().encode(reason).byteLength > GOAL_PROPOSAL_REASON_MAX_BYTES) {
+    return `Goal proposal reason exceeds ${GOAL_PROPOSAL_REASON_MAX_BYTES} UTF-8 bytes`;
+  }
+  return null;
+}
+__name(validateGoalProposalReason, "validateGoalProposalReason");
+var GOAL_PAUSE_REASON_MAX_CHARACTERS = 500;
+function validateGoalPauseReason(reason) {
+  if (!reason.trim()) return "Goal pause reason must not be empty";
+  if (reason.length > GOAL_PAUSE_REASON_MAX_CHARACTERS) {
+    let codePoints = 0;
+    for (const _codePoint of reason) {
+      if (++codePoints > GOAL_PAUSE_REASON_MAX_CHARACTERS) {
+        return `Goal pause reason exceeds ${GOAL_PAUSE_REASON_MAX_CHARACTERS} characters`;
+      }
+    }
+  }
+  return null;
+}
+__name(validateGoalPauseReason, "validateGoalPauseReason");
+var GOAL_PAUSE_REASON_USER_INTERRUPT = "Interrupted by the user. Run /goal resume to continue.";
+var GOAL_PAUSE_REASON_COMMAND = "Paused with /goal pause.";
+var GOAL_PAUSE_REASON_SESSION_TOKEN_LIMIT = "The session token limit was exceeded before the model request. Start a new session or increase sessionTokenLimit in settings.json before resuming the Goal.";
+var GOAL_PAUSE_REASON_STOP_HOOK_CAP = "A Stop hook blocked this session too many times in a row. Run /goal resume to continue.";
+var GOAL_PAUSE_REASON_SESSION_DISPOSED = "The session started closing before the turn finished. Run /goal resume to continue.";
+var GOAL_PAUSE_REASON_HEADLESS_RUN_ENDED = "The headless run finished before the Goal did. Resume the Goal in a later run.";
+var GOAL_PAUSE_REASON_NO_PROGRESS = "Three Goal turns in a row recorded nothing to judge and no proposal. Resume the Goal to try again, or edit its objective into one the model can act on and then resume it.";
+function truncateGoalPauseReason(reason) {
+  const codePoints = [...reason];
+  return codePoints.length <= GOAL_PAUSE_REASON_MAX_CHARACTERS ? reason : `${codePoints.slice(0, GOAL_PAUSE_REASON_MAX_CHARACTERS - 1).join("")}\u2026`;
+}
+__name(truncateGoalPauseReason, "truncateGoalPauseReason");
+function goalPauseReasonForFailure(message) {
+  const detail = message.trim();
+  return truncateGoalPauseReason(
+    detail ? `The Goal turn could not finish: ${detail}. Run /goal resume to continue.` : "The Goal turn could not finish. Run /goal resume to continue."
+  );
+}
+__name(goalPauseReasonForFailure, "goalPauseReasonForFailure");
+function goalPauseReasonForHeadlessFailure(message) {
+  const detail = message.trim();
+  return truncateGoalPauseReason(
+    detail ? `The headless run stopped: ${detail}. Resume the Goal in a later run.` : "The headless run stopped before the Goal turn finished. Resume the Goal in a later run."
+  );
+}
+__name(goalPauseReasonForHeadlessFailure, "goalPauseReasonForHeadlessFailure");
+function goalPauseReasonForRunBudget(budget) {
+  const detail = budget.trim();
+  return truncateGoalPauseReason(
+    detail ? `The headless run stopped at its ${detail} budget. Resume the Goal in a later run.` : "The headless run stopped at a budget. Resume the Goal in a later run."
+  );
+}
+__name(goalPauseReasonForRunBudget, "goalPauseReasonForRunBudget");
+
+// packages/core/src/goals/goal-reducer.ts
+var MAX_BLOCKED_AUDIT_COUNT = 3;
+var GoalConflictError = class extends Error {
+  constructor(current) {
+    super("Goal version does not match the current session Goal");
+    this.current = current;
+    this.name = "GoalConflictError";
+  }
+  static {
+    __name(this, "GoalConflictError");
+  }
+};
+var GoalInvalidTransitionError = class extends Error {
+  constructor(message, current) {
+    super(message);
+    this.current = current;
+    this.name = "GoalInvalidTransitionError";
+  }
+  static {
+    __name(this, "GoalInvalidTransitionError");
+  }
+};
+function elapsedActiveTime(goal, now) {
+  return goal.activeTimeMs + (goal.status === "active" ? Math.max(0, now - goal.updatedAt) : 0);
+}
+__name(elapsedActiveTime, "elapsedActiveTime");
+function reduceGoalControl(current, transition) {
+  const { request } = transition;
+  if (request.action === "create") {
+    if (current) throw new GoalConflictError(snapshotOf(current));
+    return createGoal(
+      transition.nextGoalId,
+      normalizeObjective(request.objective, snapshotOf(null)),
+      transition.now,
+      transition.cursor,
+      transition
+    );
+  }
+  assertExpectedVersion(
+    current,
+    request.expectedGoalId,
+    request.expectedRevision
+  );
+  if (request.action === "clear") return null;
+  if (request.action === "replace") {
+    return createGoal(
+      transition.nextGoalId,
+      normalizeObjective(request.objective, snapshotOf(current)),
+      transition.now,
+      transition.cursor,
+      transition
+    );
+  }
+  if (request.action === "edit") {
+    if (current.status === "complete") {
+      throw new GoalInvalidTransitionError(
+        "A completed Goal cannot be edited",
+        snapshotOf(current)
+      );
+    }
+    return transitionGoal(current, transition.now, {
+      revision: current.revision + 1,
+      objective: normalizeObjective(request.objective, snapshotOf(current)),
+      evidenceCursor: copyCursor(transition.cursor),
+      evidenceCheckpoint: void 0,
+      checkpointStalls: void 0,
+      lastCheckpointFailure: void 0,
+      noProgressTurns: void 0,
+      ...rearmedBudgets(current, transition.now, transition),
+      lastReason: void 0,
+      limitKind: void 0
+    });
+  }
+  if (request.action === "pause") {
+    if (current.status !== "active") {
+      throw new GoalInvalidTransitionError(
+        "Only an active Goal can be paused",
+        snapshotOf(current)
+      );
+    }
+    return transitionGoal(current, transition.now, {
+      status: "paused",
+      lastReason: request.reason
+    });
+  }
+  if (current.status === "complete") {
+    throw new GoalInvalidTransitionError(
+      "A completed Goal cannot be resumed",
+      snapshotOf(current)
+    );
+  }
+  if (current.status === "active") {
+    throw new GoalInvalidTransitionError(
+      "An active Goal cannot be resumed",
+      snapshotOf(current)
+    );
+  }
+  if (request.action === "resume" && current.status === "usage_limited" && isGoalBudgetLimitKind(current.limitKind)) {
+    return transitionGoal(current, transition.now, {
+      status: "active",
+      noProgressTurns: void 0,
+      ...rearmedBudgets(current, transition.now, transition),
+      lastReason: void 0,
+      limitKind: void 0
+    });
+  }
+  if (request.action !== "resume") {
+    return assertNever(request, snapshotOf(current));
+  }
+  if (current.status === "usage_limited" && isEvidenceLimited(current)) {
+    return transitionGoal(current, transition.now, {
+      status: "active",
+      evidenceCursor: copyCursor(transition.cursor),
+      evidenceCheckpoint: void 0,
+      // The streak counts checkpoints against one window; this resume starts
+      // a different one, so carrying it over would spend the new window's
+      // allowance on the old window's failures.
+      checkpointStalls: void 0,
+      lastCheckpointFailure: void 0,
+      noProgressTurns: void 0,
+      ...rearmedBudgets(current, transition.now, transition),
+      lastReason: void 0,
+      limitKind: void 0
+    });
+  }
+  return transitionGoal(current, transition.now, {
+    status: "active",
+    noProgressTurns: void 0,
+    ...rearmedBudgets(current, transition.now, transition),
+    ...current.status === "paused" ? { lastReason: void 0 } : {}
+  });
+}
+__name(reduceGoalControl, "reduceGoalControl");
+function reduceGoalTurnFinished(current, transition) {
+  if (current.status !== "active" && current.status !== "paused") {
+    throw new GoalInvalidTransitionError(
+      "Only an active or paused Goal can finish a turn",
+      snapshotOf(current)
+    );
+  }
+  return transitionGoal(current, transition.now, {
+    turnCount: current.turnCount + 1,
+    tokensUsed: current.tokensUsed + Math.max(0, transition.tokensUsed ?? 0),
+    ...transition.lastReason === void 0 ? {} : { lastReason: transition.lastReason },
+    ...transition.windDownTurnId === void 0 ? {} : { windDownTurnId: transition.windDownTurnId },
+    // Zero is spelled as no field, the same way the record persists it.
+    ...transition.noProgressTurns === void 0 ? {} : {
+      noProgressTurns: transition.noProgressTurns > 0 ? transition.noProgressTurns : void 0
+    }
+  });
+}
+__name(reduceGoalTurnFinished, "reduceGoalTurnFinished");
+function parseGoalControlRequest(value) {
+  if (!isRecord(value) || typeof value["action"] !== "string") {
+    return void 0;
+  }
+  switch (value["action"]) {
+    case "create":
+      if (!hasOnlyKeys(value, ["action", "objective"])) return void 0;
+      return typeof value["objective"] === "string" ? parseObjectiveRequest(value["action"], value["objective"]) : void 0;
+    case "replace":
+    case "edit":
+      if (!hasOnlyKeys(value, [
+        "action",
+        "objective",
+        "expectedGoalId",
+        "expectedRevision"
+      ]) || typeof value["objective"] !== "string" || !isExpectedVersion(value)) {
+        return void 0;
+      }
+      return parseObjectiveVersionedRequest(
+        value["action"],
+        value["objective"],
+        value["expectedGoalId"],
+        value["expectedRevision"]
+      );
+    case "pause": {
+      if (!hasOnlyKeys(value, [
+        "action",
+        "expectedGoalId",
+        "expectedRevision",
+        "reason"
+      ]) || !isExpectedVersion(value)) {
+        return void 0;
+      }
+      const reason = value["reason"];
+      if (reason !== void 0) {
+        if (typeof reason !== "string" || validateGoalPauseReason(reason)) {
+          return void 0;
+        }
+      }
+      return {
+        action: "pause",
+        expectedGoalId: value["expectedGoalId"],
+        expectedRevision: value["expectedRevision"],
+        ...reason === void 0 ? {} : { reason }
+      };
+    }
+    case "resume":
+    case "clear":
+      if (!hasOnlyKeys(value, ["action", "expectedGoalId", "expectedRevision"]) || !isExpectedVersion(value)) {
+        return void 0;
+      }
+      return {
+        action: value["action"],
+        expectedGoalId: value["expectedGoalId"],
+        expectedRevision: value["expectedRevision"]
+      };
+    default:
+      return void 0;
+  }
+}
+__name(parseGoalControlRequest, "parseGoalControlRequest");
+function parseGoalStateRecordPayloadV2(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "v",
+    "cause",
+    "snapshot",
+    "checkpointPending",
+    "blockedAudit"
+  ]) || value["v"] !== GOAL_STATE_VERSION || !isGoalStateCause(value["cause"]) || !isCheckpointPending(value["checkpointPending"]) || !isBlockedAudit(value["blockedAudit"])) {
+    return void 0;
+  }
+  const parsedSnapshot = parseGoalSnapshotV2(value["snapshot"]);
+  if (parsedSnapshot?.activity !== "idle") return void 0;
+  const checkpointPending = value["checkpointPending"];
+  if (checkpointPending && (parsedSnapshot.goal?.status !== "active" || checkpointPending.permit.goalId !== parsedSnapshot.goal.goalId || checkpointPending.permit.revision !== parsedSnapshot.goal.revision || checkpointPending.recordUuid === parsedSnapshot.goal.evidenceCursor.recordId || value["cause"] !== "turn_finished" && value["cause"] !== "verifier_reject")) {
+    return void 0;
+  }
+  return {
+    v: GOAL_STATE_VERSION,
+    cause: value["cause"],
+    snapshot: parsedSnapshot,
+    ...checkpointPending ? { checkpointPending: structuredClone(checkpointPending) } : {},
+    ...value["blockedAudit"] ? { blockedAudit: structuredClone(value["blockedAudit"]) } : {}
+  };
+}
+__name(parseGoalStateRecordPayloadV2, "parseGoalStateRecordPayloadV2");
+function parseGoalSnapshotV2(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["v", "goal", "activity", "clearedGoal"]) || value["v"] !== GOAL_STATE_VERSION || !isGoalActivity(value["activity"])) {
+    return void 0;
+  }
+  if (value["goal"] === null) {
+    const clearedGoal = parseGoalOrder(value["clearedGoal"]);
+    if (value["clearedGoal"] !== void 0 && !clearedGoal) return void 0;
+    return {
+      v: GOAL_STATE_VERSION,
+      goal: null,
+      activity: value["activity"],
+      ...clearedGoal ? { clearedGoal } : {}
+    };
+  }
+  if (value["clearedGoal"] !== void 0) return void 0;
+  const goal = parseGoalRecord(value["goal"]);
+  return goal ? { v: GOAL_STATE_VERSION, goal, activity: value["activity"] } : void 0;
+}
+__name(parseGoalSnapshotV2, "parseGoalSnapshotV2");
+function parseGoalOrder(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["goalId", "revision", "updatedAt"]) || typeof value["goalId"] !== "string" || !value["goalId"] || !isNonNegativeInteger(value["revision"]) || value["revision"] === 0 || !isFiniteNumber(value["updatedAt"])) {
+    return void 0;
+  }
+  return {
+    goalId: value["goalId"],
+    revision: value["revision"],
+    updatedAt: value["updatedAt"]
+  };
+}
+__name(parseGoalOrder, "parseGoalOrder");
+function parseGoalStateCause(value) {
+  return isGoalStateCause(value) ? value : void 0;
+}
+__name(parseGoalStateCause, "parseGoalStateCause");
+function createGoal(goalId, objective, now, cursor, grants) {
+  return {
+    goalId,
+    revision: 1,
+    objective,
+    status: "active",
+    evidenceCursor: copyCursor(cursor),
+    turnCount: 0,
+    activeTimeMs: 0,
+    tokensUsed: 0,
+    ...armedBudget("tokenBudget", grants.tokenBudgetGrant),
+    ...armedBudget("turnBudget", grants.turnBudgetGrant),
+    ...armedBudget("activeTimeBudgetMs", grants.activeTimeBudgetGrantMs),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+__name(createGoal, "createGoal");
+function armedBudget(field, grant) {
+  return grant !== void 0 && Number.isFinite(grant) ? { [field]: grant } : {};
+}
+__name(armedBudget, "armedBudget");
+function assertExpectedVersion(current, expectedGoalId, expectedRevision) {
+  if (!current || current.goalId !== expectedGoalId || current.revision !== expectedRevision) {
+    throw new GoalConflictError(snapshotOf(current));
+  }
+}
+__name(assertExpectedVersion, "assertExpectedVersion");
+function normalizeObjective(objective, current) {
+  const normalized = objective.trim();
+  if (!normalized) {
+    throw new GoalInvalidTransitionError(
+      "Goal objective must not be empty",
+      current
+    );
+  }
+  return normalized;
+}
+__name(normalizeObjective, "normalizeObjective");
+function isEvidenceLimited(goal) {
+  return goal.limitKind === "evidence_catalog" || goal.limitKind === "checkpoint_request" || goal.lastReason !== void 0 && goalLimitKindForReason(goal.lastReason) !== void 0;
+}
+__name(isEvidenceLimited, "isEvidenceLimited");
+function rearmedTokenBudget(current, grant) {
+  if (grant === void 0 || !isGoalTokenBudgetSpent(current)) {
+    return {};
+  }
+  return Number.isFinite(grant) ? { tokenBudget: current.tokensUsed + grant, windDownTurnId: void 0 } : { tokenBudget: void 0, windDownTurnId: void 0 };
+}
+__name(rearmedTokenBudget, "rearmedTokenBudget");
+function rearmedTurnBudget(current, grant) {
+  if (grant === void 0 || !isGoalTurnBudgetSpent(current)) {
+    return {};
+  }
+  return Number.isFinite(grant) ? { turnBudget: current.turnCount + grant, windDownTurnId: void 0 } : { turnBudget: void 0, windDownTurnId: void 0 };
+}
+__name(rearmedTurnBudget, "rearmedTurnBudget");
+function rearmedActiveTimeBudget(current, now, grant) {
+  const elapsed = elapsedActiveTime(current, now);
+  if (grant === void 0 || !isGoalActiveTimeBudgetSpent(current, elapsed)) {
+    return {};
+  }
+  return Number.isFinite(grant) ? { activeTimeBudgetMs: elapsed + grant, windDownTurnId: void 0 } : { activeTimeBudgetMs: void 0, windDownTurnId: void 0 };
+}
+__name(rearmedActiveTimeBudget, "rearmedActiveTimeBudget");
+function rearmedBudgets(current, now, grants) {
+  return {
+    ...rearmedTokenBudget(current, grants.tokenBudgetGrant),
+    ...rearmedTurnBudget(current, grants.turnBudgetGrant),
+    ...rearmedActiveTimeBudget(current, now, grants.activeTimeBudgetGrantMs)
+  };
+}
+__name(rearmedBudgets, "rearmedBudgets");
+function transitionGoal(goal, now, changes) {
+  const transitioned = {
+    ...goal,
+    ...changes,
+    activeTimeMs: elapsedActiveTime(goal, now),
+    updatedAt: now
+  };
+  if ("tokenBudget" in changes && changes.tokenBudget === void 0) {
+    delete transitioned.tokenBudget;
+  }
+  if ("turnBudget" in changes && changes.turnBudget === void 0) {
+    delete transitioned.turnBudget;
+  }
+  if ("activeTimeBudgetMs" in changes && changes.activeTimeBudgetMs === void 0) {
+    delete transitioned.activeTimeBudgetMs;
+  }
+  if ("windDownTurnId" in changes && changes.windDownTurnId === void 0) {
+    delete transitioned.windDownTurnId;
+  }
+  if ("noProgressTurns" in changes && changes.noProgressTurns === void 0) {
+    delete transitioned.noProgressTurns;
+  }
+  return transitioned;
+}
+__name(transitionGoal, "transitionGoal");
+function snapshotOf(goal) {
+  return { v: GOAL_STATE_VERSION, goal, activity: "idle" };
+}
+__name(snapshotOf, "snapshotOf");
+function copyCursor(cursor) {
+  return { recordId: cursor.recordId };
+}
+__name(copyCursor, "copyCursor");
+function parseObjectiveRequest(action, objective) {
+  const normalized = objective.trim();
+  return normalized ? { action, objective: normalized } : void 0;
+}
+__name(parseObjectiveRequest, "parseObjectiveRequest");
+function parseObjectiveVersionedRequest(action, objective, expectedGoalId, expectedRevision) {
+  const normalized = objective.trim();
+  return normalized ? { action, objective: normalized, expectedGoalId, expectedRevision } : void 0;
+}
+__name(parseObjectiveVersionedRequest, "parseObjectiveVersionedRequest");
+function parseGoalRecord(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, [
+    "goalId",
+    "revision",
+    "objective",
+    "status",
+    "evidenceCursor",
+    "turnCount",
+    "activeTimeMs",
+    "tokensUsed",
+    "tokenBudget",
+    "turnBudget",
+    "activeTimeBudgetMs",
+    "windDownTurnId",
+    "createdAt",
+    "updatedAt",
+    "evidenceCheckpoint",
+    "checkpointStalls",
+    "lastCheckpointFailure",
+    "noProgressTurns",
+    "lastReason",
+    "limitKind"
+  ]) || typeof value["goalId"] !== "string" || !value["goalId"] || !isNonNegativeInteger(value["revision"]) || value["revision"] === 0 || typeof value["objective"] !== "string" || !value["objective"].trim() || !isGoalStatus(value["status"]) || !isTranscriptCursor(value["evidenceCursor"]) || !isNonNegativeInteger(value["turnCount"]) || !isNonNegativeNumber(value["activeTimeMs"]) || value["tokensUsed"] !== void 0 && !isNonNegativeNumber(value["tokensUsed"]) || value["tokenBudget"] !== void 0 && !isNonNegativeNumber(value["tokenBudget"]) || value["turnBudget"] !== void 0 && !isNonNegativeInteger(value["turnBudget"]) || value["activeTimeBudgetMs"] !== void 0 && !isNonNegativeNumber(value["activeTimeBudgetMs"]) || value["windDownTurnId"] !== void 0 && (typeof value["windDownTurnId"] !== "string" || !value["windDownTurnId"]) || !isFiniteNumber(value["createdAt"]) || !isFiniteNumber(value["updatedAt"]) || !isGoalEvidenceCheckpoint(value["evidenceCheckpoint"]) || value["checkpointStalls"] !== void 0 && !isNonNegativeInteger(value["checkpointStalls"]) || value["lastCheckpointFailure"] !== void 0 && (typeof value["lastCheckpointFailure"] !== "string" || !value["lastCheckpointFailure"]) || value["noProgressTurns"] !== void 0 && !isNonNegativeInteger(value["noProgressTurns"]) || value["lastReason"] !== void 0 && typeof value["lastReason"] !== "string" || value["limitKind"] !== void 0 && (!isGoalLimitKind(value["limitKind"]) || value["status"] !== "usage_limited")) {
+    return void 0;
+  }
+  if (value["evidenceCheckpoint"] && value["evidenceCursor"].recordId !== value["evidenceCheckpoint"].checkpointId) {
+    return void 0;
+  }
+  return {
+    goalId: value["goalId"],
+    revision: value["revision"],
+    objective: value["objective"],
+    status: value["status"],
+    evidenceCursor: copyCursor(value["evidenceCursor"]),
+    turnCount: value["turnCount"],
+    activeTimeMs: value["activeTimeMs"],
+    // Goals persisted before `tokensUsed` existed carry no spend to restore.
+    tokensUsed: value["tokensUsed"] ?? 0,
+    // And no budget: a Goal from before budgets existed stays unbounded.
+    ...value["tokenBudget"] === void 0 ? {} : { tokenBudget: value["tokenBudget"] },
+    ...value["turnBudget"] === void 0 ? {} : { turnBudget: value["turnBudget"] },
+    ...value["activeTimeBudgetMs"] === void 0 ? {} : { activeTimeBudgetMs: value["activeTimeBudgetMs"] },
+    ...value["windDownTurnId"] === void 0 ? {} : { windDownTurnId: value["windDownTurnId"] },
+    createdAt: value["createdAt"],
+    updatedAt: value["updatedAt"],
+    ...value["evidenceCheckpoint"] === void 0 ? {} : {
+      evidenceCheckpoint: structuredClone(value["evidenceCheckpoint"])
+    },
+    // Zero is spelled as no field; a persisted 0 restores the same way.
+    ...value["checkpointStalls"] ? { checkpointStalls: value["checkpointStalls"] } : {},
+    ...value["lastCheckpointFailure"] === void 0 ? {} : { lastCheckpointFailure: value["lastCheckpointFailure"] },
+    ...value["noProgressTurns"] ? { noProgressTurns: value["noProgressTurns"] } : {},
+    ...value["lastReason"] === void 0 ? {} : { lastReason: value["lastReason"] },
+    ...value["limitKind"] === void 0 ? {} : { limitKind: value["limitKind"] }
+  };
+}
+__name(parseGoalRecord, "parseGoalRecord");
+function isExpectedVersion(value) {
+  return typeof value["expectedGoalId"] === "string" && value["expectedGoalId"].length > 0 && isNonNegativeInteger(value["expectedRevision"]) && value["expectedRevision"] > 0;
+}
+__name(isExpectedVersion, "isExpectedVersion");
+function isTranscriptCursor(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["recordId"]) && (typeof value["recordId"] === "string" || value["recordId"] === null);
+}
+__name(isTranscriptCursor, "isTranscriptCursor");
+function isGoalStatus(value) {
+  return value === "active" || value === "paused" || value === "blocked" || value === "usage_limited" || value === "complete";
+}
+__name(isGoalStatus, "isGoalStatus");
+function isGoalActivity(value) {
+  return value === "idle" || value === "running" || value === "verifying";
+}
+__name(isGoalActivity, "isGoalActivity");
+function isGoalStateCause(value) {
+  return value === "create" || value === "replace" || value === "edit" || value === "pause" || value === "resume" || value === "turn_finished" || value === "checkpoint" || value === "verifier_accept" || value === "verifier_reject" || value === "complete" || value === "blocked" || value === "usage_limited" || value === "clear" || value === "migrated";
+}
+__name(isGoalStateCause, "isGoalStateCause");
+function isGoalEvidenceCheckpoint(value) {
+  if (value === void 0) return true;
+  if (!isRecord(value) || !hasOnlyKeys(value, ["checkpointId", "createdAt", "claims"]) || typeof value["checkpointId"] !== "string" || value["checkpointId"].length === 0 || !isFiniteNumber(value["createdAt"]) || !Array.isArray(value["claims"]) || value["claims"].length === 0 || value["claims"].length > GOAL_CHECKPOINT_CLAIM_LIMIT) {
+    return false;
+  }
+  let checkpointBytes = 0;
+  for (const [index, claim] of value["claims"].entries()) {
+    if (!isRecord(claim) || !hasOnlyKeys(claim, ["id", "proofKind", "claim", "sourceRefs"]) || claim["id"] !== `${value["checkpointId"]}:${index + 1}` || !isGoalEvidenceProofKind(claim["proofKind"]) || typeof claim["claim"] !== "string" || claim["claim"].trim().length === 0 || [...claim["claim"]].length > GOAL_CHECKPOINT_CLAIM_MAX_CHARACTERS || !Array.isArray(claim["sourceRefs"]) || claim["sourceRefs"].length === 0 || claim["sourceRefs"].length > GOAL_CHECKPOINT_SOURCE_REFERENCE_LIMIT || new Set(claim["sourceRefs"]).size !== claim["sourceRefs"].length || claim["sourceRefs"].some(
+      (reference) => typeof reference !== "string" || reference.length === 0
+    )) {
+      return false;
+    }
+    checkpointBytes += new TextEncoder().encode(claim["claim"]).byteLength;
+    if (checkpointBytes > GOAL_CHECKPOINT_CLAIM_MAX_BYTES) return false;
+  }
+  return true;
+}
+__name(isGoalEvidenceCheckpoint, "isGoalEvidenceCheckpoint");
+function isCheckpointPending(value) {
+  return value === void 0 || isRecord(value) && hasOnlyKeys(value, ["permit", "recordUuid"]) && isGoalTurnPermit(value["permit"]) && typeof value["recordUuid"] === "string" && value["recordUuid"].length > 0;
+}
+__name(isCheckpointPending, "isCheckpointPending");
+function isGoalTurnPermit(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["goalId", "revision", "turnId"]) && typeof value["goalId"] === "string" && value["goalId"].length > 0 && isNonNegativeInteger(value["revision"]) && value["revision"] > 0 && typeof value["turnId"] === "string" && value["turnId"].length > 0;
+}
+__name(isGoalTurnPermit, "isGoalTurnPermit");
+function isBlockedAudit(value) {
+  return value === void 0 || isRecord(value) && hasOnlyKeys(value, ["fingerprint", "count", "turnIds"]) && typeof value["fingerprint"] === "string" && value["fingerprint"].length > 0 && isNonNegativeInteger(value["count"]) && value["count"] > 0 && value["count"] <= MAX_BLOCKED_AUDIT_COUNT && Array.isArray(value["turnIds"]) && value["turnIds"].length === value["count"] && value["turnIds"].every(
+    (turnId) => typeof turnId === "string" && turnId.length > 0
+  );
+}
+__name(isBlockedAudit, "isBlockedAudit");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function hasOnlyKeys(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key));
+}
+__name(hasOnlyKeys, "hasOnlyKeys");
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+__name(isNonNegativeInteger, "isNonNegativeInteger");
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+__name(isNonNegativeNumber, "isNonNegativeNumber");
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+__name(isFiniteNumber, "isFiniteNumber");
+function assertNever(value, snapshot) {
+  throw new GoalInvalidTransitionError(
+    `Unsupported Goal control action: ${String(value)}`,
+    snapshot
+  );
+}
+__name(assertNever, "assertNever");
+
+// packages/core/src/telemetry/goal-events.ts
+var REPORTED_CAUSES = new Set(
+  GOAL_STATE_EVENT_CAUSES
+);
+function isGoalStateEventCause(cause) {
+  return cause !== void 0 && REPORTED_CAUSES.has(cause);
+}
+__name(isGoalStateEventCause, "isGoalStateEventCause");
+function goalStateEventFromSnapshot(snapshot, cause, now = Date.now()) {
+  if (!isGoalStateEventCause(cause)) return void 0;
+  const goal = snapshot.goal;
+  if (!goal) {
+    const cleared = snapshot.clearedGoal;
+    return cause === "clear" && cleared ? makeGoalStateEvent({
+      cause,
+      goal_id: cleared.goalId,
+      revision: cleared.revision
+    }) : void 0;
+  }
+  return makeGoalStateEvent({
+    cause,
+    goal_id: goal.goalId,
+    revision: goal.revision,
+    status: goal.status,
+    limit_kind: goal.limitKind,
+    turn_count: goal.turnCount,
+    tokens_used: goal.tokensUsed,
+    no_progress_turns: goal.noProgressTurns,
+    token_budget: goal.tokenBudget,
+    turn_budget: goal.turnBudget,
+    active_time_ms: elapsedActiveTime(goal, now),
+    active_time_budget_ms: goal.activeTimeBudgetMs,
+    objective_length: [...goal.objective].length
+  });
+}
+__name(goalStateEventFromSnapshot, "goalStateEventFromSnapshot");
+
 // packages/core/src/telemetry/daemon-metrics.ts
 init_esbuild_shims();
 init_esm();
@@ -9568,6 +10367,61 @@ __name(restoreArchivedAutoSkill, "restoreArchivedAutoSkill");
 export {
   parseBooleanEnvFlag,
   resolveTelemetrySettings,
+  TERMINAL_OSC_REGEX,
+  TERMINAL_CSI_REGEX,
+  TERMINAL_SHIFT_DCS_REGEX,
+  stripTerminalControlSequences,
+  isBidiControlChar,
+  stripDisplayControlChars,
+  truncateNotificationLabel,
+  GOAL_STATE_VERSION,
+  GOAL_PROPOSAL_REASON_MAX_CHARACTERS,
+  GOAL_CHECKPOINT_CLAIM_LIMIT,
+  GOAL_CHECKPOINT_CLAIM_MAX_CHARACTERS,
+  GOAL_CHECKPOINT_CLAIM_MAX_BYTES,
+  GOAL_CHECKPOINT_SOURCE_REFERENCE_LIMIT,
+  GOAL_EVIDENCE_CATALOG_EXHAUSTED_REASON,
+  GOAL_CHECKPOINT_REQUEST_TOO_LARGE_REASON,
+  GOAL_CHECKPOINT_STALL_LIMIT,
+  GOAL_NO_PROGRESS_TURN_LIMIT,
+  goalCheckpointStalledReason,
+  capGoalCheckpointFailure,
+  goalCheckpointHealthVisible,
+  goalCheckpointHealthLine,
+  GOAL_DEFAULT_TOKEN_BUDGET,
+  goalTokenBudgetReason,
+  isGoalTokenBudgetSpent,
+  goalTurnBudgetReason,
+  isGoalTurnBudgetSpent,
+  goalActiveTimeBudgetReason,
+  isGoalActiveTimeBudgetSpent,
+  PAUSED_GOAL_SYSTEM_REMINDER,
+  isGoalEvidenceProofKind,
+  emptyGoalSnapshot,
+  goalRequiresExactPermit,
+  isRepeatedBlockerProposal,
+  GOAL_INFEASIBLE_NEXT_STEP,
+  validateGoalProposalReason,
+  GOAL_PAUSE_REASON_USER_INTERRUPT,
+  GOAL_PAUSE_REASON_COMMAND,
+  GOAL_PAUSE_REASON_SESSION_TOKEN_LIMIT,
+  GOAL_PAUSE_REASON_STOP_HOOK_CAP,
+  GOAL_PAUSE_REASON_SESSION_DISPOSED,
+  GOAL_PAUSE_REASON_HEADLESS_RUN_ENDED,
+  GOAL_PAUSE_REASON_NO_PROGRESS,
+  goalPauseReasonForFailure,
+  goalPauseReasonForHeadlessFailure,
+  goalPauseReasonForRunBudget,
+  GoalConflictError,
+  GoalInvalidTransitionError,
+  elapsedActiveTime,
+  reduceGoalControl,
+  reduceGoalTurnFinished,
+  parseGoalControlRequest,
+  parseGoalStateRecordPayloadV2,
+  parseGoalSnapshotV2,
+  parseGoalStateCause,
+  goalStateEventFromSnapshot,
   initializeDaemonMetrics,
   registerDaemonGaugeCallbacks,
   recordDaemonHttpRequest,
@@ -9617,6 +10471,11 @@ export {
   getAutoSkillCuratorStatus,
   restoreArchivedAutoSkill
 };
+/**
+ * @license
+ * Copyright 2025 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2026 Qwen Team