@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/tools/resource-gc.ts

@@ -18,15 +18,9 @@ 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,
-	revalidateMemoryGuardAction,
-} from "../runtime/memory-guard";
-import type { MemoryGuardPolicy, MemoryGuardWorkerSample } from "../runtime/memory-guard-contract";
+import { chooseMemoryGuardAction, MemoryGuardHost, resolveMemoryGuardPolicy } from "../runtime/memory-guard";
+import type { MemoryGuardPolicy } 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";
@@ -91,14 +85,6 @@ 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>;
 }
 
 /** Request collection without synchronously stopping the main event loop. */
@@ -117,9 +103,6 @@ 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) ──────────────────
@@ -135,8 +118,6 @@ let lastScreenshotScanAt = 0;
 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 {
@@ -175,8 +156,6 @@ 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);
 			}
 		}
@@ -186,11 +165,9 @@ export function registerResourceGcSession(reg: ResourceGcRegistration): () => vo
 		if (unregistered) return;
 		unregistered = true;
 		activeSessions.delete(reg.sessionId);
-		memoryGuardLastEvaluatedAt.delete(reg.sessionId);
 		memoryGuardGcActive.delete(reg.sessionId);
 		memoryGuardRestartAboveSince.delete(reg.sessionId);
-		memoryGuardWorkerIncidentIds.delete(reg.sessionId);
-		memoryGuardRestartCooldownUntil.delete(reg.sessionId);
+		memoryGuardLastEvaluatedAt.delete(reg.sessionId);
 		unregisterSchedule();
 		unregisterSettings();
 	};
@@ -514,105 +491,11 @@ function sweepMemoryPressureGuard(d: ResourceGcDeps): Promise<void> | undefined
 		}
 		memoryGuardGcActive.delete(sessionId);
 		memoryGuardRestartAboveSince.delete(sessionId);
-		memoryGuardWorkerIncidentIds.delete(sessionId);
-		memoryGuardRestartCooldownUntil.delete(sessionId);
 		memoryGuardLastEvaluatedAt.delete(sessionId);
 	}
 	if (!enabled) return 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; cwd: string }> = [];
@@ -622,8 +505,6 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 		if (!policy.enabled) {
 			memoryGuardGcActive.delete(sessionId);
 			memoryGuardRestartAboveSince.delete(sessionId);
-			memoryGuardWorkerIncidentIds.delete(sessionId);
-			memoryGuardRestartCooldownUntil.delete(sessionId);
 			memoryGuardLastEvaluatedAt.delete(sessionId);
 			continue;
 		}
@@ -637,8 +518,7 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 	const snapshot = await d.memorySnapshot();
 	let gcRequested = false;
 	const gcTelemetry: Array<{ sessionId: string } & Record<string, unknown>> = [];
-	let workerActionTaken = false;
-	for (const { sessionId, policy, cwd } of dueSessions) {
+	for (const { sessionId, policy } of dueSessions) {
 		const pressure = __selectMemoryPressureDomainForTest(snapshot, policy.policyLimitBytes);
 		const limit = resolveEffectiveMemoryLimit({
 			hardCapBytes: pressure.hardCapBytes,
@@ -647,23 +527,20 @@ async function sweepEnabledMemoryPressureGuard(d: ResourceGcDeps): Promise<void>
 		if (limit.effectiveBytes === null) {
 			memoryGuardGcActive.delete(sessionId);
 			memoryGuardRestartAboveSince.delete(sessionId);
-			memoryGuardWorkerIncidentIds.delete(sessionId);
-			memoryGuardRestartCooldownUntil.delete(sessionId);
+			memoryGuardLastEvaluatedAt.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: workerSamples,
+			workers: [],
 		});
 		const decision = chooseMemoryGuardAction({
 			domain,
 			hostSupported: false,
-			workerSupported: workerId =>
-				workerSamples.some(worker => worker.workerId === workerId && worker.accepted !== false),
+			workerSupported: () => false,
 		});
 		const usageRatio = pressure.totalUsageBytes / limit.effectiveBytes;
 		if (usageRatio >= policy.gcThresholdRatio) {
@@ -686,56 +563,14 @@ 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;
-		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);
+		if (now - aboveSince < policy.restartThresholdWindowMs) continue;
 		d.logWarn("Memory guard: restart threshold sustained", {
 			sessionId,
 			parentBytes: pressure.parentBytes,
@@ -864,8 +699,6 @@ export function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>):
 		...defaultDeps,
 		...overrides,
 		monotonicNow: overrides.monotonicNow ?? overrides.now ?? defaultDeps.monotonicNow,
-		listTeamWorkers: overrides.listTeamWorkers ?? (async () => []),
-		applyTeamWorkerGuard: overrides.applyTeamWorkerGuard ?? (async () => undefined),
 	};
 }
 
@@ -917,8 +750,6 @@ export function __resetResourceGcForTest(): void {
 	rssWarningActive = false;
 	memoryGuardGcActive.clear();
 	memoryGuardRestartAboveSince.clear();
-	memoryGuardWorkerIncidentIds.clear();
-	memoryGuardRestartCooldownUntil.clear();
 	memoryGuardLastEvaluatedAt.clear();
 	lastScreenshotScanAt = 0;
 	deps = defaultDeps;

package/src/tools/search.ts

@@ -230,6 +230,13 @@ export interface SearchToolDetails {
 	missingPaths?: string[];
 }
 
+export interface SearchToolOptions {
+	/** Per-call symmetric context width used by Cursor's native Pi grep frame. */
+	context?: number;
+	/** Per-call total match cap used by Cursor's native Pi grep frame. */
+	totalMatchLimit?: number;
+}
+
 type SearchParams = z.infer<typeof searchSchema>;
 
 export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
@@ -247,7 +254,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 	readonly parameters = searchSchema;
 	readonly strict = true;
 
-	constructor(private readonly session: ToolSession) {}
+	constructor(
+		private readonly session: ToolSession,
+		private readonly options: SearchToolOptions = {},
+	) {}
 
 	async execute(
 		_toolCallId: string,
@@ -293,8 +303,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							`or pass a UTF-8 text member.`,
 					);
 				}
-				const normalizedContextBefore = this.session.settings.get("search.contextBefore");
-				const normalizedContextAfter = this.session.settings.get("search.contextAfter");
+				const normalizedContextBefore = this.options.context ?? this.session.settings.get("search.contextBefore");
+				const normalizedContextAfter = this.options.context ?? this.session.settings.get("search.contextAfter");
+				const nativeMatchCap =
+					this.options.totalMatchLimit === undefined
+						? INTERNAL_TOTAL_CAP
+						: Math.min(INTERNAL_TOTAL_CAP, this.options.totalMatchLimit + 1);
 				const ignoreCase = i ?? false;
 				const useGitignore = gitignore ?? true;
 				const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
@@ -362,7 +376,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 									hidden: true,
 									gitignore: useGitignore,
 									cache: false,
-									maxCount: INTERNAL_TOTAL_CAP,
+									maxCount: nativeMatchCap,
 									contextBefore: normalizedContextBefore,
 									contextAfter: normalizedContextAfter,
 									maxColumns: DEFAULT_MAX_COLUMN,
@@ -397,7 +411,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 								hidden: true,
 								gitignore: useGitignore,
 								cache: false,
-								maxCount: INTERNAL_TOTAL_CAP,
+								maxCount: nativeMatchCap,
 								contextBefore: normalizedContextBefore,
 								contextAfter: normalizedContextAfter,
 								maxColumns: DEFAULT_MAX_COLUMN,
@@ -469,6 +483,12 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						}
 					}
 				}
+				const explicitMatchLimitReached =
+					this.options.totalMatchLimit !== undefined &&
+					(selectedMatches.length > this.options.totalMatchLimit || result.limitReached);
+				if (this.options.totalMatchLimit !== undefined && selectedMatches.length > this.options.totalMatchLimit) {
+					selectedMatches.length = this.options.totalMatchLimit;
+				}
 				const nextSkip = skipFiles + windowFiles.length;
 				const limitMessage = fileLimitReached
 					? `Showing files ${skipFiles + 1}-${nextSkip} of ${totalFiles}. Use skip=${nextSkip} for the next page, or narrow paths/pattern.`
@@ -608,7 +628,11 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					})),
 					truncated,
 					fileLimitReached: fileLimitReached ? DEFAULT_FILE_LIMIT : undefined,
-					perFileLimitReached: perFileLimitReached ? perFileMatchCap : undefined,
+					perFileLimitReached: explicitMatchLimitReached
+						? this.options.totalMatchLimit
+						: perFileLimitReached
+							? perFileMatchCap
+							: undefined,
 					displayContent: displayText,
 					missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 				};

package/src/tools/skill-discovery.ts

@@ -78,6 +78,7 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 			const source = input.source ?? "all";
 			const result = await discoverRuntimeSkills({
 				cwd: this.#session.cwd,
+				home: this.#session.home,
 				query: input.query,
 				source,
 				limit: input.limit,

package/src/tools/skill.ts

@@ -10,10 +10,15 @@
  * project/user skills have no native workflow mode-state, so they are dispatched
  * directly and tracked by the prompt observer instead.
  *
- * Canonical workflow chaining is refused unless the caller's `current_phase` is
- * in `{complete, completed, handoff, failed, cancelled, canceled, inactive}`.
- * The agent declares readiness either by writing `current_phase: "handoff"` to
- * its mode-state or by running the handoff verb directly.
+ * Canonical workflow chaining is refused unless the caller's phase permits it:
+ * the generic terminal set `{complete, completed, handoff, failed, cancelled,
+ * canceled, inactive}`, the caller's manifest-declared terminal states (e.g.
+ * ralplan `final`), or — for autoresearch only — any phase with a declared
+ * handoff edge (`intake`/`research`/`verdict`): a research mission never
+ * mutates and guards no approval gate, its mission state is durable, so an
+ * ongoing or verdict-complete mission may hand off to planning at any point.
+ * ralplan/ultragoal keep the explicit write-to-handoff step for live phases:
+ * their mid-flight chaining is exactly what the approval-gate guard blocks.
  */
 
 import type { AgentTool, AgentToolResult } from "@gajae-code/agent-core";
@@ -23,6 +28,7 @@ import { resolveSubskillActivationForSkillInvocation } from "../extensibility/gj
 import { findRuntimeSkillByName } from "../extensibility/runtime-skill-discovery";
 import { buildSkillPromptMessage } from "../extensibility/skills";
 import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
+import { getSkillManifest } from "../gjc-runtime/workflow-manifest";
 import skillDescription from "../prompts/tools/skill.md" with { type: "text" };
 import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
 import { isCanonicalGjcWorkflowSkill } from "../skill-state/active-state";
@@ -31,6 +37,25 @@ import { ToolError } from "./tool-errors";
 
 const TERMINAL_PHASES = new Set(["complete", "completed", "handoff", "failed", "cancelled", "canceled", "inactive"]);
 
+/**
+ * Whether the active canonical workflow's phase permits chaining into another
+ * skill. Generic terminal phases always chain; manifest terminal states cover
+ * skill-specific termini the generic set misses (ralplan "final"); and
+ * autoresearch chains from any phase with a manifest handoff edge because a
+ * research mission is safely abandonable mid-flight (read-only, durable
+ * mission state, no approval gate). ralplan/ultragoal deliberately stay
+ * blocked in live phases so mid-consensus or mid-execution chaining still
+ * requires the explicit write-to-handoff step.
+ */
+function phasePermitsChain(skill: string, phase: string): boolean {
+	if (TERMINAL_PHASES.has(phase)) return true;
+	if (!isCanonicalGjcWorkflowSkill(skill)) return false;
+	const manifest = getSkillManifest(skill);
+	if (manifest.terminalStates.includes(phase)) return true;
+	if (skill !== "autoresearch") return false;
+	return manifest.transitions.some(transition => transition.from === phase && transition.to === "handoff");
+}
+
 const skillSchema = z.object({
 	name: z.string().describe("skill name as it appears in /skill:<name>"),
 	args: z.string().describe("argument string passed to the skill").optional(),
@@ -122,7 +147,12 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 
 			const skill =
 				skills.find(s => s.name === requestedName) ??
-				(await findRuntimeSkillByName(this.#session.cwd, requestedName, this.#getRuntimeSkillPolicy()));
+				(await findRuntimeSkillByName(
+					this.#session.cwd,
+					requestedName,
+					this.#getRuntimeSkillPolicy(),
+					this.#session.home,
+				));
 			if (!skill) {
 				const available = skills.map(s => s.name).sort();
 				const hint =
@@ -137,9 +167,9 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 			// so there is no `gjc state <skill>` command to run for them.
 			if (activeSkill && isCanonicalGjcWorkflowSkill(activeSkill)) {
 				const phase = (this.#session.getActiveSkillPhase?.() ?? "running").trim().toLowerCase();
-				if (!TERMINAL_PHASES.has(phase)) {
+				if (!phasePermitsChain(activeSkill, phase)) {
 					throw new ToolError(
-						`skill tool: refusing to chain from "${activeSkill}" (phase=${phase}) into "${requestedName}". Finalize the current skill (gjc state ${activeSkill} write --input '{"current_phase":"handoff"}' --json) or run gjc state ${activeSkill} handoff --to ${requestedName} --json directly before chaining.`,
+						`skill tool: refusing to chain from "${activeSkill}" (phase=${phase}) into "${requestedName}". Run gjc state ${activeSkill} handoff --to ${requestedName} --json directly, or finalize the current skill first (gjc state ${activeSkill} write --input '{"current_phase":"handoff"}' --json) before chaining.`,
 					);
 				}
 				const cwd = this.#session.cwd;

package/src/tools/subagent-render.ts

@@ -11,13 +11,7 @@ import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import {
-	collectProviderDegradationGroups,
-	hasActiveProviderRetryInProgress,
-	providerProgressAgeLabel,
-	providerRetryPhaseLabel,
-} from "../task/provider-retry-status";
-import { renderSubagentLiveProgress } from "../task/render";
+import { providerRetryPhaseLabel } from "../task/provider-retry-status";
 import { Ellipsis, Hasher, renderStatusLine } from "../tui";
 import {
 	formatDuration,
@@ -27,7 +21,12 @@ import {
 	type ToolUIStatus,
 	truncateToWidth,
 } from "./render-utils";
-import { type SubagentSnapshot, type SubagentToolDetails, subagentAwaitRenderedStateSignature } from "./subagent";
+import {
+	type SubagentLiveProgress,
+	type SubagentSnapshot,
+	type SubagentToolDetails,
+	subagentAwaitRenderedStateSignature,
+} from "./subagent";
 
 export { subagentAwaitRenderedStateSignature } from "./subagent";
 
@@ -89,6 +88,30 @@ function snapshotHasActiveRetry(snapshot: SubagentSnapshot): boolean {
 	return hasActiveProviderRetryInProgress(snapshot.progress);
 }
 
+function hasActiveProviderRetryInProgress(progress: SubagentLiveProgress): boolean {
+	return progress.status === "running" && progress.retryState !== undefined;
+}
+
+function providerProgressAgeLabel(progress: SubagentLiveProgress["retryState"], nowMs: number): string {
+	if (progress?.lastProviderProgressAtMs === undefined) return "no provider events yet";
+	const ageSeconds = Math.max(0, Math.floor((nowMs - progress.lastProviderProgressAtMs) / 1000));
+	return `last provider progress ${ageSeconds}s ago`;
+}
+
+function collectProviderDegradationGroups(
+	progress: readonly SubagentLiveProgress[],
+): Array<{ provider: string; count: number }> {
+	const counts = new Map<string, number>();
+	for (const item of progress) {
+		if (item.status !== "running" || !item.retryState) continue;
+		const provider = item.retryState.provider ?? "provider";
+		counts.set(provider, (counts.get(provider) ?? 0) + 1);
+	}
+	return Array.from(counts, ([provider, count]) => ({ provider, count }))
+		.filter(group => group.count > 1)
+		.sort((a, b) => b.count - a.count || a.provider.localeCompare(b.provider));
+}
+
 function boundSubagentBodyLines(lines: string[], width: number): string[] {
 	return lines.map(line => (line.length > 0 ? truncateToWidth(replaceTabs(line), width, Ellipsis.Omit) : ""));
 }
@@ -166,6 +189,72 @@ function renderSubagentStatusLine(snapshot: SubagentSnapshot, theme: Theme, spin
 	return `${icon} ${id} ${status} ${duration}`;
 }
 
+function renderSubagentLiveProgress(
+	progress: SubagentLiveProgress,
+	expanded: boolean,
+	theme: Theme,
+	spinnerFrame?: number,
+	staticTime = false,
+): string[] {
+	const lines: string[] = [];
+	const prefix = theme.fg("dim", theme.tree.last);
+	const iconColor = progress.status === "failed" || progress.status === "aborted" ? "error" : "accent";
+	const icon = formatStatusIcon(
+		progress.status === "completed" ? "success" : progress.status === "failed" ? "error" : "info",
+		theme,
+		progress.status === "running" ? spinnerFrame : undefined,
+	);
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", progress.id)}`;
+	if (progress.fastMode && theme.icon.fast) statusLine += ` ${theme.icon.fast}`;
+	if (progress.retryState && progress.status === "running") {
+		statusLine += ` ${theme.fg("warning", "provider degraded")}`;
+	}
+	lines.push(statusLine);
+
+	const continuePrefix = "   ";
+	if (progress.status === "running") {
+		const tool = progress.currentTool ?? progress.recentTool;
+		if (tool) lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("muted", tool)}`);
+	}
+	if (progress.recentOutputSummary) {
+		const count = progress.recentOutputSummary.lineCount;
+		lines.push(
+			`${continuePrefix}${theme.tree.hook} ${theme.fg("dim", `recent output available (${count} ${count === 1 ? "line" : "lines"})`)}`,
+		);
+	}
+	if (progress.retryState && progress.status === "running") {
+		const retry = progress.retryState;
+		const attemptLabel = retry.unbounded
+			? `attempt ${retry.attempt}, unbounded`
+			: `attempt ${retry.attempt} of ${retry.maxAttempts}, bounded`;
+		const progressAge = staticTime ? "" : ` · ${providerProgressAgeLabel(retry, Date.now())}`;
+		let waitLabel = "";
+		if (!staticTime) {
+			const remainingMs = Math.max(0, retry.startedAtMs + retry.delayMs - Date.now());
+			waitLabel = remainingMs > 0 ? ` in ${formatDuration(remainingMs)}` : " now";
+		}
+		lines.push(
+			`${continuePrefix}${theme.tree.hook} ${theme.fg("warning", `${providerRetryPhaseLabel(retry.kind)} · retrying ${attemptLabel}${waitLabel}${progressAge}`)}`,
+		);
+	}
+	if (progress.retryFailure && progress.status !== "running") {
+		const attempts = progress.retryFailure.attempt;
+		lines.push(
+			`${continuePrefix}${theme.tree.hook} ${theme.fg("error", `auto-retry gave up after ${attempts} attempt${attempts === 1 ? "" : "s"}`)}`,
+		);
+	}
+	if (
+		expanded &&
+		progress.status === "running" &&
+		!progress.currentTool &&
+		!progress.recentTool &&
+		!progress.recentOutputSummary
+	) {
+		lines.push(`${continuePrefix}${theme.fg("dim", "running, no approved activity summary yet")}`);
+	}
+	return lines;
+}
+
 // Heavy per-subagent body. The cache path uses staticTime=true; the bounded dynamic
 // path opts into wall-clock displays when an active retry exists in the nested tree.
 function renderSubagentSnapshotBody(
@@ -198,6 +287,20 @@ function renderSubagentSnapshotBody(
 	if (snapshot.setupFailureSummary) {
 		lines.push(`  ${theme.fg("error", `Setup failure: ${snapshot.setupFailureSummary}`)}`);
 	}
+	if (snapshot.localErrorSummary) {
+		const local = snapshot.localErrorSummary;
+		lines.push(`  ${theme.fg("error", `Local failure (${local.kind}): ${local.summary}`)}`);
+		// Kind-conditional guidance: an overflow is a staging limit that
+		// reproduces on re-issue; a snapshot failure is a serialization
+		// defect. Rendering the wrong one mislabels the failure mode.
+		const guidance =
+			local.kind === "local_buffer_overflow"
+				? "Local gjc staging-buffer limit, not a provider or context-window failure; re-issuing reproduces it."
+				: local.kind === "local_snapshot_failure"
+					? "Local gjc event-serialization defect, not a provider failure; safe to retry."
+					: undefined;
+		if (guidance) lines.push(`  ${theme.fg("dim", guidance)}`);
+	}
 	if (snapshot.assignment) {
 		lines.push(`  ${theme.fg("dim", "Assignment:")}`);
 		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
@@ -220,7 +323,7 @@ function renderSubagentSnapshotBody(
 			lines.push(`  ${pl}`);
 		}
 	} else if (snapshot.liveProgressAvailable && (snapshot.status === "running" || snapshot.status === "queued")) {
-		lines.push(`  ${theme.fg("dim", "running, no activity yet")}`);
+		lines.push(`  ${theme.fg("dim", "running, no approved activity summary yet")}`);
 	}
 
 	const preview = snapshot.errorText?.trim() || snapshot.resultText?.trim();
@@ -265,6 +368,7 @@ export const subagentToolRenderer = {
 		}
 
 		const runningCount = subagents.filter(s => s.status === "running").length;
+		const failedCount = subagents.filter(s => s.status === "failed" || s.status === "not_found").length;
 		const interrupted = result.details?.interrupted === true;
 
 		// Each snapshot's rendered-state signature is constant for this component
@@ -280,14 +384,16 @@ export const subagentToolRenderer = {
 				// it is never gated by the heavy body cache.
 				const header = renderStatusLine(
 					{
-						icon: interrupted ? "warning" : runningCount > 0 ? "info" : "success",
+						icon: interrupted ? "warning" : runningCount > 0 ? "info" : failedCount > 0 ? "error" : "success",
 						spinnerFrame: !interrupted && runningCount > 0 ? options.spinnerFrame : undefined,
-						title: interrupted ? "Subagent await interrupted" : "Subagent",
+						title: interrupted ? "Subagent await interrupted" : failedCount > 0 ? "Subagent failed" : "Subagent",
 						description: interrupted
 							? "child subagents continue"
 							: runningCount > 0
 								? `awaiting ${runningCount} of ${subagents.length}`
-								: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
+								: failedCount > 0
+									? `${failedCount} ${failedCount === 1 ? "subagent" : "subagents"} failed`
+									: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
 					},
 					theme,
 				);
@@ -320,7 +426,7 @@ export const subagentToolRenderer = {
 
 				snapshotSignatures ??= subagents.map(
 					snapshot =>
-						`${subagentAwaitRenderedStateSignature([snapshot], result.details)}:${snapshot.setupFailureSummary ?? ""}`,
+						`${subagentAwaitRenderedStateSignature([snapshot], result.details)}:${snapshot.setupFailureSummary ?? ""}:${snapshot.localErrorSummary?.summary ?? ""}`,
 				);
 				subagents.forEach((snapshot, index) => {
 					// Fresh per-subagent status line (cheap), then a cached or dynamic body.