@gajae-code/coding-agent 0.18.11 → 0.18.12

package/src/sdk/prompt-deadline-flush.ts

@@ -44,7 +44,8 @@
  * WHERE it runs. `sdk.flushWorktreeOnDeadline` still defaults to on, but the
  * implicit default applies only in a LINKED worktree (`gitDir !== commonDir`) —
  * what agent/paseo sessions run in, and the #5583 field report. In the user's
- * primary checkout an autosave needs an explicit opt-in.
+ * primary checkout an autosave needs an explicit opt-in from the user/global
+ * config or a runtime override. A project `.gjc` file is not that opt-in.
  */
 
 import * as fsp from "node:fs/promises";
@@ -66,9 +67,10 @@ export interface PromptDeadlineFlushOptions {
 	/** Active session's agent directory, used to keep volatile broker state out of the WIP commit. */
 	readonly agentDir?: string;
 	/**
-	 * Whether the caller resolved `sdk.flushWorktreeOnDeadline` to `true` from a
-	 * value the user actually wrote, rather than from the schema default. Only an
-	 * explicit opt-in may autosave outside a linked worktree.
+	 * Whether the caller resolved `sdk.flushWorktreeOnDeadline` to `true` from the
+	 * user/global config or a runtime override, rather than from the schema
+	 * default or a project `.gjc` file. Only that opt-in may autosave outside a
+	 * linked worktree.
 	 */
 	readonly explicitOptIn?: boolean;
 	/**
@@ -162,6 +164,76 @@ function isLinkedWorktree(repository: git.GitRepository): boolean {
 	return path.resolve(repository.gitDir) !== path.resolve(repository.commonDir);
 }
 
+const DEADLINE_FLUSH_SETTING = "sdk.flushWorktreeOnDeadline";
+
+/**
+ * The settings view both deadline hosts already hold. `get` is the merged value
+ * (global, then project, then runtime override, otherwise the schema default).
+ * `getGlobal` and `getOverride` are the layers a project file cannot write.
+ */
+export interface DeadlineFlushSettings {
+	get(path: typeof DEADLINE_FLUSH_SETTING): unknown;
+	getAgentDir?(): string | undefined;
+	getGlobal?(path: typeof DEADLINE_FLUSH_SETTING): unknown;
+	getOverride?(path: typeof DEADLINE_FLUSH_SETTING): unknown;
+}
+
+/**
+ * True only when the user wrote `sdk.flushWorktreeOnDeadline: true` in a runtime
+ * override or the global config. The schema default and a project `.gjc` file
+ * do not count: `Settings.has()` sees the merged view, so a repo-shipped `true`
+ * would otherwise open the primary-checkout gate.
+ */
+export function explicitDeadlineFlushOptIn(settings: DeadlineFlushSettings | undefined): boolean {
+	if (!settings) return false;
+	if (typeof settings.getOverride === "function") {
+		const override = settings.getOverride(DEADLINE_FLUSH_SETTING);
+		if (override !== undefined) return override === true;
+	}
+	if (typeof settings.getGlobal === "function") return settings.getGlobal(DEADLINE_FLUSH_SETTING) === true;
+	return false;
+}
+
+/**
+ * Whether this deadline must not autosave.
+ *
+ * A runtime override wins, then the user/global value. A project file cannot
+ * cancel either one. A project `false` still opts out when the user has not
+ * written the key.
+ */
+export function deadlineFlushSuppressed(settings: DeadlineFlushSettings | undefined): boolean {
+	if (!settings) return false;
+	if (typeof settings.getOverride === "function") {
+		const override = settings.getOverride(DEADLINE_FLUSH_SETTING);
+		if (override === false) return true;
+		if (override === true) return false;
+	}
+	if (typeof settings.getGlobal === "function") {
+		const globalValue = settings.getGlobal(DEADLINE_FLUSH_SETTING);
+		if (globalValue === false) return true;
+		if (globalValue === true) return false;
+	}
+	return settings.get(DEADLINE_FLUSH_SETTING) === false;
+}
+
+/**
+ * Deadline-host entry for the worktree autosave. Both the session runtime and
+ * the notification bus call this so the opt-in decision cannot drift.
+ */
+export async function autosaveWorktreeOnPromptDeadline(
+	cwd: string,
+	settings: DeadlineFlushSettings | undefined,
+	options?: { readonly isCurrent?: () => boolean; readonly signal?: AbortSignal },
+): Promise<PromptDeadlineFlushResult | undefined> {
+	if (deadlineFlushSuppressed(settings)) return undefined;
+	return flushWorktreeOnPromptDeadline(cwd, {
+		agentDir: settings?.getAgentDir?.(),
+		explicitOptIn: explicitDeadlineFlushOptIn(settings),
+		isCurrent: options?.isCurrent,
+		signal: options?.signal,
+	});
+}
+
 /**
  * Commit any uncommitted work in the worktree owning `cwd`.
  *
@@ -195,7 +267,8 @@ export async function flushWorktreeOnPromptDeadline(
 		if (!explicitOptIn && !isLinkedWorktree(repository)) {
 			logger.debug(
 				`sdk: prompt deadline worktree autosave skipped; ${worktreeRoot} is a primary checkout the session does ` +
-					`not own. Set sdk.flushWorktreeOnDeadline to true to autosave here anyway.`,
+					`not own. Set sdk.flushWorktreeOnDeadline to true in the user config or a runtime override to ` +
+					`autosave here anyway.`,
 			);
 			return undefined;
 		}

package/src/sdk/prompt-deadline-manager.ts

@@ -103,10 +103,18 @@ export class PromptDeadlineManager {
 	readonly #uncertaintyRecoveryPending = new Set<string>();
 	readonly #expiring = new Set<string>();
 	readonly #deadlineAttempts = new Set<string>();
+	/**
+	 * The next deadline came due while `#expire` was still inside an await
+	 * (tool-boundary grace or the bounded flush). The in-flight pass owns the
+	 * single-flight slot, so the timer callback only records the follow-up and
+	 * `#onDeadline` runs it after this pass returns.
+	 */
+	readonly #deadlineFollowUps = new Set<string>();
 	readonly #pendingTerminalTransitions = new Set<string>();
 	readonly #deadlineDeferredTerminalTransitions = new Set<string>();
 	readonly #deadlineTerminalizationConfirmed = new Set<string>();
 	readonly #terminalPublicationPending = new Map<string, SdkPromptTerminalOutcome>();
+	readonly #toolsStillPendingOnLastCheck = new Set<string>();
 	readonly #deadlineStartCleanup = new Map<string, () => void>();
 	readonly #pendingTerminalFailureReasons = new Map<
 		string,
@@ -187,7 +195,11 @@ export class PromptDeadlineManager {
 	}
 
 	/** Run the durability hook under the shared bound; see `runBoundedDeadlineFlush`. */
-	async #runDeadlineFlush(correlation: InvocationCorrelation, lease: PromptDeadlineLease): Promise<void> {
+	async #runDeadlineFlush(
+		correlation: InvocationCorrelation,
+		lease: PromptDeadlineLease,
+		generation: number,
+	): Promise<void> {
 		const hook = this.#onDeadlineExceeded;
 		if (hook === undefined) return;
 		const key = leaseKey(correlation);
@@ -195,7 +207,9 @@ export class PromptDeadlineManager {
 			signal =>
 				hook(correlation, signal, () => {
 					const current = this.#leases.get(key);
-					return current === lease && this.#now() >= promptDeadlineAt(current);
+					return (
+						current === lease && current.generation === generation && this.#now() >= promptDeadlineAt(current)
+					);
 				}),
 			this.#deadlineFlushTimeoutMs,
 		);
@@ -239,12 +253,24 @@ export class PromptDeadlineManager {
 	}
 
 	async #onDeadline(key: string): Promise<void> {
-		if (this.#deadlineAttempts.has(key)) return;
+		if (this.#deadlineAttempts.has(key)) {
+			this.#deadlineFollowUps.add(key);
+			return;
+		}
 		this.#deadlineAttempts.add(key);
 		try {
-			await this.#expire(key);
+			do {
+				this.#deadlineFollowUps.delete(key);
+				await this.#expire(key);
+			} while (this.#deadlineFollowUps.has(key));
 		} finally {
 			this.#deadlineAttempts.delete(key);
+			if (this.#deadlineFollowUps.has(key)) {
+				this.#deadlineFollowUps.delete(key);
+				queueMicrotask(() => {
+					void this.#onDeadline(key);
+				});
+			}
 		}
 	}
 
@@ -385,7 +411,9 @@ export class PromptDeadlineManager {
 			terminalization =
 				(await this.#onDeadlineTerminalization?.(correlation, () => {
 					const current = this.#leases.get(key);
-					return current === lease && this.#now() >= promptDeadlineAt(current);
+					return (
+						current === lease && current.generation === generation && this.#now() >= promptDeadlineAt(current)
+					);
 				})) ?? "settled";
 		} catch {
 			terminalization = "uncertain";
@@ -410,7 +438,7 @@ export class PromptDeadlineManager {
 		// The claim above remains the durable pending marker throughout both
 		// bounded operations, so restart recovery never reports unsaved work as
 		// finished.
-		await this.#runDeadlineFlush(correlation, lease);
+		await this.#runDeadlineFlush(correlation, lease, generation);
 		// Fence again AFTER the flush (#5623 review round 2): progress can land
 		// while the bounded git operation runs and renews the lease.
 		if (this.#backOffIfSuperseded(key, lease, generation)) return;
@@ -532,14 +560,19 @@ export class PromptDeadlineManager {
 	/**
 	 * After an awaited reconciliation call, verify the captured lease is still
 	 * authoritative. Fresh attributable progress during the await advances the
-	 * lease generation and its deadline; when superseded, cancel this expiry
-	 * instance (release the expiration fence, clear any retry budget, and
-	 * reschedule the deadline) and report it so the caller stops. A cleared or
-	 * re-accepted lease is stale by identity too.
+	 * lease generation and its deadline. A tool-boundary wait or a flush can
+	 * outlive that renewed lease, so a generation mismatch is stale even when
+	 * the new deadline is already due — the time check alone would let this
+	 * pass publish with the generation it captured, the publisher would refuse,
+	 * and uncertainty recovery would refuse to re-anchor the same mismatch.
+	 * Cancel this expiry instance (release the expiration fence, clear any
+	 * retry budget, and reschedule the deadline) and report it so the caller
+	 * stops. The follow-up expiry captures the current generation. A cleared
+	 * or re-accepted lease is stale by identity too.
 	 */
-	#backOffIfSuperseded(key: string, lease: PromptDeadlineLease, _generation: number): boolean {
+	#backOffIfSuperseded(key: string, lease: PromptDeadlineLease, generation: number): boolean {
 		const current = this.#leases.get(key);
-		if (current !== lease || this.#now() < promptDeadlineAt(current)) {
+		if (current !== lease || current.generation !== generation || this.#now() < promptDeadlineAt(current)) {
 			this.#expiring.delete(key);
 			this.#expiryRetries.delete(key);
 			if (current) this.#schedule(key);
@@ -578,13 +611,32 @@ export class PromptDeadlineManager {
 		this.clear(correlation);
 	}
 
-	#scheduleTerminalPublicationRetry(key: string): void {
+	#scheduleTerminalPublicationRetry(key: string, delayMs?: number): void {
 		this.#clearTimer(key);
-		const timer = setTimeout(() => void this.#onDeadline(key), UNCERTAINTY_RETRY_DELAY_MS);
+		// Use immediate retry (0ms) if tools were pending on last check;
+		// otherwise use normal retry delay. This allows quick detection when tools drain.
+		const effectiveDelayMs =
+			delayMs ?? (this.#toolsStillPendingOnLastCheck.has(key) ? 0 : UNCERTAINTY_RETRY_DELAY_MS);
+		const timer = setTimeout(() => void this.#onDeadline(key), effectiveDelayMs);
 		(timer as unknown as { unref?: () => void }).unref?.();
 		this.#timers.set(key, timer);
 	}
 
+	/** Notify about termination check results to adjust retry strategy. */
+	notifyTerminationResult(
+		correlation: InvocationCorrelation,
+		_result: PromptDeadlineTerminalization,
+		reason: string,
+	): void {
+		const key = leaseKey(correlation);
+		if (reason.includes("tools-still-pending")) {
+			this.#toolsStillPendingOnLastCheck.add(key);
+		} else {
+			// Tools have settled or are no longer relevant
+			this.#toolsStillPendingOnLastCheck.delete(key);
+		}
+	}
+
 	#retry(key: string): void {
 		const attempts = (this.#expiryRetries.get(key) ?? 0) + 1;
 		this.#expiryRetries.set(key, attempts);
@@ -817,6 +869,7 @@ export class PromptDeadlineManager {
 		this.#terminalPublicationPending.delete(key);
 		this.#pendingTerminalFailureReasons.delete(key);
 		this.#pendingTerminalEvidence.delete(key);
+		this.#toolsStillPendingOnLastCheck.delete(key);
 	}
 
 	clearAll(): void {
@@ -839,6 +892,7 @@ export class PromptDeadlineManager {
 		this.#terminalPublicationPending.clear();
 		this.#pendingTerminalFailureReasons.clear();
 		this.#pendingTerminalEvidence.clear();
+		this.#toolsStillPendingOnLastCheck.clear();
 	}
 
 	/** For tests: current deadline or undefined if no lease. */

package/src/sdk/protocol/adapter-validation.ts

@@ -1,24 +1,57 @@
 const RELOAD_COMPONENTS = new Set(["config", "models", "skills", "extensions", "tools"]);
-const SERVICE_TIERS = new Set(["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"]);
+const SERVICE_TIERS = new Set([
+	"none",
+	"auto",
+	"default",
+	"flex",
+	"scale",
+	"priority",
+	"ultrafast",
+	"openai-only",
+	"claude-only",
+]);
 
 type Input = Record<string, unknown>;
 
 type SecretInputError = { code: "secret_field_forbidden"; message: string };
 const SECRET_FIELD = /(?:secret|token|password|credential|authorization|api[_-]?key)/i;
 
+type UltrafastRestrictionError = { code: "ultrafast_tier_forbidden"; message: string };
+
+function containsUltrafastServiceTier(value: unknown): boolean {
+	if (Array.isArray(value)) return value.some(containsUltrafastServiceTier);
+	if (!value || typeof value !== "object") return false;
+	return Object.entries(value as Record<string, unknown>).some(
+		([key, nested]) =>
+			((key === "serviceTier" || key.endsWith(".serviceTier")) && nested === "ultrafast") ||
+			containsUltrafastServiceTier(nested),
+	);
+}
+
 function containsSecretField(value: unknown): boolean {
 	if (Array.isArray(value)) return value.some(containsSecretField);
 	if (!value || typeof value !== "object") return false;
 	return Object.entries(value).some(([key, nested]) => SECRET_FIELD.test(key) || containsSecretField(nested));
 }
 
-/** Rejects secret-bearing config patches from model-facing adapter inputs. */
-export function validateAdapterSecretFields(operation: string, input: Input): SecretInputError | undefined {
-	if (operation === "config.patch" && containsSecretField(input)) {
-		return {
-			code: "secret_field_forbidden",
-			message: "config.patch secret fields are not available through this adapter.",
-		};
+/** Rejects secret-bearing and ultrafast-tier config patches from model-facing adapter inputs. */
+export function validateAdapterSecretFields(
+	operation: string,
+	input: Input,
+): SecretInputError | UltrafastRestrictionError | undefined {
+	if (operation === "config.patch") {
+		if (containsSecretField(input)) {
+			return {
+				code: "secret_field_forbidden",
+				message: "config.patch secret fields are not available through this adapter.",
+			};
+		}
+		if (containsUltrafastServiceTier(input)) {
+			return {
+				code: "ultrafast_tier_forbidden",
+				message: "config.patch serviceTier ultrafast is restricted to trusted local sources.",
+			};
+		}
 	}
 	return undefined;
 }
@@ -53,8 +86,12 @@ export function validateRequiredPromptText(operation: string, input: Input): Ada
 	return undefined;
 }
 
-/** Validates controls that adapters must reject before forwarding them to a host. */
-export function validateAdapterControl(operation: string, input: Input): AdapterValidationError | undefined {
+/** Validates controls before forwarding them; adapters reject ultrafast unless explicitly trusted. */
+export function validateAdapterControl(
+	operation: string,
+	input: Input,
+	options: { allowUltrafastTier?: boolean } = {},
+): AdapterValidationError | undefined {
 	const promptError = validateRequiredPromptText(operation, input);
 	if (promptError) return promptError;
 	if (operation === "runtime.reload") {
@@ -68,7 +105,12 @@ export function validateAdapterControl(operation: string, input: Input): Adapter
 			};
 		}
 	}
-	if (operation === "service_tier.set" && (typeof input.tier !== "string" || !SERVICE_TIERS.has(input.tier))) {
+	if (
+		operation === "service_tier.set" &&
+		(typeof input.tier !== "string" ||
+			!SERVICE_TIERS.has(input.tier) ||
+			(input.tier === "ultrafast" && options.allowUltrafastTier !== true))
+	) {
 		return { code: "invalid_input", message: "service_tier.set tier is invalid." };
 	}
 	return undefined;

package/src/sdk/protocol/operation-inventory.generated.json

@@ -4502,6 +4502,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:markProfileRoleOverrideManual",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal profile role-layer ownership tracking after explicit user assignments; not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:getActiveModelProfile",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4518,7 +4529,7 @@
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
 		"sourceKind": "agent_session",
 		"decision": "exclude",
-		"rationale": "internal session-scoped unavailable profile tracking; mutated by the session lifecycle on model-load failure, not a public SDK control seam",
+		"rationale": "internal session-scoped startup-profile recovery marker, not a user-facing SDK control seam",
 		"exclusionMetadata": {
 			"adapterMappings": "not_applicable",
 			"testIds": "not_applicable"
@@ -4529,7 +4540,7 @@
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
 		"sourceKind": "agent_session",
 		"decision": "exclude",
-		"rationale": "internal session-scoped unavailable profile query for UI status rendering; not a public SDK operation",
+		"rationale": "internal session-scoped startup-profile recovery status for UI rendering, not a public SDK operation",
 		"exclusionMetadata": {
 			"adapterMappings": "not_applicable",
 			"testIds": "not_applicable"
@@ -4568,6 +4579,39 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:getConfigurationPaths",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal config hot-reload path identity projection, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:validateConfiguration",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal read-only config hot-reload preflight, not an independent SDK operation",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:reloadConfiguration",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal transactional config hot-reload publication, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:syncEagerDelegation",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4590,6 +4634,28 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:getProfileInstalledOverrideState",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal model-profile activation rollback snapshot, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:restoreProfileInstalledOverrideState",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal model-profile activation rollback restoration, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:clearProfileInstalledOverrides",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -4828,6 +4894,39 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:prepareModelSelectionForProfileActivation",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal staged model-selection preparation for profile activation, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:commitPreparedProfileModelSelection",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal model-selection commit for profile activation, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:finishPreparedProfileModelSelection",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal post-commit model-selection refresh for profile activation, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:restoreModelSelectionForRollback",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/sdk/reconciliation-extensions.ts

@@ -10,5 +10,6 @@ export {
 	type DurableReconciliationRecord,
 	type DurableSteerReconciliationRecord,
 	type ReconciliationStore,
+	type ReconciliationStoreInstrumentationEvent,
 	resolveReconciliationSessionFile,
 } from "./bus/reconciliation-store";

package/src/sdk/session-list.ts

@@ -20,6 +20,7 @@ export const SESSION_LIST_SAVED_SESSION_OMISSION_DETAIL_CODES = [
 	"managed_gc_journal_capacity_exceeded",
 	"atomic_unavailable",
 	"invalid_request",
+	"permission_denied",
 	"durability_failed",
 	"durability_not_provable",
 	"capacity_exceeded",