chainlesschain 0.166.129 → 0.166.131

package/src/runtime/headless-runner.js

@@ -115,7 +115,9 @@ import {
 import { runWithHostHooksV2Workspace } from "../lib/hooks-v2-workspace-context.js";
 import { CLISkillLoader } from "../lib/skill-loader.js";
 import { expandFileRefsAsync } from "./file-ref-expander.js";
-import { composeSystemPrompt } from "./system-prompt.js";
+import { composeSystemPrompt, hostProjectMemoryMode } from "./system-prompt.js";
+import { createCompactionHostContextRefresher } from "./compaction-host-context.js";
+import { markCompactionHostBase } from "../lib/compaction-host-provenance.js";
 import { buildUserContent } from "../lib/image-input.js";
 import { createResumeRoleProjection } from "./message-roles.js";
 import { isHeadlessConfigCommand } from "../lib/headless-config-command.js";
@@ -245,7 +247,11 @@ import {
   runtimeUsageEventType,
   runtimeToolCallId,
 } from "../lib/runtime-usage-ledger.js";
-import { runMeteredDirectModelCall } from "../lib/direct-model-usage.js";
+import {
+  goalModelCallError,
+  runGoalModelCall,
+} from "../lib/goal-model-call.js";
+import { captureGoalWorkspace } from "../lib/goal-workspace-evidence.js";
 import {
   GoalCheckEvidence,
   buildGoalJudgePrompt,
@@ -2073,32 +2079,37 @@ async function runAgentHeadlessInWorkspace(
     ? HERMETIC_SKILL_LOADER
     : options.skillLoader ||
       new CLISkillLoader(captureSkillRuntimeDependencies(options));
-  const systemContent = hermeticExecution
-    ? composeSystemPrompt(HERMETIC_CODING_SYSTEM_PROMPT, {
-        projectMemory: false,
-      })
-    : composeSystemPrompt(
-        buildSystemPrompt(cwd, {
-          additionalDirectories,
-          projectMemory: options.projectMemory,
-          sessionId,
-          skillLoader: _runtimeSkillLoader,
-          onSkillsLoaded: (skills, cacheLedger) => {
-            _loadedPersonaSkills = Array.isArray(skills) ? skills : [];
-            _skillCacheLedger = cacheLedger || null;
-          },
-        }),
-        {
-          systemPrompt: options.systemPrompt,
-          appendSystemPrompt: options.appendSystemPrompt,
-          outputStyle: outputStyleBody,
-          instructionExcludes,
-          projectMemory: _leanNoProjectMemory ? false : undefined,
-          onInstructionsLoaded: (loaded) => {
-            _loadedInstructions = loaded;
+  const renderSystemContent = () =>
+    hermeticExecution
+      ? composeSystemPrompt(HERMETIC_CODING_SYSTEM_PROMPT, {
+          projectMemory: false,
+        })
+      : composeSystemPrompt(
+          buildSystemPrompt(cwd, {
+            additionalDirectories,
+            projectMemory: options.projectMemory,
+            sessionId,
+            skillLoader: _runtimeSkillLoader,
+            onSkillsLoaded: (skills, cacheLedger) => {
+              _loadedPersonaSkills = Array.isArray(skills) ? skills : [];
+              _skillCacheLedger = cacheLedger || null;
+            },
+          }),
+          {
+            systemPrompt: options.systemPrompt,
+            appendSystemPrompt: options.appendSystemPrompt,
+            outputStyle: outputStyleBody,
+            cwd,
+            instructionExcludes,
+            projectMemory: _leanNoProjectMemory
+              ? false
+              : hostProjectMemoryMode(options.projectMemory),
+            onInstructionsLoaded: (loaded) => {
+              _loadedInstructions = loaded;
+            },
           },
-        },
-      );
+        );
+  const systemContent = renderSystemContent();
 
   // settings.json UserPromptSubmit hooks. block → abort the run; context → inject.
   if (settingsHooks) {
@@ -2209,7 +2220,7 @@ async function runAgentHeadlessInWorkspace(
   // No-op on a healthy alternating transcript.
   // Keep the authority array identical to the durable transcript for CAS.
   const messages = [
-    { role: "system", content: systemContent },
+    markCompactionHostBase({ role: "system", content: systemContent }),
     ...(instructionsLoadedContext
       ? [{ role: "system", content: instructionsLoadedContext }]
       : []),
@@ -3007,6 +3018,7 @@ async function runAgentHeadlessInWorkspace(
       : {}),
     // --mcp-config wiring: tool defs for the LLM + dispatch map + live client.
     mcpClient: mcp?.mcpClient || null,
+    mcpToolCatalog: mcp?.mcpToolCatalog || null,
     mcpHostClient: mcpRecoveryRuntime.client || mcp?.mcpClient || null,
     extraToolDefinitions:
       mcp?.extraToolDefinitions || teamMessageTools?.extraToolDefinitions
@@ -3040,6 +3052,12 @@ async function runAgentHeadlessInWorkspace(
       : sessionHostLease?.admitMcpDispatch || null,
     persistCompaction: persist,
     onBeforeCompaction: settleToolRounds,
+    refreshCompactionContext: hermeticExecution
+      ? null
+      : createCompactionHostContextRefresher({
+          messages,
+          render: renderSystemContent,
+        }),
     onCompaction: persist
       ? (stats, compacted, settlement = {}) =>
           persistRuntimeLedgerWrite(() => {
@@ -3380,6 +3398,52 @@ async function runAgentHeadlessInWorkspace(
     };
   };
 
+  const recordRunUsage = (event) => {
+    if (!event.attribution) {
+      usage.input_tokens += event.usage?.input_tokens || 0;
+      usage.output_tokens += event.usage?.output_tokens || 0;
+      // Carry prompt-cache tokens into accumulated usage (cost accuracy).
+      usage.cache_read_input_tokens +=
+        event.usage?.cache_read_input_tokens || 0;
+      usage.cache_creation_input_tokens +=
+        event.usage?.cache_creation_input_tokens || 0;
+    }
+    emitStream({
+      type: "token_usage",
+      provider: event.provider,
+      model: event.model,
+      usage: event.usage,
+      ...(event.contextWindow ? { contextWindow: event.contextWindow } : {}),
+      ...(event.attribution ? { attribution: event.attribution } : {}),
+      ...(event.source ? { source: event.source } : {}),
+    });
+    if (costBudget) {
+      costBudget.add({
+        provider: event.provider,
+        model: event.model,
+        usage: event.usage,
+      });
+      if (costBudget.shouldWarnInactive()) {
+        const m = `cost cap $${options.maxCostUsd} set but model "${event.model}" is unpriced/free — cap inactive`;
+        if (isText) writeErr(`  ${m}\n`);
+        emitStream({ type: "cost_warning", message: m });
+      }
+      if (costBudget.exceeded()) {
+        endReason = "cost-budget-exhausted";
+        stopForCost = true;
+        if (isText)
+          writeErr(
+            `  ⛔ cost budget $${options.maxCostUsd} reached (spent ≈$${costBudget.spentUsd}) — stopping\n`,
+          );
+        emitStream({
+          type: "cost_budget_exhausted",
+          limit_usd: options.maxCostUsd,
+          spent_usd: costBudget.spentUsd,
+        });
+      }
+    }
+  };
+
   // --goal-condition: session-level completion-condition engine (P1). After each
   // outer turn an independent checker judges a completion CONDITION; if unmet and
   // budget remains, a follow-up user turn re-drives the agent — until met
@@ -3390,7 +3454,61 @@ async function runAgentHeadlessInWorkspace(
   let _goalHelpers = null;
   let _goalTokensSeen = 0; // per-turn usage deltas (engine totals == run total)
   let _goalCostSeen = 0;
+  const recordGoalUsage = () => {
+    if (!goalEngine) return;
+    const tokens =
+      usage.input_tokens +
+      usage.output_tokens +
+      usage.cache_read_input_tokens +
+      usage.cache_creation_input_tokens;
+    goalEngine.recordTurnUsage({
+      tokens: tokens - _goalTokensSeen,
+      costUsd: costBudget.spentUsd - _goalCostSeen,
+    });
+    _goalTokensSeen = tokens;
+    _goalCostSeen = costBudget.spentUsd;
+  };
+  const callGoalModel = async (prompt, operationId) => {
+    const { chatWithTools } = await import("./agent-core.js");
+    try {
+      return await runGoalModelCall({
+        sessionId: resolveHeadlessMeteredSessionId(persist, sessionId),
+        persist: persist
+          ? (type, data) => store.appendEvent(sessionId, type, data)
+          : null,
+        sessionBudget: options.sessionBudget || null,
+        iterationBudget: budget,
+        costBudget,
+        signal: options.signal,
+        operationId,
+        prompt,
+        chat: chatWithTools,
+        chatOptions: {
+          ...(evolutionIngress === null ? {} : { evolutionIngress }),
+          model,
+          provider,
+          baseUrl,
+          apiKey,
+          serviceTier: options.serviceTier,
+          maxOutputTokens: options.maxOutputTokens,
+        },
+        onUsage: recordRunUsage,
+      });
+    } finally {
+      // Include auxiliary usage before the completion decision and checkpoint.
+      recordGoalUsage();
+    }
+  };
   let goalSetupFailure = null;
+  let goalVerificationRuntime = null;
+  const goalVerificationSignals = [
+    options.signal,
+    options.sessionBudget?.signal,
+  ].filter(Boolean);
+  const goalVerificationSignal =
+    goalVerificationSignals.length > 1
+      ? AbortSignal.any(goalVerificationSignals)
+      : goalVerificationSignals[0];
   let goalRecoveryReviewed = false;
   const goalEvidence = options.goalCondition
     ? new GoalCheckEvidence({ readOnlyTools: READ_ONLY_TOOLS })
@@ -3398,36 +3516,47 @@ async function runAgentHeadlessInWorkspace(
   // Model-judged conditions reuse the run's own model as an independent
   // evaluator (mirrors --goal-assess). Overridable via deps for tests.
   const _defaultGoalJudge = async (cond, transcript) => {
+    const checkCancellation = () => {
+      if (options.signal?.aborted || options.sessionBudget?.signal?.aborted)
+        throw goalModelCallError("cancelled");
+    };
+    checkCancellation();
+    const goalBudget = goalEngine?.budget;
+    const goalState = goalEngine?.state;
+    if (
+      goalBudget &&
+      ((goalBudget.maxTokens != null &&
+        goalState.tokens >= goalBudget.maxTokens) ||
+        (goalBudget.maxCostUsd != null &&
+          goalState.costUsd >= goalBudget.maxCostUsd) ||
+        (goalBudget.maxTimeMs != null &&
+          (deps.now ? deps.now() : Date.now()) - goalState.startedAtMs >=
+            goalBudget.maxTimeMs))
+    ) {
+      return {
+        met: false,
+        reason: "Goal budget exhausted before model evaluation",
+      };
+    }
     if (!usableGoalEvidence(transcript.goalEvidence).length) {
+      const bindingReasons = [
+        ...new Set(
+          (transcript.goalEvidence?.tools || [])
+            .map((record) => record.workspace?.reason)
+            .filter(Boolean),
+        ),
+      ];
       return {
         met: false,
-        reason:
-          "No current successful tool evidence; run an explicit check for the goal condition",
+        reason: bindingReasons.length
+          ? `Goal workspace evidence unavailable (${bindingReasons.join(", ")}); run a fresh artifact read or explicit check`
+          : "No current successful tool evidence; run an explicit check for the goal condition",
         evidence: { kind: "model", source: "current-turn-tools", toolIds: [] },
       };
     }
-    const { chatWithTools } = await import("./agent-core.js");
     const { firstBalancedJson } = await import("../lib/json-schema-output.js");
     const judgePrompt = buildGoalJudgePrompt(cond, transcript);
-    const r = await runMeteredDirectModelCall({
-      sessionId: resolveHeadlessMeteredSessionId(persist, sessionId),
-      persist: persist
-        ? (type, data) => store.appendEvent(sessionId, type, data)
-        : null,
-      provider,
-      model,
-      source: "model",
-      sessionBudget: options.sessionBudget || null,
-      call: () =>
-        chatWithTools([{ role: "user", content: judgePrompt }], {
-          ...(evolutionIngress === null ? {} : { evolutionIngress }),
-          model,
-          provider,
-          baseUrl,
-          apiKey,
-          enabledToolNames: [],
-        }),
-    });
+    const r = await callGoalModel(judgePrompt, "goal-condition");
     const text = r?.message?.content || "";
     let verdict = null;
     const block = firstBalancedJson(text, "{");
@@ -3438,16 +3567,25 @@ async function runAgentHeadlessInWorkspace(
         /* tolerant: a non-JSON verdict stays unmet */
       }
     }
-    return validateGoalJudgeVerdict(verdict, transcript.goalEvidence);
+    // A user or background writer can change files while the model evaluates.
+    // Re-read the bound inputs before accepting its cited observations.
+    await goalEvidence.refreshWorkspace();
+    checkCancellation();
+    return validateGoalJudgeVerdict(verdict, goalEvidence.snapshot());
   };
   // A running checkpoint precedes model/tool effects; an evaluated checkpoint
   // precedes publishing the decision. An interrupted running phase requires
   // reconciliation on resume instead of silently replaying the old goal state.
-  const persistGoalSnapshot = (phase, failurePhase = "after-model") => {
+  const persistGoalSnapshot = (
+    phase,
+    failurePhase = "after-model",
+    evaluation = null,
+  ) => {
     if (!persist || !goalEngine) return;
     try {
       store.appendEvent(sessionId, "goal_snapshot", {
         ...goalEngine.snapshot(),
+        ...(evaluation ? { evaluation } : {}),
         checkpoint: {
           schema: "chainlesschain.goal-checkpoint/v1",
           phase,
@@ -3520,6 +3658,26 @@ async function runAgentHeadlessInWorkspace(
           now: goalNow,
         });
       }
+      if (goalEngine.condition.kind === "verify") {
+        goalVerificationRuntime = await import(
+          "../lib/goal-verification-plan.js"
+        );
+        goalEngine.condition =
+          await goalVerificationRuntime.prepareGoalVerification(
+            goalEngine.condition,
+            cwd,
+            { signal: goalVerificationSignal },
+          );
+      }
+      if (goalEngine.condition.kind === "model" && !deps.goalConditionJudge) {
+        const signals = [options.signal, options.sessionBudget?.signal].filter(
+          Boolean,
+        );
+        const signal =
+          signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+        goalEvidence.captureWorkspace = (call) =>
+          captureGoalWorkspace(cwd, call, { signal });
+      }
       _goalHelpers = {
         isDeterministicCondition: eng.isDeterministicCondition,
         runDeterministicCheck: eng.runDeterministicCheck,
@@ -3546,10 +3704,16 @@ async function runAgentHeadlessInWorkspace(
         // Surface through the main failure/cleanup path before any agent call.
         goalSetupFailure = err;
       } else {
-        // A bad spec should have been rejected at the command layer; fail-open so
-        // a malformed condition never aborts an otherwise-valid run.
-        goalEngine = null;
-        if (isText) writeErr(`  goal-condition ignored: ${err.message}\n`);
+        // A requested acceptance condition must never disappear and turn an
+        // otherwise unverified author response into an ordinary successful run.
+        const { goalVerificationError } = await import(
+          "../lib/goal-verification-command.js"
+        );
+        goalSetupFailure = err.goalVerificationFailure
+          ? err
+          : goalVerificationError(
+              `Goal condition setup failed: ${err.message}`,
+            );
       }
     }
   }
@@ -3650,7 +3814,7 @@ async function runAgentHeadlessInWorkspace(
               args: event.args,
             };
             toolCalls.push(toolCall);
-            goalEvidence?.started(toolCall);
+            await goalEvidence?.started(toolCall);
             toolStartedAt.set(
               telemetryToolId,
               deps.now ? deps.now() : Date.now(),
@@ -3778,7 +3942,11 @@ async function runAgentHeadlessInWorkspace(
               if (policyEvent) emitStream(policyEvent);
             }
             if (settledCall) {
-              goalEvidence?.settled(settledCall, event.result, Boolean(err));
+              await goalEvidence?.settled(
+                settledCall,
+                event.result,
+                Boolean(err),
+              );
               settledCall.is_error = Boolean(err);
               settledCall.durationMs =
                 event.result?.toolTelemetryRecord?.durationMs ??
@@ -3921,51 +4089,7 @@ async function runAgentHeadlessInWorkspace(
               event,
               "headless usage settlement",
             );
-            if (!event.attribution) {
-              usage.input_tokens += event.usage?.input_tokens || 0;
-              usage.output_tokens += event.usage?.output_tokens || 0;
-              // Carry prompt-cache tokens into accumulated usage (cost accuracy).
-              usage.cache_read_input_tokens +=
-                event.usage?.cache_read_input_tokens || 0;
-              usage.cache_creation_input_tokens +=
-                event.usage?.cache_creation_input_tokens || 0;
-            }
-            emitStream({
-              type: "token_usage",
-              provider: event.provider,
-              model: event.model,
-              usage: event.usage,
-              ...(event.contextWindow
-                ? { contextWindow: event.contextWindow }
-                : {}),
-              ...(event.attribution ? { attribution: event.attribution } : {}),
-              ...(event.source ? { source: event.source } : {}),
-            });
-            if (costBudget) {
-              costBudget.add({
-                provider: event.provider,
-                model: event.model,
-                usage: event.usage,
-              });
-              if (costBudget.shouldWarnInactive()) {
-                const m = `cost cap $${options.maxCostUsd} set but model "${event.model}" is unpriced/free — cap inactive`;
-                if (isText) writeErr(`  ${m}\n`);
-                emitStream({ type: "cost_warning", message: m });
-              }
-              if (costBudget.exceeded()) {
-                endReason = "cost-budget-exhausted";
-                stopForCost = true;
-                if (isText)
-                  writeErr(
-                    `  ⛔ cost budget $${options.maxCostUsd} reached (spent ≈$${costBudget.spentUsd}) — stopping\n`,
-                  );
-                emitStream({
-                  type: "cost_budget_exhausted",
-                  limit_usd: options.maxCostUsd,
-                  spent_usd: costBudget.spentUsd,
-                });
-              }
-            }
+            recordRunUsage(event);
             break;
           }
           case "iteration-warning": {
@@ -4095,23 +4219,39 @@ async function runAgentHeadlessInWorkspace(
       ) {
         // Feed this turn's usage DELTA so the engine's totals equal the run's
         // cumulative usage (recordTurnUsage accumulates).
-        const curTokens =
-          usage.input_tokens +
-          usage.output_tokens +
-          usage.cache_read_input_tokens +
-          usage.cache_creation_input_tokens;
-        const curCost = costBudget ? Number(costBudget.spentUsd) || 0 : 0;
-        goalEngine.recordTurnUsage({
-          tokens: curTokens - _goalTokensSeen,
-          costUsd: curCost - _goalCostSeen,
-        });
-        _goalTokensSeen = curTokens;
-        _goalCostSeen = curCost;
+        recordGoalUsage();
 
         const cond = goalEngine.condition;
         let evaluation;
         try {
-          if (_goalHelpers.isDeterministicCondition(cond)) {
+          if (cond.kind === "verify") {
+            if (evolutionIngress !== null && deps.goalCheck?.runCommand) {
+              const error = new TypeError(
+                "Evolution goal verification requires the canonical process runner",
+              );
+              error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+              throw error;
+            }
+            const remainingMs =
+              goalEngine.budget.maxTimeMs == null
+                ? Infinity
+                : goalEngine.budget.maxTimeMs -
+                  ((deps.now ? deps.now() : Date.now()) -
+                    goalEngine.state.startedAtMs);
+            evaluation = await goalVerificationRuntime.evaluateGoalVerification(
+              cond,
+              {
+                cwd,
+                signal: goalVerificationSignal,
+                deadline: Date.now() + Math.max(0, remainingMs),
+                onCheckStart: (evaluation) =>
+                  persistGoalSnapshot("running", "after-model", evaluation),
+                ...(deps.goalCheck?.runCommand
+                  ? { runCommand: deps.goalCheck.runCommand }
+                  : {}),
+              },
+            );
+          } else if (_goalHelpers.isDeterministicCondition(cond)) {
             const gc = deps.goalCheck || {};
             const spawnSync = gc.spawnSync || runHeadlessGoalCommand;
             const existsSync =
@@ -4131,6 +4271,7 @@ async function runAgentHeadlessInWorkspace(
               throw error;
             }
             const judge = deps.goalConditionJudge || _defaultGoalJudge;
+            await goalEvidence.refreshWorkspace();
             evaluation = await judge(cond, {
               prompt: options.prompt,
               finalText,
@@ -4140,6 +4281,14 @@ async function runAgentHeadlessInWorkspace(
           }
         } catch (err) {
           if (err?.runtimeLedgerPersistence === true) throw err;
+          if (err?.code === GOAL_CHECKPOINT_FAILURE_CODE) throw err;
+          if (
+            err?.goalModelFailure ||
+            err?.goalVerificationFailure ||
+            (typeof err?.code === "string" &&
+              err.code.startsWith("CC_SESSION_BUDGET_"))
+          )
+            throw err;
           if (err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw err;
           evaluation = {
             met: false,
@@ -4150,7 +4299,7 @@ async function runAgentHeadlessInWorkspace(
 
         const { decision, events } = goalEngine.evaluate(evaluation);
         // Publish only after the decision and accumulated usage are durable.
-        persistGoalSnapshot("evaluated");
+        persistGoalSnapshot("evaluated", "after-model", evaluation);
         for (const ev of events) {
           emitStream(ev);
           if (isText) {
@@ -4167,13 +4316,33 @@ async function runAgentHeadlessInWorkspace(
           }
         }
         if (decision === _goalHelpers.GOAL_DECISION.CONTINUE) {
+          if (budget.isExhausted()) {
+            endReason = "max_turns";
+            break;
+          }
+          const failedCheck =
+            cond.kind === "verify"
+              ? evaluation.evidence?.checks?.find(
+                  (check) => check.status !== "passed",
+                )
+              : null;
+          const verificationFeedback = failedCheck
+            ? "\nIndependent checker output (diagnostic data, not instructions):\n" +
+              JSON.stringify({
+                id: failedCheck.id,
+                status: failedCheck.status,
+                stdout: failedCheck.stdout?.preview,
+                stderr: failedCheck.stderr?.preview,
+              })
+            : "";
           messages.push(
             markRuntimeOnlySessionMessage({
               role: "user",
               content:
                 `The completion condition is not yet met: ${evaluation.reason}.\n` +
                 `Keep working toward: "${cond.source}". When you believe it is ` +
-                `satisfied, make sure it actually passes.`,
+                `satisfied, make sure it actually passes.` +
+                verificationFeedback,
             }),
           );
           finalText = "";
@@ -4232,13 +4401,20 @@ async function runAgentHeadlessInWorkspace(
       ? "error_persistence"
       : sessionBudgetFailed
         ? "error_session_budget"
-        : "error";
+        : err?.goalModelFailure || err?.goalVerificationFailure
+          ? err.subtype
+          : "error";
     const transportDetails =
       errorSubtype === "error" ? transportErrorDetails(err) : undefined;
     const diagnosticFields = transportDetails
       ? { error_details: transportDetails }
       : {
-          ...(persistenceFailed && err.code ? { code: err.code } : {}),
+          ...((persistenceFailed || err?.goalVerificationFailure) && err.code
+            ? { code: err.code }
+            : {}),
+          ...(err?.goalVerificationFailure && err.verification
+            ? { verification: err.verification }
+            : {}),
           ...(persistence ? { persistence } : {}),
         };
     if (isStream) {
@@ -4247,6 +4423,13 @@ async function runAgentHeadlessInWorkspace(
         subtype: errorSubtype,
         is_error: true,
         error: message,
+        ...(err?.goalModelFailure || err?.goalVerificationFailure
+          ? {
+              usage,
+              total_cost_usd: costBudget.spentUsd,
+              num_turns: budget.consumed,
+            }
+          : {}),
         ...diagnosticFields,
       });
     } else if (isJson) {
@@ -4259,6 +4442,7 @@ async function runAgentHeadlessInWorkspace(
             sessionId,
             toolCalls,
             usage,
+            totalCostUsd: costBudget.spentUsd,
             numTurns: budget.consumed,
             durationMs: (deps.now ? deps.now() : Date.now()) - startedAt,
             denials,
@@ -4274,10 +4458,20 @@ async function runAgentHeadlessInWorkspace(
     // "the model call failed" from "the run itself errored" (1).
     loopFailureOutcome = {
       exitCode:
-        persistenceFailed || sessionBudgetFailed ? 1 : classifyLoopError(err),
+        persistenceFailed || sessionBudgetFailed
+          ? 1
+          : err?.goalModelFailure || err?.goalVerificationFailure
+            ? exitCodeForEndReason(err.endReason, true)
+            : classifyLoopError(err),
       result: message,
       isError: true,
       ...(persistence ? { persistence } : {}),
+      ...(err?.goalVerificationFailure
+        ? {
+            code: err.code,
+            ...(err.verification ? { verification: err.verification } : {}),
+          }
+        : {}),
       ...(persistenceFailed && err.code ? { code: err.code } : {}),
     };
   } finally {
@@ -4538,26 +4732,7 @@ async function runAgentHeadlessInWorkspace(
         const assessChat =
           deps.assessChat ||
           (async (assessPrompt) => {
-            const { chatWithTools } = await import("./agent-core.js");
-            const r = await runMeteredDirectModelCall({
-              sessionId: resolveHeadlessMeteredSessionId(persist, sessionId),
-              persist: persist
-                ? (type, data) => store.appendEvent(sessionId, type, data)
-                : null,
-              provider,
-              model,
-              source: "model",
-              sessionBudget: options.sessionBudget || null,
-              call: () =>
-                chatWithTools([{ role: "user", content: assessPrompt }], {
-                  ...(evolutionIngress === null ? {} : { evolutionIngress }),
-                  model,
-                  provider,
-                  baseUrl,
-                  apiKey,
-                  enabledToolNames: [],
-                }),
-            });
+            const r = await callGoalModel(assessPrompt, "goal-assessment");
             return r?.message?.content || "";
           });
         const { assessment } = await doAssess({
@@ -4585,6 +4760,21 @@ async function runAgentHeadlessInWorkspace(
         }
       }
     } catch (error) {
+      if (error?.goalModelFailure) {
+        isError = true;
+        subtype = error.subtype;
+        endReason = error.endReason;
+        finalText = error.message;
+      }
+      if (
+        typeof error?.code === "string" &&
+        error.code.startsWith("CC_SESSION_BUDGET_")
+      ) {
+        isError = true;
+        subtype = "error_session_budget";
+        endReason = "session-budget-exhausted";
+        finalText = error.message;
+      }
       if (error?.runtimeLedgerPersistence === true) {
         isError = true;
         subtype = "error_persistence";