@gajae-code/coding-agent 0.11.2 → 0.11.4

package/src/tools/resource-gc.ts

@@ -75,12 +75,31 @@ const defaultDeps: ResourceGcDeps = {
 
 // ── Controller state (process-global; tabs/browsers are module-global too) ──────────────────
 const activeSessions = new Map<string, Settings>();
-let timer: ReturnType<typeof setTimeout> | null = null;
+
+interface ScheduleOwner {
+	generation: number;
+	token: number;
+}
+
+interface DeferredSchedule {
+	generation: number;
+	deadline: number;
+}
+
+interface WorkOwner {
+	generation: number;
+	source: "timer" | "external";
+}
+
+let pendingTimer: NodeJS.Timeout | null = null;
+let pendingDeadline: number | null = null;
+let pendingOwner: ScheduleOwner | null = null;
+let deferredSchedule: DeferredSchedule | null = null;
+let inProgressOwner: WorkOwner | null = null;
 let stopped = false;
-// Bumped on every stop so an in-flight tick from a previous schedule cannot reschedule after a
-// stop+re-register and leak a duplicate timer.
 let timerGeneration = 0;
-let inProgress = false;
+let nextTimerToken = 0;
+let schedulerNow = (): number => performance.now();
 let rssWarningActive = false;
 let lastScreenshotScanAt = 0;
 let deps: ResourceGcDeps = defaultDeps;
@@ -96,8 +115,20 @@ export interface ResourceGcRegistration {
  * session unregisters.
  */
 export function registerResourceGcSession(reg: ResourceGcRegistration): () => void {
+	const isNewSession = !activeSessions.has(reg.sessionId);
 	activeSessions.set(reg.sessionId, reg.settings);
-	ensureTimerStarted();
+	stopped = false;
+	if (isNewSession) {
+		const deadline = schedulerNow() + resolveSweepIntervalMs(reg.settings);
+		if (
+			inProgressOwner?.generation === timerGeneration &&
+			(pendingDeadline === null || pendingDeadline <= deadline)
+		) {
+			deferSchedule(timerGeneration, deadline);
+		} else {
+			requestSchedule(deadline);
+		}
+	}
 	let unregistered = false;
 	return () => {
 		if (unregistered) return;
@@ -113,51 +144,78 @@ function currentSweepIntervalMs(): number {
 	return Number.isFinite(min) ? min : DEFAULT_SWEEP_INTERVAL_MS;
 }
 
-function ensureTimerStarted(): void {
-	if (timer) return;
-	stopped = false;
-	scheduleNextSweep();
+function clearPendingSchedule(): void {
+	if (pendingTimer) clearTimeout(pendingTimer);
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
 }
 
-// Recursive setTimeout (not setInterval) so the cadence is recomputed every cycle and later
-// session register/unregister changes to resourceGc.sweepIntervalMs are honored live.
-function scheduleNextSweep(): void {
-	if (stopped || activeSessions.size === 0) {
-		timer = null;
+function requestSchedule(deadline: number): void {
+	if (stopped || activeSessions.size === 0) return;
+	if (pendingDeadline !== null && pendingDeadline <= deadline) return;
+	clearPendingSchedule();
+	const owner = { generation: timerGeneration, token: ++nextTimerToken };
+	pendingDeadline = deadline;
+	pendingOwner = owner;
+	pendingTimer = setTimeout(
+		() => {
+			void handleTimerCallback(owner, deadline);
+		},
+		Math.max(0, deadline - schedulerNow()),
+	);
+	pendingTimer.unref?.();
+}
+
+function deferSchedule(generation: number, deadline: number): void {
+	if (generation !== timerGeneration) return;
+	if (deferredSchedule?.generation === generation) {
+		deferredSchedule.deadline = Math.min(deferredSchedule.deadline, deadline);
 		return;
 	}
-	const generation = timerGeneration;
-	timer = setTimeout(() => {
-		void tickAndReschedule(generation);
-	}, currentSweepIntervalMs());
-	timer.unref?.();
+	deferredSchedule = { generation, deadline };
 }
 
-async function tickAndReschedule(generation: number): Promise<void> {
-	await runTick();
-	// A stop (and possible re-register) happened during the tick: a newer cycle owns the timer now.
-	if (generation !== timerGeneration) return;
-	scheduleNextSweep();
+async function handleTimerCallback(owner: ScheduleOwner, deadline: number): Promise<void> {
+	if (pendingOwner?.generation !== owner.generation || pendingOwner.token !== owner.token) return;
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
+	if (inProgressOwner) {
+		deferSchedule(owner.generation, deadline);
+		return;
+	}
+	await runTick(owner.generation, "timer");
+}
+
+function reconcileCurrentSchedule(): void {
+	if (stopped || activeSessions.size === 0 || inProgressOwner) return;
+	const normalDeadline = schedulerNow() + currentSweepIntervalMs();
+	const deferredDeadline = deferredSchedule?.generation === timerGeneration ? deferredSchedule.deadline : null;
+	if (deferredDeadline !== null) deferredSchedule = null;
+	requestSchedule(deferredDeadline === null ? normalDeadline : Math.min(deferredDeadline, normalDeadline));
 }
 
 function stopTimer(): void {
 	stopped = true;
 	timerGeneration++;
-	if (timer) {
-		clearTimeout(timer);
-		timer = null;
-	}
+	clearPendingSchedule();
+	deferredSchedule = null;
 }
 
-async function runTick(): Promise<void> {
-	if (inProgress) return;
-	inProgress = true;
+async function runTick(generation = timerGeneration, source: WorkOwner["source"] = "external"): Promise<void> {
+	if (inProgressOwner || activeSessions.size === 0) return;
+	const owner: WorkOwner = { generation, source };
+	inProgressOwner = owner;
 	try {
 		await sweepOnce(deps);
 	} catch (err) {
 		logger.debug("resource GC sweep failed", { error: (err as Error).message });
 	} finally {
-		inProgress = false;
+		if (inProgressOwner === owner) inProgressOwner = null;
+		// A stale completion only releases its own work lock. Once that lock is released, current
+		// generation demand (which may have deferred behind it) can be reconciled independently.
+		reconcileCurrentSchedule();
 	}
 }
 
@@ -268,24 +326,55 @@ export function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>):
 	deps = { ...defaultDeps, ...overrides };
 }
 
+export function __setResourceGcSchedulerNowForTest(now: () => number): void {
+	schedulerNow = now;
+}
+
 export async function __runResourceGcTickForTest(): Promise<void> {
 	await runTick();
 }
 
+export async function __runResourceGcTimerCallbackForTest(
+	owner: { generation: number; token: number },
+	deadline: number,
+): Promise<void> {
+	await handleTimerCallback(owner, deadline);
+}
+
 export function __getResourceGcStateForTest(): {
 	timerActive: boolean;
 	sessionCount: number;
 	rssWarningActive: boolean;
 	inProgress: boolean;
+	generation: number;
+	pendingDeadline: number | null;
+	pendingOwner: { generation: number; token: number } | null;
+	deferredDeadline: number | null;
+	deferredGeneration: number | null;
+	activeGeneration: number | null;
 } {
-	return { timerActive: timer !== null, sessionCount: activeSessions.size, rssWarningActive, inProgress };
+	return {
+		timerActive: pendingTimer !== null,
+		sessionCount: activeSessions.size,
+		rssWarningActive,
+		inProgress: inProgressOwner !== null,
+		generation: timerGeneration,
+		pendingDeadline,
+		pendingOwner: pendingOwner ? { ...pendingOwner } : null,
+		deferredDeadline: deferredSchedule?.deadline ?? null,
+		deferredGeneration: deferredSchedule?.generation ?? null,
+		activeGeneration: inProgressOwner?.generation ?? null,
+	};
 }
 
 export function __resetResourceGcForTest(): void {
 	stopTimer();
 	activeSessions.clear();
-	inProgress = false;
+	inProgressOwner = null;
+	deferredSchedule = null;
 	rssWarningActive = false;
 	lastScreenshotScanAt = 0;
+	nextTimerToken = 0;
+	schedulerNow = (): number => performance.now();
 	deps = defaultDeps;
 }

package/src/tools/subagent.ts

@@ -17,6 +17,10 @@ const MAX_LIST_LIMIT = 50;
 const RECEIPT_PREVIEW_WIDTH = 280;
 const PREVIEW_WIDTH = 2_000;
 const FULL_PREVIEW_WIDTH = 12_000;
+const RECEIPT_PREVIEW_BYTES = 1_024;
+const PREVIEW_BYTES = 8_192;
+const FULL_PREVIEW_BYTES = 49_152;
+
 const STEER_QUEUED_GUIDANCE =
 	"The steer message is queued for the subagent's next steering boundary and has not necessarily taken effect yet.";
 
@@ -783,7 +787,40 @@ function isSubagentJob(job: AsyncJob): boolean {
 }
 
 function sanitizeText(text: string, width: number): string {
-	return truncateToWidth(replaceTabs(text), width, Ellipsis.Unicode);
+	return capCodePointsAndBytes(
+		truncateToWidth(replaceTabs(text), width, Ellipsis.Unicode),
+		width,
+		previewByteCap(width),
+	);
+}
+
+function previewByteCap(width: number): number {
+	return width === FULL_PREVIEW_WIDTH
+		? FULL_PREVIEW_BYTES
+		: width === PREVIEW_WIDTH
+			? PREVIEW_BYTES
+			: RECEIPT_PREVIEW_BYTES;
+}
+
+export function capCodePointsAndBytes(text: string, maxCodePoints: number, maxBytes: number): string {
+	const ellipsis = "…";
+	const collapsed = text.replace(/…{2,}$/u, ellipsis);
+	const codePoints = [...collapsed];
+	if (codePoints.length <= maxCodePoints && Buffer.byteLength(collapsed) <= maxBytes) return collapsed;
+
+	const source = collapsed.endsWith(ellipsis) ? collapsed.slice(0, -ellipsis.length) : collapsed;
+	const ellipsisBytes = Buffer.byteLength(ellipsis);
+	let preview = "";
+	let previewBytes = 0;
+	let previewCodePoints = 0;
+	for (const codePoint of source) {
+		const codePointBytes = Buffer.byteLength(codePoint);
+		if (previewCodePoints + 1 + 1 > maxCodePoints || previewBytes + codePointBytes + ellipsisBytes > maxBytes) break;
+		preview += codePoint;
+		previewBytes += codePointBytes;
+		previewCodePoints++;
+	}
+	return `${preview}${ellipsis}`;
 }
 
 function previewJobOutput(
@@ -799,7 +836,11 @@ function previewJobOutput(
 	const width =
 		verbosity === "full" ? FULL_PREVIEW_WIDTH : verbosity === "preview" ? PREVIEW_WIDTH : RECEIPT_PREVIEW_WIDTH;
 	const normalized = replaceTabs(source.text);
-	const preview = truncateToWidth(normalized, width, Ellipsis.Unicode);
+	const preview = capCodePointsAndBytes(
+		truncateToWidth(normalized, width, Ellipsis.Unicode),
+		width,
+		previewByteCap(width),
+	);
 	return { type: source.type, preview, truncated: preview !== normalized };
 }
 

package/src/utils/file-mentions.ts

@@ -160,11 +160,11 @@ async function resolveMentionPath(
 }
 
 /**
- * Default inline cap for auto-read file mentions, deliberately below the
- * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
- * injects a smaller snippet than an explicit `read`. Overridable per call.
+ * Default inline cap for auto-read file mentions, aligned with the read-tool's
+ * 10 KiB bare-read receipt so an incidental `@path` mention injects a bounded
+ * snippet. Overridable per call.
  */
-export const DEFAULT_FILE_MENTION_INLINE_BYTES = 20 * 1024;
+export const DEFAULT_FILE_MENTION_INLINE_BYTES = 10 * 1024;
 
 function buildTextOutput(textContent: string, maxInlineBytes?: number): { output: string; lineCount: number } {
 	const cap = maxInlineBytes && maxInlineBytes > 0 ? maxInlineBytes : DEFAULT_FILE_MENTION_INLINE_BYTES;

package/src/utils/image-loading.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import type { ImageContent } from "@gajae-code/ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@gajae-code/utils";
 import { resolveReadPath } from "../tools/path-utils";
-import { formatDimensionNote, resizeImage } from "./image-resize";
+import { formatDimensionNote, resizeImageBuffer } from "./image-resize";
 
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
 export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
@@ -14,6 +14,26 @@ export interface LoadImageInputOptions {
 	maxBytes?: number;
 	resolvedPath?: string;
 	detectedMimeType?: string;
+	signal?: AbortSignal;
+}
+
+export interface LoadImageInputBytesOptions {
+	inputBuffer: Buffer;
+	resolvedPath: string;
+	mimeType: string;
+	autoResize: boolean;
+	maxBytes?: number;
+	maxOutputBytes?: number;
+	signal?: AbortSignal;
+}
+
+export interface TransformedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	buffer: Uint8Array;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: number;
 }
 
 export interface LoadedImageInput {
@@ -38,9 +58,7 @@ export class ImageInputTooLargeError extends Error {
 }
 
 export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
-	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
-		return image;
-	}
+	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) return image;
 	try {
 		const bytes = Buffer.from(image.data, "base64");
 		const data = await new Bun.Image(bytes).png().toBase64();
@@ -50,53 +68,86 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 	}
 }
 
-export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+/** Transform trusted source bytes without materializing a base64 payload. */
+export async function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput> {
 	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
-	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
-	const metadata = options.detectedMimeType
-		? { mimeType: options.detectedMimeType }
-		: await readImageMetadata(resolvedPath);
-	const mimeType = metadata?.mimeType;
-	if (!mimeType) return null;
-
-	const stat = await Bun.file(resolvedPath).stat();
-	if (stat.size > maxBytes) {
-		throw new ImageInputTooLargeError(stat.size, maxBytes);
-	}
-
-	const inputBuffer = await fs.readFile(resolvedPath);
-	if (inputBuffer.byteLength > maxBytes) {
-		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
+	options.signal?.throwIfAborted();
+	if (options.inputBuffer.byteLength > maxBytes) {
+		throw new ImageInputTooLargeError(options.inputBuffer.byteLength, maxBytes);
 	}
 
-	let outputData = Buffer.from(inputBuffer).toBase64();
-	let outputMimeType = mimeType;
-	let outputBytes = inputBuffer.byteLength;
+	let outputBuffer: Uint8Array = options.inputBuffer;
+	let outputMimeType = options.mimeType;
 	let dimensionNote: string | undefined;
 
 	if (options.autoResize) {
+		options.signal?.throwIfAborted();
 		try {
-			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
-			outputData = resized.data;
+			const resized = await resizeImageBuffer(
+				options.inputBuffer,
+				options.mimeType,
+				options.maxOutputBytes === undefined ? undefined : { maxBytes: options.maxOutputBytes },
+			);
+			options.signal?.throwIfAborted();
+			outputBuffer = resized.buffer;
 			outputMimeType = resized.mimeType;
-			outputBytes = resized.buffer.byteLength;
 			dimensionNote = formatDimensionNote(resized);
 		} catch {
-			// keep original image when resize fails
+			options.signal?.throwIfAborted();
+			// Keep the original image when optional resize fails.
 		}
 	}
 
+	options.signal?.throwIfAborted();
 	let textNote = `Read image file [${outputMimeType}]`;
-	if (dimensionNote) {
-		textNote += `\n${dimensionNote}`;
-	}
-
+	if (dimensionNote) textNote += `\n${dimensionNote}`;
 	return {
-		resolvedPath,
+		resolvedPath: options.resolvedPath,
 		mimeType: outputMimeType,
-		data: outputData,
+		buffer: outputBuffer,
 		textNote,
 		dimensionNote,
-		bytes: outputBytes,
+		bytes: outputBuffer.byteLength,
+	};
+}
+
+export function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput {
+	return {
+		resolvedPath: transformed.resolvedPath,
+		mimeType: transformed.mimeType,
+		data: Buffer.from(transformed.buffer).toBase64(),
+		textNote: transformed.textNote,
+		dimensionNote: transformed.dimensionNote,
+		bytes: transformed.bytes,
 	};
 }
+
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export async function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput> {
+	return materializeImageInput(await transformImageInputBytes(options));
+}
+
+export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
+	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
+	options.signal?.throwIfAborted();
+	const metadata = options.detectedMimeType
+		? { mimeType: options.detectedMimeType }
+		: await readImageMetadata(resolvedPath);
+	const mimeType = metadata?.mimeType;
+	if (!mimeType) return null;
+
+	options.signal?.throwIfAborted();
+	const stat = await Bun.file(resolvedPath).stat();
+	if (stat.size > maxBytes) throw new ImageInputTooLargeError(stat.size, maxBytes);
+
+	const inputBuffer = await fs.readFile(resolvedPath, { signal: options.signal });
+	return loadImageInputBytes({
+		inputBuffer,
+		resolvedPath,
+		mimeType,
+		autoResize: options.autoResize,
+		maxBytes,
+		signal: options.signal,
+	});
+}

package/src/utils/image-resize.ts

@@ -21,14 +21,14 @@ export interface ResizedImage {
 
 // 500KB target — aggressive compression; Anthropic's 5MB per-image cap is rarely the
 // binding constraint once images are downsized to 1568px (Anthropic's internal threshold).
-const DEFAULT_MAX_BYTES = 500 * 1024;
+export const DEFAULT_IMAGE_RESIZE_MAX_BYTES = 500 * 1024;
 
 const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	// Anthropic's "internal recommended size" — Anthropic model internally caps images at
 	// 1568px on the longest edge before vision processing.
 	maxWidth: 1568,
 	maxHeight: 1568,
-	maxBytes: DEFAULT_MAX_BYTES,
+	maxBytes: DEFAULT_IMAGE_RESIZE_MAX_BYTES,
 	jpegQuality: 80,
 };
 
@@ -72,14 +72,17 @@ Buffer.prototype.toBase64 = function (this: Buffer) {
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
-export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+export async function resizeImageBuffer(
+	inputBuffer: Buffer,
+	inputMimeType: string,
+	options?: ImageResizeOptions,
+): Promise<ResizedImage> {
 	const excludeWebP = options?.excludeWebP ?? isWebPExcluded();
 	const opts = { ...DEFAULT_OPTIONS, ...options, excludeWebP };
-	const inputBuffer = Buffer.from(img.data, "base64");
 
 	try {
 		const { width: originalWidth, height: originalHeight, format } = await new Bun.Image(inputBuffer).metadata();
-		const sourceMime = img.mimeType ?? `image/${format}`;
+		const sourceMime = inputMimeType ?? `image/${format}`;
 
 		// Fast path: already within dimensions AND well under budget.
 		// Threshold is 1/4 of budget — if already that compact, don't re-encode.
@@ -102,7 +105,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 				height: originalHeight,
 				wasResized: false,
 				get data() {
-					return img.data;
+					return inputBuffer.toBase64();
 				},
 			};
 		}
@@ -272,24 +275,28 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		// When the caller demanded WebP exclusion AND the original is WebP,
 		// returning the original buffer would silently violate that contract,
 		// so surface an explicit error instead.
-		if (excludeWebP && (img.mimeType === "image/webp" || !img.mimeType)) {
+		if (excludeWebP && (inputMimeType === "image/webp" || !inputMimeType)) {
 			throw new Error("resizeImage: failed to decode image and cannot honor excludeWebP for a WebP source");
 		}
 		return {
 			buffer: inputBuffer,
-			mimeType: img.mimeType,
+			mimeType: inputMimeType,
 			originalWidth: 0,
 			originalHeight: 0,
 			width: 0,
 			height: 0,
 			wasResized: false,
 			get data() {
-				return img.data;
+				return inputBuffer.toBase64();
 			},
 		};
 	}
 }
 
+export function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+	return resizeImageBuffer(Buffer.from(img.data, "base64"), img.mimeType, options);
+}
+
 /**
  * Format a dimension note for resized images.
  * This helps the model understand the coordinate mapping.