@gajae-code/coding-agent 0.15.3 → 0.15.4

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

@@ -72,6 +72,7 @@ export interface HookSelectorOptions {
 	customInput?: {
 		optionLabel: string;
 		onSubmit: (text: string) => void;
+		allowEmpty?: boolean;
 	};
 	clarificationInput?: {
 		optionLabel: string;
@@ -390,7 +391,7 @@ export class HookSelectorComponent extends Container {
 	#outline: boolean;
 	#scrollTitleRows: number | undefined;
 	#inlineEditorMaxHeight: number | undefined;
-	#customInput: { optionLabel: string; onSubmit: (text: string) => void } | undefined;
+	#customInput: { optionLabel: string; onSubmit: (text: string) => void; allowEmpty?: boolean } | undefined;
 	#clarificationInput: { optionLabel: string; onSubmit: (text: string) => void; allowEmpty?: boolean } | undefined;
 	#activeInput: { onSubmit: (text: string) => void; allowEmpty?: boolean } | undefined;
 	#inputArea: Container;

package/src/modes/controllers/extension-ui-controller.ts

@@ -1154,6 +1154,7 @@ export class ExtensionUiController {
 				customInput: dialogOptions?.customInput
 					? {
 							optionLabel: dialogOptions.customInput.optionLabel,
+							allowEmpty: (dialogOptions.customInput as { allowEmpty?: boolean }).allowEmpty,
 							onSubmit: text => {
 								const optionLabel = dialogOptions.customInput?.optionLabel;
 								this.hideHookSelector();

package/src/session/agent-session.ts

@@ -20,6 +20,7 @@ import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
 import * as util from "node:util";
 import {
+	AdaptiveCompactionTracker,
 	type AfterToolCallContext,
 	type AfterToolCallResult,
 	type Agent,
@@ -2430,6 +2431,8 @@ export class AgentSession {
 	// required to re-trigger. A content signature (not object identity) is used so
 	// it survives the message-array rebuild that compaction/prune perform.
 	#lastMidRunMaintenanceAnchorSignature: string | undefined = undefined;
+	#adaptiveCompactionTracker = new AdaptiveCompactionTracker();
+	#adaptiveCompactionRecordedMessageKey: string | undefined;
 	#resourceSampler: () => EmergencyCompactionSample = () => this.#defaultResourceSample();
 	#retainedMemorySampler: (() => RetainedMemorySample) | undefined;
 
@@ -7702,6 +7705,7 @@ export class AgentSession {
 	 * such event.
 	 */
 	#syncAgentSessionId(sessionId?: string): void {
+		this.#resetAdaptiveCompactionState();
 		this.#reasoningControlContextGeneration++;
 		const sid = this.#providerSessionId ?? sessionId ?? this.sessionManager.getSessionId();
 		this.agent.sessionId = sid;
@@ -15857,6 +15861,7 @@ export class AgentSession {
 					fromExtension,
 					preserveData,
 				);
+				this.#recordAdaptiveCompactionReset(tokensBefore);
 				await this.#applyCompactionPostAppend(compactionEntryId, firstKeptEntryId, fromExtension);
 
 				const compactionResult: CompactionResult = {
@@ -16380,7 +16385,12 @@ export class AgentSession {
 		// which breaks the provider prompt-cache prefix mid-epoch. Only prune at a
 		// sanctioned maintenance boundary, i.e. when the un-pruned context already
 		// crosses the compaction threshold. Pruning may then avert full compaction.
-		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens))
+		const adaptiveCompactionSettings = this.#recordAdaptiveCompactionCall(
+			contextTokens,
+			compactionSettings,
+			assistantMessage,
+		);
+		if (!shouldCompact(contextTokens, contextWindow, adaptiveCompactionSettings, autoCompactionOutputReserveTokens))
 			return true;
 		const pruneEstimate = estimateToolOutputPruneSavings(this.sessionManager.getBranch(), DEFAULT_PRUNE_CONFIG, {
 			relaxedMinimum: 0,
@@ -16391,7 +16401,7 @@ export class AgentSession {
 			!shouldCompact(
 				Math.max(0, contextTokens - pruneEstimate.tokensSaved),
 				contextWindow,
-				compactionSettings,
+				adaptiveCompactionSettings,
 				autoCompactionOutputReserveTokens,
 			)
 		) {
@@ -16399,7 +16409,8 @@ export class AgentSession {
 			if (ownershipSignal?.aborted) return false;
 			if (pruneResult) contextTokens = Math.max(0, contextTokens - pruneResult.tokensSaved);
 		}
-		if (shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
+		const prunedCompactionSettings = this.#compactionSettingsWithAdaptiveState(compactionSettings);
+		if (shouldCompact(contextTokens, contextWindow, prunedCompactionSettings, autoCompactionOutputReserveTokens)) {
 			// Try promotion first — if a larger model is available, switch instead of compacting
 			const promoted = await this.#tryContextPromotion(assistantMessage, ownershipSignal);
 			if (ownershipSignal?.aborted) return false;
@@ -16453,7 +16464,7 @@ export class AgentSession {
 			}
 			if (isAborted()) return result("aborted");
 
-			// In-place context-full maintenance only. "off" defers entirely; "handoff"
+			// context-full maintenance. "off" defers entirely; "handoff"
 			// keeps its existing agent_end / pre-prompt boundaries (a mid-tool-loop
 			// session swap would be far more disruptive than the overflow it avoids).
 			const compactionSettings = this.settings.getGroup("compaction");
@@ -16469,7 +16480,12 @@ export class AgentSession {
 			const autoCompactionOutputReserveTokens = 0;
 			const anchor = this.#findMidRunUsageAnchor(context.messages);
 			let contextTokens = this.#estimateMidRunContextTokens(context.messages);
-			if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
+			const adaptiveCompactionSettings = anchor
+				? this.#recordAdaptiveCompactionCall(contextTokens, compactionSettings, anchor.message)
+				: this.#compactionSettingsWithAdaptiveState(compactionSettings);
+			if (
+				!shouldCompact(contextTokens, contextWindow, adaptiveCompactionSettings, autoCompactionOutputReserveTokens)
+			) {
 				return result("not-needed");
 			}
 			// Anti-loop (#1662): a given provider response anchors at most one
@@ -16503,7 +16519,7 @@ export class AgentSession {
 				!shouldCompact(
 					Math.max(0, contextTokens - pruneEstimate.tokensSaved),
 					contextWindow,
-					compactionSettings,
+					adaptiveCompactionSettings,
 					autoCompactionOutputReserveTokens,
 				)
 			) {
@@ -16512,7 +16528,9 @@ export class AgentSession {
 				if (pruneResult?.failure === "artifact_persistence") return result("failed");
 				if (pruneResult) contextTokens = Math.max(0, contextTokens - pruneResult.tokensSaved);
 			}
-			if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
+			if (
+				!shouldCompact(contextTokens, contextWindow, adaptiveCompactionSettings, autoCompactionOutputReserveTokens)
+			) {
 				return pruneResult?.committed ? result("pruned", true) : result("not-needed");
 			}
 
@@ -16675,7 +16693,8 @@ export class AgentSession {
 		// Model maxTokens is a capability ceiling, not a per-turn reservation.
 		// Auto maintenance should track actual context fullness.
 		const autoCompactionOutputReserveTokens = 0;
-		if (!shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
+		const adaptiveCompactionSettings = this.#compactionSettingsWithAdaptiveState(compactionSettings);
+		if (!shouldCompact(contextTokens, contextWindow, adaptiveCompactionSettings, autoCompactionOutputReserveTokens)) {
 			// Below the compaction threshold: optionally run evidence-gated maintenance
 			// pruning (opt-in, high savings + cache-epoch payback required).
 			await this.#maybeRunBelowThresholdMaintenancePrune();
@@ -16691,14 +16710,15 @@ export class AgentSession {
 			!shouldCompact(
 				Math.max(0, contextTokens - pruneEstimate.tokensSaved),
 				contextWindow,
-				compactionSettings,
+				adaptiveCompactionSettings,
 				autoCompactionOutputReserveTokens,
 			)
 		) {
 			const pruneResult = await this.#pruneToolOutputs(undefined, true);
 			if (pruneResult) contextTokens = Math.max(0, contextTokens - pruneResult.tokensSaved);
 		}
-		if (shouldCompact(contextTokens, contextWindow, compactionSettings, autoCompactionOutputReserveTokens)) {
+		const prunedCompactionSettings = this.#compactionSettingsWithAdaptiveState(compactionSettings);
+		if (shouldCompact(contextTokens, contextWindow, prunedCompactionSettings, autoCompactionOutputReserveTokens)) {
 			await this.#runAutoCompaction("threshold", false, false, {
 				continueAfterMaintenance: false,
 				deferHandoffMaintenance: false,
@@ -16706,6 +16726,45 @@ export class AgentSession {
 		}
 	}
 
+	#recordAdaptiveCompactionCall<T extends { adaptive?: { enabled: boolean; turnWindow: number } }>(
+		contextTokens: number,
+		settings: T,
+		assistantMessage: AssistantMessage,
+	): T {
+		if (!settings.adaptive?.enabled) return settings;
+		this.#adaptiveCompactionTracker.setWindowMs(settings.adaptive.turnWindow * 60_000);
+		const messageKey = this.#adaptiveCompactionMessageKey(assistantMessage);
+		if (this.#adaptiveCompactionRecordedMessageKey === messageKey) {
+			return this.#compactionSettingsWithAdaptiveState(settings);
+		}
+		this.#adaptiveCompactionRecordedMessageKey = messageKey;
+		this.#adaptiveCompactionTracker.recordCall(contextTokens);
+		return this.#compactionSettingsWithAdaptiveState(settings);
+	}
+
+	#adaptiveCompactionMessageKey(message: AssistantMessage): string {
+		return `${message.provider}\u0000${message.model}\u0000${message.timestamp}\u0000${message.usage?.totalTokens ?? ""}`;
+	}
+
+	#compactionSettingsWithAdaptiveState<T extends { adaptive?: { enabled: boolean } }>(settings: T): T {
+		if (!settings.adaptive?.enabled) return settings;
+		return {
+			...settings,
+			adaptiveState: this.#adaptiveCompactionTracker.decisionState(),
+		};
+	}
+
+	#resetAdaptiveCompactionState(): void {
+		this.#adaptiveCompactionTracker.reset();
+		this.#adaptiveCompactionRecordedMessageKey = undefined;
+	}
+
+	#recordAdaptiveCompactionReset(contextTokens: number): void {
+		this.#adaptiveCompactionTracker.reset();
+		this.#adaptiveCompactionTracker.recordCompact(contextTokens);
+		this.#adaptiveCompactionRecordedMessageKey = undefined;
+	}
+
 	#assistantEndedWithSuccessfulYield(assistantMessage: AssistantMessage): boolean {
 		const toolCallId = this.#lastSuccessfulYieldToolCallId;
 		if (!toolCallId) return false;
@@ -18156,6 +18215,7 @@ export class AgentSession {
 				fromExtension,
 				preserveData,
 			);
+			this.#recordAdaptiveCompactionReset(tokensBefore);
 			await this.#applyCompactionPostAppend(compactionEntryId, firstKeptEntryId, fromExtension);
 			if (autoCompactionSignal.aborted) return await emitAborted();
 

package/src/tools/ask-contract.ts

@@ -7,6 +7,11 @@ import { INTENT_FIELD } from "@gajae-code/agent-core";
 import type { RawArgumentValidationResult } from "@gajae-code/ai/types";
 import * as z from "zod/v4";
 import { deepInterviewCharacterCount } from "../gjc-runtime/deep-interview-state";
+import {
+	isLegacyDeepInterviewPlaceholder,
+	isWorkflowPlaceholderText,
+	WORKFLOW_PLACEHOLDER_CORRECTION,
+} from "../gjc-runtime/workflow-placeholder";
 
 function deepInterviewBoundedString(maximum: number) {
 	return z.string().superRefine((value, context) => {
@@ -146,6 +151,13 @@ function createQuestionItemSchema(deepInterviewSchema: z.ZodType<DeepInterviewMe
 			workflowGate: WorkflowGateMeta.describe("optional workflow gate stage/kind override").optional(),
 		})
 		.superRefine((value, context) => {
+			if (value.deepInterview !== undefined && isWorkflowPlaceholderText(value.question)) {
+				context.addIssue({
+					code: "custom",
+					message: `deep-interview question body must ${WORKFLOW_PLACEHOLDER_CORRECTION}`,
+					path: ["question"],
+				});
+			}
 			const labels = new Set(value.options.map(option => option.label));
 			const contract = intentContract(value.deepInterview);
 			const review = intentReview(value.deepInterview);
@@ -459,19 +471,58 @@ function knownIntentRejection(arguments_: Record<string, unknown>): RawArgumentV
 		return { outcome: "reject", code: "ask-intent-contract-requires-non-empty-authority" };
 	return undefined;
 }
+
+function deepInterviewPlaceholderRejection(
+	arguments_: Record<string, unknown>,
+): RawArgumentValidationResult | undefined {
+	const root = parseEncodedContainer(arguments_);
+	if (!isPlainRecord(root)) return undefined;
+	const questions = parseEncodedContainer(root.questions);
+	if (!Array.isArray(questions)) return undefined;
+	for (const [index, rawValue] of questions.entries()) {
+		const rawQuestion = parseEncodedContainer(rawValue);
+		if (!isPlainRecord(rawQuestion) || !Object.hasOwn(rawQuestion, "deepInterview")) continue;
+		const metadata = parseEncodedContainer(rawQuestion.deepInterview);
+		if (metadata !== null && metadata !== undefined && isWorkflowPlaceholderText(rawQuestion.question)) {
+			return {
+				outcome: "reject",
+				code: "ask-deep-interview-question-body-required",
+				detail: {
+					rejectedKeys: [`questions[${index}].question`],
+					hint: WORKFLOW_PLACEHOLDER_CORRECTION,
+				},
+			};
+		}
+	}
+	for (const [index, rawValue] of questions.entries()) {
+		const question = parseEncodedContainer(rawValue);
+		if (isPlainRecord(question) && isLegacyDeepInterviewPlaceholder(question.question)) {
+			return {
+				outcome: "reject",
+				code: "ask-deep-interview-question-body-required",
+				detail: { rejectedKeys: [`questions[${index}].question`], hint: WORKFLOW_PLACEHOLDER_CORRECTION },
+			};
+		}
+	}
+	return undefined;
+}
+
 export function recoverRoundZeroIntentContract(
 	arguments_: Record<string, unknown>,
 	stage?: "topology" | "post-topology",
 ): RawArgumentValidationResult {
+	const normalizedInput = normalizeRoundZeroOptionalNulls(arguments_);
+	const placeholderRejection = deepInterviewPlaceholderRejection(normalizedInput);
+	if (placeholderRejection) return placeholderRejection;
 	// #4649: an incomplete Round-0 topology object (deepInterview present,
 	// required fields omitted) is NOT a retired-pair recovery candidate, so it
 	// would passthrough into generic Zod validation whose error names no contract
 	// and no correction — the repeat-invalid-bisect loop. Non-candidates get the
 	// targeted correction here; candidates get it only after the stricter known
 	// intent rejections below, so every previously-covered verdict is unchanged.
-	if (!isRoundZeroRecoveryCandidate(arguments_))
-		return roundZeroMetadataRejection(arguments_, stage) ?? { outcome: "passthrough" };
-	const normalizedArguments = normalizeRoundZeroOptionalNulls(arguments_);
+	if (!isRoundZeroRecoveryCandidate(normalizedInput))
+		return roundZeroMetadataRejection(normalizedInput, stage) ?? { outcome: "passthrough" };
+	const normalizedArguments = normalizedInput;
 	const knownRejection = knownIntentRejection(normalizedArguments);
 	if (knownRejection) return knownRejection;
 	const missingTopologyFields = roundZeroMetadataRejection(normalizedArguments, stage);

package/src/tools/ask.ts

@@ -114,11 +114,17 @@ const HEADLESS_CHECKBOX_CHECKED = "[x]";
 const HEADLESS_CHECKBOX_UNCHECKED = "[ ]";
 const DEEP_INTERVIEW_SELECTOR_SCROLL_TITLE_ROWS = Number.MAX_SAFE_INTEGER;
 const DEEP_INTERVIEW_RECORDER_AWAIT_TIMEOUT_MS = 250;
+export const MAX_EMPTY_CUSTOM_ATTEMPTS = 3;
+const EMPTY_CUSTOM_RETRY_MESSAGE = "Custom input cannot be empty. Enter text or cancel the ask.";
 
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
+function nonEmptyCustomInput(value: string | undefined): string | undefined {
+	return value !== undefined && value.trim().length > 0 ? value : undefined;
+}
+
 function isAskTimeoutError(error: unknown): boolean {
 	return typeof error === "object" && error !== null && (error as { code?: unknown }).code === GJC_ASK_TIMEOUT_CODE;
 }
@@ -324,7 +330,7 @@ interface UIContext {
 			onLeft?: () => void;
 			onRight?: () => void;
 			helpText?: string;
-			customInput?: { optionLabel: string; onSubmit: (text: string) => void };
+			customInput?: { optionLabel: string; onSubmit: (text: string) => void; allowEmpty?: boolean };
 			clarificationInput?: { optionLabel: string; onSubmit: (text: string) => void; allowEmpty?: boolean };
 		},
 	): Promise<string | undefined>;
@@ -400,6 +406,7 @@ async function askSingleQuestion(
 			helpText,
 			customInput: {
 				optionLabel: otherOptionLabel,
+				allowEmpty: false,
 				onSubmit: (text: string) => {
 					inlineInput = text;
 				},
@@ -541,7 +548,9 @@ async function askSingleQuestion(
 					timedOut = true;
 					break;
 				}
-				const input = inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input;
+				const input = nonEmptyCustomInput(
+					inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input,
+				);
 				if (input === undefined) {
 					break;
 				}
@@ -642,7 +651,9 @@ async function askSingleQuestion(
 			}
 		} else if (choice === otherOptionLabel) {
 			if (!selectTimedOut) {
-				const input = inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input;
+				const input = nonEmptyCustomInput(
+					inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input,
+				);
 				if (input !== undefined) {
 					customInput = input;
 					selectedOptions = [];
@@ -1100,10 +1111,15 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 
 		const askQuestion = async (
 			q: AskParams["questions"][number],
-			options?: { previous?: QuestionResult; navigation?: NavigationControls },
+			options?: {
+				previous?: QuestionResult;
+				navigation?: NavigationControls;
+				emptyCustomAttempt?: number;
+			},
 		) => {
 			const rawOptionLabels = q.options.map(o => o.label);
 			const questionIndex = params.questions.indexOf(q);
+			const emptyCustomAttempt = options?.emptyCustomAttempt ?? 0;
 			// Route headless asks through the SDK workflow-gate emitter; a connected
 			// SDK responder supplies the durable answer instead of an interactive UI.
 			if (gateEmitter && canUseWorkflowGate) {
@@ -1133,7 +1149,11 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 			try {
 				const deepInterviewPrompt = formatDeepInterviewSelectorPrompt(q.question);
 				const isDeepInterviewQuestion = deepInterviewPrompt !== null || q.deepInterview !== undefined;
-				const displayQuestion = deepInterviewPrompt ?? q.question;
+				const baseDisplayQuestion = deepInterviewPrompt ?? q.question;
+				const displayQuestion =
+					emptyCustomAttempt > 0
+						? `${baseDisplayQuestion}\n\n${EMPTY_CUSTOM_RETRY_MESSAGE} (attempt ${emptyCustomAttempt + 1} of ${MAX_EMPTY_CUSTOM_ATTEMPTS})`
+						: baseDisplayQuestion;
 				const shouldNumberOptions = isDeepInterviewQuestion || isDeepInterviewAskQuestion(q.question);
 				const optionLabels = shouldNumberOptions ? numberOptionLabels(rawOptionLabels) : rawOptionLabels;
 				const clarificationOptionLabel = shouldNumberOptions
@@ -1256,7 +1276,27 @@ export class AskTool implements AgentTool<AskParametersSchema, AskToolDetails> {
 													: { kind: "resolve_without_commit", reason: "cancelled" };
 					await settleActiveRemote(settlement);
 					activeRemoteRequest = undefined;
-					if (settlement.kind === "invalid") return askQuestion(q, options);
+					if (settlement.kind === "invalid") {
+						if (emptyCustomAttempt + 1 >= MAX_EMPTY_CUSTOM_ATTEMPTS) {
+							return {
+								optionLabels: rawOptionLabels,
+								selectedOptions: [] as string[],
+								customInput: undefined,
+								clarificationQuestion: undefined,
+								navigation: undefined,
+								cancelled: true,
+								timedOut: false,
+							};
+						}
+						// A remote source may resolve synchronously. Yield to a timer queue
+						// between retries so repeated invalid answers cannot starve the
+						// event loop indefinitely.
+						await Bun.sleep(1);
+						return askQuestion(q, {
+							...options,
+							emptyCustomAttempt: emptyCustomAttempt + 1,
+						});
+					}
 				}
 				activeRemoteRequest = undefined;
 				return {