@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/tools/resource-gc.ts

@@ -18,9 +18,15 @@ function safeProbeWindowsJobMemory(): WindowsJobMemoryProbeResult {
 
 import { logger } from "@gajae-code/utils";
 import type { Settings } from "../config/settings";
+import { executeGjcTeamApiOperation, listGjcTeams, readGjcWorkerHeartbeat } from "../gjc-runtime/team-runtime";
 import { computeMemoryGuardDomain } from "../runtime/memory-domain";
-import { chooseMemoryGuardAction, MemoryGuardHost, resolveMemoryGuardPolicy } from "../runtime/memory-guard";
-import type { MemoryGuardPolicy } from "../runtime/memory-guard-contract";
+import {
+	chooseMemoryGuardAction,
+	MemoryGuardHost,
+	resolveMemoryGuardPolicy,
+	revalidateMemoryGuardAction,
+} from "../runtime/memory-guard";
+import type { MemoryGuardPolicy, MemoryGuardWorkerSample } from "../runtime/memory-guard-contract";
 import { resolveEffectiveMemoryLimit } from "../runtime/memory-limit";
 import { listTabsForGc, releaseTabIfGcEligible, type TabGcSnapshot } from "./browser/tab-supervisor";
 import { cleanupStaleScreenshotFallbackDirs, hasCreatedScreenshotFallbackDir } from "./computer-gc";
@@ -85,6 +91,14 @@ export interface ResourceGcDeps {
 	releaseTab: (name: string, policy: { now: () => number; idleMs: number }) => Promise<boolean>;
 	cleanupScreenshots: (opts: { now: () => number; staleMs: number }) => Promise<{ scanned: number; removed: number }>;
 	screenshotArmed: () => boolean;
+	listTeamWorkers?: (cwd: string, sessionId: string) => Promise<MemoryGuardWorkerSample[]>;
+	applyTeamWorkerGuard?: (
+		cwd: string,
+		sessionId: string,
+		workerId: string,
+		excessBytes: number,
+		incidentId: string,
+	) => Promise<void>;
 }
 
 const defaultDeps: ResourceGcDeps = {
@@ -98,10 +112,13 @@ const defaultDeps: ResourceGcDeps = {
 	releaseTab: (name, policy) => releaseTabIfGcEligible(name, policy),
 	cleanupScreenshots: opts => cleanupStaleScreenshotFallbackDirs(opts),
 	screenshotArmed: () => hasCreatedScreenshotFallbackDir(),
+	listTeamWorkers: (cwd, sessionId) => sampleTeamWorkers(cwd, sessionId),
+	applyTeamWorkerGuard: (cwd, sessionId, workerId, excessBytes, incidentId) =>
+		applySelectedTeamWorker(cwd, sessionId, workerId, excessBytes, incidentId),
 };
 
 // ── Controller state (process-global; tabs/browsers are module-global too) ──────────────────
-const activeSessions = new Map<string, Settings>();
+const activeSessions = new Map<string, { settings: Settings; cwd: () => string }>();
 const scheduler = new MemoryGuardHost({
 	run: async () => {
 		await sweepOnce(deps);
@@ -114,11 +131,13 @@ const memoryGuardGcActive = new Set<string>();
 const memoryGuardLastEvaluatedAt = new Map<string, number>();
 const memoryGuardRestartAboveSince = new Map<string, number>();
 const memoryGuardRestartCooldownUntil = new Map<string, number>();
+const memoryGuardWorkerIncidentIds = new Map<string, string>();
 let deps: ResourceGcDeps = defaultDeps;
 
 export interface ResourceGcRegistration {
 	sessionId: string;
 	settings: Settings;
+	cwd?: string | (() => string);
 }
 
 function resolveSessionSweepIntervalMs(settings: Settings): number {
@@ -134,7 +153,9 @@ function resolveSessionSweepIntervalMs(settings: Settings): number {
  * session unregisters.
  */
 export function registerResourceGcSession(reg: ResourceGcRegistration): () => void {
-	activeSessions.set(reg.sessionId, reg.settings);
+	const registeredCwd = reg.cwd;
+	const cwd = typeof registeredCwd === "function" ? registeredCwd : () => registeredCwd ?? process.cwd();
+	activeSessions.set(reg.sessionId, { settings: reg.settings, cwd });
 	const unregisterSchedule = scheduler.register({
 		ownerId: reg.sessionId,
 		intervalMs: resolveSessionSweepIntervalMs(reg.settings),
@@ -149,6 +170,7 @@ export function registerResourceGcSession(reg: ResourceGcRegistration): () => vo
 			if (path === "memoryGuard.enabled" && !resolveMemoryGuardPolicy(reg.settings).enabled) {
 				memoryGuardGcActive.delete(reg.sessionId);
 				memoryGuardRestartAboveSince.delete(reg.sessionId);
+				memoryGuardWorkerIncidentIds.delete(reg.sessionId);
 				memoryGuardRestartCooldownUntil.delete(reg.sessionId);
 				memoryGuardLastEvaluatedAt.delete(reg.sessionId);
 			}
@@ -162,6 +184,7 @@ export function registerResourceGcSession(reg: ResourceGcRegistration): () => vo
 		memoryGuardLastEvaluatedAt.delete(reg.sessionId);
 		memoryGuardGcActive.delete(reg.sessionId);
 		memoryGuardRestartAboveSince.delete(reg.sessionId);
+		memoryGuardWorkerIncidentIds.delete(reg.sessionId);
 		memoryGuardRestartCooldownUntil.delete(reg.sessionId);
 		unregisterSchedule();
 		unregisterSettings();
@@ -479,13 +502,14 @@ export function __selectMemoryPressureDomainForTest(
 
 function sweepMemoryPressureGuard(d: ResourceGcDeps): Promise<void> | undefined {
 	let enabled = false;
-	for (const [sessionId, settings] of activeSessions) {
+	for (const [sessionId, { settings }] of activeSessions) {
 		if (resolveMemoryGuardPolicy(settings).enabled) {
 			enabled = true;
 			continue;
 		}
 		memoryGuardGcActive.delete(sessionId);
 		memoryGuardRestartAboveSince.delete(sessionId);
+		memoryGuardWorkerIncidentIds.delete(sessionId);
 		memoryGuardRestartCooldownUntil.delete(sessionId);
 		memoryGuardLastEvaluatedAt.delete(sessionId);
 	}
@@ -493,14 +517,107 @@ function sweepMemoryPressureGuard(d: ResourceGcDeps): Promise<void> | undefined
 	return sweepEnabledMemoryPressureGuard(d);
 }
 
+async function readLinuxWorkerRssBytes(pid: number): Promise<number | null> {
+	if (process.platform !== "linux" || !Number.isSafeInteger(pid) || pid <= 0) return null;
+	try {
+		const status = await Bun.file(`/proc/${pid}/status`).text();
+		const match = /^VmRSS:\s+(\d+)\s+kB$/m.exec(status);
+		if (!match) return null;
+		const kibibytes = Number(match[1]);
+		return Number.isSafeInteger(kibibytes) ? kibibytes * 1024 : null;
+	} catch {
+		return null;
+	}
+}
+
+async function readLinuxProcessStartTime(pid: number): Promise<string | null> {
+	try {
+		const stat = await Bun.file(`/proc/${pid}/stat`).text();
+		const commandEnd = stat.lastIndexOf(")");
+		if (commandEnd < 0) return null;
+		const startTime = stat
+			.slice(commandEnd + 2)
+			.trim()
+			.split(/\s+/)[19];
+		return startTime && /^\d+$/.test(startTime) ? startTime : null;
+	} catch {
+		return null;
+	}
+}
+
+async function sampleTeamWorkers(cwd: string, sessionId: string): Promise<MemoryGuardWorkerSample[]> {
+	if (process.platform !== "linux") return [];
+	const samples: MemoryGuardWorkerSample[] = [];
+	for (const team of await listGjcTeams(cwd, { ...process.env, GJC_SESSION_ID: sessionId })) {
+		if (team.phase === "complete" || team.phase === "cancelled") continue;
+		for (const worker of team.workers) {
+			try {
+				const heartbeat = await readGjcWorkerHeartbeat(team.team_name, worker.id, cwd, {
+					...process.env,
+					GJC_SESSION_ID: sessionId,
+				});
+				const heartbeatAt = Date.parse(heartbeat?.last_turn_at ?? "");
+				if (
+					!heartbeat?.alive ||
+					!heartbeat.process_start_time ||
+					!Number.isFinite(heartbeatAt) ||
+					Date.now() - heartbeatAt >= 120_000 ||
+					(await readLinuxProcessStartTime(heartbeat.pid)) !== heartbeat.process_start_time
+				)
+					continue;
+				const guard = (await executeGjcTeamApiOperation(
+					"read-worker-memory-guard",
+					{ team_name: team.team_name, worker: worker.id, platform: process.platform },
+					cwd,
+					{ ...process.env, GJC_SESSION_ID: sessionId },
+				)) as { automatic_action_allowed?: boolean; state?: string };
+				if (!guard.automatic_action_allowed || guard.state === "blocked") continue;
+				const bytes = await readLinuxWorkerRssBytes(heartbeat.pid);
+				if (bytes === null) continue;
+				samples.push({ workerId: `${team.team_name}/${worker.id}`, bytes, accepted: true });
+			} catch {
+				// Missing or malformed worker authority is not eligible for automatic mutation.
+			}
+		}
+	}
+	return samples;
+}
+
+async function applySelectedTeamWorker(
+	cwd: string,
+	sessionId: string,
+	workerId: string,
+	excessBytes: number,
+	incidentId: string,
+): Promise<void> {
+	const separator = workerId.lastIndexOf("/");
+	if (separator <= 0 || separator === workerId.length - 1) return;
+	const teamName = workerId.slice(0, separator);
+	const worker = workerId.slice(separator + 1);
+	await executeGjcTeamApiOperation(
+		"apply-worker-memory-guard",
+		{
+			team_name: teamName,
+			worker,
+			platform: process.platform,
+			reason: "production_memory_pressure_sweep",
+			incident_id: incidentId,
+			candidates: [{ worker_id: worker, platform: process.platform, excess_bytes: excessBytes }],
+		},
+		cwd,
+		{ ...process.env, GJC_SESSION_ID: sessionId },
+	);
+}
 async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void> {
 	const now = d.monotonicNow();
-	const dueSessions: Array<{ sessionId: string; policy: MemoryGuardPolicy }> = [];
-	for (const [sessionId, settings] of activeSessions) {
+	const dueSessions: Array<{ sessionId: string; policy: MemoryGuardPolicy; cwd: string }> = [];
+	for (const [sessionId, { settings, cwd: resolveCwd }] of activeSessions) {
 		const policy = resolveMemoryGuardPolicy(settings);
+		const cwd = resolveCwd();
 		if (!policy.enabled) {
 			memoryGuardGcActive.delete(sessionId);
 			memoryGuardRestartAboveSince.delete(sessionId);
+			memoryGuardWorkerIncidentIds.delete(sessionId);
 			memoryGuardRestartCooldownUntil.delete(sessionId);
 			memoryGuardLastEvaluatedAt.delete(sessionId);
 			continue;
@@ -508,14 +625,15 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 		const lastEvaluated = memoryGuardLastEvaluatedAt.get(sessionId);
 		if (lastEvaluated !== undefined && now - lastEvaluated < policy.checkIntervalMs) continue;
 		memoryGuardLastEvaluatedAt.set(sessionId, now);
-		dueSessions.push({ sessionId, policy });
+		dueSessions.push({ sessionId, policy, cwd });
 	}
 	if (dueSessions.length === 0) return;
 
 	const snapshot = await d.memorySnapshot();
 	let gcRequested = false;
 	const gcTelemetry: Array<{ sessionId: string } & Record<string, unknown>> = [];
-	for (const { sessionId, policy } of dueSessions) {
+	let workerActionTaken = false;
+	for (const { sessionId, policy, cwd } of dueSessions) {
 		const pressure = __selectMemoryPressureDomainForTest(snapshot, policy.policyLimitBytes);
 		const limit = resolveEffectiveMemoryLimit({
 			hardCapBytes: pressure.hardCapBytes,
@@ -524,20 +642,23 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 		if (limit.effectiveBytes === null) {
 			memoryGuardGcActive.delete(sessionId);
 			memoryGuardRestartAboveSince.delete(sessionId);
+			memoryGuardWorkerIncidentIds.delete(sessionId);
 			memoryGuardRestartCooldownUntil.delete(sessionId);
 			continue;
 		}
+		const workerSamples = await (d.listTeamWorkers ?? (async () => []))(cwd, sessionId);
 		const domain = computeMemoryGuardDomain({
 			effectiveLimitBytes: limit.effectiveBytes,
 			totalUsageBytes: pressure.totalUsageBytes,
 			parentBytes: pressure.parentBytes,
 			parentReserveBytes: policy.parentReserveBytes,
-			workers: [],
+			workers: workerSamples,
 		});
 		const decision = chooseMemoryGuardAction({
 			domain,
 			hostSupported: false,
-			workerSupported: () => false,
+			workerSupported: workerId =>
+				workerSamples.some(worker => worker.workerId === workerId && worker.accepted !== false),
 		});
 		const usageRatio = pressure.totalUsageBytes / limit.effectiveBytes;
 		if (usageRatio >= policy.gcThresholdRatio) {
@@ -560,17 +681,57 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 
 		if (usageRatio < policy.restartThresholdRatio) {
 			memoryGuardRestartAboveSince.delete(sessionId);
+			memoryGuardWorkerIncidentIds.delete(sessionId);
 			continue;
 		}
 		const aboveSince = memoryGuardRestartAboveSince.get(sessionId);
 		if (aboveSince === undefined) {
 			memoryGuardRestartAboveSince.set(sessionId, now);
+			memoryGuardWorkerIncidentIds.set(sessionId, `worker-pressure:${sessionId}:${Math.trunc(now)}`);
 			continue;
 		}
 		const cooldownUntil = memoryGuardRestartCooldownUntil.get(sessionId) ?? 0;
 		if (now - aboveSince < policy.restartThresholdWindowMs || now < cooldownUntil) continue;
-		memoryGuardRestartCooldownUntil.set(sessionId, now + policy.cooldownMs);
-		d.logWarn("Memory guard: restart threshold sustained; restart remains advisory-only", {
+		const workerIncidentId =
+			memoryGuardWorkerIncidentIds.get(sessionId) ?? `worker-pressure:${sessionId}:${Math.trunc(aboveSince)}`;
+		let workerActionAttemptedForSession = false;
+		if (decision.kind === "execute" && decision.target.kind === "worker" && !workerActionTaken) {
+			const refreshedWorkers = await (d.listTeamWorkers ?? (async () => []))(cwd, sessionId);
+			const refreshedDomain = computeMemoryGuardDomain({
+				effectiveLimitBytes: limit.effectiveBytes,
+				totalUsageBytes: pressure.totalUsageBytes,
+				parentBytes: pressure.parentBytes,
+				parentReserveBytes: policy.parentReserveBytes,
+				workers: refreshedWorkers,
+			});
+			const refreshedDecision = chooseMemoryGuardAction({
+				domain: refreshedDomain,
+				hostSupported: false,
+				workerSupported: workerId =>
+					refreshedWorkers.some(worker => worker.workerId === workerId && worker.accepted !== false),
+			});
+			const revalidated = revalidateMemoryGuardAction(decision, refreshedDecision);
+			if (revalidated.kind !== "execute" || revalidated.target.kind !== "worker") continue;
+			workerActionTaken = true;
+			workerActionAttemptedForSession = true;
+			try {
+				await (d.applyTeamWorkerGuard ?? (async () => undefined))(
+					cwd,
+					sessionId,
+					revalidated.target.workerId,
+					revalidated.target.excessBytes,
+					workerIncidentId,
+				);
+			} catch (error) {
+				d.logWarn("Memory guard: team worker action failed; continuing sweep", {
+					sessionId,
+					workerId: revalidated.target.workerId,
+					error: String(error),
+				});
+			}
+		}
+		if (workerActionAttemptedForSession) memoryGuardRestartCooldownUntil.set(sessionId, now + policy.cooldownMs);
+		d.logWarn("Memory guard: restart threshold sustained", {
 			sessionId,
 			parentBytes: pressure.parentBytes,
 			totalUsageBytes: pressure.totalUsageBytes,
@@ -598,9 +759,9 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 
 function ownerBrowserPolicy(snapshot: TabGcSnapshot): BrowserGcPolicy | null {
 	if (!snapshot.ownerId) return null;
-	const settings = activeSessions.get(snapshot.ownerId);
-	if (!settings) return null;
-	return resolveBrowserGcPolicy(settings);
+	const registration = activeSessions.get(snapshot.ownerId);
+	if (!registration) return null;
+	return resolveBrowserGcPolicy(registration.settings);
 }
 
 /** Coarse, ordering-only eligibility; the live recheck in releaseTabIfGcEligible is authoritative. */
@@ -639,7 +800,7 @@ async function sweepBrowserTabs(d: ResourceGcDeps): Promise<void> {
 function pressuredOwnerIds(d: ResourceGcDeps): Set<string> {
 	const rss = d.rssBytes();
 	const owners = new Set<string>();
-	for (const [sessionId, settings] of activeSessions) {
+	for (const [sessionId, { settings }] of activeSessions) {
 		const policy = resolveBrowserGcPolicy(settings);
 		if (policy.enabled && rss > policy.rssLimitBytes) owners.add(sessionId);
 	}
@@ -678,7 +839,7 @@ async function sweepScreenshots(d: ResourceGcDeps): Promise<void> {
 
 	let staleMs: number | null = null;
 	let scanIntervalMs = Number.POSITIVE_INFINITY;
-	for (const settings of activeSessions.values()) {
+	for (const { settings } of activeSessions.values()) {
 		const policy = resolveComputerGcPolicy(settings);
 		if (!policy.enabled) continue;
 		staleMs = staleMs === null ? policy.staleMs : Math.min(staleMs, policy.staleMs);
@@ -698,6 +859,8 @@ export function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>):
 		...defaultDeps,
 		...overrides,
 		monotonicNow: overrides.monotonicNow ?? overrides.now ?? defaultDeps.monotonicNow,
+		listTeamWorkers: overrides.listTeamWorkers ?? (async () => []),
+		applyTeamWorkerGuard: overrides.applyTeamWorkerGuard ?? (async () => undefined),
 	};
 }
 
@@ -749,6 +912,7 @@ export function __resetResourceGcForTest(): void {
 	rssWarningActive = false;
 	memoryGuardGcActive.clear();
 	memoryGuardRestartAboveSince.clear();
+	memoryGuardWorkerIncidentIds.clear();
 	memoryGuardRestartCooldownUntil.clear();
 	memoryGuardLastEvaluatedAt.clear();
 	lastScreenshotScanAt = 0;

package/src/tools/review.ts

@@ -188,15 +188,13 @@ export interface SubmitReviewDetails {
 // Re-export types for external use
 export type { ReportFindingDetails };
 /**
- * Coerce a tool-side `ReportFindingDetails` into the cross-boundary
- * `ReviewFinding` shape consumed by the reviewer agent's JTD output schema.
+ * Convert tool-side `ReportFindingDetails` into the numeric-priority
+ * `ReviewFinding` shape used by caller-owned reviewer payloads.
  *
  * The `report_finding` tool exposes `priority` as a string enum (`"P0".."P3"`)
- * for ergonomics, but the bundled reviewer schema (and every custom review
- * agent that mirrors it) declares `priority: number`. Without this coercion
- * the auto-populated `findings[]` fails JTD validation and every review run
- * that surfaces a finding is rejected with `findings.0.priority: expected
- * number, received string`.
+ * for ergonomics, while reviewer schemas may explicitly declare numeric
+ * priorities. This pure conversion does not add findings to completion data;
+ * callers that include `findings` own both that field and its output schema.
  */
 export function toReviewFinding(details: ReportFindingDetails): ReviewFinding {
 	return {

package/src/tools/search.ts

@@ -287,6 +287,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					rawPaths: resolvedPaths,
 					cwd: this.session.cwd,
 					getArtifactsDir: this.session.getArtifactsDir,
+					getAuthorizedArtifactsDirs: this.session.getAuthorizedArtifactsDirs,
 					internalUrlAction: "search",
 					trackImmutableSources: true,
 					surfaceExactFilePaths: true,

package/src/tools/subagent-render.ts

@@ -192,6 +192,9 @@ function renderSubagentSnapshotBody(
 	}
 	if (snapshot.description) lines.push(`  ${theme.fg("dim", `Description: ${snapshot.description}`)}`);
 	if (snapshot.outputRef) lines.push(`  ${theme.fg("dim", `Output: ${snapshot.outputRef}`)}`);
+	if (snapshot.setupFailureSummary) {
+		lines.push(`  ${theme.fg("error", `Setup failure: ${snapshot.setupFailureSummary}`)}`);
+	}
 	if (snapshot.assignment) {
 		lines.push(`  ${theme.fg("dim", "Assignment:")}`);
 		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
@@ -312,8 +315,9 @@ export const subagentToolRenderer = {
 					);
 				}
 
-				snapshotSignatures ??= subagents.map(snapshot =>
-					subagentAwaitRenderedStateSignature([snapshot], result.details),
+				snapshotSignatures ??= subagents.map(
+					snapshot =>
+						`${subagentAwaitRenderedStateSignature([snapshot], result.details)}:${snapshot.setupFailureSummary ?? ""}`,
 				);
 				subagents.forEach((snapshot, index) => {
 					// Fresh per-subagent status line (cheap), then a cached or dynamic body.

package/src/tools/subagent.ts

@@ -65,6 +65,8 @@ export interface SubagentSnapshot {
 	durationMs: number;
 	resultText?: string;
 	errorText?: string;
+	/** Safe setup failure cause retained from the executor launch path. */
+	setupFailureSummary?: string;
 	resultPreview?: string;
 	outputRef?: string;
 	truncated?: boolean;
@@ -603,6 +605,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			}
 			if (snapshot.description) lines.push(`Description: ${snapshot.description}`);
 			if (snapshot.outputRef) lines.push(`Output: ${snapshot.outputRef}`);
+			if (snapshot.setupFailureSummary) lines.push(`Setup failure: ${snapshot.setupFailureSummary}`);
 			if (snapshot.assignment) lines.push("Assignment:", "```", snapshot.assignment, "```");
 			if (snapshot.steerMessage) {
 				lines.push(`Steer (${snapshot.steerState ?? "queued"}):`, "```", snapshot.steerMessage, "```");
@@ -731,6 +734,9 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 						truncated: output.truncated,
 					}
 				: {}),
+			...(job.setupFailureSummary
+				? { setupFailureSummary: sanitizeText(job.setupFailureSummary, RECEIPT_PREVIEW_WIDTH) }
+				: {}),
 			...(outputRef ? { outputRef } : {}),
 			...(runningTimeoutGuidance ? { guidance: runningTimeoutGuidance } : {}),
 			...this.#modelFields(record),

package/src/tools/telegram-send.ts

@@ -31,8 +31,10 @@ export class TelegramSendTool implements AgentTool<typeof telegramSendSchema, Te
 	readonly summary = "Send a workspace file to Telegram";
 	readonly loadMode = "discoverable";
 	readonly description =
-		"Send a file from the current workspace to the connected Telegram chat as a document. The path must resolve " +
-		"(after following symlinks) to a regular file inside the project root; paths outside the workspace are rejected.";
+		"Send a file from the current workspace to the connected Telegram chat. Recognized images are converted to " +
+		"Telegram-compatible photos when possible, including WebP; other files are sent as documents with their MIME " +
+		"type preserved. The path must resolve (after following symlinks) to a regular file inside the project root; " +
+		"paths outside the workspace are rejected.";
 	readonly parameters = telegramSendSchema;
 	readonly strict = true;
 
@@ -109,6 +111,7 @@ export class TelegramSendTool implements AgentTool<typeof telegramSendSchema, Te
 			};
 		}
 		const abs = contained.path;
+		const mime = Bun.file(abs).type;
 
 		const sink = getTelegramFileSink(sessionId);
 		if (!sink) {
@@ -126,7 +129,7 @@ export class TelegramSendTool implements AgentTool<typeof telegramSendSchema, Te
 			};
 		}
 
-		const result = await sink({ path: abs, caption: params.caption });
+		const result = await sink({ path: abs, caption: params.caption, mime });
 		if (result.ok) {
 			return {
 				content: [{ type: "text", text: `Sent ${path.basename(abs)} to Telegram.` }],

package/src/tools/tool-result.ts

@@ -1,6 +1,6 @@
 import type { AgentToolResult } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent } from "@gajae-code/ai";
-import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputSummary, ReadWindow, TruncationResult } from "../session/streaming-output";
 import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
 import { outputMeta } from "./output-meta";
 
@@ -32,6 +32,19 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return this;
 	}
 
+	truncationWindows(
+		windows: ReadWindow,
+		options?: {
+			artifactId?: string;
+			noticeOwner?: "body";
+			maxBytes?: number;
+			rangeBase?: "file" | "window";
+		},
+	): this {
+		this.#meta.truncationWindows(windows, options);
+		return this;
+	}
+
 	truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this {
 		this.#meta.truncationFromSummary(summary, options);
 		return this;

package/src/utils/gh.ts

@@ -0,0 +1,39 @@
+const DEFAULT_GH_TIMEOUT_MS = 5_000;
+
+export interface GhResult {
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+	timedOut?: boolean;
+}
+
+export type RunGh = (args: string[], options?: { timeoutMs?: number }) => Promise<GhResult>;
+
+/** Run GitHub CLI without allowing it to consume the parent terminal's input. */
+export async function runGhDefault(args: string[], options?: { timeoutMs?: number }): Promise<GhResult> {
+	const ghPath = Bun.which("gh");
+	if (!ghPath) {
+		return { exitCode: -1, stdout: "", stderr: "gh not found", timedOut: false };
+	}
+	const timeoutMs = options?.timeoutMs ?? DEFAULT_GH_TIMEOUT_MS;
+	let timedOut = false;
+	try {
+		const proc = Bun.spawn([ghPath, ...args], { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+		const timer = setTimeout(() => {
+			timedOut = true;
+			proc.kill();
+		}, timeoutMs);
+		try {
+			const [stdout, stderr] = await Promise.all([
+				new Response(proc.stdout).text(),
+				new Response(proc.stderr).text(),
+			]);
+			const exitCode = await proc.exited;
+			return { exitCode, stdout, stderr, timedOut };
+		} finally {
+			clearTimeout(timer);
+		}
+	} catch (err) {
+		return { exitCode: -1, stdout: "", stderr: err instanceof Error ? err.message : String(err), timedOut };
+	}
+}

package/src/utils/image-resize.ts

@@ -6,6 +6,7 @@ export interface ImageResizeOptions {
 	maxBytes?: number;
 	jpegQuality?: number;
 	excludeWebP?: boolean;
+	forceReencode?: boolean;
 }
 
 export interface ResizedImage {
@@ -30,6 +31,7 @@ const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	maxHeight: 1568,
 	maxBytes: DEFAULT_IMAGE_RESIZE_MAX_BYTES,
 	jpegQuality: 80,
+	forceReencode: false,
 };
 
 /**
@@ -94,6 +96,7 @@ export async function resizeImageBuffer(
 			originalWidth <= opts.maxWidth &&
 			originalHeight <= opts.maxHeight &&
 			originalSize <= comfortableSize &&
+			!opts.forceReencode &&
 			!(opts.excludeWebP && sourceMime === "image/webp")
 		) {
 			return {

package/src/web/search/providers/anthropic.ts

@@ -14,7 +14,7 @@ import {
 	buildAnthropicUrl,
 	stripClaudeToolPrefix,
 } from "@gajae-code/ai";
-import { $env } from "@gajae-code/utils";
+import { $credentialEnv, $env } from "@gajae-code/utils";
 import type {
 	AnthropicApiResponse,
 	AnthropicCitation,
@@ -275,8 +275,8 @@ export async function searchAnthropic(
 	params: SearchParams | AnthropicSearchParams,
 	_legacyStorage?: unknown,
 ): Promise<SearchResponse> {
-	const searchApiKey = $env.ANTHROPIC_SEARCH_API_KEY;
-	const searchBaseUrl = $env.ANTHROPIC_SEARCH_BASE_URL;
+	const searchApiKey = $credentialEnv("ANTHROPIC_SEARCH_API_KEY");
+	const searchBaseUrl = $credentialEnv("ANTHROPIC_SEARCH_BASE_URL");
 	let auth: AnthropicAuthConfig | undefined;
 	// When reusing the active model's own credentials (native search over a
 	// proxy), prefer its wire model id and carry its request headers through.
@@ -360,7 +360,7 @@ export class AnthropicProvider extends SearchProvider {
 	readonly label = "Anthropic";
 
 	isAvailable(authStorage: AuthStorage): Promise<boolean> | boolean {
-		return Boolean($env.ANTHROPIC_SEARCH_API_KEY) || authStorage.hasAuth("anthropic");
+		return Boolean($credentialEnv("ANTHROPIC_SEARCH_API_KEY")) || authStorage.hasAuth("anthropic");
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {

package/src/web/search/providers/codex.ts

@@ -36,7 +36,7 @@ const DEFAULT_INSTRUCTIONS =
 	"You are a helpful assistant with web search capabilities. Search the web to answer the user's question accurately and cite your sources.";
 
 function getConfiguredModel(): string | undefined {
-	const configuredModel = $env.PI_CODEX_WEB_SEARCH_MODEL?.trim();
+	const configuredModel = ($env.GJC_OPENAI_CODE_WEB_SEARCH_MODEL ?? $env.PI_CODEX_WEB_SEARCH_MODEL)?.trim();
 	return configuredModel ? configuredModel : undefined;
 }
 

package/src/web/search/providers/kimi.ts

@@ -5,7 +5,7 @@
  * Endpoint: POST https://api.kimi.com/coding/v1/search
  */
 import type { AuthStorage } from "@gajae-code/ai";
-import { $env } from "@gajae-code/utils";
+import { $credentialEnv } from "@gajae-code/utils";
 
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -55,8 +55,17 @@ function asTrimmed(value: string | undefined): string | undefined {
 	return trimmed.length > 0 ? trimmed : undefined;
 }
 
+/** Test seam: the Kimi search base URL as resolved from trusted env. */
+export function resolveKimiSearchBaseUrlForTest(): string {
+	return resolveBaseUrl();
+}
+
 function resolveBaseUrl(): string {
-	return asTrimmed($env.MOONSHOT_SEARCH_BASE_URL) ?? asTrimmed($env.KIMI_SEARCH_BASE_URL) ?? KIMI_SEARCH_URL;
+	return (
+		asTrimmed($credentialEnv("MOONSHOT_SEARCH_BASE_URL")) ??
+		asTrimmed($credentialEnv("KIMI_SEARCH_BASE_URL")) ??
+		KIMI_SEARCH_URL
+	);
 }
 
 /** Find Kimi search credentials from environment or AuthStorage. */
@@ -65,7 +74,8 @@ async function findApiKey(
 	sessionId: string | undefined,
 	signal: AbortSignal | undefined,
 ): Promise<string | null> {
-	const envKey = asTrimmed($env.MOONSHOT_SEARCH_API_KEY) ?? asTrimmed($env.KIMI_SEARCH_API_KEY);
+	const envKey =
+		asTrimmed($credentialEnv("MOONSHOT_SEARCH_API_KEY")) ?? asTrimmed($credentialEnv("KIMI_SEARCH_API_KEY"));
 	if (envKey) return envKey;
 
 	return (
@@ -157,8 +167,8 @@ export class KimiProvider extends SearchProvider {
 
 	isAvailable(authStorage: AuthStorage): boolean {
 		return (
-			!!asTrimmed($env.MOONSHOT_SEARCH_API_KEY) ||
-			!!asTrimmed($env.KIMI_SEARCH_API_KEY) ||
+			!!asTrimmed($credentialEnv("MOONSHOT_SEARCH_API_KEY")) ||
+			!!asTrimmed($credentialEnv("KIMI_SEARCH_API_KEY")) ||
 			authStorage.hasAuth("moonshot") ||
 			authStorage.hasAuth("kimi-code")
 		);