@gajae-code/coding-agent 0.12.5 → 0.12.7

package/src/internal-urls/local-protocol.ts

@@ -80,10 +80,32 @@ async function listFilesRecursively(rootPath: string): Promise<string[]> {
 
 	return files.sort((a, b) => a.localeCompare(b));
 }
+function localListingLabel(file: string): string {
+	return file.replace(/[\\[\]\r\n]/g, character => {
+		switch (character) {
+			case "\r":
+				return "\\r";
+			case "\n":
+				return "\\n";
+			default:
+				return `\\${character}`;
+		}
+	});
+}
+
+function localListingHref(file: string): string {
+	return file
+		.split("/")
+		.map(component => encodeURIComponent(component).replaceAll("(", "%28").replaceAll(")", "%29"))
+		.join("/");
+}
 
 async function buildListing(url: InternalUrl, localRoot: string): Promise<InternalResource> {
 	const files = await listFilesRecursively(localRoot);
-	const listing = files.length === 0 ? "(empty)" : files.map(file => `- [${file}](local://${file})`).join("\n");
+	const listing =
+		files.length === 0
+			? "(empty)"
+			: files.map(file => `- [${localListingLabel(file)}](local://${localListingHref(file)})`).join("\n");
 	const content =
 		`# Local\n\n` +
 		`Session-scoped scratch space for large intermediate data, subagent handoffs, and reusable planning artifacts.\n\n` +
@@ -103,31 +125,30 @@ async function buildListing(url: InternalUrl, localRoot: string): Promise<Intern
 function extractRelativePath(url: InternalUrl): string {
 	const host = url.rawHost || url.hostname;
 	const pathname = url.rawPathname ?? url.pathname;
-
-	const combined = host
-		? pathname && pathname !== "/"
-			? `${host}${pathname}`
-			: host
-		: pathname && pathname !== "/"
-			? pathname.slice(1)
-			: "";
-
-	if (!combined) {
-		return "";
-	}
-
-	let decoded: string;
+	const encodedAuthority = /^local:\/\/([^/?#]*)/i.exec(url.href)?.[1] ?? "";
+	const validatedHost = host;
+	let decodedPathname = pathname;
 	try {
-		decoded = decodeURIComponent(combined.replaceAll("\\", "/"));
+		const decodedAuthority = decodeURIComponent(encodedAuthority);
+		if (host && decodedAuthority !== host) throw new Error("authority_mismatch");
+		decodedPathname = decodeURIComponent(pathname.replaceAll("\\", "/"));
 	} catch {
 		throw new Error(`Invalid URL encoding in local:// path: ${url.href}`);
 	}
+	const combined = validatedHost
+		? decodedPathname && decodedPathname !== "/"
+			? `${validatedHost}${decodedPathname}`
+			: validatedHost
+		: decodedPathname && decodedPathname !== "/"
+			? decodedPathname.slice(1)
+			: "";
+	if (!combined) return "";
 	try {
-		validateRelativePath(decoded);
+		validateRelativePath(combined);
 	} catch (error) {
 		throw toLocalValidationError(error);
 	}
-	return decoded;
+	return combined;
 }
 
 function safeSessionId(options: LocalProtocolOptions): string {

package/src/modes/acp/acp-agent.ts

@@ -718,6 +718,7 @@ export class AcpAgent implements Agent {
 	readonly #resolvingExisting = new Map<string, PendingAttachment>();
 	readonly #knownSessionCwds = new Map<string, string>();
 	readonly #knownSessionMetadata = new Map<string, { title?: string; updatedAt?: string }>();
+	readonly #pendingDeleteLocators = new Map<string, { cwd: string; path: string }>();
 	readonly #pendingCloseIdempotencyKeys = new Map<string, string>();
 	readonly #sessionEpochs = new Map<string, number>();
 	readonly #tearingDown = new Map<string, number>();
@@ -918,24 +919,35 @@ export class AcpAgent implements Agent {
 
 	async deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse> {
 		const record = this.#sessions.get(params.sessionId);
-		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId);
-		// ACP's delete request has no cwd. Only delete sessions this connection has
-		// already scoped through the broker; unknown ids remain the protocol no-op.
-		if (!cwd) return {};
+		const pendingLocator = this.#pendingDeleteLocators.get(params.sessionId);
+		const cwd = record?.cwd ?? this.#knownSessionCwds.get(params.sessionId) ?? pendingLocator?.cwd;
+		// ACP's delete request has no cwd. Unknown ids remain the protocol no-op,
+		// while the broker can reconstruct an authenticated pending locator from its durable ledger.
+		if (!cwd) {
+			await (await this.#brokerAdapter()).global(
+				"session.delete",
+				{ sessionId: params.sessionId },
+				this.#lifecycleIdempotencyKey(params.sessionId, "session.delete"),
+			);
+			return {};
+		}
 		this.#beginTeardown(params.sessionId);
 		try {
 			await this.#teardownSession(params.sessionId, "deleted", true);
-			let saved: string;
-			try {
-				saved = await this.#resolveSavedSession(params.sessionId, cwd);
-			} catch (error) {
-				if (error instanceof AcpSdkAdapterError && error.code === "not_found") {
-					this.#knownSessionCwds.delete(params.sessionId);
-					this.#knownSessionMetadata.delete(params.sessionId);
-					return {};
+			let saved = pendingLocator?.cwd === cwd ? pendingLocator.path : undefined;
+			if (!saved) {
+				try {
+					saved = await this.#resolveSavedSession(params.sessionId, cwd);
+				} catch (error) {
+					if (error instanceof AcpSdkAdapterError && error.code === "not_found") {
+						this.#knownSessionCwds.delete(params.sessionId);
+						this.#knownSessionMetadata.delete(params.sessionId);
+						return {};
+					}
+					throw error;
 				}
-				throw error;
 			}
+			this.#pendingDeleteLocators.set(params.sessionId, { cwd, path: saved });
 			await (await this.#brokerAdapter()).global(
 				"session.delete",
 				{ sessionId: params.sessionId, sessionPath: saved, cwd, target: { path: cwd } },
@@ -943,6 +955,7 @@ export class AcpAgent implements Agent {
 			);
 			this.#knownSessionCwds.delete(params.sessionId);
 			this.#knownSessionMetadata.delete(params.sessionId);
+			this.#pendingDeleteLocators.delete(params.sessionId);
 			return {};
 		} finally {
 			this.#finishTeardown(params.sessionId);
@@ -2168,6 +2181,7 @@ export class AcpAgent implements Agent {
 		this.#resolvingExisting.clear();
 		this.#knownSessionCwds.clear();
 		this.#knownSessionMetadata.clear();
+		this.#pendingDeleteLocators.clear();
 		this.#pendingCloseIdempotencyKeys.clear();
 		if (this.#closing.size === 0) this.#closing.clear();
 		this.#tearingDown.clear();

package/src/modes/components/gjc-bundle-settings.ts

@@ -56,6 +56,7 @@ export interface GjcBundleSettingsDependencies {
 export interface GjcBundleSettingsCallbacks {
 	onClose: () => void;
 	onBundlesChanged?: () => void;
+	onRenderRequested?: () => void;
 }
 
 export type GjcBundleSettingsState =
@@ -187,6 +188,7 @@ export class GjcBundleSettingsComponent extends Container {
 			),
 		);
 		this.addChild(new DynamicBorder());
+		this.callbacks.onRenderRequested?.();
 	}
 
 	#renderList(): void {

package/src/modes/components/plugin-settings.ts

@@ -127,6 +127,7 @@ export interface PluginDetailCallbacks {
 	onFeatureChange: (feature: string, enabled: boolean) => void;
 	onConfigChange: (key: string, value: unknown) => void;
 	onBack: () => void;
+	onRenderRequested?: () => void;
 }
 
 /**
@@ -288,6 +289,7 @@ export class PluginDetailComponent extends Container {
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.fg("dim", "  Enter to edit · Esc to go back"), 0, 0));
 		this.addChild(new DynamicBorder());
+		this.callbacks.onRenderRequested?.();
 	}
 
 	handleInput(data: string): void {
@@ -409,6 +411,7 @@ class ConfigInputSubmenu extends Container {
 export interface PluginSettingsCallbacks {
 	onClose: () => void;
 	onPluginChanged: () => void;
+	onRenderRequested?: () => void;
 }
 
 /** Component with handleInput method */
@@ -450,6 +453,7 @@ export class PluginSettingsComponent extends Container {
 		});
 
 		this.addChild(this.#viewComponent);
+		this.callbacks.onRenderRequested?.();
 	}
 
 	#showPluginDetail(plugin: InstalledPlugin): void {
@@ -477,6 +481,7 @@ export class PluginSettingsComponent extends Container {
 				this.callbacks.onPluginChanged();
 			},
 			onBack: () => this.#showPluginList(),
+			onRenderRequested: () => this.callbacks.onRenderRequested?.(),
 		});
 
 		this.addChild(this.#viewComponent);

package/src/modes/components/settings-selector.ts

@@ -719,6 +719,8 @@ export interface SettingsCallbacks {
 	getStatusLinePreview?: (width?: number) => string;
 	/** Called when plugins change */
 	onPluginsChanged?: () => void;
+	/** Called when asynchronously rebuilt settings content needs a repaint. */
+	onRenderRequested?: () => void;
 	/** Called when an interactive setting cannot be committed. */
 	onError?: (message: string) => void;
 	/** Called when settings panel is closed */
@@ -1287,6 +1289,7 @@ export class SettingsSelectorComponent extends Container {
 		this.#pluginComponent = new PluginSettingsComponent(this.context.cwd, {
 			onClose: () => this.callbacks.onCancel(),
 			onPluginChanged: () => this.callbacks.onPluginsChanged?.(),
+			onRenderRequested: () => this.callbacks.onRenderRequested?.(),
 		});
 		this.addChild(this.#pluginComponent);
 	}
@@ -1296,6 +1299,7 @@ export class SettingsSelectorComponent extends Container {
 			{
 				onClose: () => this.callbacks.onCancel(),
 				onBundlesChanged: () => this.callbacks.onPluginsChanged?.(),
+				onRenderRequested: () => this.callbacks.onRenderRequested?.(),
 			},
 			{
 				runtimeSnapshotProvider: this.context.gjcRuntimeSnapshot,

package/src/modes/controllers/selector-controller.ts

@@ -1334,6 +1334,7 @@ export class SelectorController {
 						onPluginsChanged: () => {
 							this.ctx.ui.requestRender();
 						},
+						onRenderRequested: () => this.ctx.ui.requestRender(),
 						onCancel: () => {
 							done();
 							// Restore status line to saved settings

package/src/prompts/tools/monitor.md

@@ -1,8 +1,8 @@
-Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you're waiting for the user to answer a question.
+Start a background monitor that streams events from a long-running script. Each stdout line is captured; persistent notifications are latest-biased and coalesced over a short debounce window, while terminal completion flushes the newest pending line. Events arrive on their own schedule and are not replies from the user, even if one lands while you're waiting for the user to answer a question.
 
 Pick by how many notifications you need:
 - **One** ("tell me when the server is ready / the build finishes") → use `bash` with `async: true`. That returns a single completion notification when the command exits.
-- **Many ongoing events** (logs, polling, file watching) → use `monitor`. The script keeps running and every new line of stdout becomes one event delivered into the conversation between turns.
+- **Many ongoing events** (logs, polling, file watching) → use `monitor`. The script keeps running and new stdout is captured; persistent notifications are coalesced so ordinary log traffic does not create one model turn per line.
 
 `monitor` uses the same permission rules as `bash`. To stop a monitor, cancel its background task via `job` with the returned `task_id`, or end the session.
 
@@ -15,7 +15,7 @@ Pick by how many notifications you need:
 
 ## Inputs
 
-- `command` (required): shell command to run as a background monitor. Each stdout line is delivered as a separate task-notification event.
+- `command` (required): shell command to run as a background monitor. Stdout is captured line-by-line; persistent notifications are coalesced before delivery.
 - `kind` (required): one of `"log"`, `"poll"`, `"watch"`, `"other"`. Describes the monitoring strategy so listings can surface useful categories.
 - `description` (required): short human-readable description of what is being monitored. Appears in task listings.
 - `timeout` (optional): maximum wall-clock seconds the monitor may run before automatic shutdown. Omit for the session lifetime.
@@ -23,7 +23,7 @@ Pick by how many notifications you need:
 
 ## Output
 
-Returns `Monitor started · task <task_id>` plus a task entry visible via `job({list: true})`. Each stdout line of the monitored command becomes a `<task-notification>` event delivered between turns.
+Returns `Monitor started · task <task_id>` plus a task entry visible via `job({list: true})`. Persistent notifications contain the latest line and the count of earlier coalesced lines; terminal completion flushes the newest pending line.
 
 ## Cancellation
 

package/src/sdk/broker/broker.ts

@@ -24,7 +24,7 @@ import {
 	redactBrokerDiscovery,
 } from "./discovery";
 import { deriveIdempotencyIdentity } from "./identity";
-import { executeLifecycle, isCanonicalSessionId } from "./lifecycle";
+import { canonicalDeleteLocatorPath, executeLifecycle, isCanonicalSessionId } from "./lifecycle";
 
 import {
 	type LifecycleDurableEffectsReceipt,
@@ -71,6 +71,7 @@ export type BrokerErrorCode =
 export type BrokerCleanupIdentity = {
 	dev: string;
 	ino: string;
+	nlink?: string;
 	size: number;
 	mtimeNs: string;
 	sha256: string;
@@ -102,6 +103,7 @@ export type BrokerArtifactTree = {
 
 export type BrokerCleanupEvidence = {
 	phase: "artifacts" | "transcript" | "metadata" | "lifecycle";
+	cleanupReceiptVersion?: 1;
 	/** Ledger-bound deletion target; never reconstructed from a retry request. */
 	sessionsRoot?: string;
 	transcriptPath?: string;
@@ -110,6 +112,7 @@ export type BrokerCleanupEvidence = {
 	sessionId?: string;
 	artifactsIdentity?: BrokerCleanupIdentity;
 	transcriptIdentity?: BrokerCleanupIdentity;
+	transcriptParentIdentity?: { dev: string; ino: string };
 	/** Identity-bound lifecycle metadata marker retained when exact cleanup is deferred. */
 	metadataIdentity?: BrokerCleanupIdentity;
 	metadataPath?: string;
@@ -122,9 +125,17 @@ export type BrokerCleanupEvidence = {
 	/** Append-only terminal proof for lifecycle metadata cleanup. */
 	metadataCompleted?: true;
 	detachedArtifactsPath?: string;
+	retainedArtifactsSuccessorPath?: string;
+	retainedArtifactsPlaceholderPath?: string;
+	retainedArtifactsUnknownPath?: string;
+	retainedArtifactsSideAuthority?: "none" | "retained";
 	detachedTranscriptPath?: string;
+	retainedTranscriptSuccessorPath?: string;
+	retainedTranscriptPlaceholderPath?: string;
+	retainedTranscriptUnknownPath?: string;
 	/** Durable proof that artifact cleanup completed before transcript mutation. */
 	artifactsRemoved?: boolean;
+	artifactsAbsentAtAuthorization?: true;
 	/** Preauthorized no-replace artifact quarantine path persisted before detach. */
 	plannedArtifactsPath?: string;
 	/** Identity-bound artifact tree authority persisted before broker detach and replayed exactly. */
@@ -133,6 +144,7 @@ export type BrokerCleanupEvidence = {
 	plannedTranscriptPath?: string;
 	/** Fully identity-bound startup-failure cleanup plan, persisted before any detach. */
 	lifecycleFiles?: BrokerLifecycleCleanupFile[];
+	lifecycleParentIdentity?: { dev: string; ino: string };
 	/** Delete metadata receipts authorize only the canonical marker/ready sibling pair. */
 	lifecycleDeleteMetadata?: true;
 };
@@ -157,6 +169,14 @@ function isCleanupPending(response: BrokerResponse): boolean {
 	return !response.ok && response.error.code === "cleanup_pending" && response.error.cleanup !== undefined;
 }
 
+function cleanupFromResponse(response: unknown): BrokerCleanupEvidence | undefined {
+	return isBrokerResponse(response) && !response.ok ? response.error.cleanup : undefined;
+}
+function pendingCleanupSessionId(response: BrokerResponse): string | undefined {
+	if (response.ok || response.error.code !== "cleanup_pending") return undefined;
+	return typeof response.error.cleanup?.sessionId === "string" ? response.error.cleanup.sessionId : undefined;
+}
+
 function lifecycleResponseState(response: BrokerResponse): LifecycleState {
 	if (response.ok) return "terminal_ok";
 	if (isCleanupPending(response)) return "effect_started";
@@ -165,8 +185,8 @@ function lifecycleResponseState(response: BrokerResponse): LifecycleState {
 
 type InputNormalization = { input: Record<string, unknown> } | BrokerResponse;
 
-function isBrokerResponse(value: InputNormalization): value is BrokerResponse {
-	return "ok" in value;
+function isBrokerResponse(value: unknown): value is BrokerResponse {
+	return typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean";
 }
 
 function normalizeAliasedString(
@@ -224,11 +244,12 @@ function normalizeBrokerInput(operation: string, input: Record<string, unknown>)
 		typeof input.target === "object" && input.target !== null && !Array.isArray(input.target)
 			? (input.target as Record<string, unknown>)
 			: undefined;
+	const normalizeLifecycleDirectory = operation === "session.delete" ? canonicalDeleteLocatorPath : path.resolve;
 	const cwd = normalizeAliasedString(
 		{ cwd: input.cwd, path: input.path, targetPath: target?.path },
 		"cwd",
 		["path", "targetPath"],
-		value => path.resolve(value),
+		normalizeLifecycleDirectory,
 	);
 	if (cwd.error) return error("invalid_input", cwd.error);
 	if (cwd.value !== undefined) {
@@ -239,7 +260,7 @@ function normalizeBrokerInput(operation: string, input: Record<string, unknown>)
 		{ stateRoot: input.stateRoot, targetStateRoot: target?.stateRoot },
 		"stateRoot",
 		["targetStateRoot"],
-		value => path.resolve(value),
+		normalizeLifecycleDirectory,
 	);
 	if (stateRoot.error) return error("invalid_input", stateRoot.error);
 	if (stateRoot.value !== undefined && (!cwd.value || stateRoot.value !== path.join(cwd.value, ".gjc", "state")))
@@ -254,6 +275,11 @@ function normalizeBrokerInput(operation: string, input: Record<string, unknown>)
 		if (Object.keys(normalizedTarget).length > 0) normalized.target = normalizedTarget;
 		else delete normalized.target;
 	}
+	if (operation === "session.delete") {
+		const sessionPath = normalizeAliasedString(input, "sessionPath", [], canonicalDeleteLocatorPath);
+		if (sessionPath.error) return error("invalid_input", sessionPath.error);
+		if (sessionPath.value !== undefined) normalized.sessionPath = sessionPath.value;
+	}
 	return { input: normalized };
 }
 function canonicalJson(value: unknown): string {
@@ -798,7 +824,61 @@ export class Broker {
 			.update(canonicalJson(lifecycleTarget(operation, input)))
 			.digest("hex");
 		const identity = await deriveIdempotencyIdentity(this.settings.agentDir, operation, idempotencyKey, target);
-		const requestHash = createHash("sha256").update(canonicalJson({ operation, input })).digest("hex");
+		let reconstructedDeleteCleanup: BrokerCleanupEvidence | undefined;
+		if (operation === "session.delete" && input.cwd === undefined && input.sessionPath === undefined) {
+			const entry = this.ledger.get(identity);
+			const cleanup = cleanupFromResponse(entry?.response) ?? cleanupFromResponse(entry?.unresolvedCleanupResponse);
+			reconstructedDeleteCleanup = cleanup;
+			const requestedSessionId = typeof input.sessionId === "string" ? input.sessionId : undefined;
+			if (!cleanup) {
+				if (requestedSessionId && this.ledger.hasUncertainCleanupForSession(requestedSessionId, identity))
+					return error(
+						"terminal_uncertain",
+						"Session cleanup authority is uncertain and cannot be deleted safely",
+					);
+				const pending = requestedSessionId
+					? this.ledger.findCleanupPendingBySessionId(requestedSessionId, identity)
+					: undefined;
+				if (pending) {
+					const pendingResponse = cleanupFromResponse(pending.response)
+						? pending.response
+						: pending.unresolvedCleanupResponse;
+					if (isBrokerResponse(pendingResponse)) return pendingResponse;
+					return error(
+						"terminal_uncertain",
+						"Session cleanup authority is pending under another lifecycle identity",
+					);
+				}
+				if (entry) {
+					if (isBrokerResponse(entry.response)) return entry.response;
+					return error("terminal_uncertain", "Existing session.delete ledger evidence lacks replayable authority");
+				}
+				if (requestedSessionId) {
+					await this.index.refresh();
+					if (this.index.listSessions().sessions.some(session => session.sessionId === requestedSessionId))
+						return error(
+							"terminal_uncertain",
+							"Indexed session requires durable locator authority before deletion",
+						);
+				}
+				return { ok: true, result: requestedSessionId ? { sessionId: requestedSessionId } : undefined };
+			}
+			if (
+				cleanup &&
+				cleanup.sessionId === requestedSessionId &&
+				typeof cleanup.cwd === "string" &&
+				typeof cleanup.transcriptPath === "string"
+			)
+				input = {
+					sessionId: cleanup.sessionId,
+					cwd: cleanup.cwd,
+					stateRoot: path.join(cleanup.cwd, ".gjc", "state"),
+					sessionPath: cleanup.transcriptPath,
+				};
+		}
+		const storedRequestHash = reconstructedDeleteCleanup ? this.ledger.get(identity)?.requestHash : undefined;
+		const requestHash =
+			storedRequestHash ?? createHash("sha256").update(canonicalJson({ operation, input })).digest("hex");
 		const prev = this.#chains.get(target) ?? Promise.resolve();
 		let release!: () => void;
 		const current = new Promise<void>(resolve => (release = resolve));
@@ -812,8 +892,8 @@ export class Broker {
 			const begun = await this.ledger.begin(identity, requestHash);
 			if (begun.kind === "replay") {
 				const replay = begun.entry.response as BrokerResponse;
-				if (!(!replay.ok && replay.error.cleanup)) return replay;
-				const cleanup = replay.error.cleanup;
+				const cleanup = cleanupFromResponse(replay) ?? reconstructedDeleteCleanup;
+				if (!cleanup) return replay;
 				const outcome = await executeLifecycle(this, operation, input, identity, cleanup);
 				const response = outcome.response;
 				await this.ledger.transition(identity, lifecycleResponseState(response), {
@@ -828,11 +908,13 @@ export class Broker {
 				return error("idempotency_conflict", "idempotency key was used with a different request");
 			if (begun.kind === "terminal_uncertain") {
 				const replay = (begun.entry.response ?? beforeBegin?.response) as BrokerResponse | undefined;
-				if (!replay || replay.ok || !replay.error.cleanup)
+				const cleanup = (replay ? cleanupFromResponse(replay) : undefined) ?? reconstructedDeleteCleanup;
+				if (!cleanup)
 					return replay ?? error("terminal_uncertain", "prior lifecycle operation outcome is uncertain");
-				const outcome = await executeLifecycle(this, operation, input, identity, replay.error.cleanup);
+				const outcome = await executeLifecycle(this, operation, input, identity, cleanup);
 				const response = outcome.response;
 				await this.ledger.transition(identity, lifecycleResponseState(response), {
+					...(pendingCleanupSessionId(response) ? { intendedSessionId: pendingCleanupSessionId(response) } : {}),
 					response,
 					responseDigest: createHash("sha256").update(canonicalJson(response)).digest("hex"),
 					...(outcome.durableEffects ? { durableEffects: outcome.durableEffects } : {}),
@@ -844,6 +926,7 @@ export class Broker {
 			const outcome = await executeLifecycle(this, operation, input, identity);
 			const response = outcome.response;
 			await this.ledger.transition(identity, lifecycleResponseState(response), {
+				...(pendingCleanupSessionId(response) ? { intendedSessionId: pendingCleanupSessionId(response) } : {}),
 				resultSessionId:
 					response.ok && typeof (response.result as { sessionId?: unknown } | undefined)?.sessionId === "string"
 						? (response.result as { sessionId: string }).sessionId