@gajae-code/coding-agent 0.14.0 → 0.14.1

package/src/modes/components/tool-execution.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@gajae-code/agent-core";
+import { type AgentTool, isToolFailureEnvelope } from "@gajae-code/agent-core";
 import {
 	type AnimationRegistration,
 	Box,
@@ -201,6 +201,7 @@ export interface ToolExecutionHandle {
 export class ToolExecutionComponent extends Container {
 	#contentBox: Box; // Used for custom tools and bash visual truncation
 	#contentText: Text; // For built-in tools (with its own padding/bg)
+	#usesContentBox: boolean; // Which of the two the constructor put in the tree
 	#multiFileBoxes: (Box | Spacer)[] = []; // Extra boxes for multi-file edit results
 	#imageComponents: Image[] = [];
 	#imageSpacers: Spacer[] = [];
@@ -299,7 +300,8 @@ export class ToolExecutionComponent extends Container {
 		// Use Box for custom tools or built-in tools that have renderers
 		const hasRenderer = toolName in toolRenderers;
 		const hasCustomRenderer = !!(tool?.renderCall || tool?.renderResult);
-		if (hasCustomRenderer || hasRenderer) {
+		this.#usesContentBox = hasCustomRenderer || hasRenderer;
+		if (this.#usesContentBox) {
 			this.addChild(this.#contentBox);
 		} else {
 			this.addChild(this.#contentText);
@@ -639,8 +641,26 @@ export class ToolExecutionComponent extends Container {
 		this.#renderState.isPartial = this.#isPartial;
 		this.#renderState.spinnerFrame = this.#spinnerFrame;
 
-		// Check for custom tool rendering
-		if (this.#tool && (this.#tool.renderCall || this.#tool.renderResult)) {
+		// A call the loop rejected carries the loop's failure envelope in place of the
+		// tool's own details. A renderer owns only its own detail shape, so handing it
+		// the envelope either throws — leaving the TUI's bare `[render error: Box]`
+		// fallback line — or paints the tool's own card while the rejection reason is
+		// dropped. The reason is the only content left, so render it the way a tool
+		// without a renderer already reports failure.
+		if (this.#usesContentBox && this.#result?.isError && isToolFailureEnvelope(this.#result.details)) {
+			for (const box of this.#multiFileBoxes) {
+				this.removeChild(box);
+			}
+			this.#multiFileBoxes = [];
+			this.#contentBox.setBgFn(bgFn);
+			this.#contentBox.clear();
+			this.#contentBox.addChild(new Text(renderStatusLine({ icon: "error", title: this.#toolLabel }, theme), 0, 0));
+			const reason = this.#getTextOutput().trimEnd();
+			if (reason) {
+				this.#contentBox.addChild(new Text(theme.fg("toolOutput", replaceTabs(reason)), 0, 0));
+			}
+		} else if (this.#tool && (this.#tool.renderCall || this.#tool.renderResult)) {
+			// Custom tool rendering
 			const tool = this.#tool;
 			const mergeCallAndResult = Boolean((tool as { mergeCallAndResult?: boolean }).mergeCallAndResult);
 			// Custom tools use Box for flexible component rendering

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

@@ -398,7 +398,7 @@ export class CommandController {
 			const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
 			for (let j = toolCalls.length - 1; j >= 0; j--) {
 				const tc = toolCalls[j];
-				if (tc.name === "bash" && typeof tc.arguments.command === "string") {
+				if (tc.name === "bash" && typeof tc.arguments?.command === "string") {
 					this.#doCopy(tc.arguments.command, "Copied last bash command to clipboard");
 					return;
 				}
@@ -629,7 +629,9 @@ export class CommandController {
 		if (!usageReports) {
 			const provider = this.ctx.session as { fetchUsageReports?: () => Promise<UsageReport[] | null> };
 			if (!provider.fetchUsageReports) {
-				this.ctx.showWarning("Usage reporting is not configured for this session.");
+				this.ctx.showWarning(
+					"Usage reporting is not configured for this session: no provider exposes usage limits here.",
+				);
 				return;
 			}
 			try {
@@ -641,7 +643,9 @@ export class CommandController {
 		}
 
 		if (!usageReports || usageReports.length === 0) {
-			this.ctx.showWarning("No usage data available.");
+			this.ctx.showWarning(
+				"No usage data available: the configured providers reported no limits. Subscription/OAuth credentials report limits; plain API keys usually do not.",
+			);
 			return;
 		}
 
@@ -1604,6 +1608,39 @@ function formatUnlimitedReportLabel(report: UsageReport, reportIndex: number): s
 	return `account ${reportIndex + 1}`;
 }
 
+/**
+ * Two-unit countdown for usage windows. `formatDuration` collapses everything
+ * past 48h to a single rounded unit, so a weekly window reads `7d` whether 6.6
+ * or 7.4 days remain — useless when the question is "how long until I get my
+ * quota back". Kept local to the usage panel so job/elapsed rendering keeps the
+ * coarse label.
+ */
+function formatResetCountdown(ms: number): string {
+	const totalMinutes = Math.max(0, Math.floor(ms / 60_000));
+	if (totalMinutes < 1) return "<1m";
+	if (totalMinutes < 60) return `${totalMinutes}m`;
+	const totalHours = Math.floor(totalMinutes / 60);
+	if (totalHours < 48) {
+		const minutes = totalMinutes % 60;
+		return minutes > 0 ? `${totalHours}h ${minutes}m` : `${totalHours}h`;
+	}
+	const days = Math.floor(totalHours / 24);
+	const hours = totalHours % 24;
+	return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+}
+
+/** Absolute local reset time, so a long countdown maps onto a real calendar day. */
+function formatResetAt(resetsAt: number, nowMs: number): string {
+	const date = new Date(resetsAt);
+	const withinADay = resetsAt - nowMs < 24 * 3_600_000;
+	return date.toLocaleString(undefined, {
+		month: withinADay ? undefined : "short",
+		day: withinADay ? undefined : "numeric",
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+}
+
 function formatResetShort(limit: UsageLimit, nowMs: number): string | undefined {
 	if (limit.window?.resetsAt !== undefined) {
 		return formatDuration(limit.window.resetsAt - nowMs);
@@ -1611,6 +1648,61 @@ function formatResetShort(limit: UsageLimit, nowMs: number): string | undefined
 	return undefined;
 }
 
+/** Squeeze a label from the middle, keeping both ends. */
+function squeezeMiddle(label: string, maxWidth: number): string {
+	if (visibleWidth(label) <= maxWidth) return label;
+	if (maxWidth <= 3) return truncateJobLabel(label, maxWidth);
+	const chars = [...label];
+	const headBudget = Math.ceil((maxWidth - 1) / 2);
+	const tailBudget = maxWidth - 1 - headBudget;
+	let head = "";
+	for (const char of chars) {
+		if (visibleWidth(head + char) > headBudget) break;
+		head += char;
+	}
+	let tail = "";
+	for (let index = chars.length - 1; index >= 0; index--) {
+		const next = chars[index]! + tail;
+		if (visibleWidth(next) > tailBudget) break;
+		tail = next;
+	}
+	return `${head}…${tail}`;
+}
+
+function accountLocalPart(label: string): string {
+	const at = label.lastIndexOf("@");
+	return at > 0 ? label.slice(0, at) : label;
+}
+
+/**
+ * Fit account labels into `maxWidth` while keeping them mutually
+ * distinguishable. Credentials pooled on one provider share a domain and often
+ * a prefix, so truncating each label in isolation collapses every column into
+ * the same stub — which defeats the only reason the panel shows accounts at
+ * all. Try progressively cheaper representations and keep the first one that is
+ * still unique; if nothing is, tag the columns with an index so the rows can at
+ * least be told apart.
+ */
+function truncateAccountLabels(labels: string[], maxWidth: number): string[] {
+	const distinctInput = new Set(labels).size;
+	const strategies: ((label: string) => string)[] = [
+		label => label,
+		label => accountLocalPart(label),
+		label => truncateJobLabel(accountLocalPart(label), maxWidth),
+		label => squeezeMiddle(accountLocalPart(label), maxWidth),
+	];
+	for (const strategy of strategies) {
+		const candidate = labels.map(strategy);
+		const fits = candidate.every(entry => visibleWidth(entry) <= maxWidth);
+		if (fits && new Set(candidate).size === distinctInput) return candidate;
+	}
+	return labels.map((label, index) => {
+		const tag = `#${index + 1}`;
+		const budget = Math.max(1, maxWidth - visibleWidth(tag));
+		return `${truncateJobLabel(accountLocalPart(label), budget)}${tag}`;
+	});
+}
+
 function formatAccountHeaderRow(
 	limits: UsageLimit[],
 	reports: UsageReport[],
@@ -1638,9 +1730,13 @@ function formatAccountHeaderRow(
 		});
 	}
 
-	return parts.map(p => {
-		const prefix = truncateJobLabel(p.label, prefixBudget);
-		const prefixCell = prefix + " ".repeat(prefixBudget - visibleWidth(prefix));
+	const prefixes = truncateAccountLabels(
+		parts.map(p => p.label),
+		prefixBudget,
+	);
+	return parts.map((p, index) => {
+		const prefix = prefixes[index]!;
+		const prefixCell = prefix + " ".repeat(Math.max(0, prefixBudget - visibleWidth(prefix)));
 		if (!p.suffix) return prefixCell + " ".repeat(maxSuffixWidth + gap);
 		const suffixPad = " ".repeat(maxSuffixWidth - visibleWidth(p.suffix));
 		return `${prefixCell} ${suffixPad}${uiTheme.fg("dim", p.suffix)}`;
@@ -1688,18 +1784,24 @@ function formatAggregateAmount(limits: UsageLimit[]): string {
 	return `${limits.length} accts`;
 }
 
+/**
+ * Reset line for one window. Renders a range when the accounts in the window
+ * reset at materially different times, and pins the earliest reset to an
+ * absolute local time so "when do I get my quota back" is answerable without
+ * doing date arithmetic in your head.
+ */
 function resolveResetRange(limits: UsageLimit[], nowMs: number): string | null {
 	const absolute = limits
 		.map(limit => limit.window?.resetsAt)
 		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
 	if (absolute.length === 0) return null;
-	const offsets = absolute.map(value => value - nowMs);
-	const minReset = Math.min(...offsets);
-	const maxReset = Math.max(...offsets);
-	if (maxReset - minReset > 60_000) {
-		return `resets in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
+	const earliest = Math.min(...absolute);
+	const latest = Math.max(...absolute);
+	const at = formatResetAt(earliest, nowMs);
+	if (latest - earliest > 60_000) {
+		return `resets in ${formatResetCountdown(earliest - nowMs)}–${formatResetCountdown(latest - nowMs)} (first ${at})`;
 	}
-	return `resets in ${formatDuration(minReset)}`;
+	return `resets in ${formatResetCountdown(earliest - nowMs)} (${at})`;
 }
 
 function resolveStatusIcon(status: UsageLimit["status"], uiTheme: typeof theme): string {
@@ -1868,7 +1970,7 @@ export function renderUsageReports(
 				padColumn(renderUsageBar(limit, uiTheme, sectionColumnWidth), sectionColumnWidth),
 			);
 			lines.push(`  ${bars.join(" ")} ${amountText}`.trimEnd());
-			const resetText = sortedLimits.length <= 1 ? resolveResetRange(sortedLimits, nowMs) : null;
+			const resetText = resolveResetRange(sortedLimits, nowMs);
 			if (resetText) {
 				lines.push(`  ${uiTheme.fg("dim", resetText)}`.trimEnd());
 			}

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

@@ -315,6 +315,10 @@ export class InputController {
 		return this.ctx.keybindings.getKeys("app.interrupt").some(key => matchesKey(data, key));
 	}
 
+	#matchesClearKey(data: string): boolean {
+		return this.ctx.keybindings.getKeys("app.clear").some(key => matchesKey(data, key));
+	}
+
 	#hasHookDialog(): boolean {
 		return Boolean(this.ctx.hookSelector || this.ctx.hookInput || this.ctx.hookEditor);
 	}
@@ -327,12 +331,25 @@ export class InputController {
 		);
 	}
 
+	#handlePendingSteerInterrupt(): boolean {
+		if (!this.#steerConsumePending) return false;
+		this.#resetEscapeGestures();
+		if (!this.ctx.session.hasQueuedSteering) {
+			this.#steerConsumePending = false;
+			return false;
+		}
+
+		this.#steerConsumePending = false;
+		this.restoreQueuedMessagesToEditor({ abort: true });
+		return true;
+	}
+
 	#handleCancellableWorkEscape(options: {
 		loading?: boolean;
 		processes?: boolean;
 		modes?: boolean;
 		maintenance?: boolean;
-		retry?: boolean;
+		retry?: "escape" | "clear";
 		streaming?: boolean;
 	}): boolean {
 		if (options.loading && this.ctx.loadingAnimation) {
@@ -376,7 +393,7 @@ export class InputController {
 		}
 		if (options.retry) {
 			if (this.#isRetryBackoffActive()) {
-				if (this.ctx.retryEscapePrimed) {
+				if (options.retry === "clear" || this.ctx.retryEscapePrimed) {
 					this.ctx.session.abortRetry();
 				} else {
 					this.ctx.retryEscapePrimed = true;
@@ -407,9 +424,36 @@ export class InputController {
 		}
 		this.#globalInterruptUnsubscribe?.();
 		this.#globalInterruptUnsubscribe = this.ctx.ui.addInputListener(data => {
-			if (!this.#matchesInterruptKey(data)) {
+			const isInterruptKey = this.#matchesInterruptKey(data);
+			const isClearKey = this.#matchesClearKey(data);
+			if (!isInterruptKey && !isClearKey) {
+				return undefined;
+			}
+			if (isClearKey && !isInterruptKey && this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
+				this.#resetEscapeGestures();
+				return { consume: true };
+			}
+			if (isClearKey && !isInterruptKey && this.ctx.hookSelector?.hasActiveInlineInput?.() === true) {
+				this.#resetEscapeGestures();
 				return undefined;
 			}
+			if (isClearKey && !isInterruptKey) {
+				if (this.#handlePendingSteerInterrupt()) return { consume: true };
+				if (
+					!this.#handleCancellableWorkEscape({
+						loading: true,
+						processes: true,
+						modes: true,
+						maintenance: true,
+						retry: "clear",
+						streaming: true,
+					})
+				) {
+					return undefined;
+				}
+				this.#resetEscapeGestures();
+				return { consume: true };
+			}
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				this.#resetEscapeGestures();
 				return { consume: true };
@@ -428,7 +472,7 @@ export class InputController {
 					processes: hookDialogActive,
 					modes: false,
 					maintenance: true,
-					retry: true,
+					retry: "escape",
 					streaming: hookDialogActive,
 				})
 			) {
@@ -492,19 +536,8 @@ export class InputController {
 				this.#resetEscapeGestures();
 				return;
 			}
-			if (this.#steerConsumePending) {
-				this.#resetEscapeGestures();
-				if (this.ctx.session.hasQueuedSteering) {
-					// Second Esc before the scheduled steer continuation drains the
-					// queue: restore/drop the queued steer and perform a real abort,
-					// even if abort cleanup already made the session look idle.
-					this.#steerConsumePending = false;
-					this.restoreQueuedMessagesToEditor({ abort: true });
-					return;
-				}
-				this.#steerConsumePending = false;
-			}
-			if (this.#handleCancellableWorkEscape({ maintenance: true, retry: true })) {
+			if (this.#handlePendingSteerInterrupt()) return;
+			if (this.#handleCancellableWorkEscape({ maintenance: true, retry: "escape" })) {
 				this.#resetEscapeGestures();
 				return;
 			}
@@ -514,7 +547,7 @@ export class InputController {
 					processes: true,
 					modes: true,
 					maintenance: true,
-					retry: true,
+					retry: "escape",
 					streaming: true,
 				})
 			) {

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -1041,10 +1041,10 @@ export class FileGateStore implements GateStore {
 		}
 	}
 	private flushState(next: FileState): void {
-		mkdirSync(path.dirname(this.filePath), { recursive: true });
 		const tmp = `${this.filePath}.tmp-${process.pid}-${Date.now()}`;
 		let renamed = false;
 		try {
+			mkdirSync(path.dirname(this.filePath), { recursive: true });
 			const fd = openSync(tmp, "w");
 			try {
 				writeFileSync(fd, JSON.stringify(next, null, 2));
@@ -1125,6 +1125,15 @@ export class FileGateStore implements GateStore {
 			}
 		}
 		next.runtimeInstanceId = instanceId;
+		// Nothing to persist yet: an empty store carries no gates or counters a
+		// later process could recover or quarantine, so stamping the runtime
+		// instance id now would mkdir under the cwd at construction time and
+		// defeat the lazy first-write contract (#4568). Adopt it in memory so it
+		// rides along with the first real mutation instead.
+		if (Object.keys(next.gates).length === 0 && Object.keys(next.counters).length === 0) {
+			this.state = next;
+			return;
+		}
 		this.commit(next);
 	}
 	list(): PersistedGate[] {

package/src/sdk/broker/lifecycle.ts

@@ -827,6 +827,18 @@ function observeProcess(
 	expectedIncarnation: string | undefined,
 	readIncarnation: (pid: number) => string | undefined = processIncarnation,
 ): ProcessObservation {
+	if (process.platform === "win32") {
+		try {
+			const reference = nativeLifecycle().Process.fromPid(pid);
+			if (reference?.status() !== "running") return "exited";
+		} catch {
+			return "uncertain";
+		}
+		if (!expectedIncarnation) return "uncertain";
+		const actualIncarnation = readIncarnation(pid);
+		if (!actualIncarnation) return "uncertain";
+		return actualIncarnation === expectedIncarnation ? "alive" : "exited";
+	}
 	try {
 		process.kill(pid, 0);
 	} catch (error) {
@@ -843,6 +855,15 @@ function observeProcess(
 	return actualIncarnation === expectedIncarnation ? "alive" : "exited";
 }
 
+/** Test seam for the lifecycle-owned process observation boundary. */
+export function observeProcessForTest(
+	pid: number,
+	expectedIncarnation: string | undefined,
+	readIncarnation: (pid: number) => string | undefined = processIncarnation,
+): ProcessObservation {
+	return observeProcess(pid, expectedIncarnation, readIncarnation);
+}
+
 function hasObservedProcessExit(pid: number): boolean {
 	try {
 		process.kill(pid, 0);

package/src/sdk/broker/session-index.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { logger, resolveEquivalentPath } from "@gajae-code/utils";
+import { nativeProcessBindings } from "@gajae-code/utils/native-process";
 import { withFileLock } from "../../config/file-lock";
 import { processIncarnation } from "./process-incarnation";
 import {
@@ -754,6 +755,18 @@ async function replaceAtomically(file: string, contents: Buffer | string): Promi
 }
 
 function alive(pid: number): boolean {
+	if (process.platform === "win32") {
+		try {
+			// Bun's signal-0 probe is not a reliable Windows liveness authority for a
+			// detached child: it can report a non-live process even while the child
+			// has already published its endpoint. Use the native process handle, which
+			// is also the source of the process-incarnation fence, and fail closed when
+			// the handle cannot be opened.
+			return nativeProcessBindings().Process.fromPid(pid)?.status() === "running";
+		} catch {
+			return false;
+		}
+	}
 	try {
 		process.kill(pid, 0);
 		return true;

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -274,7 +274,7 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * Generation 169 delivers every ring-positioned session event live through the
  * bounded, capability-gated directed subscriber leg used by replay.
  */
-export const DAEMON_GENERATION = 169;
+export const DAEMON_GENERATION = 170;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

package/src/sdk/bus/telegram-daemon.ts

@@ -6841,7 +6841,11 @@ export class TelegramNotificationDaemon {
 		if (timer !== undefined) (this.opts.clearTimeoutImpl ?? clearTimeout)(timer);
 		this.#rejectedTopicCleanupTimers.delete(sessionId);
 	}
-	#leaseAllows(session: AttachmentSession, logicalSessionId = this.#logicalSessionId(session)): boolean {
+	#leaseAllows(
+		session: AttachmentSession,
+		logicalSessionId = this.#logicalSessionId(session),
+		options?: { allowLeaseRearm?: boolean },
+	): boolean {
 		if (this.#droppedSessions.has(session)) return false;
 		if (!this.#topicAdmissionAllows(session)) return false;
 		const closedBinding = this.closedEndpointKeys.get(logicalSessionId);
@@ -6853,13 +6857,22 @@ export class TelegramNotificationDaemon {
 		if (lease?.state !== "authorized" || lease.logicalSessionId !== logicalSessionId) return false;
 		if (this.#logicalSessionOwners.get(logicalSessionId) !== session) return false;
 		const record = this.topics.get(logicalSessionId);
+		// Lease re-arm mirrors `acquireLease` admission: an expired-but-still-owned
+		// active lease, or a same-owner grace-window resume. Every other authority
+		// state (archive/inactive/quarantine/malformed) stays fenced.
+		const authorityResumable =
+			options?.allowLeaseRearm !== true
+				? record?.authorityState === "active"
+				: record?.authorityState === "active" ||
+					(record?.authorityState === "disconnect_grace" &&
+						(record.disconnectGraceExpiresAt ?? 0) > this.runtime.now());
 		return (
 			lease.binding.logicalSessionId === logicalSessionId &&
 			(!record ||
-				(record.authorityState === "active" &&
+				(authorityResumable &&
 					!record.bindingMalformed &&
 					record.leaseOwner === this.installationHostId &&
-					(record.leaseExpiresAt ?? 0) > this.runtime.now() &&
+					(options?.allowLeaseRearm === true || (record.leaseExpiresAt ?? 0) > this.runtime.now()) &&
 					record.chatId === lease.binding.chatId))
 		);
 	}
@@ -9807,7 +9820,10 @@ export class TelegramNotificationDaemon {
 			)
 				continue;
 			const sessionId = this.#logicalSessionId(session);
-			if (renewed.has(sessionId) || !this.#leaseAllows(session, sessionId)) continue;
+			// A live trusted attachment may re-arm its own expired host lease: the
+			// authority above (owner, binding, state) is what makes renewal safe, and
+			// gating renewal on an unexpired lease made expiry permanent (#4647).
+			if (renewed.has(sessionId) || !this.#leaseAllows(session, sessionId, { allowLeaseRearm: true })) continue;
 			renewed.add(sessionId);
 			if (!(await this.#renewTopicLease(sessionId, session)))
 				logger.warn(`notifications: Telegram topic lease renewal was not admitted for session ${sessionId}`);
@@ -10280,8 +10296,15 @@ export class TelegramNotificationDaemon {
 		if (msg?.type === "event_replay_result") return;
 		if (!this.#topicAdmissionAllows(session)) return;
 		if (msg && typeof msg === "object") await this.#updateLogicalSessionForThreadedFrame(session, msg);
-		if (session.logicalSessionIdTrusted && !this.#leaseAllows(session))
-			await this.#failPublicationPreSend(publicationId, "trusted attachment lease is stale");
+		if (session.logicalSessionIdTrusted && !this.#leaseAllows(session)) {
+			// A still-owned live attachment re-arms its own expired host lease before
+			// the gate so slow turns do not permanently strand the topic (#4647);
+			// every other authority failure still fails closed below.
+			if (this.#leaseAllows(session, undefined, { allowLeaseRearm: true }))
+				await this.#renewTopicLease(this.#logicalSessionId(session), session);
+			if (!this.#leaseAllows(session))
+				await this.#failPublicationPreSend(publicationId, "trusted attachment lease is stale");
+		}
 		session.activePublicationId = publicationId;
 		try {
 			if (await this.#frameRouter.dispatch(session, msg as Record<string, unknown>)) return;

package/src/sdk/router/session-router.ts

@@ -1,7 +1,7 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { logger } from "@gajae-code/utils";
+import { logger, resolveEquivalentPath } from "@gajae-code/utils";
 import {
 	SessionIndex as DefaultSessionIndex,
 	type IndexedSession,
@@ -837,11 +837,18 @@ export class SessionRouter {
 		if (!isSessionAuthorityEligible(indexed)) return null;
 		const repo = path.resolve(indexed.locator.repo);
 		const defaultStateRoot = path.join(repo, ".gjc", "state");
-		const indexedStateRoot = path.resolve(indexed.locator.stateRoot);
+		// The session index stores the lifecycle caller's lexical cwd in `locator.repo`
+		// (reconcileReadyScope re-scopes only that field) while `locator.stateRoot` is
+		// the host process's physical path, because process.cwd() resolves symlinks.
+		// The scope test therefore compares path identity, not spelling: a lexical
+		// match fails for every symlinked cwd (macOS /var -> /private/var,
+		// /home/jun/desk -> /data/Lina-Desk), the adopted attachment is retired on
+		// reconcile, and session/new surfaces "lost exact Router authority".
+		const indexedStateRoot = resolveEquivalentPath(indexed.locator.stateRoot);
 		const scope =
-			indexedStateRoot === defaultStateRoot
+			indexedStateRoot === resolveEquivalentPath(defaultStateRoot)
 				? "default"
-				: indexedStateRoot === path.join(defaultStateRoot, "chat")
+				: indexedStateRoot === resolveEquivalentPath(path.join(defaultStateRoot, "chat"))
 					? "chat"
 					: undefined;
 		if (!scope || indexed.endpointMtimeMs === undefined || !Number.isFinite(indexed.endpointMtimeMs)) return null;

package/src/session/account-inventory.ts

@@ -204,8 +204,12 @@ function storedHealth(authStorage: AuthStorage, row: CredentialInventoryRecord):
 	};
 }
 
-function storedUsage(authStorage: AuthStorage, row: CredentialInventoryRecord): AccountUsageCache | undefined {
-	return authStorage.getCachedUsageReport(row.provider as Provider, row.id);
+function storedUsage(
+	authStorage: AuthStorage,
+	row: CredentialInventoryRecord,
+	baseUrl?: string,
+): AccountUsageCache | undefined {
+	return authStorage.getCachedUsageReport(row.provider as Provider, row.id, baseUrl);
 }
 
 function safeUsageUnit(value: unknown): UsageUnit {
@@ -308,6 +312,17 @@ function redactUsageCache(usage: CachedUsageReport | undefined): AccountUsageCac
 	};
 }
 
+function freshUsageCache(report: CachedUsageReport["report"]): AccountUsageCache {
+	const now = Date.now();
+	return {
+		report: redactUsageReport(report),
+		fetchedAt: finiteNumber(report.fetchedAt) ?? now,
+		freshUntil: now + 15 * 60_000,
+		retainUntil: now + 24 * 60 * 60_000,
+		freshness: "fresh",
+	};
+}
+
 function canPinStoredOAuth(authStorage: AuthStorage, provider: string): boolean {
 	if (authStorage.hasRuntimeApiKey(provider) || authStorage.hasConfigApiKey(provider)) return false;
 	return !getEnvApiKey(provider);
@@ -352,6 +367,7 @@ function addStoredRows(
 	authStorage: AuthStorage,
 	inventory: CredentialInventoryRecord[],
 	sessionId: string | undefined,
+	baseUrlResolver?: (provider: string) => string | undefined,
 ): void {
 	const removalTargetIds = new Set(
 		(typeof authStorage.listCredentialRemovalTargets === "function"
@@ -361,7 +377,7 @@ function addStoredRows(
 	);
 	for (const record of inventory) {
 		const identityLabel = asSafeLabel(record.identityLabel);
-		const safeUsage = redactUsageCache(storedUsage(authStorage, record));
+		const safeUsage = redactUsageCache(storedUsage(authStorage, record, baseUrlResolver?.(record.provider)));
 		const active =
 			typeof record.provider === "string" &&
 			authStorage.getSessionCredentialRowId(record.provider, sessionId) === record.id;
@@ -453,7 +469,9 @@ export function buildAccountInventorySnapshot(input: AccountInventoryInput): Acc
 	const nowMs = input.nowMs ?? Date.now();
 	const inventory = input.authStorage.listCredentialInventory();
 	const rows: AccountInventoryRow[] = [];
-	addStoredRows(rows, input.authStorage, inventory, input.sessionId);
+	addStoredRows(rows, input.authStorage, inventory, input.sessionId, provider =>
+		input.modelRegistry?.getProviderBaseUrl?.(provider),
+	);
 	addSyntheticRows(rows, input.authStorage, providerSet(input, inventory), input.sessionId);
 	rows.sort((left, right) => left.id.localeCompare(right.id));
 	return { generatedAt: nowMs, generation: input.authStorage.getGeneration(), rows };
@@ -464,7 +482,6 @@ export const buildAccountInventory = buildAccountInventorySnapshot;
 
 function applyStoredCheck(
 	rows: AccountInventoryRow[],
-	authStorage: AuthStorage,
 	results: CredentialHealthResult[],
 ): AccountInventoryCheckResult[] {
 	const byId = new Map(rows.filter(row => row.credentialId !== undefined).map(row => [row.credentialId!, row]));
@@ -477,14 +494,8 @@ function applyStoredCheck(
 			reason: asSafeLabel(result.reason),
 		};
 		if (result.report) {
-			const cached =
-				row.credentialId === undefined
-					? undefined
-					: authStorage.getCachedUsageReport(row.provider as Provider, row.credentialId);
-			if (cached) {
-				row.usage = redactUsageCache(cached);
-				row.capabilities.hasCachedUsage = true;
-			}
+			row.usage = freshUsageCache(result.report);
+			row.capabilities.hasCachedUsage = true;
 		}
 		checked.push({
 			rowId: row.id,
@@ -509,7 +520,6 @@ export async function checkAccountInventory(input: AccountInventoryInput): Promi
 	const authStorage = input.authStorage;
 	applyStoredCheck(
 		rows,
-		authStorage,
 		await authStorage.checkCredentials({
 			provider: input.provider,
 			baseUrlResolver: provider => input.modelRegistry?.getProviderBaseUrl?.(provider),
@@ -539,13 +549,7 @@ export async function checkAccountInventory(input: AccountInventoryInput): Promi
 		};
 		recordSourceHealth(authStorage, row.provider, row.source as SyntheticAccountSource, result.ok, result.reason);
 		if (result.report) {
-			row.usage = {
-				report: redactUsageReport(result.report),
-				fetchedAt: finiteNumber(result.report.fetchedAt) ?? 0,
-				freshUntil: Date.now() + 15 * 60_000,
-				retainUntil: Date.now() + 24 * 60 * 60_000,
-				freshness: "fresh",
-			};
+			row.usage = freshUsageCache(result.report);
 			row.capabilities.hasCachedUsage = true;
 		}
 	}