@agent-native/core 0.132.2 → 0.133.0

package/src/agent/engine/failure-taxonomy.ts

@@ -0,0 +1,123 @@
+import { classifyTerminalErrorCode } from "./error-detail.js";
+
+export const AGENT_FAILURE_TAXONOMY_CODES = [
+  "provider_network_error",
+  "provider_config_error",
+  "overloaded_error",
+  "authentication_error",
+  "unknown",
+] as const;
+
+export type AgentFailureTaxonomyCode =
+  (typeof AGENT_FAILURE_TAXONOMY_CODES)[number];
+
+export type AgentFailureRegime = "interactive" | "scheduled";
+
+export interface AgentFailureTaxonomy {
+  code: AgentFailureTaxonomyCode;
+  label: string;
+  regime: AgentFailureRegime;
+  source: "error_code" | "error_detail" | "unknown";
+}
+
+const LABELS: Record<AgentFailureTaxonomyCode, string> = {
+  provider_network_error: "SSL/TLS provider transport drop",
+  provider_config_error: "Model reasoning_effort with tools",
+  overloaded_error: "Provider overloaded_error",
+  authentication_error: "Missing provider authentication",
+  unknown: "Unclassified failure",
+};
+
+function knownCode(value: unknown): AgentFailureTaxonomyCode | undefined {
+  const normalized =
+    typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (
+    normalized === "provider_network_error" ||
+    normalized === "connection_error" ||
+    normalized === "network_error" ||
+    normalized === "ssl_error" ||
+    normalized === "tls_error"
+  ) {
+    return "provider_network_error";
+  }
+  if (
+    normalized === "provider_config_error" ||
+    normalized === "reasoning_effort_tools"
+  ) {
+    return "provider_config_error";
+  }
+  if (
+    normalized === "overloaded_error" ||
+    normalized === "provider_overloaded"
+  ) {
+    return "overloaded_error";
+  }
+  if (
+    normalized === "authentication_error" ||
+    normalized === "missing_authentication_header" ||
+    normalized === "http_401" ||
+    normalized === "unauthorized"
+  ) {
+    return "authentication_error";
+  }
+  return undefined;
+}
+
+/**
+ * Classify the production failure families used by the Factory triage queue.
+ * The regime is deliberately derived from the durable run id, not inferred
+ * from prose: scheduled runs use the `job-` namespace and interactive runs do
+ * not. This keeps a healthy chat sample from hiding a scheduled outage.
+ */
+export function classifyAgentFailure(input: {
+  runId?: unknown;
+  errorCode?: unknown;
+  errorDetail?: unknown;
+  terminalReason?: unknown;
+  terminalEvent?: unknown;
+  regime?: AgentFailureRegime;
+}): AgentFailureTaxonomy {
+  const regime =
+    input.regime ??
+    (typeof input.runId === "string" && input.runId.startsWith("job-")
+      ? "scheduled"
+      : "interactive");
+  const explicit = knownCode(input.errorCode);
+  if (explicit) {
+    return {
+      code: explicit,
+      label: LABELS[explicit],
+      regime,
+      source: "error_code",
+    };
+  }
+
+  const evidence = [
+    input.errorCode,
+    input.errorDetail,
+    input.terminalReason,
+    input.terminalEvent,
+  ].filter((value) => value !== undefined && value !== null);
+  for (const value of evidence) {
+    const text =
+      typeof value === "string"
+        ? value
+        : (JSON.stringify(value) ?? String(value));
+    const classified = knownCode(classifyTerminalErrorCode(text));
+    if (classified) {
+      return {
+        code: classified,
+        label: LABELS[classified],
+        regime,
+        source: "error_detail",
+      };
+    }
+  }
+
+  return {
+    code: "unknown",
+    label: LABELS.unknown,
+    regime,
+    source: "unknown",
+  };
+}

package/src/agent/engine/index.ts

@@ -25,6 +25,7 @@ export {
   getConfiguredEngineNameForRequest,
   getStoredModelForEngine,
   normalizeModelForEngine,
+  resolveDelegatedRunModel,
   resolveEnginePreservesCustomModels,
   type NormalizeModelOptions,
   detectEngineFromEnv,
@@ -54,3 +55,10 @@ export {
 } from "./anthropic-engine.js";
 export { createAISDKEngine, type AISDKProvider } from "./ai-sdk-engine.js";
 export { registerBuiltinEngines } from "./builtin.js";
+export {
+  AGENT_FAILURE_TAXONOMY_CODES,
+  classifyAgentFailure,
+  type AgentFailureRegime,
+  type AgentFailureTaxonomy,
+  type AgentFailureTaxonomyCode,
+} from "./failure-taxonomy.js";

package/src/agent/engine/registry.ts

@@ -13,6 +13,7 @@ import { createRequire } from "node:module";
 import {
   assertCredentialStoreReadable,
   canUseDeployCredentialFallbackForRequest,
+  getBuilderCredentialAuthFailure,
   getProviderCredentialAuthFailure,
   readDeployCredentialEnv,
   resolveBuilderCredentialsDetailed,
@@ -272,6 +273,70 @@ export function normalizeModelForEngine(
   );
 }
 
+type ModelResolvableEngine = Pick<
+  AgentEngine,
+  "name" | "defaultModel" | "supportedModels" | "preserveCustomModels"
+>;
+
+/**
+ * Bound an untrusted, caller-supplied model preference to this engine's own
+ * catalog. Returns `undefined` — never a substitute — when the hint names
+ * anything the engine does not already offer, so a peer can never move the run
+ * to a different provider, an unknown id, or a capability tier this engine was
+ * not going to serve on its own.
+ */
+function resolveModelHintForEngine(
+  engine: ModelResolvableEngine,
+  hint: string | null | undefined,
+): string | undefined {
+  const candidate = typeof hint === "string" ? hint.trim() : "";
+  if (!candidate || candidate === "auto") return undefined;
+  // An engine with no catalog, or one that passes custom ids through verbatim
+  // (an OpenAI-compatible gateway), cannot prove membership — so it takes no
+  // hint at all rather than forwarding an unverifiable id to a provider.
+  if (engine.preserveCustomModels || engine.supportedModels.length === 0) {
+    return undefined;
+  }
+  const normalized = normalizeModelForEngine(engine, candidate);
+  // `normalizeModelForEngine` answers `defaultModel` both for "this IS the
+  // default" and for "no idea what this is", so an unmatched hint is only
+  // distinguishable by re-checking the raw candidate. Anything else it returns
+  // is a real catalog hit.
+  const matched =
+    normalized === engine.defaultModel
+      ? engine.supportedModels.includes(candidate)
+      : engine.supportedModels.includes(normalized);
+  return matched ? normalized : undefined;
+}
+
+/**
+ * Model for a delegated (A2A) run, in strict precedence: the receiving app's
+ * explicit configuration, then its own stored setting, then the caller's hint,
+ * then the engine default. An app that pins a model keeps it; a hint only fills
+ * the gap where the receiver would otherwise take a default it never chose.
+ *
+ * A rejected hint is logged and dropped — a delegated run must never fail over
+ * a preference.
+ */
+export function resolveDelegatedRunModel(
+  engine: ModelResolvableEngine,
+  options: {
+    explicitModel?: string | null;
+    storedModel?: string | null;
+    callerModelHint?: string | null;
+  },
+): string {
+  const own = options.explicitModel ?? options.storedModel;
+  if (own) return normalizeModelForEngine(engine, own);
+  const hinted = resolveModelHintForEngine(engine, options.callerModelHint);
+  if (!hinted && options.callerModelHint) {
+    console.log(
+      `[a2a] Ignoring caller model hint "${options.callerModelHint}" — not offered by engine ${engine.name}`,
+    );
+  }
+  return normalizeModelForEngine(engine, hinted ?? engine.defaultModel);
+}
+
 /**
  * Whether models saved or read for this engine ENTRY should be preserved
  * verbatim instead of normalized against the built-in catalog.
@@ -360,10 +425,7 @@ export function detectEngineFromEnv(): AgentEngineEntry | null {
   return null;
 }
 
-async function envKeyUsableForEntry(
-  entry: AgentEngineEntry,
-  key: string,
-): Promise<boolean> {
+async function envKeyUsableForEntry(key: string): Promise<boolean> {
   if (
     !(
       canUseDeployCredentialFallbackForRequest(key) &&
@@ -372,19 +434,41 @@ async function envKeyUsableForEntry(
   ) {
     return false;
   }
-  if (entry.name === "builder") {
-    return true;
-  }
   const value = readDeployCredentialEnv(key);
   if (!value) return false;
   return !(await getProviderCredentialAuthFailure({ key, value }));
 }
 
+/**
+ * Builder's deploy-env fallback is checked as a pair, not per-key: the
+ * auth-failure marker is fingerprinted from privateKey+publicKey together
+ * (see `builderCredentialFingerprint`), so a single-key lookup can never
+ * match it. Without this, a rejected deploy-level Builder key would keep
+ * reporting "usable" through this env-only path forever — the same class of
+ * bug as the per-scope check in `credential-provider.ts`'s
+ * `isCompleteBuilderConnection`.
+ */
+async function hasUsableBuilderEnvKeys(): Promise<boolean> {
+  const privateKey = canUseDeployCredentialFallbackForRequest(
+    "BUILDER_PRIVATE_KEY",
+  )
+    ? readDeployCredentialEnv("BUILDER_PRIVATE_KEY")
+    : null;
+  const publicKey = canUseDeployCredentialFallbackForRequest(
+    "BUILDER_PUBLIC_KEY",
+  )
+    ? readDeployCredentialEnv("BUILDER_PUBLIC_KEY")
+    : null;
+  if (!privateKey || !publicKey) return false;
+  return !(await getBuilderCredentialAuthFailure({ privateKey, publicKey }));
+}
+
 async function hasUsableEnvKeys(entry: AgentEngineEntry): Promise<boolean> {
   if (!isAgentEnginePackageInstalled(entry)) return false;
   if (entry.requiredEnvVars.length === 0) return false;
+  if (entry.name === "builder") return hasUsableBuilderEnvKeys();
   for (const key of entry.requiredEnvVars) {
-    if (!(await envKeyUsableForEntry(entry, key))) return false;
+    if (!(await envKeyUsableForEntry(key))) return false;
   }
   return true;
 }

package/src/agent/engine/translate-ai-sdk.ts

@@ -7,6 +7,10 @@
  * `ModelMessage` shapes.
  */
 
+import {
+  classifyProviderError,
+  describeErrorWithCauses,
+} from "./error-detail.js";
 import { backfillEngineMessagesToolResults } from "./translate-anthropic.js";
 import type {
   EngineTool,
@@ -294,11 +298,22 @@ export function aiSdkPartToEngineEvents(part: any): EngineEvent[] {
     case "error": {
       const errMsg =
         part.error instanceof Error
-          ? part.error.message
+          ? describeErrorWithCauses(part.error)
           : typeof part.error === "string"
             ? part.error
             : JSON.stringify(part.error);
-      events.push({ type: "stop", reason: "error", error: errMsg });
+      // `streamText` reports a failed provider request as a stream part rather
+      // than a throw, so this is the arrival path for most provider HTTP
+      // failures. It used to emit the message alone, discarding the
+      // APICallError's statusCode/isRetryable — which is why they all landed as
+      // `unknown` and were retried only if their prose happened to match a
+      // keyword. Same classifier as the thrown path in ai-sdk-engine.ts.
+      events.push({
+        type: "stop",
+        reason: "error",
+        error: errMsg,
+        ...classifyProviderError(part.error),
+      });
       break;
     }
 

package/src/agent/production-agent.ts

@@ -84,6 +84,7 @@ import {
   LLM_MISSING_CREDENTIALS_MESSAGE,
   userFacingLlmCredentialError,
 } from "./engine/credential-errors.js";
+import { isProviderConnectionErrorMessage } from "./engine/error-detail.js";
 import {
   resolveEngine,
   registerBuiltinEngines,
@@ -1312,7 +1313,7 @@ export function isRetryableError(err: unknown): boolean {
     msg.includes("gateway error") ||
     msg.includes("socket hang up") ||
     msg.includes("connection reset") ||
-    hasProviderConnectionErrorMessage(msg) ||
+    isProviderConnectionErrorMessage(msg) ||
     msg.includes("too many requests") ||
     msg.includes("timeout") ||
     msg.includes("gateway timeout") ||
@@ -1321,17 +1322,6 @@ export function isRetryableError(err: unknown): boolean {
   );
 }
 
-function hasProviderConnectionErrorMessage(message: string): boolean {
-  const normalized = message.toLowerCase();
-  // Anthropic's APIConnectionError uses "Connection error."; AI SDK wraps
-  // OpenAI TLS failures as "Cannot connect to API". Both can cross a worker
-  // boundary without their structured EngineError metadata.
-  return (
-    normalized.includes("connection error") ||
-    normalized.includes("cannot connect to api")
-  );
-}
-
 // ---------------------------------------------------------------------------
 // Context-window overflow recovery
 // ---------------------------------------------------------------------------
@@ -2264,7 +2254,7 @@ export function isResumableEngineError(err: unknown): boolean {
     text.includes("econnaborted") ||
     text.includes("fetch failed") ||
     text.includes("network error") ||
-    hasProviderConnectionErrorMessage(text) ||
+    isProviderConnectionErrorMessage(text) ||
     text.includes("connection reset") ||
     text.includes("connection closed") ||
     text.includes("stream closed") ||
@@ -6104,7 +6094,7 @@ function isRecoverableContinuationError(event: {
     code === "http_529" ||
     code === "run_timeout" ||
     message.includes("timeout") ||
-    hasProviderConnectionErrorMessage(message) ||
+    isProviderConnectionErrorMessage(message) ||
     message.includes("temporarily unavailable")
   );
 }
@@ -6432,7 +6422,7 @@ export async function runAgentLoopWithMainChatInternalContinuations(
       type: "error",
       error: RUN_BUDGET_EXHAUSTED_MESSAGE,
       errorCode: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
-      recoverable: true,
+      recoverable: false,
     });
   }
   return usage;
@@ -6661,9 +6651,9 @@ export async function claimBackgroundWorkerRunEarly(opts: {
       .join(" "),
   ).catch(() => {});
 
-  // A failed durable abort read is fail-closed: never let a worker execute
-  // after cancellation just because the database was temporarily unreadable.
-  if (await turnAborted(threadId, turnId).catch(() => true)) {
+  // A failed durable abort read must surface as infrastructure failure. It is
+  // not evidence that the user stopped the turn.
+  if (await turnAborted(threadId, turnId)) {
     await abortRun(opts.runId, "user").catch(() => {});
     return { claimed: false, skipped: "turn-aborted" };
   }
@@ -6674,7 +6664,7 @@ export async function claimBackgroundWorkerRunEarly(opts: {
     }).catch(() => {});
   }
 
-  if (await turnAborted(threadId, turnId).catch(() => true)) {
+  if (await turnAborted(threadId, turnId)) {
     await abortRun(opts.runId, "user").catch(() => {});
     return { claimed: false, skipped: "turn-aborted" };
   }
@@ -6687,7 +6677,7 @@ export async function claimBackgroundWorkerRunEarly(opts: {
 
   await record(opts.runId, RUN_DIAG_STAGE.workerClaimed).catch(() => {});
   await heartbeat(opts.runId).catch(() => {});
-  if (await turnAborted(threadId, turnId).catch(() => true)) {
+  if (await turnAborted(threadId, turnId)) {
     await abortRun(opts.runId, "user").catch(() => {});
     return { claimed: false, skipped: "turn-aborted" };
   }
@@ -7143,11 +7133,7 @@ export async function chainServerDrivenContinuation(opts: {
   };
   delete continuationBody[AGENT_CHAT_BACKGROUND_RUN_FIELD];
   try {
-    if (
-      await d
-        .isTurnAborted(effectiveThreadId, effectiveTurnId)
-        .catch(() => true)
-    ) {
+    if (await d.isTurnAborted(effectiveThreadId, effectiveTurnId)) {
       await d.markRunAborted(runId, "user").catch(() => {});
       return;
     }
@@ -7196,11 +7182,7 @@ export async function chainServerDrivenContinuation(opts: {
         insertErr instanceof Error ? insertErr.message : insertErr,
       );
     }
-    if (
-      await d
-        .isTurnAborted(effectiveThreadId, effectiveTurnId)
-        .catch(() => true)
-    ) {
+    if (await d.isTurnAborted(effectiveThreadId, effectiveTurnId)) {
       if (nextRowInserted)
         await d.markRunAborted(nextRunId, "user").catch(() => {});
       await d.markRunAborted(runId, "user").catch(() => {});
@@ -8376,9 +8358,7 @@ export function createProductionAgentHandler(
           : runId;
     if (
       isBackgroundWorker &&
-      (await isTurnAborted(effectiveThreadId, effectiveTurnId).catch(
-        () => true,
-      ))
+      (await isTurnAborted(effectiveThreadId, effectiveTurnId))
     ) {
       await markRunAborted(runId, "user").catch(() => {});
       return { ok: true, stopped: true };

package/src/agent/run-loop-with-resume.ts

@@ -605,7 +605,7 @@ export async function runAgentLoopDirectWithSoftTimeout(
       type: "error",
       error: RUN_BUDGET_EXHAUSTED_MESSAGE,
       errorCode: RUN_BUDGET_EXHAUSTED_ERROR_CODE,
-      recoverable: true,
+      recoverable: false,
     });
     reportFinalOutcome({
       state: "failed",

package/src/agent/run-manager.ts

@@ -4,6 +4,11 @@ import {
   LLM_MISSING_CREDENTIALS_ERROR_CODE,
   LLM_MISSING_CREDENTIALS_MESSAGE,
 } from "./engine/credential-errors.js";
+import {
+  classifyTerminalErrorCode,
+  describeErrorWithCauses,
+  isProviderConnectionError,
+} from "./engine/error-detail.js";
 import { EngineError } from "./engine/types.js";
 import {
   insertRun,
@@ -341,23 +346,16 @@ function getRunErrorMessage(err: unknown): string {
   return "Unknown error";
 }
 
-function isProviderConnectionErrorMessage(message: string): boolean {
-  const normalized = message.trim().toLowerCase();
-  return (
-    normalized === "connection error." ||
-    normalized.includes("cannot connect to api:")
-  );
-}
-
 function getRunErrorCode(err: unknown): string | undefined {
   if (err instanceof EngineError) {
     if (err.errorCode) return err.errorCode;
     if (err.statusCode === 429) return PROVIDER_RATE_LIMITED_ERROR_CODE;
   }
-  if (err instanceof Error && isProviderConnectionErrorMessage(err.message)) {
-    return PROVIDER_NETWORK_ERROR_CODE;
-  }
-  return undefined;
+  if (isProviderConnectionError(err)) return PROVIDER_NETWORK_ERROR_CODE;
+  // The code rides the error EVENT to the client, which decides recovery from
+  // it — so an uncoded transport failure has to be classified here too, not
+  // only when the run row is persisted.
+  return classifyTerminalErrorCode(describeErrorWithCauses(err));
 }
 
 function getEngineRunErrorDetails(err: EngineError): string | undefined {
@@ -376,7 +374,7 @@ function shouldCaptureRunError(err: unknown): boolean {
   }
   if (!(err instanceof Error)) return true;
   if (/^40[13] status code\b/i.test(err.message)) return false;
-  if (isProviderConnectionErrorMessage(err.message)) return false;
+  if (isProviderConnectionError(err)) return false;
   if (!errorCode) return true;
   const normalizedCode = errorCode.toLowerCase();
   return (
@@ -984,6 +982,13 @@ export function startRun(
   // false-stale-reap zombie scenario where the reaper flipped the row while
   // this isolate was briefly unable to heartbeat (DB latency / GC pause).
   let lastAbortCheck = Date.now() - 3000;
+  // A read failure here used to be indistinguishable from "not aborted" —
+  // exactly the coerced-to-false pattern that lets a real Stop go unseen for
+  // the rest of the run. Count consecutive failures like the heartbeat-write
+  // handler above; past the same threshold, fail closed (self-abort with a
+  // reason outside TURN_ENDING_ABORT_REASONS/RECOVERABLE_ABORT_REASONS, so it
+  // surfaces as a typed error) instead of silently retrying forever.
+  let consecutiveAbortCheckFailures = 0;
   const checkSqlAbort = () => {
     const now = Date.now();
     if (now - lastAbortCheck < 3000) return;
@@ -1004,7 +1009,26 @@ export function startRun(
           }
         }
       })
-      .catch(() => {});
+      .then(() => {
+        consecutiveAbortCheckFailures = 0;
+      })
+      .catch((error) => {
+        consecutiveAbortCheckFailures += 1;
+        if (consecutiveAbortCheckFailures >= 3) {
+          captureError(error, {
+            route: "/_agent-native/agent-chat",
+            tags: {
+              source: "agent-run-manager",
+              phase: "abort-check",
+              consecutiveFailures: String(consecutiveAbortCheckFailures),
+            },
+            extra: { runId, threadId },
+          });
+          if (!abort.signal.aborted) {
+            abortInMemoryRun(run, "abort_check_unavailable");
+          }
+        }
+      });
   };
 
   // Heartbeat: bump heartbeat_at every 1.5s so watchers can detect a dead
@@ -1456,6 +1480,11 @@ export function startRun(
               ? completionError.message
               : String(completionError));
         }
+        // An engine that emitted an error event without a code has NOT told us
+        // the failure is unclassifiable — it told us nothing. Recover the code
+        // from the message before falling back to "unknown", which the client
+        // reads as "do not attempt recovery".
+        errorCode ??= classifyTerminalErrorCode(errorDetail);
         runTerminalErrorCode = errorCode ?? "unknown";
         runTerminalErrorDetail = errorDetail;
         await setRunError(runId, errorCode ?? "unknown", errorDetail);

package/src/agent/run-store.ts

@@ -946,6 +946,16 @@ export interface UnclaimedBackgroundRunRow {
    *  pre-inserted — independent of any liveness bump a redispatch attempt
    *  makes along the way. */
   startedAt: number;
+  /**
+   * Whether the row still carries the `dispatch_payload` a redispatched worker
+   * would rehydrate its request body from. Eligibility for this sweep does NOT
+   * imply it: a background row can reach the grace window having never had a
+   * payload at all. Redispatching one of those asserts `payloadRef: true` to a
+   * worker that then cannot rehydrate, so it kills the run as
+   * `dispatch_payload_missing` — a reason that reads like data loss for what is
+   * really an un-redispatchable handoff.
+   */
+  hasDispatchPayload: boolean;
 }
 
 /**
@@ -965,7 +975,10 @@ export async function listUnclaimedBackgroundRunRows(): Promise<
   const { rows } = await client.execute({
     // CAST keeps the ms-epoch param 64-bit on Postgres (see
     // backgroundAwareStaleCutoffSql for the int4-inference failure mode).
-    sql: `SELECT id, started_at FROM agent_runs
+    // Report payload presence rather than filtering on it: a payload-less row
+    // must still be VISIBLE to the sweep so the slow pass can reap it. Filtering
+    // it out here would leave it `running` forever.
+    sql: `SELECT id, started_at, (dispatch_payload IS NOT NULL) AS has_dispatch_payload FROM agent_runs
           WHERE status = 'running'
             AND dispatch_mode = 'background'
             AND COALESCE(heartbeat_at, started_at) < (CAST(? AS BIGINT) - ${UNCLAIMED_BACKGROUND_RUN_GRACE_MS})`,
@@ -975,11 +988,15 @@ export async function listUnclaimedBackgroundRunRows(): Promise<
   for (const row of rows ?? []) {
     const id = (row as { id?: unknown }).id;
     const startedAt = (row as { started_at?: unknown }).started_at;
+    const hasPayload = (row as { has_dispatch_payload?: unknown })
+      .has_dispatch_payload;
     if (typeof id === "string" && id) {
       result.push({
         id,
         startedAt:
           typeof startedAt === "number" ? startedAt : Number(startedAt) || 0,
+        // SQLite returns 1/0 where Postgres returns a boolean.
+        hasDispatchPayload: hasPayload === true || hasPayload === 1,
       });
     }
   }
@@ -1147,10 +1164,20 @@ export async function setRunTerminalReason(
     await ensureRunTables();
     const client = getDbExec();
     const reason = terminalReason.slice(0, 200);
+    // Write-once for a row that is already terminal. Three writers in three
+    // isolates race on this column — the mid-run checkpoint, the run-manager's
+    // finalization, and the background worker's failure path — with no ordering
+    // between them, and last-writer-wins let a late checkpoint relabel a row
+    // another isolate had already finalized. That produced impossible rows
+    // (status='errored' carrying a continuation reason, no error_code, no
+    // terminal event) and misattributed 130 production runs to a failure mode
+    // they never hit. A row still `running` has no honest reason yet, so it
+    // stays writable; once one is recorded on a terminal row, it stands.
+    const guard = `AND (status = 'running' OR terminal_reason IS NULL OR terminal_reason = '')`;
     await client.execute({
       sql: isContinuationTerminalReason(reason)
-        ? `UPDATE agent_runs SET terminal_reason = ?, status = CASE WHEN status = 'completed' THEN 'truncated' ELSE status END WHERE id = ?`
-        : `UPDATE agent_runs SET terminal_reason = ? WHERE id = ?`,
+        ? `UPDATE agent_runs SET terminal_reason = ?, status = CASE WHEN status = 'completed' THEN 'truncated' ELSE status END WHERE id = ? ${guard}`
+        : `UPDATE agent_runs SET terminal_reason = ? WHERE id = ? ${guard}`,
       args: [reason, runId],
     });
   } catch {