@gajae-code/coding-agent 0.4.4 → 0.5.0

package/src/thinking.ts

@@ -2,45 +2,7 @@ import { type ResolvedThinkingLevel, ThinkingLevel } from "@gajae-code/agent-cor
 import { clampThinkingLevelForModel, type Effort, THINKING_EFFORTS } from "@gajae-code/ai/model-thinking";
 import type { Model } from "@gajae-code/ai/types";
 
-/**
- * Metadata used to render thinking selector values in the coding-agent UI.
- */
-export interface ThinkingLevelMetadata {
-	value: ThinkingLevel;
-	label: string;
-	description: string;
-}
-
-const THINKING_LEVEL_METADATA: Record<ThinkingLevel, ThinkingLevelMetadata> = {
-	[ThinkingLevel.Inherit]: {
-		value: ThinkingLevel.Inherit,
-		label: "inherit",
-		description: "Inherit session default",
-	},
-	[ThinkingLevel.Off]: { value: ThinkingLevel.Off, label: "off", description: "No reasoning" },
-	[ThinkingLevel.Minimal]: {
-		value: ThinkingLevel.Minimal,
-		label: "min",
-		description: "Very brief reasoning (~1k tokens)",
-	},
-	[ThinkingLevel.Low]: { value: ThinkingLevel.Low, label: "low", description: "Light reasoning (~2k tokens)" },
-	[ThinkingLevel.Medium]: {
-		value: ThinkingLevel.Medium,
-		label: "medium",
-		description: "Moderate reasoning (~8k tokens)",
-	},
-	[ThinkingLevel.High]: { value: ThinkingLevel.High, label: "high", description: "Deep reasoning (~16k tokens)" },
-	[ThinkingLevel.XHigh]: {
-		value: ThinkingLevel.XHigh,
-		label: "xhigh",
-		description: "Maximum reasoning (~32k tokens)",
-	},
-	[ThinkingLevel.Max]: {
-		value: ThinkingLevel.Max,
-		label: "max",
-		description: "Opus maximum reasoning",
-	},
-};
+export { getThinkingLevelMetadata, type ThinkingLevelMetadata } from "./thinking-metadata";
 
 const THINKING_LEVELS = new Set<string>([ThinkingLevel.Inherit, ThinkingLevel.Off, ...THINKING_EFFORTS]);
 const EFFORT_LEVELS = new Set<string>(THINKING_EFFORTS);
@@ -59,13 +21,6 @@ export function parseThinkingLevel(value: string | null | undefined): ThinkingLe
 	return value !== undefined && value !== null && THINKING_LEVELS.has(value) ? (value as ThinkingLevel) : undefined;
 }
 
-/**
- * Returns display metadata for a thinking selector.
- */
-export function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata {
-	return THINKING_LEVEL_METADATA[level];
-}
-
 /**
  * Converts an agent-local selector into the effort sent to providers.
  */
@@ -91,3 +46,28 @@ export function resolveThinkingLevelForModel(
 	}
 	return clampThinkingLevelForModel(model, level);
 }
+
+export function clampExplicitThinkingLevelForModel(
+	model: Model | undefined,
+	level: ThinkingLevel | undefined,
+): ThinkingLevel | undefined {
+	if (level === undefined || level === ThinkingLevel.Inherit || level === ThinkingLevel.Off) {
+		return level;
+	}
+	return clampThinkingLevelForModel(model, level);
+}
+
+export function formatClampedModelSelector(selector: string, model: Model | undefined): string {
+	const slashIdx = selector.indexOf("/");
+	if (slashIdx <= 0) return selector;
+	const id = selector.slice(slashIdx + 1);
+	const colonIdx = id.lastIndexOf(":");
+	if (colonIdx === -1) return selector;
+	const suffix = id.slice(colonIdx + 1);
+	const thinkingLevel = parseThinkingLevel(suffix);
+	if (!thinkingLevel) return selector;
+	const clamped = clampExplicitThinkingLevelForModel(model, thinkingLevel);
+	return clamped && clamped !== ThinkingLevel.Inherit
+		? `${selector.slice(0, slashIdx + 1)}${id.slice(0, colonIdx)}:${clamped}`
+		: selector.slice(0, slashIdx + 1) + id.slice(0, colonIdx);
+}

package/src/tools/bash.ts

@@ -51,7 +51,7 @@ async function saveBashOriginalArtifact(session: ToolSession, originalText: stri
 const bashSchemaBase = z.object({
 	command: z.string().describe("command to execute"),
 	env: z.record(z.string().regex(BASH_ENV_NAME_PATTERN), z.string()).optional().describe("extra env vars"),
-	timeout: z.number().default(300).describe("timeout in seconds").optional(),
+	timeout: z.number().default(300).describe("timeout in seconds, NOT milliseconds (30 = 30s)").optional(),
 	cwd: z.string().describe("working directory").optional(),
 	pty: z.boolean().describe("run in pty mode").optional(),
 });

package/src/tools/index.ts

@@ -240,6 +240,8 @@ export interface ToolSession {
 	getToolChoiceQueue?(): ToolChoiceQueue;
 	/** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
 	buildToolChoice?(toolName: string): ToolChoice | undefined;
+	/** Build a named tool-choice decision, preserving whether exact named forcing survived capability degradation. */
+	buildToolChoiceResult?(toolName: string): import("../utils/tool-choice").NamedToolChoiceResult;
 	/** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
 	steer?(message: { customType: string; content: string; details?: unknown }): void;
 	/** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
@@ -403,7 +405,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		toolNames && toolNames.length > 0 ? [...new Set(toolNames.map(name => name.toLowerCase()))] : undefined;
 	const goalEnabled = session.settings.get("goal.enabled");
 	const goalStateToolNames = [...GOAL_MODE_TOOL_NAMES];
-	if (goalEnabled && session.getGoalRuntime !== undefined && requestedTools && !requestedTools.includes("goal")) {
+	if (goalEnabled && requestedTools && !requestedTools.includes("goal")) {
 		requestedTools = [...requestedTools, "goal"];
 	}
 	if (goalEnabled && requestedTools) {
@@ -482,7 +484,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		allToolsByRequestName.set(name.toLowerCase(), [name, factory]);
 	}
 	const isToolAllowed = (name: string) => {
-		if (name === "goal") return goalEnabled && session.getGoalRuntime !== undefined;
+		if (name === "goal") return goalEnabled;
 		if (goalStateToolNames.includes(name as (typeof GOAL_MODE_TOOL_NAMES)[number])) return goalEnabled;
 		if (name === "lsp") return enableLsp && session.settings.get("lsp.enabled");
 		if (name === "bash") return true;

package/src/tools/resolve.ts

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { ToolChoice } from "@gajae-code/ai";
 import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import { prompt, untilAborted } from "@gajae-code/utils";
@@ -38,6 +39,21 @@ export interface ResolveToolDetails {
  * semantics. No session-level abstraction is needed: callers pass their
  * apply/reject functions directly.
  */
+/**
+ * Tags preview-fallback handlers installed in the session's standing-resolve
+ * slot so newer previews can replace older ones (latest-preview-wins) without
+ * ever displacing a mode-owned handler such as plan mode's approval handler.
+ */
+const previewResolveFallbacks = new WeakSet<object>();
+
+function markPreviewResolveFallback(handler: (input: unknown) => Promise<unknown> | unknown): void {
+	previewResolveFallbacks.add(handler);
+}
+
+function isPreviewResolveFallback(handler: (input: unknown) => Promise<unknown> | unknown): boolean {
+	return previewResolveFallbacks.has(handler);
+}
+
 export function queueResolveHandler(
 	session: ToolSession,
 	options: {
@@ -48,8 +64,6 @@ export function queueResolveHandler(
 	},
 ): void {
 	const queue = session.getToolChoiceQueue?.();
-	const forced = session.buildToolChoice?.("resolve");
-	if (!queue || !forced || typeof forced === "string") return;
 
 	const steerReminder = (): void => {
 		session.steer?.({
@@ -63,27 +77,88 @@ export function queueResolveHandler(
 		});
 	};
 
-	const pushDirective = (): void => {
+	// Re-evaluated on every push (including apply-error re-pushes) so a runtime
+	// incapability discovered mid-turn degrades the NEXT push instead of
+	// replaying a stale forced choice the model can never satisfy.
+	const resolveForcedChoice = (): { forced: ToolChoice | undefined; exactNamed: boolean } => {
+		const toolChoiceResult = session.buildToolChoiceResult?.("resolve");
+		if (toolChoiceResult !== undefined) {
+			return { forced: toolChoiceResult.choice, exactNamed: toolChoiceResult.exactNamed };
+		}
+		// Legacy bridge fallback: sessions that only provide buildToolChoice
+		// (older SDK embedders, test harnesses) keep the previous behavior — a
+		// named object choice is treated as exact named forcing.
+		const legacyChoice = session.buildToolChoice?.("resolve");
+		const isNamedObject = typeof legacyChoice === "object" && legacyChoice !== null;
+		return { forced: isNamedObject ? legacyChoice : undefined, exactNamed: isNamedObject };
+	};
+
+	const clearFallback = (): void => {
+		// Identity-aware: only clear the shared standing slot when it still holds
+		// THIS preview's fallback. Plan mode (or a newer preview) may have
+		// replaced it in the meantime — leave theirs untouched.
+		if (session.peekStandingResolveHandler?.() === invoke) {
+			session.setStandingResolveHandler?.(null);
+		}
+	};
+
+	const invoke = async (input: unknown): Promise<AgentToolResult<unknown>> => {
+		const result = await runResolveInvocation(input as ResolveParams, {
+			sourceToolName: options.sourceToolName,
+			label: options.label,
+			apply: options.apply,
+			reject: options.reject,
+			onApplyError: () => {
+				// Apply threw (e.g. ast_edit overlapping replacements). Re-push the
+				// same directive so the preview remains pending and the model can
+				// `discard` or fix-and-retry on the next turn instead of being
+				// stranded with no pending action to address. The re-push goes
+				// through the exactNamed gate again — degraded models fall back
+				// to the reminder alone. The standing fallback stays installed so
+				// a voluntary resolve can still reach the pending action.
+				pushDirective();
+				steerReminder();
+			},
+		});
+		// Apply succeeded or the preview was discarded: the pending action is
+		// finished, so the voluntary-dispatch fallback must not linger.
+		clearFallback();
+		return result;
+	};
+	markPreviewResolveFallback(invoke);
+
+	// Voluntary-dispatch fallback: when forcing is unavailable (statically
+	// degraded) or later removed (runtime degradeInFlight drops the queue
+	// directive that owns the invoker), the model can still call `resolve`.
+	// ResolveTool.execute consults the queue invoker first, so the standing
+	// handler only serves degraded paths. Latest preview wins (mirroring the
+	// queue's pushOnce now:true semantics): a newer preview's fallback replaces
+	// an older preview's, but NEVER clobbers a non-preview standing handler
+	// (e.g. plan mode's approval handler).
+	const installFallback = (): void => {
+		if (!session.setStandingResolveHandler) return;
+		const existing = session.peekStandingResolveHandler?.();
+		if (existing === invoke) return;
+		if (existing !== undefined && !isPreviewResolveFallback(existing)) return;
+		session.setStandingResolveHandler(invoke);
+	};
+
+	const pushDirective = (): boolean => {
+		const { forced, exactNamed } = resolveForcedChoice();
+		if (!queue || !forced || !exactNamed) {
+			installFallback();
+			return false;
+		}
 		queue.pushOnce(forced, {
 			label: `pending-action:${options.sourceToolName}`,
 			now: true,
 			onRejected: () => "requeue",
-			onInvoked: async (input: unknown) =>
-				runResolveInvocation(input as ResolveParams, {
-					sourceToolName: options.sourceToolName,
-					label: options.label,
-					apply: options.apply,
-					reject: options.reject,
-					onApplyError: () => {
-						// Apply threw (e.g. ast_edit overlapping replacements). Re-push the
-						// same directive so the preview remains pending and the model can
-						// `discard` or fix-and-retry on the next turn instead of being
-						// stranded with no pending action to address.
-						pushDirective();
-						steerReminder();
-					},
-				}),
+			onInvoked: invoke,
 		});
+		// Forced directive may still be degraded mid-turn by a runtime
+		// incapability discovery; keep the fallback armed for that case.
+		installFallback();
+		return true;
 	};
 
 	pushDirective();

package/src/tools/subagent-render.ts

@@ -73,7 +73,11 @@ function renderSubagentSnapshot(
 		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
 	}
 
-	if (snapshot.progress) {
+	// Defense in depth: the producer only attaches `progress` when a live
+	// producer exists (subagent.ts #liveProgressFields), but the renderer
+	// also honors an explicit `liveProgressAvailable: false` so stale retained
+	// progress can never resurrect a live panel (AC5).
+	if (snapshot.progress && snapshot.liveProgressAvailable !== false) {
 		// Live streaming panel (full task-panel parity), indented under the header.
 		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, spinnerFrame)) {
 			lines.push(`  ${pl}`);
@@ -142,6 +146,11 @@ export const subagentToolRenderer = {
 				);
 
 				const lines: string[] = [header];
+				// Discoverability: the inline panel is a bounded preview; the session
+				// observer (ctrl+s) streams the full per-subagent message history.
+				if (runningCount > 0) {
+					lines.push(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`);
+				}
 				for (const snapshot of subagents) {
 					lines.push(...renderSubagentSnapshot(snapshot, expanded, theme, options.spinnerFrame));
 				}

package/src/utils/edit-mode.ts

@@ -1,4 +1,4 @@
-import { $env } from "@gajae-code/utils/env";
+import { $env } from "../../../utils/src/env";
 
 export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 

package/src/utils/title-generator.ts

@@ -12,7 +12,7 @@ import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
-const DEFAULT_TERMINAL_TITLE = "π";
+const DEFAULT_TERMINAL_TITLE = "GJC";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 const MAX_INPUT_CHARS = 2000;
@@ -20,6 +20,13 @@ const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
 const SET_TITLE_TOOL_NAME = "set_title";
 
+// Some models (notably cursor/composer-*) ignore the forced set_title tool call
+// and instead emit a long free-text narrative. Without the tool call we fall back
+// to the plain text, so cap its length: a real 3-6 word title never exceeds these.
+// Beyond the cap we treat the response as a non-title hallucination and reject it.
+const MAX_TITLE_CHARS = 80;
+const MAX_TITLE_WORDS = 12;
+
 const setTitleTool: Tool = {
 	name: SET_TITLE_TOOL_NAME,
 	description: "Set the generated session title.",
@@ -169,7 +176,14 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 			textTitle += content.text;
 		}
 	}
-	return textTitle.trim();
+	// Plain-text fallback (no set_title tool call): only accept it if it actually
+	// looks like a title. A model that ignored the tool and rambled produces a long
+	// blob — reject it so the caller falls back rather than persisting the narrative.
+	const trimmed = textTitle.trim();
+	if (trimmed.length > MAX_TITLE_CHARS || trimmed.split(/\s+/).length > MAX_TITLE_WORDS) {
+		return "";
+	}
+	return trimmed;
 }
 
 /**

package/src/utils/tool-choice.ts

@@ -1,33 +1,62 @@
-import type { Api, Model, ToolChoice } from "@gajae-code/ai";
+import type { Api, Model, ResolveToolChoiceResult, ToolChoice } from "@gajae-code/ai";
+import { resolveToolChoice } from "@gajae-code/ai";
 
 /**
  * Build a provider-aware tool choice that targets one specific tool when supported.
  * Providers that only expose required/any forcing may still honor named choices by
  * narrowing their request tool list before transport.
  */
-export function buildNamedToolChoice(toolName: string, model?: Model<Api>): ToolChoice | undefined {
-	if (!model) return undefined;
+export interface NamedToolChoiceResult {
+	choice: ToolChoice | undefined;
+	exactNamed: boolean;
+	resolved?: ResolveToolChoiceResult;
+}
 
-	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") {
-		return { type: "tool", name: toolName };
-	}
+export function buildNamedToolChoiceResult(toolName: string, model?: Model<Api>): NamedToolChoiceResult {
+	if (!model) return { choice: undefined, exactNamed: false };
 
-	if (
+	let namedChoice: ToolChoice | undefined;
+	let namedShape = false;
+
+	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") {
+		namedChoice = { type: "tool", name: toolName };
+		namedShape = true;
+	} else if (
 		model.api === "openai-codex-responses" ||
 		model.api === "openai-responses" ||
 		model.api === "openai-completions" ||
-		model.api === "azure-openai-responses"
+		model.api === "azure-openai-responses" ||
+		model.api === "ollama-chat"
+	) {
+		namedChoice = { type: "function", name: toolName };
+		namedShape = true;
+	} else if (
+		model.api === "google-generative-ai" ||
+		model.api === "google-gemini-cli" ||
+		model.api === "google-vertex"
 	) {
-		return { type: "function", name: toolName };
+		namedChoice = "required";
 	}
 
-	if (model.api === "ollama-chat") {
-		return { type: "function", name: toolName };
-	}
+	if (!namedChoice) return { choice: undefined, exactNamed: false };
 
-	if (model.api === "google-generative-ai" || model.api === "google-gemini-cli" || model.api === "google-vertex") {
-		return "required";
-	}
+	const resolved = resolveToolChoice(model, namedChoice);
+	const exactNamed = namedShape && resolved.resolvedLevel === "named" && resolved.targetToolName === toolName;
+	return {
+		choice: exactNamed ? resolved.resolvedChoice : undefined,
+		exactNamed,
+		resolved,
+	};
+}
 
-	return undefined;
+/**
+ * Legacy capability-aware wrapper. May return a lossy `"required"` when named
+ * forcing degrades (e.g. Google APIs, or compat `toolChoiceSupport: "required"`),
+ * which forces *some* tool rather than `toolName` specifically. Queue directives
+ * that need exact tool identity (resolve / todo_write / yield) MUST use
+ * `buildNamedToolChoiceResult` and gate on `exactNamed` instead.
+ */
+export function buildNamedToolChoice(toolName: string, model?: Model<Api>): ToolChoice | undefined {
+	const result = buildNamedToolChoiceResult(toolName, model);
+	return result.choice ?? result.resolved?.resolvedChoice;
 }