@sayknow-cli/coding-agent 0.5.2 → 0.5.8

package/src/session/agent-session.ts

@@ -42,10 +42,13 @@ import {
 } from "@sayknow-cli/agent-core";
 import { normalizeMessagesForProvider } from "@sayknow-cli/agent-core/agent-loop";
 import {
+	type AdaptiveCompactionOptions,
+	AdaptiveCompactionTracker,
 	AUTO_HANDOFF_THRESHOLD_FOCUS,
 	CompactionCancelledError,
 	type CompactionPreparation,
 	type CompactionResult,
+	type CompactionSettings as CoreCompactionSettings,
 	calculateContextTokens,
 	calculatePromptTokens,
 	collectEntriesForBranchSummary,
@@ -545,6 +548,8 @@ export interface AgentSessionConfig {
 	/** Rebuild the SSH tool from current capability discovery results. */
 	reloadSshTool?: () => Promise<AgentTool | null>;
 	requestedToolNames?: ReadonlySet<string>;
+	/** True only when the caller explicitly selected no tools. */
+	explicitlyDisabledTools?: boolean;
 	/** Optional per-session allowlist for tools exposed through search_tool_bm25. */
 	discoverableToolAllowedNames?: readonly string[];
 	/** Optional accessor for live MCP server instructions, injected as untrusted user-role request data. */
@@ -1748,6 +1753,7 @@ export class AgentSession {
 	// Handoff state
 	#handoffAbortController: AbortController | undefined = undefined;
 	#skipPostTurnMaintenanceAssistantTimestamp: number | undefined = undefined;
+	#suppressNextPostTurnMaintenanceAfterAutoHandoff = false;
 
 	// Retry state
 	#retryAbortController: AbortController | undefined = undefined;
@@ -1759,6 +1765,7 @@ export class AgentSession {
 	#overflowMaintenanceAttempts = 0;
 	#defaultFallbackExhaustedLastTurn = false;
 	#fallbackInvocationId = 0;
+	#fallbackSuppressedSelectors = new Set<string>();
 	// Todo completion reminder state
 	#todoReminderCount = 0;
 	#todoWriteFailureCount = 0;
@@ -1853,6 +1860,7 @@ export class AgentSession {
 	#getMcpServerInstructions: (() => Map<string, string> | undefined) | undefined;
 	#reloadSshTool: (() => Promise<AgentTool | null>) | undefined;
 	#requestedToolNames: ReadonlySet<string> | undefined;
+	#explicitlyDisabledTools: boolean;
 	#baseSystemPrompt: string[];
 	#initialWorkspaceTree: WorkspaceTree | undefined;
 	/** Throttle cache for the per-turn volatile workspace-tree scan (see #buildVolatileProjectContextMessage). */
@@ -2043,6 +2051,12 @@ export class AgentSession {
 		});
 	}
 
+	#sessionTransitionAdmissionBusyError(): AgentBusyError {
+		return Object.assign(new AgentBusyError("Cannot start a turn while a session transition is in progress."), {
+			code: "busy",
+		});
+	}
+
 	/**
 	 * Reject a turn start while a handoff transition owns the session. Handoff never
 	 * routes its own generation/injection through these turn-start chokepoints, and
@@ -2068,6 +2082,7 @@ export class AgentSession {
 	 * orchestrator does not hold it), so there is no self-deadlock.
 	 */
 	#sessionTransitionKind: string | undefined;
+	#sessionTurnAdmissionFenced = false;
 
 	#beginSessionTransition(kind: string): void {
 		if (this.#sessionTransitionKind !== undefined) {
@@ -2108,6 +2123,7 @@ export class AgentSession {
 				code: "busy",
 			});
 		}
+		if (this.#sessionTurnAdmissionFenced) throw this.#sessionTransitionAdmissionBusyError();
 
 		const entry: SessionAdmissionEntry = {
 			kind,
@@ -2136,6 +2152,13 @@ export class AgentSession {
 				code: "busy",
 			});
 		}
+		if (this.#sessionTurnAdmissionFenced) {
+			entry.released = true;
+			entry.settled.resolve();
+			if (this.#activeSessionAdmission === entry) this.#activeSessionAdmission = undefined;
+			this.#activateNextSessionAdmission();
+			throw this.#sessionTransitionAdmissionBusyError();
+		}
 
 		const release = () => {
 			if (entry.released) return;
@@ -2372,6 +2395,7 @@ export class AgentSession {
 		this.#toolRegistry = config.toolRegistry ?? new Map();
 		this.#workflowGateToolSession = config.workflowGateToolSession;
 		this.#requestedToolNames = config.requestedToolNames;
+		this.#explicitlyDisabledTools = config.explicitlyDisabledTools === true;
 		this.#transformContext = config.transformContext ?? (messages => messages);
 		this.#onPayload = config.onPayload;
 		this.rawSseDebugBuffer = config.rawSseDebugBuffer ?? new RawSseDebugBuffer();
@@ -3779,8 +3803,9 @@ export class AgentSession {
 					this.#resolveTtsrResume();
 				}
 				this.#queueDeferredTtsrInjectionIfNeeded(assistantMsg);
-				if (this.#handoffAbortController) {
+				if (this.#handoffAbortController || this.#suppressNextPostTurnMaintenanceAfterAutoHandoff) {
 					this.#skipPostTurnMaintenanceAssistantTimestamp = assistantMsg.timestamp;
+					this.#suppressNextPostTurnMaintenanceAfterAutoHandoff = false;
 				}
 				if (
 					assistantMsg.stopReason !== "error" &&
@@ -5872,6 +5897,7 @@ export class AgentSession {
 	}
 
 	async activateDiscoveredTools(toolNames: string[]): Promise<string[]> {
+		if (this.#explicitlyDisabledTools) return [];
 		const previousSelectedMCPToolNames = this.getSelectedMCPToolNames();
 		const previousSelectedDiscoveredBuiltinToolNames = this.#getSelectedDiscoveredBuiltinToolNames();
 		const nextActiveToolNames = this.getActiveToolNames();
@@ -6099,7 +6125,9 @@ export class AgentSession {
 			nextSelectedDiscoveredBuiltinToolNames?: string[];
 		},
 	): Promise<void> {
-		toolNames = [...new Set([...toolNames.map(name => name.toLowerCase()), ...this.#mandatoryMCPToolNames])];
+		toolNames = this.#explicitlyDisabledTools
+			? []
+			: [...new Set([...toolNames.map(name => name.toLowerCase()), ...this.#mandatoryMCPToolNames])];
 		const previousSelectedMCPToolNames = options?.previousSelectedMCPToolNames ?? this.getSelectedMCPToolNames();
 		const previousSelectedDiscoveredBuiltinToolNames =
 			options?.previousSelectedDiscoveredBuiltinToolNames ?? this.#getSelectedDiscoveredBuiltinToolNames();
@@ -6209,6 +6237,11 @@ export class AgentSession {
 		await this.#applyActiveToolsByName(nextActive);
 	}
 
+	/** Whether the caller explicitly selected no tools for this session. */
+	hasExplicitlyDisabledTools(): boolean {
+		return this.#explicitlyDisabledTools;
+	}
+
 	/**
 	 * Set active tools by name.
 	 * Only tools in the registry can be enabled. Unknown tool names are ignored.
@@ -6220,6 +6253,11 @@ export class AgentSession {
 	}
 
 	async #restoreMCPSelectionsForSessionContext(sessionContext: SessionContext): Promise<void> {
+		if (this.#explicitlyDisabledTools) {
+			this.#selectedDiscoveredToolNames.clear();
+			await this.#applyActiveToolsByName([], { persistMCPSelection: false });
+			return;
+		}
 		if (!this.#mcpDiscoveryEnabled && this.#resolveEffectiveDiscoveryMode() !== "all") {
 			await this.#attachAskToolIfWorkflowActive();
 			return;
@@ -7073,6 +7111,7 @@ export class AgentSession {
 			this.#toolRegistry.set(askTool.name, askTool);
 		}
 
+		if (this.#explicitlyDisabledTools) return;
 		try {
 			if ((this.#workflowGateEmitter?.listPendingGates?.().length ?? 0) > 0) {
 				this.#attachAskTool();
@@ -7118,6 +7157,7 @@ export class AgentSession {
 	}
 
 	#attachAskTool(): void {
+		if (this.#explicitlyDisabledTools) return;
 		const askTool = this.#toolRegistry.get("ask");
 		if (!askTool || this.getActiveToolNames().includes(askTool.name)) return;
 		this.#setGuardedAgentTools([...this.agent.state.tools, askTool]);
@@ -7200,6 +7240,7 @@ export class AgentSession {
 	}
 
 	async #activatePendingSkcGoalModeRequest(): Promise<boolean> {
+		if (this.#explicitlyDisabledTools) return false;
 		if (!this.settings.get("goal.enabled")) return false;
 		const pendingGoal = await consumePendingGoalModeRequest(
 			this.sessionManager.getCwd(),
@@ -7212,9 +7253,10 @@ export class AgentSession {
 		}
 
 		const previousTools = this.getActiveToolNames();
-		const goalTools = [...new Set([...previousTools, "goal"])];
 		await this.#goalRuntime.createGoal({ objective: pendingGoal.objective, provenance: pendingGoal.provenance });
-		await this.setActiveToolsByName(goalTools);
+		if (!this.#explicitlyDisabledTools) {
+			await this.setActiveToolsByName([...new Set([...previousTools, "goal"])]);
+		}
 		if (this.isStreaming) {
 			await this.sendGoalModeContext({ deliverAs: "steer" });
 		}
@@ -9472,7 +9514,6 @@ export class AgentSession {
 					persistMCPSelection: false,
 					nextSelectedDiscoveredBuiltinToolNames: [],
 				});
-			} else {
 			}
 		}
 		this.#todoReminderCount = 0;
@@ -10066,7 +10107,13 @@ export class AgentSession {
 			});
 			if (!resolved.model) continue;
 
-			if (roleModels.some(candidate => modelsAreEqual(candidate.model, resolved.model))) continue;
+			if (
+				roleModels.some(
+					candidate =>
+						modelsAreEqual(candidate.model, resolved.model) && candidate.thinkingLevel === resolved.thinkingLevel,
+				)
+			)
+				continue;
 			roleModels.push({
 				role,
 				model: resolved.model,
@@ -10726,6 +10773,43 @@ export class AgentSession {
 		return 0;
 	}
 
+	/**
+	 * Call-rate tracker backing opt-in adaptive compaction. Always maintained so
+	 * enabling the setting mid-session has immediate, honest state; the recorded
+	 * rate only reaches a threshold decision while `compaction.adaptive.enabled`
+	 * is true.
+	 */
+	#adaptiveCompaction = new AdaptiveCompactionTracker();
+
+	#adaptiveCompactionOptions(): AdaptiveCompactionOptions {
+		return {
+			enabled: this.settings.get("compaction.adaptive.enabled"),
+			baseThresholdPercent: this.settings.get("compaction.adaptive.baseThresholdPercent"),
+			aggression: this.settings.get("compaction.adaptive.aggression"),
+			turnWindow: this.settings.get("compaction.adaptive.turnWindow"),
+			minThresholdPercent: this.settings.get("compaction.adaptive.minThresholdPercent"),
+		};
+	}
+
+	/**
+	 * Compaction settings for a threshold decision.
+	 *
+	 * `getGroup("compaction")` flattens `compaction.adaptive.*` into dotted keys,
+	 * so the nested options object is assembled explicitly here. The tracker
+	 * window follows the configured minutes so a settings change takes effect
+	 * without restarting the session.
+	 */
+	#compactionSettingsWithAdaptive(): CoreCompactionSettings {
+		const adaptive = this.#adaptiveCompactionOptions();
+		const windowMinutes = Number.isFinite(adaptive.turnWindow) ? Math.max(1, adaptive.turnWindow) : 15;
+		this.#adaptiveCompaction.setWindowMs(windowMinutes * 60_000);
+		return {
+			...this.settings.getGroup("compaction"),
+			adaptive,
+			adaptiveState: this.#adaptiveCompaction.decisionState(),
+		};
+	}
+
 	/**
 	 * Evidence-gated below-threshold maintenance pruning (Finding 13). Runs
 	 * #pruneToolOutputs ONCE, below the compaction threshold, only when it is
@@ -11392,13 +11476,15 @@ export class AgentSession {
 			}
 			return this.#scheduleOverflowRetryContinuation(generation);
 		}
-		const compactionSettings = this.settings.getGroup("compaction");
+		const compactionSettings = this.#compactionSettingsWithAdaptive();
 		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return false;
 
 		// Case 2: Threshold - turn succeeded but context is getting large
 		// Skip if this was an error (non-overflow errors don't have usage data)
 		if (assistantMessage.stopReason === "error") return false;
 		let contextTokens = calculateContextTokens(assistantMessage.usage);
+		this.#adaptiveCompaction.recordCall(contextTokens);
+		compactionSettings.adaptiveState = this.#adaptiveCompaction.decisionState();
 		// Model maxTokens is a capability ceiling, not a per-turn reservation.
 		// Auto maintenance should track actual context fullness.
 		const autoCompactionOutputReserveTokens = 0;
@@ -11626,6 +11712,11 @@ export class AgentSession {
 		this.#resourceSampler = sampler;
 	}
 
+	/** Test seam: drive the pre-prompt emergency/threshold check directly. */
+	runPrePromptContextCheckForTests(pendingMessages: readonly AgentMessage[] = []): Promise<void> {
+		return this.#checkEstimatedContextBeforePrompt(pendingMessages);
+	}
+
 	setRetainedMemorySampler(sampler: (() => RetainedMemorySample) | undefined): void {
 		this.#retainedMemorySampler = sampler;
 	}
@@ -11659,26 +11750,31 @@ export class AgentSession {
 			materializedResidentBytes: this.#streamingEditFileCache.totalBytes,
 			tuiChatChildren: retainedMemory.tuiChatChildren ?? 0,
 			tuiCachedRenderBytes: retainedMemory.tuiCachedRenderBytes ?? 0,
+			transcriptFileBytes: this.sessionManager.getTranscriptFileBytes(),
 		};
 	}
 
 	async #checkEstimatedContextBeforePromptOnce(pendingMessages: readonly AgentMessage[]): Promise<void> {
 		const model = this.model;
 		if (!model) return;
-		const contextWindow = model.contextWindow ?? 0;
-		if (contextWindow <= 0) return;
 		// F6: non-disableable emergency floor — compact before OOM even when token-based
 		// compaction is disabled or its threshold is set too high (weak-hardware protection).
 		const emergencyReason = emergencyCompactionReason(this.#resourceSampler());
 		if (emergencyReason) {
 			logger.warn("Emergency compaction triggered (resource floor exceeded)", { reason: emergencyReason });
-			await this.#runAutoCompaction("overflow", false, false, {
+			const status = await this.#runAutoCompaction("overflow", false, false, {
 				continueAfterMaintenance: false,
 				deferHandoffMaintenance: false,
 				force: true,
 			});
+			if (emergencyReason === "transcriptFile" && status.kind === "skipped") {
+				logger.warn("Transcript emergency compaction was skipped; rewriting exact live entries");
+				await this.sessionManager.rewriteEntries();
+			}
 			return;
 		}
+		const contextWindow = model.contextWindow ?? 0;
+		if (contextWindow <= 0) return;
 		const compactionSettings = this.settings.getGroup("compaction");
 		if (!compactionSettings.enabled || compactionSettings.strategy === "off") return;
 
@@ -11712,6 +11808,7 @@ export class AgentSession {
 			await this.#runAutoCompaction("threshold", false, false, {
 				continueAfterMaintenance: false,
 				deferHandoffMaintenance: false,
+				suppressNextPostTurnMaintenanceAfterHandoff: true,
 			});
 		}
 	}
@@ -11803,6 +11900,7 @@ export class AgentSession {
 			return;
 		}
 
+		if (this.#explicitlyDisabledTools) return;
 		this.#attachAskTool();
 
 		const reminder = prompt.render(planModeToolDecisionReminderPrompt, {
@@ -12691,6 +12789,11 @@ export class AgentSession {
 
 	/**
 	 * Internal: Run auto-compaction with events.
+	 *
+	 * Wraps the run so a completed compaction resets the adaptive call-rate
+	 * tracker in exactly one place. The post-compaction context size is reported
+	 * as 0 because the next recorded call carries the real provider number; the
+	 * tracker only uses this value as a fallback for callers that pass none.
 	 */
 	async #runAutoCompaction(
 		reason: "overflow" | "threshold" | "idle",
@@ -12702,6 +12805,25 @@ export class AgentSession {
 			force?: boolean;
 			signal?: AbortSignal;
 			beforeTerminalOverflowNoop?: () => void;
+			suppressNextPostTurnMaintenanceAfterHandoff?: boolean;
+		},
+	): Promise<AutoCompactionTerminalStatus> {
+		const status = await this.#runAutoCompactionInner(reason, willRetry, deferred, options);
+		if (status.kind === "compacted") this.#adaptiveCompaction.recordCompact(0);
+		return status;
+	}
+
+	async #runAutoCompactionInner(
+		reason: "overflow" | "threshold" | "idle",
+		willRetry: boolean,
+		deferred = false,
+		options?: {
+			continueAfterMaintenance?: boolean;
+			deferHandoffMaintenance?: boolean;
+			force?: boolean;
+			signal?: AbortSignal;
+			beforeTerminalOverflowNoop?: () => void;
+			suppressNextPostTurnMaintenanceAfterHandoff?: boolean;
 		},
 	): Promise<AutoCompactionTerminalStatus> {
 		const compactionSettings = this.settings.getGroup("compaction");
@@ -12783,6 +12905,9 @@ export class AgentSession {
 				if (autoCompactionSignal.aborted) return await emitAborted();
 
 				if (handoffResult) {
+					if (options?.suppressNextPostTurnMaintenanceAfterHandoff) {
+						this.#suppressNextPostTurnMaintenanceAfterAutoHandoff = true;
+					}
 					await this.#emitSessionEvent({
 						type: "auto_compaction_end",
 						action,
@@ -13502,12 +13627,15 @@ export class AgentSession {
 			if (controller.chain.entries.length > 1) await this.#advanceDefaultFallback(controller, "new_turn", 0);
 			return;
 		}
+		const primarySelector = controller.chain.entries[0];
 		if (
 			this.settings.get("retry.fallbackRevertPolicy") === "cooldown-expiry" &&
-			controller.activeIndex > 0
-			// TODO(upstream-v0.11): ModelRegistry.getSelectorSuppressionStatus was removed;
-			// rewire the cooldown-expiry revert policy to the new suppression API when available.
+			controller.activeIndex > 0 &&
+			primarySelector &&
+			this.#fallbackSuppressedSelectors.has(primarySelector) &&
+			!this.#modelRegistry.isSelectorSuppressed(primarySelector)
 		) {
+			this.#fallbackSuppressedSelectors.delete(primarySelector);
 			controller.resetForNewTurn();
 		}
 	}
@@ -13560,7 +13688,9 @@ export class AgentSession {
 		const existing = this.#defaultFallbackController;
 		if (
 			existing &&
-			(existing.chain.origin === "runtime" || existing.chain.entries.join("\u0000") === chain.entries.join("\u0000"))
+			(existing.chain.origin === "runtime" ||
+				(existing.activeIndex > 0 && existing.chain.entries.length > 1) ||
+				existing.chain.entries.join("\u0000") === chain.entries.join("\u0000"))
 		) {
 			return existing;
 		}
@@ -13846,6 +13976,7 @@ export class AgentSession {
 
 		if (managedFallback && trigger.class === "rate_limit" && trigger.retryAfterMs !== undefined && failedSelector) {
 			this.#modelRegistry.suppressSelector(failedSelector, Date.now() + trigger.retryAfterMs);
+			this.#fallbackSuppressedSelectors.add(failedSelector);
 		}
 
 		const retry = async (ownership?: ManagedAttemptContinuationOwnership): Promise<void> => {
@@ -15074,14 +15205,22 @@ export class AgentSession {
 	 * Switch to a different session file.
 	 * Aborts current operation, loads messages, restores model/thinking.
 	 * Listeners are preserved and will continue receiving events.
+	 * `requireIdle` rejects an active turn and fences new admissions for the transition.
 	 * @returns true if switch completed, false if cancelled by hook
 	 */
 	async switchSession(
 		sessionPath: string,
-		options?: { transition?: SessionSwitchEvent["transition"] },
+		options?: { transition?: SessionSwitchEvent["transition"]; requireIdle?: boolean },
 	): Promise<boolean> {
 		this.#beginSessionTransition("switch-session");
 		try {
+			if (options?.requireIdle) {
+				this.#sessionTurnAdmissionFenced = true;
+				if (this.isStreaming || this.#activeSessionAdmission !== undefined)
+					throw Object.assign(new AgentBusyError("Cannot switch sessions while a response or turn is active."), {
+						code: "busy",
+					});
+			}
 			const previousSessionFile = this.sessionManager.getSessionFile();
 			const switchingToDifferentSession = previousSessionFile
 				? path.resolve(previousSessionFile) !== path.resolve(sessionPath)
@@ -15307,6 +15446,7 @@ export class AgentSession {
 				throw error;
 			}
 		} finally {
+			this.#sessionTurnAdmissionFenced = false;
 			this.#endSessionTransition();
 		}
 	}

package/src/session/internal/managed-session-scope.ts

@@ -702,7 +702,7 @@ function inspectCandidate(filePath: string, provenance: "v2" | "legacy"): Manage
 			provenance,
 			migrationState: provenance === "v2" ? "native_v2" : "legacy_unmigrated",
 			identity: {
-				canonicalPath: path.resolve(filePath),
+				canonicalPath: canonicalizeTrustedPath(filePath),
 				sessionId: header.id,
 				...snapshot.identity,
 				mtimeMs: Number(named.mtimeMs),
@@ -740,6 +740,7 @@ function listDirectoryCandidates(
 	directory: string,
 	provenance: "v2" | "legacy",
 	scope: ManagedScope,
+	maxCandidates?: number,
 ): readonly CandidateInspection[] {
 	let directoryStat: fs.Stats;
 	try {
@@ -749,8 +750,28 @@ function listDirectoryCandidates(
 		throw error;
 	}
 	if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) throw new Error("unsafe directory");
-	return fs
-		.readdirSync(directory, { withFileTypes: true })
+	let entries: fs.Dirent[];
+	if (maxCandidates === undefined) {
+		entries = fs.readdirSync(directory, { withFileTypes: true });
+	} else {
+		entries = [];
+		let scannedEntries = 0;
+		const handle = fs.opendirSync(directory);
+		try {
+			for (;;) {
+				const entry = handle.readSync();
+				if (!entry) break;
+				scannedEntries++;
+				if (scannedEntries > maxCandidates * 4 + 128) throw new Error("candidate_capacity_exceeded");
+				if (!entry.name.endsWith(".jsonl")) continue;
+				entries.push(entry);
+				if (entries.length > maxCandidates) throw new Error("candidate_capacity_exceeded");
+			}
+		} finally {
+			handle.closeSync();
+		}
+	}
+	return entries
 		.filter(entry => entry.name.endsWith(".jsonl"))
 		.map(entry => {
 			const filePath = path.join(directory, entry.name);
@@ -967,7 +988,10 @@ export function prepareManagedSessionScopeForWriteSync(
 	}
 }
 
-export function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing {
+export function listManagedCandidates(
+	scope: ManagedScope,
+	options?: { maxCandidates?: number },
+): ManagedCandidateListing {
 	try {
 		let root: fs.Stats;
 		try {
@@ -990,8 +1014,19 @@ export function listManagedCandidates(scope: ManagedScope): ManagedCandidateList
 			})),
 		];
 		const seen = new Set<string>();
+		let inspectedCandidates = 0;
 		for (const directory of directories) {
-			for (const candidate of listDirectoryCandidates(directory.path, directory.provenance, scope)) {
+			const remainingCandidates =
+				options?.maxCandidates === undefined ? undefined : options.maxCandidates - inspectedCandidates;
+			for (const candidate of listDirectoryCandidates(
+				directory.path,
+				directory.provenance,
+				scope,
+				remainingCandidates,
+			)) {
+				inspectedCandidates++;
+				if (options?.maxCandidates !== undefined && inspectedCandidates > options.maxCandidates)
+					throw new Error("candidate_capacity_exceeded");
 				if ("code" in candidate) {
 					invalid.push({ code: candidate.code });
 					continue;
@@ -1108,7 +1143,7 @@ function sameCandidate(left: ManagedCandidate, right: ManagedCandidate): boolean
 
 function matchesExpectedResumeIdentity(candidate: ManagedCandidate, expected: ResumeSessionIdentity): boolean {
 	return (
-		path.resolve(candidate.identity.canonicalPath) === path.resolve(expected.canonicalPath) &&
+		canonicalizeTrustedPath(candidate.identity.canonicalPath) === canonicalizeTrustedPath(expected.canonicalPath) &&
 		candidate.identity.sessionId === expected.sessionId &&
 		candidate.identity.dev === expected.dev &&
 		candidate.identity.ino === expected.ino &&

package/src/session/internal/managed-session-storage.ts

@@ -880,6 +880,20 @@ export class ManagedSessionDescendantStore {
 		};
 	}
 
+	/** Read only the exact managed file size through the retained root authority. */
+	sizeSync(relativePath: string): number | null {
+		this.#assertBound();
+		if (!this.#authority) throw new Error("managed_size_authority_unavailable");
+		const relative = this.#relative(this.#resolve(relativePath));
+		const result = this.#authority.stat(relative);
+		if (!result.ok) {
+			if (result.code === "not_found") return null;
+			throw new Error(result.code ?? "managed_size_failed");
+		}
+		if (!result.identity) throw new Error("Managed descendant identity is unavailable");
+		return Number(result.identity.size);
+	}
+
 	/** Remove an exact captured file without reopening its pathname as authority. */
 	removeExpected(relativePath: string, expected: ManagedFileSnapshot): void {
 		this.#assertBound();