@gajae-code/coding-agent 0.12.12 → 0.12.14

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

@@ -16,11 +16,13 @@
 
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import { logger } from "@gajae-code/utils";
 import {
 	bold,
 	buildCompactChoiceGrid,
 	escapeHtml,
 	numberedOptionList,
+	renumberableOptionText,
 	splitTelegramHtml,
 	TELEGRAM_PARSE_MODE,
 } from "./html-format";
@@ -34,6 +36,44 @@ const REFERENCE_CLIENT_HELLO = {
 	capabilities: ["ask_controls_v1"],
 } as const;
 
+const MAX_DIAGNOSTIC_CAPABILITIES = 4;
+const MAX_DIAGNOSTIC_CAPABILITY_CODE_POINTS = 64;
+const MAX_DIAGNOSTIC_ERROR_NAME_CODE_POINTS = 64;
+const MAX_DIAGNOSTIC_ERROR_MESSAGE_CODE_POINTS = 128;
+
+function boundedDiagnosticText(value: string, maxCodePoints: number): string {
+	let result = "";
+	let codePoints = 0;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0)!;
+		if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) continue;
+		result += character;
+		codePoints++;
+		if (codePoints === maxCodePoints) break;
+	}
+	return result;
+}
+
+function boundedDiagnosticCallbackError(error: unknown): Readonly<{ errorName: string; errorMessage: string }> {
+	let errorName = "UnknownError";
+	let errorMessage = "Diagnostic callback threw";
+	try {
+		if (error instanceof Error) {
+			errorName = boundedDiagnosticText(error.name, MAX_DIAGNOSTIC_ERROR_NAME_CODE_POINTS) || "Error";
+			errorMessage =
+				boundedDiagnosticText(error.message, MAX_DIAGNOSTIC_ERROR_MESSAGE_CODE_POINTS) ||
+				"Diagnostic callback threw";
+		} else {
+			errorMessage =
+				boundedDiagnosticText(String(error), MAX_DIAGNOSTIC_ERROR_MESSAGE_CODE_POINTS) ||
+				"Diagnostic callback threw";
+		}
+	} catch {
+		// Hostile thrown values must not escape the diagnostic failure boundary.
+	}
+	return Object.freeze({ errorName, errorMessage });
+}
+
 /** One inline-keyboard button. */
 export interface InlineButton {
 	text: string;
@@ -254,7 +294,7 @@ export function buildActionMarkdown(action: {
 	const options = action.options ?? [];
 	const displayOptions = withRecommendedOptionLabel(options, action.recommendedIndex);
 	if (options.length === 0) return `${heading}\n\n(reply with text)`;
-	const list = displayOptions.map((label, i) => `${i + 1}. ${label.replace(/^\s*\d+[.)]\s+/, "")}`).join("\n");
+	const list = displayOptions.map((label, i) => `${i + 1}. ${renumberableOptionText(label)}`).join("\n");
 	return `${heading}\n\n${list}`;
 }
 
@@ -406,6 +446,12 @@ export function readEndpoint(path: string): { url: string; token: string; pid?:
 	};
 }
 
+/** A bounded, diagnostic-only notification mirrored to reference-client embedders. */
+export type TelegramReferenceDiagnostic = Readonly<{
+	code: "action_unavailable";
+	requiredCapabilities: readonly string[];
+}>;
+
 /** Options for {@link runTelegramReferenceClient}. */
 export interface TelegramReferenceOptions {
 	botToken: string;
@@ -414,6 +460,11 @@ export interface TelegramReferenceOptions {
 	apiBase?: string;
 	fetchImpl?: typeof fetch;
 	sound?: TelegramNotificationSound;
+	/**
+	 * Additive mirror of bounded logger diagnostics. It never receives tokens,
+	 * identifiers, raw frames, Telegram content, or WebSocket replies.
+	 */
+	onDiagnostic?: (diagnostic: TelegramReferenceDiagnostic) => void;
 }
 
 /**
@@ -470,15 +521,27 @@ export async function runTelegramReferenceClient(opts: TelegramReferenceOptions)
 				msg.kind ?? "ask",
 			);
 		} else if (msg.type === "action_unavailable") {
-			const requiredCapabilities = Array.isArray(msg.requiredCapabilities)
-				? msg.requiredCapabilities
-						.filter((capability): capability is string => typeof capability === "string")
-						.slice(0, 4)
-						.map(capability => capability.slice(0, 64))
-				: [];
-			console.warn(
-				`Telegram reference client: server withheld a controlled ask because this client lacks requiredCapabilities=[${requiredCapabilities.join(", ") || "unspecified"}].`,
+			const requiredCapabilities = Object.freeze(
+				Array.isArray(msg.requiredCapabilities)
+					? msg.requiredCapabilities
+							.filter((capability): capability is string => typeof capability === "string")
+							.slice(0, MAX_DIAGNOSTIC_CAPABILITIES)
+							.map(capability => boundedDiagnosticText(capability, MAX_DIAGNOSTIC_CAPABILITY_CODE_POINTS))
+					: [],
 			);
+			const diagnostic: TelegramReferenceDiagnostic = Object.freeze({
+				code: "action_unavailable",
+				requiredCapabilities,
+			});
+			logger.warn("Telegram reference client action unavailable", diagnostic);
+			try {
+				opts.onDiagnostic?.(diagnostic);
+			} catch (error) {
+				logger.warn("Telegram reference client diagnostic callback failed", {
+					code: "diagnostic_callback_failed",
+					...boundedDiagnosticCallbackError(error),
+				});
+			}
 			// Diagnostic only: never turn it into a Telegram prompt or option buttons.
 			return;
 		} else if (msg.type === "action_resolved" && msg.id === latestPendingAskId) {

package/src/sdk/session.ts

@@ -1253,7 +1253,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				return SessionManager.create(cwd, SessionManager.managedDestination(cwd, agentDir));
 			}));
 		const logicalSessionId = sessionManager.getSessionId();
-		const providerSessionId = options.providerSessionId ?? options.forkContextSeed?.cacheIdentity ?? logicalSessionId;
+		// Fork-context seeds carry conversation content only, never provider identity:
+		// a shared continuity id would make concurrent subagents present the same
+		// session_id upstream, where session-owning transports reject the extra
+		// downstreams (owner_busy) and degrade those turns to uncached HTTP.
+		const providerSessionId = options.providerSessionId ?? logicalSessionId;
 		const modelApiKeyAvailability = new Map<string, boolean>();
 		const getModelAvailabilityKey = (candidate: Model): string =>
 			`${candidate.provider}\u0000${candidate.baseUrl ?? ""}`;

package/src/session/agent-session.ts

@@ -159,7 +159,6 @@ export interface ForkContextSeed {
 	messages: Message[];
 	agentMessages: AgentMessage[];
 	metadata: ForkContextSeedMetadata;
-	cacheIdentity?: string;
 	appendOnlyPrefixSnapshot?: StablePrefixSnapshot;
 }
 
@@ -167,7 +166,6 @@ export interface ForkContextSeedOptions {
 	maxMessages: number;
 	maxTokens: number;
 	preserveLatestUser?: boolean;
-	cacheIdentity?: string;
 	signal?: AbortSignal;
 }
 
@@ -3118,7 +3116,6 @@ export class AgentSession {
 					maxTokens,
 					skippedReasons: {},
 				},
-				cacheIdentity: options.cacheIdentity ?? this.sessionId,
 			};
 		}
 		const transformedMessages = await this.#transformContext([...this.messages], options.signal);
@@ -3318,7 +3315,6 @@ export class AgentSession {
 				maxTokens,
 				skippedReasons,
 			},
-			cacheIdentity: options.cacheIdentity ?? this.sessionId,
 			appendOnlyPrefixSnapshot,
 		};
 	}

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

@@ -943,6 +943,13 @@ export class ManagedSessionDescendantStore {
 			detachOnly: true,
 			quarantineName,
 		});
+		if (
+			!detached.ok &&
+			detached.code === "not_found" &&
+			detached.retainedSuccessorPath === undefined &&
+			detached.retainedUnknownPath === undefined
+		)
+			return;
 		if (
 			(!detached.ok && detached.code !== "cleanup_pending") ||
 			detached.detachedPath !== path.join(this.#baseDir, quarantineName) ||
@@ -956,7 +963,13 @@ export class ManagedSessionDescendantStore {
 	#reconcileLegacyReplacementCleanupReceipt(receiptPath: string, name: string): void {
 		const binding = legacyReplacementCleanupReceiptBinding(name);
 		if (!binding) throw new Error("managed_replace_cleanup_receipt_invalid");
-		const receipt = captureManagedFileNoFollow(receiptPath);
+		let receipt: ManagedFileSnapshot;
+		try {
+			receipt = captureManagedFileNoFollow(receiptPath);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+			throw error;
+		}
 		const parsed = parseLegacyReplacementCleanupReceipt(receipt.bytes);
 		const expectedPredecessor = path.join(
 			this.#baseDir,
@@ -985,7 +998,16 @@ export class ManagedSessionDescendantStore {
 		if (!exactUnlinkCompleted(retired) && retired.code !== "not_found")
 			throw new Error(`managed_replace_cleanup_pending:${retired.code ?? "unknown"}`);
 
-		const currentReceipt = captureManagedFileNoFollow(receiptPath);
+		let currentReceipt: ManagedFileSnapshot;
+		try {
+			currentReceipt = captureManagedFileNoFollow(receiptPath);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				fsyncDirectory(this.#baseDir);
+				return;
+			}
+			throw error;
+		}
 		if (
 			!sameIdentity(currentReceipt.identity, receipt.identity) ||
 			currentReceipt.identity.sha256 !== receipt.identity.sha256

package/src/session/session-manager.ts

@@ -76,6 +76,7 @@ import {
 	assertManagedDirectoryRoot,
 	captureManagedFileNoFollow,
 	fsyncManagedArtifactTree,
+	MANAGED_ARTIFACT_MAX_FILE_BYTES,
 	type ManagedDirectoryRoot,
 	type ManagedFileSnapshot,
 	ManagedSessionDescendantStore,
@@ -915,12 +916,25 @@ export interface ResumeTailTerminal {
 
 export interface ResumeTailError {
 	kind: "error";
-	reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled";
+	reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled" | "oversized";
+	size?: number;
 }
 
 export type SessionDirectoryMigrationPolicy = ManagedMigrationPolicy;
 export type SessionAppendPersistenceFailurePhase = "current_append" | "prior_failure";
 
+/**
+ * Safety bound for resuming a single transcript file. Matches the managed-storage
+ * per-file artifact limit (`MANAGED_ARTIFACT_MAX_FILE_BYTES`): transcripts at or above
+ * this size are not loaded into memory wholesale because the decode + per-line JSON
+ * parse + identity hash would OOM or stall the process (#3851). The bound is a
+ * load-time guard only; it does not raise the on-disk managed-storage limit.
+ */
+export const RESUME_TRANSCRIPT_MAX_BYTES = MANAGED_ARTIFACT_MAX_FILE_BYTES;
+
+export const SESSION_OVERSIZED_RECOVERY_MESSAGE =
+	"The selected session transcript is too large to resume safely. Use `gjc export <session-file>` to export its content into a new session, or remove/archive it after confirming its content is no longer needed.";
+
 export class SessionAppendPersistenceError extends Error {
 	readonly phase: SessionAppendPersistenceFailurePhase;
 	readonly entryId: string;
@@ -964,6 +978,17 @@ export class SessionArtifactCapacityError extends Error {
 	}
 }
 
+export class SessionTranscriptOversizedError extends Error {
+	readonly code = "oversized";
+	readonly size: number;
+
+	constructor(size: number) {
+		super(SESSION_OVERSIZED_RECOVERY_MESSAGE);
+		this.name = "SessionTranscriptOversizedError";
+		this.size = size;
+	}
+}
+
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
 	kind: "opened";
@@ -979,6 +1004,7 @@ export interface StrictSessionOpenFailure {
 		| "artifact_capacity_exceeded"
 		| "migration_busy";
 	message?: string;
+	size?: number;
 }
 
 /** Exact transcript bytes and authority captured from one descriptor-bound read. */
@@ -2346,6 +2372,12 @@ function inspectResumeSessionFile(
 	if (!before.isFile || !storage.readSnapshotSync) {
 		return { kind: "error", reason: "read-failed" };
 	}
+	// Fail closed on oversized transcripts before the full read/decode/parse
+	// path that would otherwise OOM or stall the process (#3851). The stat is
+	// already in hand; this bound matches the managed-storage per-file limit.
+	if (before.size > RESUME_TRANSCRIPT_MAX_BYTES) {
+		return { kind: "error", reason: "oversized", size: before.size };
+	}
 
 	let bytes: Uint8Array;
 	let snapshot: SessionStorageStat;
@@ -4378,12 +4410,6 @@ function extractTextFromContent(content: Message["content"]): string {
 
 const SESSION_LIST_PREFIX_BYTES = 4096;
 const SESSION_LIST_TRAILING_PATCH_BYTES = 4096;
-// Hard cap on how many trailing bytes the listers may scan for header patches.
-// moveTo folds cwd patches into line 1 via a full atomic rewrite, so only a
-// recent title patch can live unfolded near EOF; anything buried deeper is
-// folded on the next natural full rewrite. Keeping this bounded preserves the
-// O(SESSION_LIST_PREFIX_BYTES) listing cost that SESSION_LIST_PREFIX_BYTES exists for.
-const SESSION_LIST_TRAILING_PATCH_SCAN_CAP = SESSION_LIST_TRAILING_PATCH_BYTES * 4;
 const SESSION_NAME_MAX_CHARS = 1_000;
 const SESSION_LIST_PARALLEL_THRESHOLD = 64;
 const SESSION_LIST_MAX_WORKERS = 16;
@@ -4419,12 +4445,17 @@ async function readSessionListTrailingPatches(
 	if (size <= SESSION_LIST_PREFIX_BYTES) return [];
 	const latest: HeaderPatchRecord["patch"] = {};
 	let position = size;
-	const scanFloor = Math.max(0, size - SESSION_LIST_TRAILING_PATCH_SCAN_CAP);
+	// Reverse-scan from EOF in fixed chunks. Stop once both cwd and title
+	// resolve so recent patches stay cheap. Continue past the historical 16 KiB
+	// window when a field is still missing so a buried but canonically valid
+	// header_patch remains listable without a full sequential JSONL parse (#3633).
+	// Chunks that cannot contain a header_patch marker skip JSON parsing.
 	let trailingFragment = Buffer.alloc(0);
 	const chunkSize = Math.min(buffer.byteLength, SESSION_LIST_TRAILING_PATCH_BYTES);
+	const headerPatchMarker = Buffer.from("header_patch");
 	const handle = await fs.promises.open(file, "r");
 	try {
-		while (position > scanFloor && (latest.cwd === undefined || latest.title === undefined)) {
+		while (position > 0 && (latest.cwd === undefined || latest.title === undefined)) {
 			const start = Math.max(0, position - chunkSize);
 			const length = position - start;
 			const { bytesRead } = await handle.read(buffer, 0, length, start);
@@ -4440,18 +4471,26 @@ async function readSessionListTrailingPatches(
 				trailingFragment = combined.subarray(0, firstNewline);
 				complete = combined.subarray(firstNewline + 1);
 			}
-			const lines = complete.toString("utf8").split("\n");
-			for (let index = lines.length - 1; index >= 0; index--) {
-				const line = lines[index];
-				if (!line) continue;
-				try {
-					const record = JSON.parse(line) as SessionPatchRecord;
-					if (!isHeaderPatchRecord(record)) continue;
-					if (latest.cwd === undefined && typeof record.patch.cwd === "string") latest.cwd = record.patch.cwd;
-					if (latest.title === undefined && typeof record.patch.title === "string")
-						latest.title = record.patch.title;
-				} catch {
-					// Ignore malformed or partial records exactly as the canonical loader does.
+			// Marker may straddle the discarded partial first line; still parse when
+			// the raw chunk or carried fragment could hold a header_patch record.
+			const mayContainPatch =
+				complete.includes(headerPatchMarker) ||
+				buffer.subarray(0, bytesRead).includes(headerPatchMarker) ||
+				trailingFragment.includes(headerPatchMarker);
+			if (mayContainPatch) {
+				const lines = complete.toString("utf8").split("\n");
+				for (let index = lines.length - 1; index >= 0; index--) {
+					const line = lines[index];
+					if (!line?.includes("header_patch")) continue;
+					try {
+						const record = JSON.parse(line) as SessionPatchRecord;
+						if (!isHeaderPatchRecord(record)) continue;
+						if (latest.cwd === undefined && typeof record.patch.cwd === "string") latest.cwd = record.patch.cwd;
+						if (latest.title === undefined && typeof record.patch.title === "string")
+							latest.title = record.patch.title;
+					} catch {
+						// Ignore malformed or partial records exactly as the canonical loader does.
+					}
 				}
 			}
 			position = start;
@@ -9938,6 +9977,16 @@ export class SessionManager {
 		// owner-only and reparse guards accept.
 		if (storage instanceof FileSessionStorage) filePath = canonicalizeTrustedPath(filePath);
 		if (destination.kind === "explicit" || !(storage instanceof FileSessionStorage)) {
+			// Fail closed on oversized transcripts before the full read in the explicit path too (#3851).
+			// A missing file falls through to loadEntriesFromFile, which returns [] and creates
+			// a fresh session — matching the pre-existing behavior.
+			try {
+				const preStat = storage.statSync(filePath);
+				if (preStat.size > RESUME_TRANSCRIPT_MAX_BYTES) throw new SessionTranscriptOversizedError(preStat.size);
+			} catch (error) {
+				if (error instanceof SessionTranscriptOversizedError) throw error;
+				if (!isEnoent(error)) throw error;
+			}
 			const entries = await loadEntriesFromFile(filePath, storage);
 			const header = entries.find(entry => entry.type === "session") as SessionHeader | undefined;
 			const manager = new SessionManager(
@@ -9958,6 +10007,7 @@ export class SessionManager {
 				await manager.#initSessionFile(filePath);
 				return manager;
 			}
+			if (inspected.reason === "oversized") throw new SessionTranscriptOversizedError(inspected.size ?? 0);
 			throw new Error(`Could not open session: ${inspected.reason}`);
 		}
 		const opened = await SessionManager.openExistingStrict(inspected.identity, destination, storage, migrationPolicy);
@@ -9967,6 +10017,7 @@ export class SessionManager {
 				throw new SessionArtifactCapacityError(
 					opened.message ?? "Session artifacts exceed the migration capacity.",
 				);
+			if (opened.reason === "oversized") throw new SessionTranscriptOversizedError(opened.size ?? 0);
 			if (opened.reason === "migration_busy") throw new SessionMigrationBusyError();
 			throw new Error(`Could not open session: ${opened.reason}`);
 		}
@@ -10705,7 +10756,10 @@ export class SessionManager {
 		const dir = destination.directory;
 		const openSelectedStrictly = async (selectedPath: string): Promise<SessionManager | undefined> => {
 			const inspected = await SessionManager.inspectSessionTailReadOnly(selectedPath, storage);
-			if (inspected.kind === "error") return undefined;
+			if (inspected.kind === "error") {
+				if (inspected.reason === "oversized") throw new SessionTranscriptOversizedError(inspected.size ?? 0);
+				return undefined;
+			}
 			const opened = await SessionManager.openExistingStrict(
 				inspected.identity,
 				destination,
@@ -10718,6 +10772,7 @@ export class SessionManager {
 					throw new SessionArtifactCapacityError(
 						opened.message ?? "Session artifacts exceed the migration capacity.",
 					);
+				if (opened.reason === "oversized") throw new SessionTranscriptOversizedError(opened.size ?? 0);
 				if (opened.reason === "migration_busy") throw new SessionMigrationBusyError();
 				return undefined;
 			}

package/src/setup/provider-presets.json

@@ -1,6 +1,6 @@
 [
-  {"id":"minimax","aliases":["minimax-code"],"name":"MiniMax Coding Plan","description":"OpenAI-compatible MiniMax Coding Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code","baseUrl":"https://api.minimax.io/v1","apiKeyEnv":"MINIMAX_CODE_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
-  {"id":"minimax-cn","aliases":["minimax-code-cn","minimaxi"],"name":"MiniMax Coding Plan (China)","description":"OpenAI-compatible MiniMax China endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code-cn","baseUrl":"https://api.minimaxi.com/v1","apiKeyEnv":"MINIMAX_CODE_CN_API_KEY","models":["minimax-m3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"minimax","aliases":["minimax-code"],"name":"MiniMax Coding Plan","description":"OpenAI-compatible MiniMax Coding Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code","baseUrl":"https://api.minimax.io/v1","apiKeyEnv":"MINIMAX_CODE_API_KEY","models":["MiniMax-M3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"minimax-cn","aliases":["minimax-code-cn","minimaxi"],"name":"MiniMax Coding Plan (China)","description":"OpenAI-compatible MiniMax China endpoint","compatibility":"openai","api":"openai-completions","providerId":"minimax-code-cn","baseUrl":"https://api.minimaxi.com/v1","apiKeyEnv":"MINIMAX_CODE_CN_API_KEY","models":["MiniMax-M3"],"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
   {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}},
-  {"id":"alibaba-token-plan","aliases":["alibaba","token-plan"],"name":"Alibaba Token Plan","description":"OpenAI-compatible Alibaba Token Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"alibaba-token-plan","baseUrl":"https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1","apiKeyEnv":"ALIBABA_TOKEN_PLAN_API_KEY","models":["qwen3.8-max-preview","qwen-3.8-max","glm-5.2","deepseek-v4-pro"],"modelApi":{"qwen3.8-max-preview":"openai-responses","qwen-3.8-max":"openai-responses","glm-5.2":"openai-completions","deepseek-v4-pro":"openai-completions"},"compat":{"supportsDeveloperRole":false}}
+  {"id":"alibaba-token-plan","aliases":["alibaba","token-plan"],"name":"Alibaba Token Plan","description":"OpenAI-compatible Alibaba Token Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"alibaba-token-plan","baseUrl":"https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1","apiKeyEnv":"ALIBABA_TOKEN_PLAN_API_KEY","models":["qwen3.8-max-preview","qwen3.8-max","glm-5.2","deepseek-v4-pro"],"modelApi":{"qwen3.8-max-preview":"openai-responses","qwen3.8-max":"openai-responses","glm-5.2":"openai-completions","deepseek-v4-pro":"openai-completions"},"compat":{"supportsDeveloperRole":false}}
 ]

package/src/thinking-metadata.ts

@@ -39,7 +39,8 @@ const THINKING_LEVEL_METADATA: Record<ThinkingLevelValue, ThinkingLevelMetadata>
 	max: {
 		value: "max",
 		label: "max",
-		description: "Opus maximum reasoning",
+		// Provider-neutral: max is not Anthropic/Opus-specific (OpenAI, Luna, etc.).
+		description: "Absolute maximum reasoning",
 	},
 };
 

package/src/tools/ask.ts

@@ -763,6 +763,8 @@ interface AskSingleQuestionOptions {
 	onRemoteState?: (state: {
 		interaction: "selector" | "custom_editor" | "clarification_editor";
 		selectedCount: number;
+		/** Currently selected option labels, so a remote transport can render the selection. */
+		selectedOptions: readonly string[];
 		hasNonWhitespaceCustom: boolean;
 	}) => void;
 }
@@ -900,6 +902,7 @@ async function askSingleQuestion(
 			options.onRemoteState?.({
 				interaction: "custom_editor",
 				selectedCount: selectedOptions.length,
+				selectedOptions: [...selectedOptions],
 				hasNonWhitespaceCustom: (customInput?.trim().length ?? 0) > 0,
 			});
 			return ui.editor("Enter your response:", undefined, dialogOptions, { promptStyle: true });
@@ -913,6 +916,7 @@ async function askSingleQuestion(
 			options.onRemoteState?.({
 				interaction: "clarification_editor",
 				selectedCount: selectedOptions.length,
+				selectedOptions: [...selectedOptions],
 				hasNonWhitespaceCustom: false,
 			});
 			return ui.editor("Ask a clarification question:", undefined, dialogOptions, { promptStyle: true });
@@ -949,6 +953,7 @@ async function askSingleQuestion(
 			options.onRemoteState?.({
 				interaction: "selector",
 				selectedCount: selected.size,
+				selectedOptions: [...selected],
 				hasNonWhitespaceCustom: (customInput?.trim().length ?? 0) > 0,
 			});
 			const prefix = selected.size > 0 ? `(${selected.size} selected) ` : "";
@@ -1054,6 +1059,7 @@ async function askSingleQuestion(
 		options.onRemoteState?.({
 			interaction: "selector",
 			selectedCount: selectedOptions.length,
+			selectedOptions: [...selectedOptions],
 			hasNonWhitespaceCustom: (customInput?.trim().length ?? 0) > 0,
 		});
 		const {
@@ -1591,6 +1597,8 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 					options: remoteSelectorOptions,
 					interaction: "selector",
 					...(recommendedIndex === undefined ? {} : { recommendedIndex }),
+					multi: q.multi === true,
+					selectedOptions: [...(initialSelection?.selectedOptions ?? [])],
 					controls: askRemoteControls({
 						multi: q.multi === true,
 						questionIndex,
@@ -1625,6 +1633,8 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 							...(state.interaction === "selector" && recommendedIndex !== undefined
 								? { recommendedIndex }
 								: {}),
+							multi: q.multi === true,
+							selectedOptions: [...state.selectedOptions],
 							controls:
 								state.interaction === "selector"
 									? askRemoteControls({

package/src/tools/index.ts

@@ -139,6 +139,13 @@ export interface AskAnswerRequest {
 	controls: readonly AskRemoteControl[];
 	/** Optional zero-based recommendation into the authoritative raw options. */
 	recommendedIndex?: number;
+	/** True while the question accepts several options before the navigation control commits. */
+	multi?: boolean;
+	/**
+	 * Options currently selected in the multi-select loop, as authoritative option
+	 * labels. Remote transports render the selection state so a toggle is visible.
+	 */
+	selectedOptions?: readonly string[];
 }
 
 export type AskRemoteInteraction =

package/src/tools/todo-write.ts

@@ -73,14 +73,14 @@ function hasUnknownKeys(value: object, allowed: Set<string>): boolean {
 }
 
 function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgumentValidationResult {
-	if (hasUnknownKeys(arguments_, TODO_WRITE_KEYS)) return { outcome: "reject" };
+	if (hasUnknownKeys(arguments_, TODO_WRITE_KEYS)) return { outcome: "reject", code: "todo-write-unknown-root-key" };
 	if (!Array.isArray(arguments_.ops)) return { outcome: "passthrough" };
 	for (const entry of arguments_.ops) {
 		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
-		if (hasUnknownKeys(entry, TODO_OP_KEYS)) return { outcome: "reject" };
+		if (hasUnknownKeys(entry, TODO_OP_KEYS)) return { outcome: "reject", code: "todo-write-unknown-op-entry-key" };
 		const record = entry as Record<string, unknown>;
 		if ((record.op === "done" || record.op === "drop") && !record.task && !record.phase) {
-			return { outcome: "reject" };
+			return { outcome: "reject", code: "todo-write-done-drop-requires-target" };
 		}
 		const list = record.list;
 		if (!Array.isArray(list)) continue;
@@ -91,7 +91,7 @@ function validateRawTodoArguments(arguments_: Record<string, unknown>): RawArgum
 				!Array.isArray(item) &&
 				hasUnknownKeys(item, TODO_INIT_ENTRY_KEYS)
 			)
-				return { outcome: "reject" };
+				return { outcome: "reject", code: "todo-write-unknown-init-entry-key" };
 		}
 	}
 	return { outcome: "passthrough" };