@gajae-code/coding-agent 0.12.4 → 0.12.6

package/src/tools/eval.ts

@@ -11,8 +11,17 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
-import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
+import {
+	DEFAULT_ARTIFACT_MAX_BYTES,
+	DEFAULT_MAX_BYTES,
+	OutputSink,
+	type OutputSummary,
+	TailBuffer,
+	type TerminalArtifactPublisher,
+	truncateHeadBytes,
+} from "../session/streaming-output";
 import { getTreeBranch, getTreeContinuePrefix, renderCodeCell } from "../tui";
+import { isValidArtifactId } from "../utils/artifact-id";
 import { resolveEvalBackends, type ToolSession } from ".";
 import {
 	formatStyledTruncationWarning,
@@ -163,6 +172,55 @@ interface ResolvedEvalCell {
 	resolved: ResolvedBackend;
 }
 
+const EVAL_ARTIFACT_ALLOCATION_WAIT_MS = 500;
+const EVAL_ARTIFACT_ALLOCATION_LIMIT = 64;
+const pendingEvalArtifactAllocations = new Set<Promise<unknown>>();
+
+async function allocateEvalArtifact(
+	session: ToolSession,
+	signal?: AbortSignal,
+): Promise<{ path?: string; id?: string; diagnostic?: string }> {
+	if (!session.allocateOutputArtifact) return {};
+	if (signal?.aborted) throw new ToolAbortError();
+	if (pendingEvalArtifactAllocations.size >= EVAL_ARTIFACT_ALLOCATION_LIMIT) {
+		return { diagnostic: "pending Eval artifact allocation limit reached" };
+	}
+	const allocation = Promise.resolve().then(() => session.allocateOutputArtifact!("eval"));
+	pendingEvalArtifactAllocations.add(allocation);
+	void allocation.then(
+		() => pendingEvalArtifactAllocations.delete(allocation),
+		() => pendingEvalArtifactAllocations.delete(allocation),
+	);
+	const aborted = Promise.withResolvers<{ status: "aborted" }>();
+	const onAbort = () => aborted.resolve({ status: "aborted" });
+	signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		const outcome = await Promise.race([
+			allocation.then(
+				value => ({ status: "ok" as const, value }),
+				error => ({
+					status: "failed" as const,
+					diagnostic: error instanceof Error ? error.message : String(error),
+				}),
+			),
+			Bun.sleep(EVAL_ARTIFACT_ALLOCATION_WAIT_MS).then(() => ({
+				status: "timeout" as const,
+				diagnostic: `did not settle within ${EVAL_ARTIFACT_ALLOCATION_WAIT_MS}ms`,
+			})),
+			aborted.promise,
+		]);
+		if (outcome.status === "aborted") throw new ToolAbortError();
+		if (outcome.status !== "ok") return { diagnostic: outcome.diagnostic.slice(0, 512) };
+		const { path, id } = outcome.value ?? {};
+		if (!path || !isValidArtifactId(id)) {
+			return { diagnostic: "artifact storage is unavailable or returned an invalid artifact id" };
+		}
+		return { path, id };
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+	}
+}
+
 function uniqueEvalLanguages(cells: ResolvedEvalCell[]): EvalLanguage[] {
 	return [...new Set(cells.map(cell => cell.resolved.backend.id))];
 }
@@ -265,10 +323,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		const sessionAbortController = new AbortController();
 		let outputSink: OutputSink | undefined;
 		let outputSummary: OutputSummary | undefined;
+		let artifactAllocationDiagnostic: string | undefined;
 		let outputDumped = false;
 		const finalizeOutput = async (): Promise<OutputSummary | undefined> => {
 			if (outputDumped || !outputSink) return outputSummary;
 			outputSummary = await outputSink.dump();
+			if (artifactAllocationDiagnostic) outputSummary.artifactFailureDiagnostic = artifactAllocationDiagnostic;
 			outputDumped = true;
 			return outputSummary;
 		};
@@ -334,11 +394,34 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 
 				const sessionFile = session.getSessionFile?.() ?? undefined;
 				const kernelOwnerId = session.getEvalKernelOwnerId?.() ?? undefined;
-				const { path: artifactPath, id: artifactId } = (await session.allocateOutputArtifact?.("eval")) ?? {};
+				const artifactManager = session.getArtifactManager?.();
+				const managedArtifactPublisher: TerminalArtifactPublisher | undefined = artifactManager?.getManagedStore()
+					? Object.assign(
+							async (content: string) => {
+								const contentBytes = Buffer.byteLength(content, "utf8");
+								const artifactId = await artifactManager.save(content, "eval");
+								if (contentBytes <= DEFAULT_ARTIFACT_MAX_BYTES) {
+									return { status: "published" as const, artifactId };
+								}
+								const retainedBytes = truncateHeadBytes(content, DEFAULT_ARTIFACT_MAX_BYTES).bytes;
+								return {
+									status: "published" as const,
+									artifactId,
+									omittedBytes: contentBytes - retainedBytes,
+								};
+							},
+							{ owner: artifactManager },
+						)
+					: undefined;
+				const allocation = managedArtifactPublisher ? {} : await allocateEvalArtifact(session, signal);
+				artifactAllocationDiagnostic = allocation.diagnostic;
+				const { path: artifactPath, id: artifactId } = allocation;
+				if (signal?.aborted) throw new ToolAbortError();
 				session.assertEvalExecutionAllowed?.();
 				outputSink = new OutputSink({
 					artifactPath,
 					artifactId,
+					artifactPublisher: managedArtifactPublisher,
 					headBytes: resolveOutputSinkHeadBytes(session.settings),
 					maxColumns: resolveOutputMaxColumns(session.settings),
 					onChunk: chunk => {
@@ -376,8 +459,6 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						session,
 						deadlineMs,
 						reset: cell.reset,
-						artifactPath,
-						artifactId,
 						onChunk: chunk => {
 							outputSink!.push(chunk);
 						},
@@ -545,6 +626,7 @@ async function summarizeFinal(
 	const outputBytes = Buffer.byteLength(combinedOutput, "utf-8");
 	const missingLines = Math.max(0, rawSummary.totalLines - rawSummary.outputLines);
 	const missingBytes = Math.max(0, rawSummary.totalBytes - rawSummary.outputBytes);
+	const artifactRepresentationIncomplete = rawSummary.output !== combinedOutput || rawSummary.artifactId !== undefined;
 	return {
 		output: combinedOutput,
 		truncated: rawSummary.truncated,
@@ -553,6 +635,19 @@ async function summarizeFinal(
 		outputLines,
 		outputBytes,
 		artifactId: rawSummary.artifactId,
+		artifactVerified: rawSummary.artifactVerified,
+		artifactTruncatedBytes: rawSummary.artifactTruncatedBytes,
+		sourceTruncatedBytes: rawSummary.sourceTruncatedBytes,
+		sourceCaptureIncomplete:
+			rawSummary.sourceCaptureIncomplete === true || artifactRepresentationIncomplete || undefined,
+		headRange: rawSummary.headRange,
+		tailRange: rawSummary.tailRange,
+		elidedBytes: rawSummary.elidedBytes,
+		elidedLines: rawSummary.elidedLines,
+		columnDroppedBytes: rawSummary.columnDroppedBytes,
+		columnTruncatedLines: rawSummary.columnTruncatedLines,
+		columnMax: rawSummary.columnMax,
+		artifactFailureDiagnostic: rawSummary.artifactFailureDiagnostic,
 	};
 }
 

package/src/tools/fetch.ts

@@ -10,9 +10,15 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
 import type { AgentStorage } from "../session/agent-storage";
-import { DEFAULT_MAX_BYTES, type TruncationDirection, truncateContent } from "../session/streaming-output";
+import {
+	DEFAULT_ARTIFACT_MAX_BYTES,
+	DEFAULT_MAX_BYTES,
+	type TruncationDirection,
+	truncateContent,
+} from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
+import { isValidArtifactId } from "../utils/artifact-id";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { parseHtmlLazy } from "../utils/linkedom";
 import { INSANE_NOTES } from "../web/insane/bridge";
@@ -22,7 +28,7 @@ import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { applyListLimit } from "./list-limit";
-import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
+import { formatArtifactEvidenceNotice, type OutputMeta } from "./output-meta";
 import { formatExpandHint, getDomain, replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -1144,6 +1150,9 @@ export interface ReadUrlToolDetails {
 
 interface ReadUrlCacheEntry {
 	artifactId?: string;
+	artifactVerified?: boolean;
+	artifactFailureDiagnostic?: string;
+	artifactStorageIncomplete?: boolean;
 	details: ReadUrlToolDetails;
 	image?: FetchImagePayload;
 	/** Complete URL output, including its preamble and body. */
@@ -1180,7 +1189,7 @@ async function materializeReadUrlCacheEntry(
 	entry: ReadUrlCacheEntry,
 ): Promise<ReadUrlCacheEntry | null> {
 	if (entry.output.length > 0) return entry;
-	if (entry.artifactId) {
+	if (isValidArtifactId(entry.artifactId) && entry.artifactVerified === true) {
 		const artifactOutput = await readArtifactOutput(session, entry.artifactId);
 		if (artifactOutput !== null) {
 			// Artifacts retain their trust-boundary wrapper. Keep the raw preamble
@@ -1188,6 +1197,7 @@ async function materializeReadUrlCacheEntry(
 			return {
 				...entry,
 				output: artifactOutput,
+				artifactVerified: true,
 				...(entry.wrappedPreambleChars !== undefined ? { wrappedPreambleChars: entry.wrappedPreambleChars } : {}),
 			};
 		}
@@ -1195,17 +1205,60 @@ async function materializeReadUrlCacheEntry(
 	return null;
 }
 
-async function persistReadUrlArtifact(session: ToolSession, output: string): Promise<string | undefined> {
-	const { path: artifactPath, id } = (await session.allocateOutputArtifact?.("read")) ?? {};
-	if (!artifactPath) return undefined;
-	await Bun.write(artifactPath, wrapUntrustedContent(output));
-	return id;
+const READ_URL_ARTIFACT_WAIT_MS = 500;
+const READ_URL_ARTIFACT_PENDING_LIMIT = 64;
+const pendingReadUrlArtifactWrites = new Set<Promise<unknown>>();
+
+async function persistReadUrlArtifact(
+	session: ToolSession,
+	output: string,
+): Promise<{ artifactId?: string; diagnostic?: string; storageIncomplete?: boolean }> {
+	if (pendingReadUrlArtifactWrites.size >= READ_URL_ARTIFACT_PENDING_LIMIT) {
+		return { diagnostic: "pending URL artifact persistence limit reached" };
+	}
+	const promise = Promise.resolve().then(async () => {
+		const wrapped = wrapUntrustedContent(output);
+		const artifactManager = session.getArtifactManager?.();
+		if (artifactManager?.getManagedStore()) {
+			const artifactId = await artifactManager.save(wrapped, "read");
+			const contentBytes = Buffer.byteLength(wrapped, "utf8");
+			return {
+				artifactId,
+				storageIncomplete: contentBytes > DEFAULT_ARTIFACT_MAX_BYTES || undefined,
+			};
+		}
+		const { path: artifactPath, id } = (await session.allocateOutputArtifact?.("read")) ?? {};
+		if (!artifactPath || !isValidArtifactId(id)) {
+			return { diagnostic: "artifact storage is unavailable or returned an invalid artifact id" };
+		}
+		await Bun.write(artifactPath, wrapped);
+		return { artifactId: id };
+	});
+	pendingReadUrlArtifactWrites.add(promise);
+	void promise.then(
+		() => pendingReadUrlArtifactWrites.delete(promise),
+		() => pendingReadUrlArtifactWrites.delete(promise),
+	);
+	return Promise.race([
+		promise.catch(error => ({
+			diagnostic: error instanceof Error ? error.message.slice(0, 512) : String(error).slice(0, 512),
+		})),
+		Bun.sleep(READ_URL_ARTIFACT_WAIT_MS).then(() => ({
+			diagnostic: `did not settle within ${READ_URL_ARTIFACT_WAIT_MS}ms`,
+		})),
+	]);
 }
 
 async function ensureReadUrlCacheArtifact(session: ToolSession, entry: ReadUrlCacheEntry): Promise<ReadUrlCacheEntry> {
-	if (entry.artifactId) return entry;
-	const artifactId = await persistReadUrlArtifact(session, entry.output);
-	return artifactId ? { ...entry, artifactId } : entry;
+	if (isValidArtifactId(entry.artifactId) && entry.artifactVerified === true) return entry;
+	const persisted = await persistReadUrlArtifact(session, entry.output);
+	return {
+		...entry,
+		artifactId: persisted.artifactId,
+		artifactVerified: persisted.artifactId !== undefined,
+		artifactFailureDiagnostic: persisted.diagnostic,
+		artifactStorageIncomplete: persisted.storageIncomplete,
+	};
 }
 
 function cacheReadUrlEntry(session: ToolSession, requestedUrl: string, raw: boolean, entry: ReadUrlCacheEntry): void {
@@ -1230,10 +1283,13 @@ async function buildReadUrlCacheEntry(
 	const storage = session.settings.getStorage();
 	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal, storage);
 	const built = buildUrlReadOutput(result, result.content);
-	const artifactId = options?.ensureArtifact ? await persistReadUrlArtifact(session, built.output) : undefined;
+	const persistedArtifact = options?.ensureArtifact ? await persistReadUrlArtifact(session, built.output) : {};
 
 	return {
-		artifactId,
+		artifactId: persistedArtifact.artifactId,
+		artifactVerified: persistedArtifact.artifactId !== undefined,
+		artifactFailureDiagnostic: persistedArtifact.diagnostic,
+		artifactStorageIncomplete: persistedArtifact.storageIncomplete,
 		details: {
 			kind: "url",
 			url: result.url,
@@ -1371,7 +1427,7 @@ export async function executeReadUrl(
 		direction: effectiveDirection,
 	});
 	const needsArtifact = truncation.truncated;
-	if (needsArtifact && !cacheEntry.artifactId) {
+	if (needsArtifact && (!isValidArtifactId(cacheEntry.artifactId) || cacheEntry.artifactVerified !== true)) {
 		cacheEntry = await ensureReadUrlCacheArtifact(session, cacheEntry);
 		cacheReadUrlEntry(session, params.path, params.raw ?? false, cacheEntry);
 	}
@@ -1398,6 +1454,9 @@ export async function executeReadUrl(
 		resultBuilder.truncation(truncation, {
 			direction: effectiveDirection === "both" ? "middle" : effectiveDirection === "last" ? "tail" : "head",
 			artifactId: cacheEntry.artifactId,
+			artifactVerified: cacheEntry.artifactVerified === true || undefined,
+			artifactFailureDiagnostic: cacheEntry.artifactFailureDiagnostic,
+			sourceCaptureIncomplete: cacheEntry.details.truncated || cacheEntry.artifactStorageIncomplete || undefined,
 			...(effectiveDirection !== "head" ? { maxBytes: DEFAULT_MAX_BYTES } : {}),
 		});
 	} else if (cacheEntry.details.truncated) {
@@ -1501,7 +1560,10 @@ export function renderReadUrlResult(
 	metadataLines.push(`${uiTheme.fg("muted", "Chars:")} ${charCount}`);
 	if (truncated) {
 		metadataLines.push(uiTheme.fg("warning", `${uiTheme.status.warning} Output truncated`));
-		if (truncation?.artifactId) metadataLines.push(formatStyledArtifactReference(truncation.artifactId, uiTheme));
+		if (truncation?.artifactId && truncation.artifactVerified === true) {
+			const artifactNotice = formatArtifactEvidenceNotice(truncation);
+			if (artifactNotice) metadataLines.push(uiTheme.fg("warning", artifactNotice));
+		}
 	}
 	if (hasNotes) {
 		metadataLines.push(`${uiTheme.fg("muted", "Notes:")} ${details.notes.join("; ")}`);

package/src/tools/find.ts

@@ -14,7 +14,7 @@ import { type TruncationResult, truncateHead } from "../session/streaming-output
 import { Ellipsis, fileHyperlink, renderFileList, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
-import { formatFullOutputReference, type OutputMeta } from "./output-meta";
+import { formatArtifactEvidenceNotice, type OutputMeta } from "./output-meta";
 import {
 	formatPathRelativeToCwd,
 	hasGlobPathChars,
@@ -510,8 +510,12 @@ export const findToolRenderer = {
 		if (details?.resultLimitReached) truncationReasons.push(`limit ${details.resultLimitReached} results`);
 		if (limits?.resultLimit) truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
 		if (truncation) truncationReasons.push(truncation.truncatedBy === "lines" ? "line limit" : "size limit");
-		const artifactId = truncation && "artifactId" in truncation ? truncation.artifactId : undefined;
-		if (artifactId) truncationReasons.push(formatFullOutputReference(artifactId));
+		const artifactEvidence = details?.meta?.truncation
+			? formatArtifactEvidenceNotice(details.meta.truncation)
+			: truncation && "artifactId" in truncation
+				? formatArtifactEvidenceNotice(truncation as NonNullable<OutputMeta["truncation"]>)
+				: undefined;
+		if (artifactEvidence) truncationReasons.push(artifactEvidence);
 
 		const extraLines: string[] = [];
 		if (truncationReasons.length > 0) {

package/src/tools/monitor.ts

@@ -51,6 +51,7 @@ const MONITOR_LABEL_MAX = 120;
 const MAX_PENDING_MONITOR_NOTIFICATIONS = 3;
 const MONITOR_NOTIFICATION_LINE_MAX_BYTES = 16 * 1024;
 const MONITOR_NOTIFICATION_LINE_MAX_LINES = 20;
+const PERSISTENT_MONITOR_DEBOUNCE_MS = 250;
 
 function buildMonitorLabel(params: MonitorParams): string {
 	const base = `[monitor:${params.kind}] ${params.description}`;
@@ -124,6 +125,7 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 		const controller = { closed: false };
 		let currentJobId = "";
 		let sequence = 0;
+		let flushTimer: NodeJS.Timeout | undefined;
 		let latestLine: string | undefined;
 		let coalescedCount = 0;
 		let flushScheduled = false;
@@ -136,6 +138,10 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			(message.details as { taskId?: string } | undefined)?.taskId === currentJobId;
 		const flushLatest = () => {
 			if (!persistent || latestLine === undefined) return;
+			if (flushTimer) {
+				clearTimeout(flushTimer);
+				flushTimer = undefined;
+			}
 			const line = latestLine;
 			const count = coalescedCount;
 			latestLine = undefined;
@@ -205,7 +211,7 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			coalescedCount += flushScheduled ? 1 : 0;
 			if (flushScheduled) return;
 			flushScheduled = true;
-			queueMicrotask(flushLatest);
+			flushTimer = setTimeout(flushLatest, PERSISTENT_MONITOR_DEBOUNCE_MS);
 		};
 		const monitorJob = await bash.startMonitorJob(
 			{ command: params.command, timeout: params.timeout },