@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/session/agent-session.ts

@@ -349,12 +349,7 @@ import {
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
 import type { CheckpointState } from "../tools/checkpoint";
-import {
-	createArtifactFailurePreview,
-	type OutputMeta,
-	outputMeta,
-	wrapToolWithMetaNotice,
-} from "../tools/output-meta";
+import { outputMeta, wrapToolWithMetaNotice } from "../tools/output-meta";
 import { normalizeLocalScheme, resolveReadPath, resolveToCwd } from "../tools/path-utils";
 import { registerResourceGcSession } from "../tools/resource-gc";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo-write";
@@ -1062,102 +1057,6 @@ function boundAgentBashArtifactSaveDiagnostic(error: unknown): string {
 	return truncateHeadBytes(normalized, AGENT_BASH_ARTIFACT_SAVE_DIAGNOSTIC_MAX_BYTES).text;
 }
 
-const PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS = 500;
-const PRE_ADMISSION_ARTIFACT_MAX_PENDING_SAVES = 2;
-
-type PreAdmissionArtifactSaveOutcome =
-	| { kind: "saved"; saved: Awaited<ReturnType<SessionManager["saveArtifactReceipt"]>> }
-	| { kind: "failed"; error: unknown };
-
-interface PreAdmissionArtifactSaveAdmission {
-	readonly pending: Set<Promise<PreAdmissionArtifactSaveOutcome>>;
-}
-
-/**
- * Pre-admission spills are owned by their concrete SessionManager. A stalled
- * save remains admitted until its promise settles, so timeout does not turn
- * each subsequent tool result into another retained full payload.
- */
-const preAdmissionArtifactSaveAdmissions = new WeakMap<SessionManager, PreAdmissionArtifactSaveAdmission>();
-
-function preAdmissionArtifactSaveAdmissionFor(sessionManager: SessionManager): PreAdmissionArtifactSaveAdmission {
-	let admission = preAdmissionArtifactSaveAdmissions.get(sessionManager);
-	if (!admission) {
-		admission = { pending: new Set() };
-		preAdmissionArtifactSaveAdmissions.set(sessionManager, admission);
-	}
-	return admission;
-}
-
-function beginPreAdmissionArtifactSave(
-	sessionManager: SessionManager,
-	content: string,
-	toolType: string,
-): { kind: "capacity" } | { kind: "started"; outcome: Promise<PreAdmissionArtifactSaveOutcome> } {
-	const admission = preAdmissionArtifactSaveAdmissionFor(sessionManager);
-	if (admission.pending.size >= PRE_ADMISSION_ARTIFACT_MAX_PENDING_SAVES) return { kind: "capacity" };
-
-	let outcome: Promise<PreAdmissionArtifactSaveOutcome>;
-	try {
-		outcome = sessionManager.saveArtifactReceipt(content, toolType).then(
-			saved => ({ kind: "saved" as const, saved }),
-			error => ({ kind: "failed" as const, error }),
-		);
-	} catch (error) {
-		return { kind: "started", outcome: Promise.resolve({ kind: "failed", error }) };
-	}
-	admission.pending.add(outcome);
-	void outcome.then(
-		() => admission.pending.delete(outcome),
-		() => admission.pending.delete(outcome),
-	);
-	return { kind: "started", outcome };
-}
-
-function replaceToolResultWithArtifactFailurePreview(
-	message: ToolResultMessage,
-	fullText: string,
-	maxInlineBytes: number | undefined,
-	diagnostic: string,
-): void {
-	const preview = createArtifactFailurePreview(fullText, maxInlineBytes, diagnostic);
-	const existingDetails =
-		message.details && typeof message.details === "object" ? (message.details as Record<string, unknown>) : {};
-	const existingMeta =
-		existingDetails.meta && typeof existingDetails.meta === "object" ? (existingDetails.meta as OutputMeta) : {};
-	const existingTruncation = existingMeta.truncation;
-	const totalLines = fullText.length > 0 ? fullText.split("\n").length : 0;
-	const outputLines = preview.text.length > 0 ? preview.text.split("\n").length : 0;
-	const outputBytes = Buffer.byteLength(preview.text, "utf-8");
-	const truncation: NonNullable<OutputMeta["truncation"]> = {
-		...(existingTruncation ?? {}),
-		direction: "tail",
-		truncatedBy: "bytes",
-		noticeOwner: undefined,
-		totalLines,
-		totalBytes: Buffer.byteLength(fullText, "utf-8"),
-		outputLines,
-		outputBytes,
-		maxBytes: maxInlineBytes,
-		shownRange: undefined,
-		headRange: undefined,
-		tailRange: undefined,
-		nextOffset: undefined,
-		artifactId: undefined,
-		artifactVerified: false,
-		sourceCaptureIncomplete: true,
-		artifactFailureDiagnostic: diagnostic,
-	};
-	message.details = {
-		...existingDetails,
-		meta: { ...existingMeta, truncation },
-	};
-	message.content = [
-		...message.content.filter((block): block is ImageContent => block.type === "image"),
-		{ type: "text", text: preview.text },
-	];
-}
-
 function summarizeAgentBashArtifactSave(
 	artifactId: string,
 	originalText: string,
@@ -1970,13 +1869,6 @@ export class AgentSession {
 		this.#retryReplayEpoch++;
 		this.#retryReplayUnsafeEpoch = undefined;
 		this.#firstEventTimeoutRetryStartedAt = Date.now();
-		if (
-			this.#extensionRunner?.hasHandlers("context") ||
-			this.#extensionRunner?.hasHandlers("before_provider_request") ||
-			this.#extensionRunner?.hasHandlers("after_provider_response")
-		) {
-			this.#markRetryReplayUnsafe();
-		}
 	}
 
 	#markRetryReplayUnsafe(): void {
@@ -1986,6 +1878,14 @@ export class AgentSession {
 	get #hasCleanRetryReplaySafety(): boolean {
 		return this.#retryReplayEpoch > 0 && this.#retryReplayUnsafeEpoch !== this.#retryReplayEpoch;
 	}
+	#bindAttemptScope(scope: AttemptScope | undefined): void {
+		if (!scope) return;
+		this.#attemptRecordStore.register(scope);
+		this.#attemptRecordStore.establishClean(scope);
+	}
+	#isRetryScopeClean(scope: AttemptScope | undefined): boolean {
+		return scope !== undefined && this.#attemptRecordStore.isClean(scope);
+	}
 	#prePromptContextCheckPromise: Promise<void> | undefined = undefined;
 	/** Display-only context snapshot; pre-prompt compaction estimates deliberately remain uncached. */
 	#contextUsageCache: { key: string; value: ContextUsage } | undefined;
@@ -1999,6 +1899,8 @@ export class AgentSession {
 	// Handoff state
 	#handoffAbortController: AbortController | undefined = undefined;
 	#skipPostTurnMaintenanceAssistantTimestamp: number | undefined = undefined;
+	/** Scope cleanliness captured after message_end extension delivery and before terminal agent_end retirement. */
+	#assistantAttemptScopes = new WeakMap<AssistantMessage, { scope?: AttemptScope; wasClean: boolean }>();
 
 	// Retry state
 	#retryAbortController: AbortController | undefined = undefined;
@@ -2707,6 +2609,7 @@ export class AgentSession {
 		if (this.#extensionRunner && typeof this.#extensionRunner.setAttemptRecordStore === "function") {
 			this.#extensionRunner.setAttemptRecordStore(this.#attemptRecordStore);
 		}
+		this.agent.setMainAttemptScopeObserver(scope => this.#bindAttemptScope(scope));
 		this.#skills = config.skills ?? [];
 		this.#skillWarnings = config.skillWarnings ?? [];
 		this.#customCommands = config.customCommands ?? [];
@@ -3782,101 +3685,39 @@ export class AgentSession {
 		const textParts = message.content.flatMap(block => (block.type === "text" ? [block.text] : []));
 		if (textParts.length === 0) return;
 		const fullText = textParts.join("\n");
-		const configuredInlineKiB = this.settings.get("tools.maxInlineResultBytes");
-		const maxInlineBytes =
-			configuredInlineKiB > 0 ? Math.max(1024, Math.floor(configuredInlineKiB * 1024)) : undefined;
-		const totalBytes = Buffer.byteLength(fullText, "utf-8");
-		const exceedsInlineCap = maxInlineBytes !== undefined && totalBytes > maxInlineBytes;
 		const contextWindow = this.model?.contextWindow;
 		const thresholdTokens = Math.min(
 			8_000,
 			contextWindow && contextWindow > 0 ? Math.floor(contextWindow * 0.05) : 8_000,
 		);
-		// The inline byte cap is an independent admission bound and must be checked
-		// before token heuristics can opt this result out of spilling.
-		if (!exceedsInlineCap && (thresholdTokens <= 0 || estimateTextTokensHeuristic(fullText) <= thresholdTokens))
-			return;
+		if (thresholdTokens <= 0 || estimateTextTokensHeuristic(fullText) <= thresholdTokens) return;
 
-		const saveAdmission = beginPreAdmissionArtifactSave(this.sessionManager, fullText, "tool-result");
-		if (saveAdmission.kind === "capacity") {
-			replaceToolResultWithArtifactFailurePreview(
-				message,
-				fullText,
-				maxInlineBytes,
-				"artifact save capacity exhausted; the previous save is still settling",
-			);
-			return;
-		}
 		try {
-			const saveOutcome = await Promise.race([
-				saveAdmission.outcome,
-				Bun.sleep(PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS).then(() => ({ kind: "timeout" as const })),
-			]);
-			if (saveOutcome.kind !== "saved" || !saveOutcome.saved) {
-				const diagnostic =
-					saveOutcome.kind === "timeout"
-						? `did not settle within ${PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS}ms`
-						: saveOutcome.kind === "failed"
-							? boundAgentBashArtifactSaveDiagnostic(saveOutcome.error)
-							: "artifact storage is unavailable";
-				replaceToolResultWithArtifactFailurePreview(message, fullText, maxInlineBytes, diagnostic);
-				return;
-			}
-			const saved = saveOutcome.saved;
-			const existingDetails = message.details;
-			const detailRecord =
-				existingDetails && typeof existingDetails === "object" ? (existingDetails as Record<string, unknown>) : {};
-			const existingMeta =
-				detailRecord.meta && typeof detailRecord.meta === "object" ? (detailRecord.meta as OutputMeta) : {};
-			const existingTruncation = existingMeta.truncation;
-			const priorLoss = existingTruncation !== undefined;
+			const artifactId = await this.sessionManager.saveArtifact(fullText, "tool-result");
+			if (!artifactId) return;
 			const digest = crypto.createHash("sha256").update(fullText).digest("hex");
-			const sourceCaptureIncomplete = priorLoss || !saved.complete || undefined;
-			const preview = createPreAdmissionArtifactSpillPreview(fullText, saved.id, digest, {
-				maxInlineBytes,
-				fullOutput: saved.complete && !priorLoss,
-			});
+			const preview = createPreAdmissionArtifactSpillPreview(fullText, artifactId, digest);
 			const spillMeta = outputMeta()
 				.truncationFromText(preview, {
 					direction: "middle",
 					totalLines: fullText.split("\n").length,
-					totalBytes,
-					artifactId: saved.id,
-					artifactVerified: true,
-					sourceCaptureIncomplete,
-					...(maxInlineBytes !== undefined ? { maxBytes: maxInlineBytes } : {}),
+					totalBytes: Buffer.byteLength(fullText, "utf-8"),
+					artifactId,
 				})
 				.get();
-			const spillTruncation = spillMeta?.truncation;
-			const artifactTruncatedBytes =
-				Math.max(existingTruncation?.artifactTruncatedBytes ?? 0, saved.omittedBytes ?? 0) || undefined;
-			const mergedTruncation = spillTruncation
-				? {
-						...existingTruncation,
-						...spillTruncation,
-						artifactId: saved.id,
-						artifactVerified: true,
-						artifactTruncatedBytes,
-						sourceTruncatedBytes: existingTruncation?.sourceTruncatedBytes,
-						sourceCaptureIncomplete,
-						columnDroppedBytes: existingTruncation?.columnDroppedBytes,
-						shownRange: sourceCaptureIncomplete ? undefined : spillTruncation.shownRange,
-						headRange: sourceCaptureIncomplete ? undefined : spillTruncation.headRange,
-						tailRange: sourceCaptureIncomplete ? undefined : spillTruncation.tailRange,
-						nextOffset: sourceCaptureIncomplete ? undefined : spillTruncation.nextOffset,
-					}
-				: existingTruncation;
-			message.details = {
-				...detailRecord,
-				meta: { ...existingMeta, ...spillMeta, truncation: mergedTruncation },
-			};
+			const existingDetails = message.details;
+			const detailRecord =
+				existingDetails && typeof existingDetails === "object" ? (existingDetails as Record<string, unknown>) : {};
+			const existingMeta =
+				detailRecord.meta && typeof detailRecord.meta === "object"
+					? (detailRecord.meta as Record<string, unknown>)
+					: {};
+			message.details = { ...detailRecord, meta: { ...existingMeta, ...spillMeta } };
 			message.content = [
 				...message.content.filter((block): block is ImageContent => block.type === "image"),
 				{ type: "text", text: preview },
 			];
 		} catch (error) {
-			const diagnostic = boundAgentBashArtifactSaveDiagnostic(error);
-			replaceToolResultWithArtifactFailurePreview(message, fullText, maxInlineBytes, diagnostic);
 			logger.warn("Failed to spill oversized tool result before context admission", {
 				toolName: message.toolName,
 				error: error instanceof Error ? error.message : String(error),
@@ -3902,11 +3743,7 @@ export class AgentSession {
 	/** Internal handler for agent events - shared by subscribe and reconnect */
 	#handleAgentEvent = async (event: AgentEvent, activePromptHandle?: string): Promise<void> => {
 		const attemptScope = (event as AgentEvent & { scope?: AttemptScope }).scope;
-		if ((event.type === "agent_start" || event.type === "turn_start") && attemptScope) {
-			this.#attemptRecordStore.register(attemptScope);
-			this.#attemptRecordStore.establishClean(attemptScope);
-		}
-		if (this.#extensionRunner?.hasHandlers(event.type)) this.#markRetryReplayUnsafe();
+
 		if (
 			event.type === "tool_execution_start" ||
 			event.type === "tool_execution_update" ||
@@ -4110,6 +3947,12 @@ export class AgentSession {
 		}
 
 		await this.#emitSessionEvent(displayEvent);
+		if (event.type === "message_end" && event.message.role === "assistant") {
+			this.#assistantAttemptScopes.set(event.message, {
+				scope: attemptScope,
+				wasClean: this.#isRetryScopeClean(attemptScope),
+			});
+		}
 		if (
 			displayEvent !== event &&
 			displayEvent.type === "message_end" &&
@@ -4484,7 +4327,14 @@ export class AgentSession {
 			if (this.#isRetryableError(msg)) {
 				const transportFailure = (msg as AssistantMessage & { transportFailure?: TransportFailureFacts })
 					.transportFailure;
-				const didRetry = await this.#handleRetryableError(msg, false, transportFailure);
+				const messageScope = this.#assistantAttemptScopes.get(msg);
+				const didRetry = await this.#handleRetryableError(
+					msg,
+					false,
+					transportFailure,
+					messageScope?.scope ?? event.scope,
+					messageScope?.wasClean ?? false,
+				);
 				if (didRetry) return; // Retry was initiated, don't proceed to compaction
 			}
 			if (this.#retryAttempt > 0) {
@@ -6001,6 +5851,7 @@ export class AgentSession {
 		this.#abortActiveMidRunBarriers();
 		this.abortCompaction();
 		this.agent.abort();
+		this.agent.setMainAttemptScopeObserver(undefined);
 		// Disconnect the Agent event bridge NOW — before the maintenance join and the
 		// bounded idle / forceAbort below — so no agent_end emitted during teardown
 		// (including the one forceAbort emits) can re-enter #handleAgentEvent and start
@@ -14736,6 +14587,8 @@ export class AgentSession {
 			outcome.failure.message,
 			true,
 			outcome.failure.transportFailure,
+			outcome.scope,
+			this.#isRetryScopeClean(outcome.scope),
 		) as Promise<ManagedAttemptDecision>;
 	}
 
@@ -14896,6 +14749,8 @@ export class AgentSession {
 		message: AssistantMessage,
 		managedOutcome = false,
 		transportFailure?: TransportFailureFacts,
+		scope?: AttemptScope,
+		scopeWasClean = this.#isRetryScopeClean(scope),
 	): Promise<boolean | ManagedAttemptDecision> {
 		const controller = this.#defaultFallbackChain();
 		const managedFallback = controller.chain.entries.length > 1;
@@ -14910,12 +14765,16 @@ export class AgentSession {
 		if (!managedFallback && !retrySettings.enabled) return false;
 		const classification = this.#classifyErrorForRetry(message);
 		const firstEventTimeout = classification === "first_event_timeout";
-		if (!managedFallback && firstEventTimeout) {
-			this.#firstEventTimeoutRetryStartedAt ??= Date.now();
+		if (!managedFallback && firstEventTimeout && this.#retryAttempt === 0) {
+			this.#firstEventTimeoutRetryStartedAt = Date.now();
 		}
-		// First-event timeouts are replay-safe only before any model progress,
-		// abort, or extension/provider lifecycle participation.
-		if (firstEventTimeout && (!this.#hasCleanRetryReplaySafety || assistantMessageHasVisibleOrToolContent(message))) {
+		const requiresScopedFirstEventTimeout = managedFallback || !legacyRetryConfigured;
+		if (
+			firstEventTimeout &&
+			(assistantMessageHasVisibleOrToolContent(message) ||
+				(this.#retryAttempt > 0 && !this.#hasCleanRetryReplaySafety) ||
+				(requiresScopedFirstEventTimeout && (!this.#isTypedFirstEventTimeout(message) || !scope || !scopeWasClean)))
+		) {
 			return managedOutcome
 				? {
 						type: "terminal",
@@ -14943,14 +14802,12 @@ export class AgentSession {
 		// before the failure. This bypasses #hasCleanRetryReplaySafety because the
 		// content-free check is the replay-safety guarantee for credential rotation.
 		const canReplayRotatedCredential = credentialRotated;
-		// Bare defaults admit only clean, side-effect-free canonical stream watchdog failures,
-		// content-free quota/rate-limit credential rotations, and the explicit Codex
-		// capacity-overload event.
+		// Bare defaults retain their narrow watchdog and Codex admissions. A
+		// first-event timeout adds the typed, content-free, current-clean-scope
+		// requirement above; other transient watchdogs preserve legacy behavior.
 		if (!managedFallback && !legacyRetryConfigured && !canReplayRotatedCredential) {
 			const bareDefaultCodexOverload = isBareDefaultCodexOverload(message);
 			const bareDefaultWrappedFirstEventTimeout = isBareDefaultWrappedFirstEventTimeout(message);
-			// Content-free Codex overload is replay-safe by the same reasoning as
-			// credential rotation: no partial output means no observable state.
 			const canReplayCodexOverload = bareDefaultCodexOverload;
 			if (
 				(!canReplayCodexOverload &&
@@ -14959,7 +14816,7 @@ export class AgentSession {
 					(hasBareDefaultRetryDisqualifyingFacts(message) ||
 						(classification !== "transient" && classification !== "first_event_timeout") ||
 						!BARE_DEFAULT_WATCHDOG_ERROR.test(message.errorMessage ?? ""))) ||
-				(!canReplayCodexOverload && !this.#hasCleanRetryReplaySafety)
+				(!canReplayCodexOverload && !firstEventTimeout && !this.#hasCleanRetryReplaySafety)
 			) {
 				return false;
 			}