@qwen-code/qwen-code 0.21.3 → 0.21.4-nightly.20260804.d6f55a1c9

package/chunks/{chunk-QWW6I2UO.js → chunk-PFQWATDS.js}

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-ZGSUFIL5.js";
+} from "./chunk-DMI5SX2V.js";
 import {
   handleAtCommand
-} from "./chunk-XMJO6C44.js";
+} from "./chunk-PYXZLKUJ.js";
 import {
   JsonOutputAdapter
-} from "./chunk-K2J5JZ6B.js";
+} from "./chunk-B452JFK7.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-L7FTDKCD.js";
+} from "./chunk-23DFTW2G.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,11 +24,11 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-4AGGSHCH.js";
+} from "./chunk-SVR6JPEL.js";
 import {
   RunBudgetEnforcer,
   cleanupReviewWorktreeLeases
-} from "./chunk-QPSYIV2O.js";
+} from "./chunk-4RNMAX6B.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -36,10 +36,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-EGYJRIDF.js";
+} from "./chunk-7DKCE4VO.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-5VYFXHY2.js";
+} from "./chunk-XKX3PNZR.js";
 import {
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   buildSessionRecoveryPlanFromApiHistory,
@@ -57,16 +57,19 @@ import {
   parseAndFormatApiError,
   partitionByConcurrencySafety,
   restoreWorktreeContext
-} from "./chunk-UQDFEU47.js";
+} from "./chunk-7E5BCHGR.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
 import {
   promptIdContext
 } from "./chunk-O6GEWCJA.js";
+import {
+  GoalPersistenceUnavailableError
+} from "./chunk-MBEMTXQT.js";
 import {
   isSystemReminderContent
-} from "./chunk-SRY26X4H.js";
+} from "./chunk-WVAESIM6.js";
 import {
   formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
@@ -76,21 +79,21 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-4K3RV3OA.js";
+} from "./chunk-36Q4BOUL.js";
 import {
   ToolNames
-} from "./chunk-CFDR3GNL.js";
+} from "./chunk-D7D7RXIJ.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry
-} from "./chunk-O2ZYHG33.js";
+} from "./chunk-5L6CQ4ZU.js";
 import {
   FatalInputError,
   createDebugLogger
 } from "./chunk-3RXUYQJI.js";
 import {
   registerCleanup
-} from "./chunk-QDWLUXKP.js";
+} from "./chunk-3X3CRYEU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -133,6 +136,84 @@ function formatLoopDetectedMessage(loopType) {
   return `Loop detection halted the run${detail}.${hint}`;
 }
 __name(formatLoopDetectedMessage, "formatLoopDetectedMessage");
+function sameGoalPermit(left, right) {
+  return left?.goalId === right.goalId && left.revision === right.revision && left.turnId === right.turnId;
+}
+__name(sameGoalPermit, "sameGoalPermit");
+function buildGoalContinuationParts(turn) {
+  return [
+    {
+      text: [
+        "Continue working on the active Goal.",
+        "Use get_goal for the authoritative objective and evidence state.",
+        "Follow the objective's requested output format exactly. Do not add progress, status, or completion commentary unless the objective asks for it.",
+        "If completion depends on content delivered in this turn, deliver only that content and call get_goal in the same response before update_goal.",
+        `Runtime continuation context: ${turn.continuationContext}`,
+        ...turn.verifierFeedback ? [`Verifier feedback: ${turn.verifierFeedback}`] : []
+      ].join("\n")
+    }
+  ];
+}
+__name(buildGoalContinuationParts, "buildGoalContinuationParts");
+function projectLegacyActiveGoal(snapshot) {
+  const goal = snapshot.goal;
+  if (goal?.status !== "active") return null;
+  return {
+    condition: goal.objective,
+    iterations: goal.turnCount,
+    setAt: goal.createdAt,
+    tokensAtStart: 0,
+    hookId: `goal-v2:${goal.goalId}:${goal.revision}`,
+    ...goal.lastReason === void 0 ? {} : { lastReason: goal.lastReason }
+  };
+}
+__name(projectLegacyActiveGoal, "projectLegacyActiveGoal");
+function formatGoalState(snapshot, operation) {
+  const goal = snapshot.goal;
+  if (!goal) {
+    return operation === "clear" ? "Goal cleared." : "No Goal is set.";
+  }
+  const status = goal.status === "usage_limited" ? "usage limited" : goal.status;
+  const summary = `Goal ${status}: ${goal.objective}`;
+  return (goal.status === "blocked" || goal.status === "usage_limited") && goal.lastReason ? `${summary}
+Reason: ${goal.lastReason}` : summary;
+}
+__name(formatGoalState, "formatGoalState");
+async function claimUserGoalTurn(runtime, turnKey, signal) {
+  const immediate = runtime.permitForTurn(turnKey) ?? runtime.beginTurn(turnKey);
+  if (immediate || runtime.getSnapshot().goal?.status !== "active") {
+    return immediate;
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let unsubscribe = /* @__PURE__ */ __name(() => {
+    }, "unsubscribe");
+    const finish = /* @__PURE__ */ __name((permit, error) => {
+      if (settled) return;
+      settled = true;
+      unsubscribe();
+      signal.removeEventListener("abort", onAbort);
+      if (error !== void 0) reject(error);
+      else resolve(permit);
+    }, "finish");
+    const inspect = /* @__PURE__ */ __name(() => {
+      try {
+        const permit = runtime.permitForTurn(turnKey);
+        if (permit || runtime.getSnapshot().goal?.status !== "active") {
+          finish(permit);
+        }
+      } catch (error) {
+        finish(void 0, error);
+      }
+    }, "inspect");
+    const onAbort = /* @__PURE__ */ __name(() => finish(void 0), "onAbort");
+    unsubscribe = runtime.subscribe(inspect);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    else inspect();
+  });
+}
+__name(claimUserGoalTurn, "claimUserGoalTurn");
 function skipHeadlessLoopSentinel(scheduler, job) {
   if (!isHeadlessLoopSentinel(job.prompt)) {
     return false;
@@ -235,10 +316,145 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
       () => cleanupReviewWorktrees(1e3)
     );
     let turnCount = 0;
+    let limitedTurnCount = 0;
     let totalApiDurationMs = 0;
     const startTime = Date.now();
     const geminiClient = config.getGeminiClient();
     const abortController = options.abortController ?? new AbortController();
+    const queuedGoalTurns = [];
+    let activeGoalTurn;
+    let goalRuntimeUnsubscribe;
+    const emitGoalSnapshot = /* @__PURE__ */ __name((snapshot) => {
+      adapter.processEvent({
+        type: "goal_state" /* GoalState */,
+        value: snapshot
+      });
+      adapter.processEvent({
+        type: "active_goal" /* ActiveGoal */,
+        value: projectLegacyActiveGoal(snapshot)
+      });
+    }, "emitGoalSnapshot");
+    const observeGoalRuntime = /* @__PURE__ */ __name((runtime) => {
+      goalRuntimeUnsubscribe ??= runtime.subscribe(emitGoalSnapshot);
+    }, "observeGoalRuntime");
+    const enforceSessionTurnLimit = /* @__PURE__ */ __name(async (isRuntimeGoalTurn) => {
+      if (isRuntimeGoalTurn) return;
+      limitedTurnCount++;
+      const maxSessionTurns = config.getMaxSessionTurns();
+      if (maxSessionTurns >= 0 && limitedTurnCount > maxSessionTurns) {
+        await failClosedActiveGoalTurn(
+          "Headless Goal stopped after the session turn limit"
+        );
+        await settleBeforeTerminalOutput();
+        await handleMaxTurnsExceededError(config);
+      }
+    }, "enforceSessionTurnLimit");
+    let goalHostUnbind;
+    const goalHost = {
+      startGoalTurn: /* @__PURE__ */ __name(async (input2) => {
+        if (queuedGoalTurns.some(
+          ({ permit }) => permit.turnId === input2.permit.turnId
+        )) {
+          return;
+        }
+        queuedGoalTurns.push({
+          permit: { ...input2.permit },
+          turnKey: `goal-runtime:${input2.permit.turnId}`,
+          controller: new AbortController(),
+          origin: "runtime",
+          continuationContext: input2.continuationContext,
+          ...input2.verifierFeedback ? { verifierFeedback: input2.verifierFeedback } : {}
+        });
+      }, "startGoalTurn"),
+      preemptGoalTurn: /* @__PURE__ */ __name((reason) => {
+        for (const turn of queuedGoalTurns.splice(0)) {
+          turn.controller.abort(reason);
+        }
+        activeGoalTurn?.controller.abort(reason);
+      }, "preemptGoalTurn")
+    };
+    const bindGoalHost = /* @__PURE__ */ __name(() => {
+      goalHostUnbind ??= config.bindGoalTurnHost(goalHost);
+    }, "bindGoalHost");
+    let settlingGoalTurn;
+    let goalTurnSettlement;
+    const failClosedActiveGoalTurn = /* @__PURE__ */ __name((reason) => {
+      const turn = activeGoalTurn;
+      if (!turn) return Promise.resolve();
+      if (settlingGoalTurn === turn && goalTurnSettlement) {
+        return goalTurnSettlement;
+      }
+      settlingGoalTurn = turn;
+      goalTurnSettlement = (async () => {
+        if (!turn.controller.signal.aborted) {
+          turn.controller.abort(reason);
+        }
+        try {
+          const runtime = await config.getGoalRuntimeReady();
+          if (!sameGoalPermit(runtime.permitForTurn(turn.turnKey), turn.permit)) {
+            return;
+          }
+          if (runtime.getSnapshot().goal?.status === "active") {
+            try {
+              await runtime.dispatch({
+                action: "pause",
+                expectedGoalId: turn.permit.goalId,
+                expectedRevision: turn.permit.revision
+              });
+            } catch (error) {
+              debugLogger.warn("Failed to pause terminal headless Goal", error);
+            }
+          }
+          try {
+            await config.getChatRecordingService?.()?.flush();
+          } catch (error) {
+            debugLogger.warn("Failed to flush terminal headless Goal", error);
+          }
+          if (sameGoalPermit(runtime.permitForTurn(turn.turnKey), turn.permit)) {
+            await runtime.finishTurn(turn.permit);
+          }
+        } catch (error) {
+          debugLogger.warn("Failed to close terminal headless Goal", error);
+        } finally {
+          if (activeGoalTurn === turn) {
+            activeGoalTurn = void 0;
+          }
+          if (settlingGoalTurn === turn) {
+            settlingGoalTurn = void 0;
+            goalTurnSettlement = void 0;
+          }
+        }
+      })();
+      return goalTurnSettlement;
+    }, "failClosedActiveGoalTurn");
+    const finishGoalTurn = /* @__PURE__ */ __name(async (turn) => {
+      const runtime = await config.getGoalRuntimeReady();
+      if (!sameGoalPermit(runtime.permitForTurn(turn.turnKey), turn.permit)) {
+        return;
+      }
+      let abortSettlement;
+      const pauseOnAbort = /* @__PURE__ */ __name(() => {
+        abortSettlement ??= runtime.dispatch({
+          action: "pause",
+          expectedGoalId: turn.permit.goalId,
+          expectedRevision: turn.permit.revision
+        }).then(() => void 0).catch((error) => {
+          debugLogger.warn("Failed to pause aborted headless Goal", error);
+        });
+      }, "pauseOnAbort");
+      abortController.signal.addEventListener("abort", pauseOnAbort, {
+        once: true
+      });
+      if (abortController.signal.aborted) pauseOnAbort();
+      try {
+        if (!abortController.signal.aborted) {
+          await runtime.finishTurn(turn.permit);
+        }
+      } finally {
+        abortController.signal.removeEventListener("abort", pauseOnAbort);
+        await abortSettlement;
+      }
+    }, "finishGoalTurn");
     const budgetEnforcer = new RunBudgetEnforcer(
       {
         maxWallTimeSeconds: config.getMaxWallTimeSeconds(),
@@ -248,8 +464,11 @@ async function runNonInteractive(config, settings, input, prompt_id, options = {
     );
     budgetEnforcer.start();
     const routeAbort = /* @__PURE__ */ __name(async () => {
-      await settleBeforeTerminalOutput();
       const exceeded = budgetEnforcer.getExceeded();
+      await failClosedActiveGoalTurn(
+        exceeded?.message ?? "Headless Goal execution was cancelled"
+      );
+      await settleBeforeTerminalOutput();
       if (exceeded) {
         await handleBudgetExceededError(config, exceeded);
         throw new Error(exceeded.message);
@@ -465,6 +684,41 @@ ${reason}
               }
               slashHandled = true;
               break;
+            case "goal_control": {
+              const { snapshot } = slashCommandResult.response;
+              observeGoalRuntime(await config.getGoalRuntimeReady());
+              emitGoalSnapshot(snapshot);
+              const message = formatGoalState(
+                snapshot,
+                slashCommandResult.operation.kind
+              );
+              const shouldRunGoalWorker = snapshot.goal?.status === "active" && (slashCommandResult.operation.kind === "set" || slashCommandResult.operation.kind === "edit" || slashCommandResult.operation.kind === "resume");
+              if (!shouldRunGoalWorker) {
+                await emitNonInteractiveFinalMessage({
+                  message,
+                  isError: false,
+                  adapter,
+                  config,
+                  startTimeMs: startTime,
+                  beforeEmit: settleBeforeTerminalOutput
+                });
+                return 0;
+              }
+              if (outputFormat === "text" /* TEXT */) {
+                process.stdout.write(`${message}
+`);
+              }
+              bindGoalHost();
+              activeGoalTurn = queuedGoalTurns.shift();
+              if (!activeGoalTurn) {
+                throw new FatalInputError(
+                  "The Goal runtime did not schedule a continuation."
+                );
+              }
+              initialPartList = buildGoalContinuationParts(activeGoalTurn);
+              slashHandled = true;
+              break;
+            }
             case "message": {
               await emitNonInteractiveFinalMessage({
                 message: slashCommandResult.content,
@@ -614,6 +868,43 @@ ${text}
           }
         }
       }
+      const initialSendType = continueSendType ?? options.sendMessageType ?? "userQuery" /* UserQuery */;
+      if (!activeGoalTurn && initialSendType === "userQuery" /* UserQuery */) {
+        try {
+          const runtime = await config.getGoalRuntimeReady();
+          observeGoalRuntime(runtime);
+          if (runtime.getSnapshot().goal?.status === "active") {
+            const permit = await claimUserGoalTurn(
+              runtime,
+              prompt_id,
+              abortController.signal
+            );
+            if (abortController.signal.aborted) {
+              await routeAbort();
+            }
+            if (permit) {
+              const goal = runtime.getSnapshot().goal;
+              if (!goal) {
+                throw new Error("Goal turn admission lost its active Goal");
+              }
+              const verifierFeedback = runtime.getVerifierFeedback(permit);
+              activeGoalTurn = {
+                permit,
+                turnKey: prompt_id,
+                controller: new AbortController(),
+                origin: "user",
+                continuationContext: goal.objective,
+                ...verifierFeedback ? { verifierFeedback } : {}
+              };
+              bindGoalHost();
+            }
+          }
+        } catch (error) {
+          if (!(error instanceof GoalPersistenceUnavailableError)) {
+            throw error;
+          }
+        }
+      }
       let currentMessages = [{ role: "user", parts: initialParts }];
       const registry = config.getBackgroundTaskRegistry();
       registry.setNotificationCallback((displayText, modelText, meta) => {
@@ -681,6 +972,7 @@ ${text}
         });
       }
       let isFirstTurn = true;
+      let isFirstGoalSegment = activeGoalTurn !== void 0;
       let hasUnsentToolResponse = false;
       let modelOverride = inlineModelOverride ?? fullTurnModelOverride;
       const inlineModelOverrideActive = inlineModelOverride !== void 0;
@@ -696,6 +988,9 @@ ${text}
       let loopDetected = false;
       let loopDetectedMessage = formatLoopDetectedMessage(void 0);
       const emitStructuredSuccess = /* @__PURE__ */ __name(async () => {
+        await failClosedActiveGoalTurn(
+          "Headless Goal ended with structured output"
+        );
         registry.abortAll();
         const holdbackDeadline = Date.now() + STRUCTURED_SHUTDOWN_HOLDBACK_MS;
         while (Date.now() < holdbackDeadline && registry.hasUnfinalizedTasks()) {
@@ -718,6 +1013,9 @@ ${text}
         return 0;
       }, "emitStructuredSuccess");
       const emitLoopDetectedResult = /* @__PURE__ */ __name(async () => {
+        await failClosedActiveGoalTurn(
+          "Headless Goal stopped after loop detection"
+        );
         registry.abortAll();
         flushQueuedNotificationsToSdk(localQueue);
         finalizeOneShotMonitors();
@@ -742,6 +1040,7 @@ ${text}
       const handledProviderToolCallIds = geminiClient.getHistoryFunctionResponseIds();
       const duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
       const processToolCallBatch = /* @__PURE__ */ __name(async (batchRequests, setModelOverride, runtimeView) => {
+        let terminateTurn = false;
         const responseByRequest = /* @__PURE__ */ new Map();
         const statusByResponse = /* @__PURE__ */ new Map();
         const structuredOutputActive = config.getJsonSchema() && batchRequests.some((r) => r.name === ToolNames.STRUCTURED_OUTPUT);
@@ -777,7 +1076,8 @@ ${text}
           );
           return {
             responseParts: [],
-            repeatedDuplicateProviderToolCall: true
+            repeatedDuplicateProviderToolCall: true,
+            terminateTurn: false
           };
         }
         const respondedRequests = /* @__PURE__ */ new Set();
@@ -838,7 +1138,10 @@ ${text}
           const response = await executeToolCall(
             config,
             requestInfo,
-            abortController.signal,
+            activeGoalTurn ? AbortSignal.any([
+              abortController.signal,
+              activeGoalTurn.controller.signal
+            ]) : abortController.signal,
             {
               recordToolResult: false,
               onToolResultFullTurnModel: /* @__PURE__ */ __name((model) => {
@@ -874,6 +1177,7 @@ ${text}
           }
           adapter.emitToolResult(requestInfo, toolResponse);
           responseByRequest.set(requestInfo, toolResponse);
+          terminateTurn ||= toolResponse.terminateTurn === true;
           config.getGeminiClient().recordCompletedToolCall(
             requestInfo.name,
             requestInfo.args
@@ -903,14 +1207,16 @@ ${text}
             responseParts,
             resultDisplay: error.message,
             error,
-            errorType: "execution_denied" /* EXECUTION_DENIED */
+            errorType: "execution_denied" /* EXECUTION_DENIED */,
+            executionStatus: "not_started"
           });
           responseByRequest.set(requestInfo, {
             callId: requestInfo.callId,
             responseParts,
             resultDisplay: error.message,
             error,
-            errorType: "execution_denied" /* EXECUTION_DENIED */
+            errorType: "execution_denied" /* EXECUTION_DENIED */,
+            executionStatus: "not_started"
           });
           executedRequests.add(requestInfo);
         }, "finalizePlanModeEntrySiblingSkip");
@@ -1006,7 +1312,8 @@ ${text}
               responseParts,
               resultDisplay: skippedOutput,
               error: void 0,
-              errorType: void 0
+              errorType: void 0,
+              executionStatus: "not_started"
             };
             adapter.emitToolResult(call, toolResponse);
             responseByRequest.set(call, toolResponse);
@@ -1047,12 +1354,14 @@ ${text}
             status: statusByResponse.get(response) ?? (response.error ? "error" : "success"),
             resultDisplay: response.resultDisplay,
             error: response.error,
-            errorType: response.errorType
+            errorType: response.errorType,
+            executionStatus: response.executionStatus
           });
         }
         return {
           responseParts: toolResponseParts,
-          repeatedDuplicateProviderToolCall: false
+          repeatedDuplicateProviderToolCall: false,
+          terminateTurn
         };
       }, "processToolCallBatch");
       let currentPromptId = prompt_id;
@@ -1061,7 +1370,7 @@ ${text}
         if (!isFirstTurn && pendingTeammateMessages.length > 0) {
           const batch = pendingTeammateMessages.splice(0);
           const teammatePart = { text: batch.join("\n\n") };
-          if (hasUnsentToolResponse && currentMessages[0]) {
+          if ((hasUnsentToolResponse || activeGoalTurn) && currentMessages[0]) {
             currentMessages[0].parts = [
               ...currentMessages[0].parts || [],
               teammatePart
@@ -1073,12 +1382,12 @@ ${text}
         }
         hasUnsentToolResponse = false;
         turnCount++;
-        if (config.getMaxSessionTurns() >= 0 && turnCount > config.getMaxSessionTurns()) {
-          await settleBeforeTerminalOutput();
-          await handleMaxTurnsExceededError(config);
-        }
+        const goalTurn = activeGoalTurn;
+        await enforceSessionTurnLimit(goalTurn?.origin === "runtime");
         let sendType;
-        if (isFirstTurn) {
+        if (goalTurn) {
+          sendType = isFirstGoalSegment ? goalTurn.origin === "runtime" ? "goal" /* Goal */ : "userQuery" /* UserQuery */ : "toolResult" /* ToolResult */;
+        } else if (isFirstTurn) {
           sendType = continueSendType ?? options.sendMessageType ?? "userQuery" /* UserQuery */;
         } else if (isTeammateTurn) {
           sendType = "teammate" /* Teammate */;
@@ -1099,10 +1408,17 @@ ${text}
             modelOverride,
             ...isFirstTurn && options.notificationDisplayText && {
               notificationDisplayText: options.notificationDisplayText
-            }
+            },
+            ...goalTurn ? {
+              goalPermit: goalTurn.permit,
+              goalTurnKey: goalTurn.turnKey,
+              goalSignal: goalTurn.controller.signal,
+              goalOrigin: goalTurn.origin
+            } : {}
           }
         );
         isFirstTurn = false;
+        isFirstGoalSegment = false;
         adapter.startAssistantMessage();
         for await (const event of responseStream) {
           if (abortController.signal.aborted) {
@@ -1144,10 +1460,12 @@ ${text}
         if (loopDetected) {
           return emitLoopDetectedResult();
         }
+        let shouldFinalizeTurn = toolCallRequests.length === 0;
         if (toolCallRequests.length > 0) {
           const {
             responseParts: toolResponseParts,
-            repeatedDuplicateProviderToolCall
+            repeatedDuplicateProviderToolCall,
+            terminateTurn
           } = await processToolCallBatch(
             toolCallRequests,
             (override) => {
@@ -1173,9 +1491,56 @@ ${text}
             );
             return emitLoopDetectedResult();
           }
-          currentMessages = [{ role: "user", parts: toolResponseParts }];
-          hasUnsentToolResponse = true;
-        } else {
+          if (terminateTurn && activeGoalTurn) {
+            geminiClient.addHistory({
+              role: "user",
+              parts: toolResponseParts
+            });
+            await config.getChatRecordingService?.()?.flush();
+            await finishGoalTurn(activeGoalTurn);
+            activeGoalTurn = void 0;
+            const nextGoalTurn = queuedGoalTurns.shift();
+            if (nextGoalTurn) {
+              activeGoalTurn = nextGoalTurn;
+              isFirstGoalSegment = true;
+              currentMessages = [
+                {
+                  role: "user",
+                  parts: buildGoalContinuationParts(nextGoalTurn)
+                }
+              ];
+              hasUnsentToolResponse = false;
+              continue;
+            }
+            shouldFinalizeTurn = true;
+          }
+          if (!shouldFinalizeTurn) {
+            currentMessages = [{ role: "user", parts: toolResponseParts }];
+            hasUnsentToolResponse = true;
+          }
+        }
+        if (shouldFinalizeTurn) {
+          if (activeGoalTurn) {
+            const completedGoalTurn = activeGoalTurn;
+            await config.getChatRecordingService?.()?.flush();
+            await finishGoalTurn(completedGoalTurn);
+            if (activeGoalTurn === completedGoalTurn) {
+              activeGoalTurn = void 0;
+            }
+            const nextGoalTurn = queuedGoalTurns.shift();
+            if (nextGoalTurn) {
+              activeGoalTurn = nextGoalTurn;
+              isFirstGoalSegment = true;
+              currentMessages = [
+                {
+                  role: "user",
+                  parts: buildGoalContinuationParts(nextGoalTurn)
+                }
+              ];
+              hasUnsentToolResponse = false;
+              continue;
+            }
+          }
           const teamManager = config.getTeamManager();
           if (teamManager?.hasActiveTeammates()) {
             if (teamManager.allRemainingStalled()) {
@@ -1209,8 +1574,7 @@ ${text}
             }
           }
           if (abortController.signal.aborted) {
-            await settleBeforeTerminalOutput();
-            await handleCancellationError(config);
+            await routeAbort();
           }
           if (teamManager) {
             await teamManager.drainLeaderInbox();
@@ -1239,10 +1603,7 @@ ${text}
               todoWorkChainId: batch[0]?.todoWorkChainId
             };
             turnCount++;
-            if (config.getMaxSessionTurns() >= 0 && turnCount > config.getMaxSessionTurns()) {
-              await settleBeforeTerminalOutput();
-              await handleMaxTurnsExceededError(config);
-            }
+            await enforceSessionTurnLimit(false);
             let itemMessages = [
               { role: "user", parts: [{ text: item.modelText }] }
             ];
@@ -1465,6 +1826,9 @@ ${text}
         }
       }
     } catch (error) {
+      await failClosedActiveGoalTurn(
+        error instanceof Error ? error.message : "Headless Goal execution failed"
+      );
       try {
         adapter.finalizeAssistantMessage();
       } catch {
@@ -1501,6 +1865,13 @@ ${text}
       }
       await handleError(error, config);
     } finally {
+      await failClosedActiveGoalTurn(
+        "Headless Goal host stopped before its permit was released"
+      );
+      goalRuntimeUnsubscribe?.();
+      goalRuntimeUnsubscribe = void 0;
+      goalHostUnbind?.();
+      goalHostUnbind = void 0;
       if (workflowApprovalChannelRegistered) {
         config.getWorkflowRunRegistry().setApprovalRequestCallback(void 0);
       }