@gajae-code/coding-agent 0.12.2 → 0.12.5

package/src/task/receipt.ts

@@ -39,6 +39,7 @@ export interface TaskResultReceipt {
 	cost?: number;
 	usageCostBreakdownComplete?: true;
 	branchName?: string;
+	persistence?: SingleResult["persistence"];
 	retryFailure?: { attempt: number; errorSummary: string };
 	setupFailure?: { summary: string };
 	errorSummary?: string;
@@ -128,6 +129,18 @@ function buildSafeSynopsis(raw: SingleResult, outputRef: TaskResultReceipt["outp
 	if (raw.retryFailure) {
 		return `Task ${status}; retry stopped after attempt ${raw.retryFailure.attempt}.`;
 	}
+	if (raw.persistence?.outcome === "recovery_available") {
+		const recovery = raw.persistence.recoveryRef
+			? ` Recovery patch: ${raw.persistence.recoveryRef.uri} (${raw.persistence.recoveryRef.sizeBytes} bytes).`
+			: "";
+		return `Task ${status}; changes were not persisted to the owner worktree.${recovery}`;
+	}
+	if (raw.persistence?.outcome === "applied") {
+		return `Task ${status}; changes persisted to the owner worktree.`;
+	}
+	if (raw.persistence?.outcome === "no_changes") {
+		return `Task ${status}; no changes to persist.`;
+	}
 	if (raw.abortReason) {
 		return `Task ${status}; abort reason recorded.`;
 	}
@@ -143,7 +156,7 @@ function buildSafeSynopsis(raw: SingleResult, outputRef: TaskResultReceipt["outp
 function getStatus(raw: SingleResult): TaskResultReceipt["status"] {
 	if (raw.paused) return "paused";
 	if (raw.aborted) return "aborted";
-	if (raw.exitCode === 0 && raw.error) return "merge_failed";
+	if (raw.exitCode === 0 && (raw.error || raw.persistence?.outcome === "recovery_available")) return "merge_failed";
 	if (raw.exitCode !== 0 || raw.error) return "failed";
 	return "completed";
 }
@@ -275,11 +288,18 @@ export function buildTaskReceipt(raw: SingleResult): TaskResultReceipt {
 		usageCostBreakdownComplete:
 			raw.usageCostBreakdownComplete === true && hasCompleteUsageCostBreakdown(raw.usage) ? true : undefined,
 		branchName: raw.branchName,
+		persistence: raw.persistence,
 		fastMode: raw.fastMode,
 		retryFailure: raw.retryFailure
 			? { attempt: raw.retryFailure.attempt, errorSummary: "Retry failure recorded." }
 			: undefined,
-		errorSummary: raw.setupFailure?.summary ?? (raw.error ? "Error recorded." : undefined),
+		errorSummary:
+			raw.setupFailure?.summary ??
+			(raw.error
+				? "Error recorded."
+				: raw.persistence?.outcome === "recovery_available"
+					? "Changes were not persisted to the owner worktree."
+					: undefined),
 		setupFailure: raw.setupFailure ? { summary: raw.setupFailure.summary } : undefined,
 		abortSummary: raw.abortReason ? "Abort reason recorded." : undefined,
 		preview,

package/src/task/render.ts

@@ -7,7 +7,7 @@
 import path from "node:path";
 import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
-import { formatNumber } from "@gajae-code/utils";
+import { formatNumber, sanitizeText } from "@gajae-code/utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import {
@@ -917,6 +917,17 @@ function renderAgentResult(result: TaskResultReceipt, isLast: boolean, expanded:
 		lines.push(`${continuePrefix}${theme.fg("warning", "low ROI: produced no material contribution")}`);
 	}
 
+	if (result.persistence?.recoveryRef) {
+		const label = result.persistence.ownerWorktreeApplied ? "Recovery patch" : "Unapplied recovery patch";
+		const recoveryUri = truncateToWidth(replaceTabs(sanitizeText(result.persistence.recoveryRef.uri)), 80);
+		lines.push(
+			`${continuePrefix}${theme.fg(
+				result.persistence.ownerWorktreeApplied ? "dim" : "warning",
+				`${label}: ${recoveryUri} (${formatBytes(result.persistence.recoveryRef.sizeBytes)})`,
+			)}`,
+		);
+	}
+
 	if (result.outputRef) {
 		lines.push(
 			`${continuePrefix}${theme.fg(

package/src/task/types.ts

@@ -425,6 +425,20 @@ export function createSetupFailureSummary(error: unknown): SetupFailureSummary {
 	};
 }
 
+export interface TaskRecoveryArtifactRef {
+	uri: string;
+	sizeBytes: number;
+	sha256: string;
+	/** Recovery artifacts remain readable for the parent session lifetime. */
+	durability: "session";
+}
+
+export interface TaskPersistenceResult {
+	outcome: "applied" | "no_changes" | "recovery_available";
+	ownerWorktreeApplied: boolean;
+	recoveryRef?: TaskRecoveryArtifactRef;
+}
+
 /** Result from a single agent execution */
 export interface SingleResult {
 	index: number;
@@ -470,6 +484,10 @@ export interface SingleResult {
 	nestedPatches?: NestedRepoPatch[];
 	/** Whether isolated execution produced a non-empty root or nested patch. */
 	producedChanges?: boolean;
+	/** Receipt-safe owner-worktree persistence result for isolated execution. */
+	persistence?: TaskPersistenceResult;
+	/** Identity-bound patch artifact captured before isolation cleanup. */
+	recoveryRef?: TaskRecoveryArtifactRef;
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;
 	/** Full wrapper-owned review evidence, kept separate from caller completion data. */

package/src/task/worktree.ts

@@ -83,13 +83,19 @@ async function captureUntrackedPatch(repoRoot: string, untracked: readonly strin
 	if (untracked.length === 0) return "";
 	const nullPath = getGitNoIndexNullPath();
 	const untrackedDiffs = await Promise.all(
-		untracked.map(entry =>
-			git.diff(repoRoot, {
+		untracked.map(async entry => {
+			const absolutePath = path.join(repoRoot, entry);
+			const stat = await fs.lstat(absolutePath);
+			if (stat.isFile()) {
+				const handle = await fs.open(absolutePath, "r");
+				await handle.close();
+			}
+			return await git.diff(repoRoot, {
 				allowFailure: true,
 				binary: true,
 				noIndex: { left: nullPath, right: entry },
-			}),
-		),
+			});
+		}),
 	);
 	return untrackedDiffs.filter(diff => diff.trim()).join("\n");
 }
@@ -135,26 +141,40 @@ export async function captureBaseline(repoRoot: string): Promise<WorktreeBaselin
 	return { root, nested };
 }
 
-async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise<string> {
+async function captureRepoCurrentTree(repoDir: string): Promise<string> {
 	const currentHead = (await git.head.sha(repoDir)) ?? "";
 	const currentStaged = await git.diff(repoDir, { binary: true, cached: true });
 	const currentUnstaged = await git.diff(repoDir, { binary: true });
 	const currentUntracked = await git.ls.untracked(repoDir);
 	const currentUntrackedPatch = await captureUntrackedPatch(repoDir, currentUntracked);
+	return await writeSyntheticTree(repoDir, currentHead, [currentStaged, currentUnstaged, currentUntrackedPatch]);
+}
 
+async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise<string> {
 	const baselineTree = await writeSyntheticTree(repoDir, rb.headCommit, [rb.staged, rb.unstaged, rb.untrackedPatch]);
-	const currentTree = await writeSyntheticTree(repoDir, currentHead, [
-		currentStaged,
-		currentUnstaged,
-		currentUntrackedPatch,
-	]);
+	const currentTree = await captureRepoCurrentTree(repoDir);
 
 	return git.diff.tree(repoDir, baselineTree, currentTree, {
-		allowFailure: true,
 		binary: true,
 	});
 }
 
+/** Confirm that applying patches to the captured owner baseline exactly matches the current owner worktree. */
+export async function verifyRootPatchesApplied(
+	repoRoot: string,
+	baseline: WorktreeBaseline,
+	patches: readonly string[],
+): Promise<boolean> {
+	const baselineTree = await writeSyntheticTree(repoRoot, baseline.root.headCommit, [
+		baseline.root.staged,
+		baseline.root.unstaged,
+		baseline.root.untrackedPatch,
+	]);
+	const expectedTree = await writeSyntheticTree(repoRoot, baselineTree, patches);
+	const currentTree = await captureRepoCurrentTree(repoRoot);
+	return expectedTree === currentTree;
+}
+
 export interface NestedRepoPatch {
 	relativePath: string;
 	patch: string;
@@ -163,64 +183,123 @@ export interface NestedRepoPatch {
 export interface DeltaPatchResult {
 	rootPatch: string;
 	nestedPatches: NestedRepoPatch[];
+	captureErrors?: string[];
+}
+
+export interface RecoveryPatchBundle {
+	version: 1;
+	rootPatch: string;
+	nestedPatches: NestedRepoPatch[];
+	captureErrors?: string[];
+}
+
+function captureErrorCode(error: unknown): string {
+	const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+	return typeof code === "string" && code.length > 0 ? code : "unknown_error";
+}
+
+export function serializeRecoveryPatchBundle(delta: DeltaPatchResult): string {
+	if (delta.nestedPatches.length === 0 && !delta.captureErrors?.length) return delta.rootPatch;
+	return `${JSON.stringify({
+		version: 1,
+		rootPatch: delta.rootPatch,
+		nestedPatches: delta.nestedPatches,
+		...(delta.captureErrors?.length ? { captureErrors: delta.captureErrors } : {}),
+	} satisfies RecoveryPatchBundle)}\n`;
+}
+
+export async function verifyNestedPatchesApplied(
+	repoRoot: string,
+	baseline: WorktreeBaseline,
+	patches: readonly NestedRepoPatch[],
+): Promise<boolean> {
+	const grouped = new Map<string, string[]>();
+	for (const patch of patches) {
+		const current = grouped.get(patch.relativePath) ?? [];
+		current.push(patch.patch);
+		grouped.set(patch.relativePath, current);
+	}
+	for (const [relativePath, repoPatches] of grouped) {
+		const nestedBaseline = baseline.nested.find(entry => entry.relativePath === relativePath)?.baseline;
+		if (!nestedBaseline) return false;
+		const nestedDir = path.join(repoRoot, relativePath);
+		const baselineTree = await writeSyntheticTree(nestedDir, nestedBaseline.headCommit, [
+			nestedBaseline.staged,
+			nestedBaseline.unstaged,
+			nestedBaseline.untrackedPatch,
+		]);
+		const expectedTree = await writeSyntheticTree(nestedDir, baselineTree, repoPatches);
+		if ((await captureRepoCurrentTree(nestedDir)) !== expectedTree) return false;
+	}
+	return true;
 }
 
 export async function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult> {
 	const rootPatch = await captureRepoDeltaPatch(isolationDir, baseline.root);
 	const nestedPatches: NestedRepoPatch[] = [];
+	const captureErrors: string[] = [];
 
 	for (const { relativePath, baseline: nb } of baseline.nested) {
 		const nestedDir = path.join(isolationDir, relativePath);
 		try {
 			await fs.access(path.join(nestedDir, ".git"));
-		} catch {
-			continue;
+			const patch = await captureRepoDeltaPatch(nestedDir, nb);
+			if (patch.trim()) nestedPatches.push({ relativePath, patch });
+		} catch (error) {
+			captureErrors.push(`Nested repository capture failed (${relativePath}): ${captureErrorCode(error)}`);
 		}
-		const patch = await captureRepoDeltaPatch(nestedDir, nb);
-		if (patch.trim()) nestedPatches.push({ relativePath, patch });
 	}
 
-	return { rootPatch, nestedPatches };
+	return { rootPatch, nestedPatches, ...(captureErrors.length ? { captureErrors } : {}) };
 }
 
-/**
- * Apply nested repo patches directly to their working directories after parent merge.
- * @param commitMessage Optional async function to generate a commit message from the combined diff.
- *                      If omitted or returns null, falls back to a generic message.
- */
-export async function applyNestedPatches(
-	repoRoot: string,
-	patches: NestedRepoPatch[],
-	commitMessage?: (diff: string) => Promise<string | null>,
-): Promise<void> {
-	// Group patches by target repo to apply all at once and commit
+/** Preflight every nested delta, then roll back earlier repositories if a later apply fails. */
+export async function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[]): Promise<void> {
 	const byRepo = new Map<string, NestedRepoPatch[]>();
-	for (const p of patches) {
-		if (!p.patch.trim()) continue;
-		const group = byRepo.get(p.relativePath) ?? [];
-		group.push(p);
-		byRepo.set(p.relativePath, group);
+	for (const patch of patches) {
+		if (!patch.patch.trim()) continue;
+		const group = byRepo.get(patch.relativePath) ?? [];
+		group.push(patch);
+		byRepo.set(patch.relativePath, group);
 	}
 
-	for (const [relativePath, repoPatches] of byRepo) {
+	const prepared: Array<{ relativePath: string; nestedDir: string; combinedPatch: string }> = [];
+	for (const [relativePath, repoPatches] of [...byRepo.entries()].sort(([left], [right]) =>
+		left.localeCompare(right),
+	)) {
 		const nestedDir = path.join(repoRoot, relativePath);
 		try {
 			await fs.access(path.join(nestedDir, ".git"));
 		} catch {
-			continue;
+			throw new Error(`Nested repository is unavailable: ${relativePath}`);
 		}
-
-		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
-		for (const { patch } of repoPatches) {
-			await git.patch.applyText(nestedDir, patch);
+		const combinedPatch = git.patch.join(repoPatches.map(entry => entry.patch));
+		if (!(await git.patch.canApplyText(nestedDir, combinedPatch))) {
+			throw new Error(`Nested repository patch does not apply cleanly: ${relativePath}`);
 		}
+		prepared.push({ relativePath, nestedDir, combinedPatch });
+	}
 
-		// Commit so nested repo history reflects the task changes
-		if ((await git.status(nestedDir)).trim().length > 0) {
-			const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-			await git.stage.files(nestedDir);
-			await git.commit(nestedDir, msg);
+	const applied: typeof prepared = [];
+	try {
+		for (const entry of prepared) {
+			await git.patch.applyText(entry.nestedDir, entry.combinedPatch);
+			applied.push(entry);
+		}
+	} catch (error) {
+		const rollbackFailures: string[] = [];
+		for (const entry of applied.reverse()) {
+			try {
+				await git.patch.applyText(entry.nestedDir, entry.combinedPatch, { reverse: true });
+			} catch {
+				rollbackFailures.push(entry.relativePath);
+			}
 		}
+		const message = error instanceof Error ? error.message : String(error);
+		const rollback = rollbackFailures.length
+			? `; rollback failed for: ${rollbackFailures.join(", ")}`
+			: "; earlier nested patches were rolled back";
+		throw new Error(`Nested repository patch application failed: ${message}${rollback}`);
 	}
 }
 

package/src/tools/subagent-render.ts

@@ -182,12 +182,15 @@ function renderSubagentSnapshotBody(
 		lines.push(`  ${theme.fg("dim", `Agent: ${snapshot.agent} (${snapshot.agentSource})`)}`);
 	}
 	if (snapshot.effectiveModel) {
+		// Fast mode is a property of the tier this model runs under, so the ⚡ glyph
+		// belongs on the model line rather than the id.
+		const fastSuffix = snapshot.fastMode && theme.icon.fast ? ` ${theme.icon.fast}` : "";
 		if (snapshot.modelFellBack && snapshot.requestedModel) {
 			lines.push(
-				`  ${theme.fg("warning", `Model: ${snapshot.effectiveModel} (requested ${snapshot.requestedModel}, fell back — no credentials)`)}`,
+				`  ${theme.fg("warning", `Model: ${snapshot.effectiveModel} (requested ${snapshot.requestedModel}, fell back — no credentials)`)}${fastSuffix}`,
 			);
 		} else {
-			lines.push(`  ${theme.fg("dim", `Model: ${snapshot.effectiveModel}`)}`);
+			lines.push(`  ${theme.fg("dim", `Model: ${snapshot.effectiveModel}`)}${fastSuffix}`);
 		}
 	}
 	if (snapshot.description) lines.push(`  ${theme.fg("dim", `Description: ${snapshot.description}`)}`);

package/src/tools/subagent.ts

@@ -84,6 +84,8 @@ export interface SubagentSnapshot {
 	requestedModel?: string;
 	/** True when the requested model lacked credentials and fell back to the parent model. */
 	modelFellBack?: boolean;
+	/** True when the effective subagent provider is in fast mode. */
+	fastMode?: boolean;
 }
 
 export type SubagentAwaitOutcome = "completed" | "timed_out" | "interrupted";
@@ -698,6 +700,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		if (record.effectiveModel) fields.effectiveModel = record.effectiveModel;
 		if (record.requestedModel) fields.requestedModel = record.requestedModel;
 		if (record.modelFellBack) fields.modelFellBack = true;
+		if (record.fastMode) fields.fastMode = true;
 		return fields;
 	}
 
@@ -906,6 +909,7 @@ function canonicalizeSnapshotForSignature(snapshot: SubagentSnapshot): unknown {
 		effectiveModel: snapshot.effectiveModel ?? null,
 		requestedModel: snapshot.requestedModel ?? null,
 		modelFellBack: snapshot.modelFellBack ?? false,
+		fastMode: snapshot.fastMode ?? false,
 		// durationMs intentionally excluded (time-derived; would defeat idle gating).
 		progress: snapshot.progress ? canonicalizeProgressForSignature(snapshot.progress) : null,
 	};
@@ -933,6 +937,10 @@ function canonicalizeProgressForSignature(progress: AgentProgress): unknown {
 		cost: progress.cost,
 		modelOverride: progress.modelOverride ?? null,
 		modelSubstitutionWarning: progress.modelSubstitutionWarning ?? null,
+		// The nested task panel renders this, so it must reach the signature or a
+		// fast-mode-only change would render differently while comparing byte-identical,
+		// suppressing the very update that introduces the glyph.
+		fastMode: progress.fastMode ?? false,
 		// durationMs intentionally excluded (time-derived).
 		extractedToolData: progress.extractedToolData
 			? canonicalizeExtractedToolDataForSignature(progress.extractedToolData)

package/src/utils/git.ts

@@ -85,6 +85,7 @@ export interface PushOptions {
 export interface PatchOptions {
 	readonly cached?: boolean;
 	readonly check?: boolean;
+	readonly reverse?: boolean;
 	readonly env?: Record<string, string | undefined>;
 	readonly signal?: AbortSignal;
 }
@@ -358,6 +359,7 @@ function buildApplyArgs(patchPath: string, options: PatchOptions): string[] {
 	const args = ["apply"];
 	if (options.check) args.push("--check");
 	if (options.cached) args.push("--cached");
+	if (options.reverse) args.push("--reverse");
 	args.push("--binary", patchPath);
 	return args;
 }