@gajae-code/coding-agent 0.12.8 → 0.12.11

package/src/session/agent-session.ts

@@ -109,6 +109,7 @@ import {
 	streamSimple,
 } from "@gajae-code/ai";
 import {
+	type AuthDisposition,
 	beginAttempt,
 	classifyFallbackTrigger,
 	type FallbackAttemptToken,
@@ -426,6 +427,7 @@ import {
 	getLatestCompactionEntry,
 	getSessionMessageEntryId,
 	getSessionMessageObservationId,
+	SessionAppendPersistenceError,
 	transferSessionMessageIdentity,
 } from "./session-manager";
 import { getEntriesForInternalRead, getSessionContextForInternalRead } from "./session-manager-internal";
@@ -3898,14 +3900,19 @@ export class AgentSession {
 			) {
 				const isRosterReminder = event.message.role === "custom" && event.message.customType === "irc-peer-roster";
 				if (!isRosterReminder) {
-					this.#appendCustomMessageEntry(
-						event.message.customType,
-						event.message.content,
-						event.message.display,
-						event.message.details,
-						event.message.attribution ?? "agent",
-						getSessionMessageObservationId(event.message),
-					);
+					try {
+						this.#appendCustomMessageEntry(
+							event.message.customType,
+							event.message.content,
+							event.message.display,
+							event.message.details,
+							event.message.attribution ?? "agent",
+							getSessionMessageObservationId(event.message),
+						);
+					} catch (error) {
+						this.agent.abort();
+						throw error;
+					}
 				}
 			} else if (
 				event.message.role === "user" ||
@@ -3914,7 +3921,73 @@ export class AgentSession {
 				event.message.role === "toolResult" ||
 				event.message.role === "fileMention"
 			) {
-				this.sessionManager.appendMessage(event.message);
+				try {
+					this.sessionManager.appendMessage(event.message);
+				} catch (error) {
+					if (
+						event.message.role !== "toolResult" ||
+						event.message.toolName !== "todo_write" ||
+						!(error instanceof SessionAppendPersistenceError) ||
+						error.phase !== "current_append"
+					) {
+						this.agent.abort();
+						throw error;
+					}
+					this.agent.abort();
+
+					const failure = error.persistenceError.message;
+					const failedEntryId = error.entryId;
+					this.#syncTodoPhasesFromBranch();
+					event.message.isError = true;
+					event.message.content = [
+						{
+							type: "text",
+							text: `Todo state persistence failed: ${failure}\nDo not change the payload solely because of this failure. The durable outcome is unknown; reconcile the session state before retrying or continuing.`,
+						},
+					];
+					event.message.details = {
+						...(event.message.details && typeof event.message.details === "object" ? event.message.details : {}),
+						phases: this.getTodoPhases(),
+						failureKind: "persistence",
+					};
+					this.agent.touchContext();
+					let recovered = false;
+					try {
+						await this.sessionManager.recoverPersistenceFailure();
+						recovered = true;
+					} catch (recoveryError) {
+						logger.warn("Todo persistence recovery failed", {
+							error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
+						});
+					}
+					if (recovered) {
+						const durableTodoResult = this.sessionManager
+							.getBranch()
+							.find(
+								entry =>
+									entry.id === failedEntryId &&
+									entry.type === "message" &&
+									entry.message.role === "toolResult" &&
+									entry.message.toolName === "todo_write",
+							);
+						this.#syncTodoPhasesFromBranch();
+						if (durableTodoResult?.type === "message" && durableTodoResult.message.role === "toolResult") {
+							event.message.content = durableTodoResult.message.content;
+							event.message.details = durableTodoResult.message.details;
+							event.message.isError = durableTodoResult.message.isError;
+						} else {
+							event.message.details = {
+								...(event.message.details && typeof event.message.details === "object"
+									? event.message.details
+									: {}),
+								phases: this.getTodoPhases(),
+								failureKind: "persistence",
+							};
+							this.sessionManager.appendMessage(event.message);
+							this.agent.touchContext();
+						}
+					}
+				}
 			}
 		}
 
@@ -4188,7 +4261,13 @@ export class AgentSession {
 			if (event.message.role === "toolResult") {
 				const { toolName, details, isError, content } = event.message as {
 					toolName?: string;
-					details?: { path?: string; phases?: TodoPhase[]; report?: string; startedAt?: string };
+					details?: {
+						path?: string;
+						phases?: TodoPhase[];
+						report?: string;
+						startedAt?: string;
+						failureKind?: "payload_rejected" | "argument_validation" | "execution" | "persistence";
+					};
 					isError?: boolean;
 					content?: Array<TextContent | ImageContent>;
 				};
@@ -4201,22 +4280,34 @@ export class AgentSession {
 				}
 				if (toolName === "todo_write" && isError) {
 					const errorText = content?.find(part => part.type === "text")?.text;
+					const payloadRejected =
+						details?.failureKind === "payload_rejected" || details?.failureKind === "argument_validation";
 					const reminderText = [
 						"<system-reminder>",
-						"todo_write failed, so todo progress is not visible to the user.",
+						payloadRejected
+							? "todo_write rejected its payload. The requested todo update was not applied."
+							: "todo_write did not complete because the turn aborted during runtime execution or persistence.",
 						errorText ? `Failure: ${errorText}` : "Failure: todo_write returned an error.",
-						"Fix the todo payload and call todo_write again before continuing.",
+						payloadRejected
+							? "Correct the payload and call todo_write again before continuing."
+							: "Do not change the payload solely because of this failure. The durable outcome is unknown; reconcile the session state before retrying or continuing.",
 						"</system-reminder>",
 					].join("\n");
-					await this.sendCustomMessage(
-						{
-							customType: "todo-write-error-reminder",
-							content: reminderText,
-							display: false,
-							details: { toolName, errorText },
-						},
-						{ deliverAs: "nextTurn" },
-					);
+					try {
+						await this.sendCustomMessage(
+							{
+								customType: "todo-write-error-reminder",
+								content: reminderText,
+								display: false,
+								details: { toolName, errorText },
+							},
+							{ deliverAs: "nextTurn" },
+						);
+					} catch (error) {
+						logger.warn("Todo write error reminder persistence failed", {
+							error: error instanceof Error ? error.message : String(error),
+						});
+					}
 				}
 				if (toolName === "checkpoint" && !isError) {
 					const checkpointEntryId = this.sessionManager.getLeafId();
@@ -14228,6 +14319,12 @@ export class AgentSession {
 			);
 		}
 		const trigger = classifyFallbackTrigger(transportFailure ?? { status: message.errorStatus });
+		// A plain `forbidden` is terminal. Without this, the blanket
+		// `transportFailure` admission below re-admits a committed forbidden
+		// failure into retry policy: credential mutation is vetoed downstream, but
+		// the chain would still retry and advance models on a request the caller is
+		// simply not authorized to make.
+		if (trigger.class === "auth" && trigger.authDisposition === "forbidden") return false;
 		if (transportFailure) return true;
 		if (
 			trigger.class === "rate_limit" ||
@@ -14616,7 +14713,10 @@ export class AgentSession {
 		message: AssistantMessage,
 		allowLegacyUsageLimit: boolean,
 		transportFailure?: TransportFailureFacts,
-	): { class: FallbackTriggerClass; retryAfterMs?: number } | undefined {
+		// `authDisposition` is carried through from `classifyFallbackTrigger`, whose
+		// result is returned verbatim below. Narrowing it away here would silently
+		// disable the terminal-403 guard in `#markFailedCredential`.
+	): { class: FallbackTriggerClass; retryAfterMs?: number; authDisposition?: AuthDisposition } | undefined {
 		if (classifyContextOverflow(message, transportFailure, this.model?.contextWindow ?? 0)) return undefined;
 		const transport = classifyFallbackTrigger(transportFailure ?? { status: message.errorStatus });
 		if (transport.class !== "other") return transport;
@@ -14723,25 +14823,60 @@ export class AgentSession {
 		return `Model fallback chain exhausted; models tried: ${tried}; models skipped: ${skipped}`;
 	}
 
-	async #markFailedCredential(trigger: { class: FallbackTriggerClass; retryAfterMs?: number }): Promise<boolean> {
+	/**
+	 * Marks the credential that just failed and reports whether the session
+	 * actually moved to a DIFFERENT stored credential.
+	 *
+	 * Three invariants this enforces, in order:
+	 *
+	 * 1. **Pin guard, first and for every trigger class.** A pinned credential
+	 *    (`--api-key` or `--credential`) must never be mutated or rotated away
+	 *    from. Both overrides are consulted: they live in separate maps, so
+	 *    checking only `hasRuntimeApiKey` would silently rotate a `--credential`
+	 *    pin. Previously the guard existed only on the quota path, so the `auth`
+	 *    path invalidated pinned credentials outright.
+	 * 2. **A terminal `forbidden` never mutates credential state.** Rotation
+	 *    would hide an authorization defect and cycle through healthy rows.
+	 * 3. **Distinct-row proof in BOTH branches.** `invalidateCredentialMatching`
+	 *    reports "I matched and blocked a row", which is not the same as "the
+	 *    session now uses a different credential" — with a single-row pool it is
+	 *    true while nothing rotated. Both branches therefore re-resolve and
+	 *    require the active key to have actually changed.
+	 */
+	async #markFailedCredential(trigger: {
+		class: FallbackTriggerClass;
+		retryAfterMs?: number;
+		authDisposition?: AuthDisposition;
+	}): Promise<boolean> {
 		if (!this.model || (trigger.class !== "auth" && trigger.class !== "quota" && trigger.class !== "rate_limit")) {
 			return false;
 		}
+		// (2) Terminal forbidden: no credential state may change.
+		if (trigger.class === "auth" && trigger.authDisposition === "forbidden") return false;
+
 		const authStorage = this.#modelRegistry.authStorage;
+		const provider = this.model.provider;
+		// (1) Pin guard, before any mutation and for every branch.
+		if (authStorage.hasRuntimeApiKey(provider) || authStorage.hasRuntimeCredentialSelector(provider)) return false;
+
 		const providerAffinitySessionId = this.agent.providerSessionId ?? this.agent.sessionId ?? this.sessionId;
+		const activeApiKey = await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId);
+
+		let mutated: boolean;
 		if (trigger.class === "auth") {
-			const apiKey = await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId);
-			if (!isAuthenticated(apiKey)) return false;
-			return authStorage.invalidateCredentialMatching(this.model.provider, apiKey, {
+			if (!isAuthenticated(activeApiKey)) return false;
+			mutated = await authStorage.invalidateCredentialMatching(provider, activeApiKey, {
 				sessionId: providerAffinitySessionId,
 			});
+		} else {
+			mutated = await authStorage.markUsageLimitReached(provider, providerAffinitySessionId, {
+				retryAfterMs: trigger.retryAfterMs,
+			});
 		}
-		if (authStorage.hasRuntimeApiKey(this.model.provider)) return false;
-		const activeApiKey = await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId);
-		const rotated = await authStorage.markUsageLimitReached(this.model.provider, providerAffinitySessionId, {
-			retryAfterMs: trigger.retryAfterMs,
-		});
-		return rotated && (await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId)) !== activeApiKey;
+		if (!mutated) return false;
+
+		// (3) Distinct-row proof.
+		return (await this.#modelRegistry.getApiKey(this.model, providerAffinitySessionId)) !== activeApiKey;
 	}
 
 	/** Handle retryable errors with exponential backoff. */
@@ -14836,8 +14971,15 @@ export class AgentSession {
 			credentialRotated = await this.#markFailedCredential(trigger);
 		}
 		if (credentialRotated) {
-			if (managedFallback) controller.restorePreviousEntryForRetry();
-			outcome = "retry";
+			// A rotation only becomes a same-model retry if the controller can
+			// actually be rewound. `restorePreviousEntryForRetry()` refuses once an
+			// entry's restore budget is consumed or attempts are exhausted; ignoring
+			// that would force `outcome = "retry"` while `activeIndex` stays on the
+			// next entry and `this.model` stays on the previous one — splitting
+			// attempt attribution, exhaustion, and sticky selection across two models.
+			if (!managedFallback || controller.restorePreviousEntryForRetry()) {
+				outcome = "retry";
+			}
 		}
 		if (outcome === "exhausted") {
 			if (managedFallback) {