@gajae-code/agent-core 0.13.2 → 0.13.3

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.13.3] - 2026-08-15
+
+### Fixed
+- Emergency compaction now considers managed transcript file size so sessions compact before the managed per-file limit (#4411).
+- Managed runs discard assistant turns whose tool calls carried `\uXXXX`-escaped arguments and report them through the typed `escaped_arguments_discarded` outcome instead of executing unverifiable text; unmanaged runs reject such calls per-call with an actionable error (#4515).
+
 ## [0.13.2] - 2026-08-13
 
 ## [0.13.1] - 2026-08-11

package/dist/types/compaction/compaction.d.ts

@@ -80,7 +80,7 @@ export declare function effectiveReserveTokens(contextWindow: number, settings:
  */
 export declare function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings, maxOutputTokens?: number): boolean;
 /** Reason a compaction was triggered. `token` is the normal user-configurable path; the rest are emergency floors. */
-export type CompactionTriggerReason = "token" | "heap" | "retainedMemory" | "providerBytes" | "messageCount" | "imageBytes";
+export type CompactionTriggerReason = "token" | "heap" | "retainedMemory" | "transcriptFile" | "providerBytes" | "messageCount" | "imageBytes";
 /** A point-in-time resource sample. Supplied by an injectable sampler so tests never read real RSS. */
 export interface EmergencyCompactionSample {
     /** Resident heap bytes (e.g. process.memoryUsage().heapUsed). */
@@ -99,6 +99,8 @@ export interface EmergencyCompactionSample {
     tuiChatChildren?: number;
     /** Bytes retained by TUI render caches. */
     tuiCachedRenderBytes?: number;
+    /** On-disk JSONL transcript file size in bytes; 0/undefined when unknown. */
+    transcriptFileBytes?: number;
 }
 export interface EmergencyCompactionLimits {
     heapUsedBytes: number;
@@ -109,6 +111,7 @@ export interface EmergencyCompactionLimits {
     retainedMemoryDiagnosticBytes?: number;
     tuiChatChildren?: number;
     tuiChatChildrenDiagnostic?: number;
+    transcriptFileBytes?: number;
 }
 export declare function resetEmergencyRetainedMemoryDiagnosticsForTests(): void;
 export declare function resolveEmergencyCompactionLimits(totalMemoryBytes?: number): EmergencyCompactionLimits;
@@ -119,7 +122,7 @@ export declare function resolveEmergencyCompactionLimits(totalMemoryBytes?: numb
  */
 export declare const DEFAULT_EMERGENCY_COMPACTION_LIMITS: EmergencyCompactionLimits;
 /**
- * Returns the first emergency limit exceeded (heap > retainedMemory > providerBytes > imageBytes > messageCount),
+ * Returns the first emergency limit exceeded (heap > retainedMemory > transcriptFile > providerBytes > imageBytes > messageCount),
  * or null when none is. Pure apart from retained-memory diagnostics; the caller routes the result through the
  * normal pair-safe `compact()` cut logic so a tool_use/tool_result pair is never split.
  */

package/dist/types/types.d.ts

@@ -162,6 +162,11 @@ export type ManagedAttemptOutcome = {
         transportFailure?: TransportFailureFacts;
     };
     scope?: AttemptScope;
+} | {
+    type: "escaped_arguments_discarded";
+    /** The defective assistant turn; already removed from usable history by the loop. */
+    message: AssistantMessage;
+    scope?: AttemptScope;
 } | {
     type: "context_overflow_discarded";
     message: AssistantMessage;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/agent-core",
-	"version": "0.13.2",
+	"version": "0.13.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -32,9 +32,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/ai": "0.13.2",
-		"@gajae-code/natives": "0.13.2",
-		"@gajae-code/utils": "0.13.2",
+		"@gajae-code/ai": "0.13.3",
+		"@gajae-code/natives": "0.13.3",
+		"@gajae-code/utils": "0.13.3",
 		"@opentelemetry/api": "^1.9.0"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -263,6 +263,15 @@ function managedContextOverflowOutcome(message: AssistantMessage, scope?: Attemp
 	return { type: "context_overflow_discarded", message, scope };
 }
 
+/** Whether any tool call in the turn carried `\uXXXX`-escaped arguments. */
+function hasEscapedNonAsciiToolCall(message: AssistantMessage): boolean {
+	return message.content.some(block => block.type === "toolCall" && block.escapedNonAsciiArguments === true);
+}
+
+function managedEscapedArgumentsOutcome(message: AssistantMessage, scope?: AttemptScope): ManagedAttemptOutcome {
+	return { type: "escaped_arguments_discarded", message, scope };
+}
+
 function managedFailureMessage(error: unknown, config: AgentLoopConfig): AssistantMessage {
 	const errorMessage = managedProperty(error, "message");
 	const transportFailure = managedTransportFailure(error);
@@ -809,6 +818,7 @@ function managedAssistantContent(value: unknown): AssistantMessage["content"][nu
 	const intent = managedProperty(value, "intent");
 	const customWireName = managedProperty(value, "customWireName");
 	const incompleteArguments = managedProperty(value, "incompleteArguments");
+	const escapedNonAsciiArguments = managedProperty(value, "escapedNonAsciiArguments");
 	return {
 		type,
 		id,
@@ -818,6 +828,7 @@ function managedAssistantContent(value: unknown): AssistantMessage["content"][nu
 		...(typeof intent === "string" ? { intent } : {}),
 		...(typeof customWireName === "string" ? { customWireName } : {}),
 		...(typeof incompleteArguments === "boolean" ? { incompleteArguments } : {}),
+		...(typeof escapedNonAsciiArguments === "boolean" ? { escapedNonAsciiArguments } : {}),
 	};
 }
 
@@ -1773,6 +1784,35 @@ async function runLoopBody(
 				}
 			}
 
+			// Escaped-non-ASCII tool arguments: managed bounded turn resample.
+			//
+			// Arguments that spell a printable non-ASCII character as `\uXXXX`
+			// instead of literal UTF-8 are a wire-format defect, not a decision the
+			// model needs to be told about. The payload parses cleanly, but one
+			// mistyped nibble decodes to a different, equally valid character, so it
+			// can never be verified or repaired after the fact. Reporting it as a
+			// tool error spends the whole turn and writes the literal escape syntax
+			// back into the context the model samples from next. A managed
+			// invocation instead drops the defective turn and reports it through the
+			// typed `escaped_arguments_discarded` outcome so the session policy owns
+			// a bounded same-model retry; the defect is never treated as provider
+			// evidence, so the fallback chain never advances on it. Unmanaged runs
+			// keep the per-call rejection in `executeToolCalls` as the terminal
+			// answer.
+			if (
+				config.fallbackManaged &&
+				message.stopReason !== "error" &&
+				message.stopReason !== "aborted" &&
+				hasEscapedNonAsciiToolCall(message)
+			) {
+				transaction?.discard();
+				currentContext.messages.splice(contextMessageCount);
+				newMessages.splice(newMessageCount);
+				await config.onManagedAttemptOutcome?.(managedEscapedArgumentsOutcome(message, transaction?.scope));
+				stream.end(newMessages);
+				return;
+			}
+
 			const overflow = managedContextOverflow(message, config);
 			if (config.fallbackManaged && overflow) {
 				transaction?.discard();
@@ -2743,6 +2783,20 @@ async function executeToolCalls(
 							`Re-issue the call with complete arguments, splitting the work into smaller steps if needed.`,
 					);
 				}
+				if (toolCall.escapedNonAsciiArguments) {
+					record.argumentValidationFailed = true;
+					// The arguments decoded cleanly, but they were spelled as `\uXXXX`
+					// escapes rather than literal UTF-8. Hand-written hex is where models
+					// mistype digits, and every mistyped nibble decodes to a different but
+					// equally valid character — the payload is unverifiable and cannot be
+					// repaired after parsing, so it is rejected rather than executed on
+					// silently corrupted text.
+					throw new Error(
+						`Tool call "${toolCall.name}" spelled non-ASCII text as \\uXXXX escapes instead of literal UTF-8. ` +
+							`Escaped text cannot be verified — a single wrong hex digit silently becomes a different character — ` +
+							`so the call was not executed. Re-issue it writing every non-ASCII character literally.`,
+					);
+				}
 				if (!tool) {
 					// A discoverable tool that hasn't been activated yet resolves to
 					// undefined here. The model often "remembers" such a tool (e.g.

package/src/compaction/compaction.ts

@@ -253,6 +253,7 @@ export type CompactionTriggerReason =
 	| "token"
 	| "heap"
 	| "retainedMemory"
+	| "transcriptFile"
 	| "providerBytes"
 	| "messageCount"
 	| "imageBytes";
@@ -275,6 +276,8 @@ export interface EmergencyCompactionSample {
 	tuiChatChildren?: number;
 	/** Bytes retained by TUI render caches. */
 	tuiCachedRenderBytes?: number;
+	/** On-disk JSONL transcript file size in bytes; 0/undefined when unknown. */
+	transcriptFileBytes?: number;
 }
 
 export interface EmergencyCompactionLimits {
@@ -286,6 +289,7 @@ export interface EmergencyCompactionLimits {
 	retainedMemoryDiagnosticBytes?: number;
 	tuiChatChildren?: number;
 	tuiChatChildrenDiagnostic?: number;
+	transcriptFileBytes?: number;
 }
 
 const MAX_EMERGENCY_HEAP_FLOOR_BYTES = 1_536 * 1024 * 1024; // 1.5 GiB resident heap
@@ -293,6 +297,7 @@ const EMERGENCY_RETAINED_MEMORY_BYTES = 128 * 1024 * 1024;
 const DIAGNOSTIC_RETAINED_MEMORY_BYTES = 64 * 1024 * 1024;
 const EMERGENCY_TUI_CHAT_CHILDREN = 1000;
 const DIAGNOSTIC_TUI_CHAT_CHILDREN = 700;
+const EMERGENCY_TRANSCRIPT_FILE_BYTES = 48 * 1024 * 1024; // 48 MiB (75% of the 64 MiB managed cap)
 let retainedMemoryDiagnosticActive = false;
 let tuiChatChildrenDiagnosticActive = false;
 
@@ -315,6 +320,7 @@ export function resolveEmergencyCompactionLimits(totalMemoryBytes: number = os.t
 		retainedMemoryDiagnosticBytes: DIAGNOSTIC_RETAINED_MEMORY_BYTES,
 		tuiChatChildren: EMERGENCY_TUI_CHAT_CHILDREN,
 		tuiChatChildrenDiagnostic: DIAGNOSTIC_TUI_CHAT_CHILDREN,
+		transcriptFileBytes: EMERGENCY_TRANSCRIPT_FILE_BYTES,
 	};
 }
 
@@ -326,7 +332,7 @@ export function resolveEmergencyCompactionLimits(totalMemoryBytes: number = os.t
 export const DEFAULT_EMERGENCY_COMPACTION_LIMITS: EmergencyCompactionLimits = resolveEmergencyCompactionLimits();
 
 /**
- * Returns the first emergency limit exceeded (heap > retainedMemory > providerBytes > imageBytes > messageCount),
+ * Returns the first emergency limit exceeded (heap > retainedMemory > transcriptFile > providerBytes > imageBytes > messageCount),
  * or null when none is. Pure apart from retained-memory diagnostics; the caller routes the result through the
  * normal pair-safe `compact()` cut logic so a tool_use/tool_result pair is never split.
  */
@@ -360,6 +366,11 @@ export function emergencyCompactionReason(
 		tuiChatChildren >= (limits.tuiChatChildren ?? EMERGENCY_TUI_CHAT_CHILDREN)
 	)
 		return "retainedMemory";
+	if (
+		sample.transcriptFileBytes &&
+		sample.transcriptFileBytes > (limits.transcriptFileBytes ?? EMERGENCY_TRANSCRIPT_FILE_BYTES)
+	)
+		return "transcriptFile";
 	if (sample.providerBytes > limits.providerBytes) return "providerBytes";
 	if (sample.imageBytes > limits.imageBytes) return "imageBytes";
 	if (sample.messageCount > limits.messageCount) return "messageCount";

package/src/types.ts

@@ -182,6 +182,12 @@ export type ManagedAttemptOutcome =
 			};
 			scope?: AttemptScope;
 	  }
+	| {
+			type: "escaped_arguments_discarded";
+			/** The defective assistant turn; already removed from usable history by the loop. */
+			message: AssistantMessage;
+			scope?: AttemptScope;
+	  }
 	| { type: "context_overflow_discarded"; message: AssistantMessage; scope?: AttemptScope }
 	| { type: "run_terminal"; reason: "cancelled" | "error" | "exhausted"; scope?: AttemptScope };