@gajae-code/coding-agent 0.8.2 → 0.9.0

package/src/tools/output-meta.ts

@@ -554,13 +554,17 @@ function getSpillConfig(s: Settings | undefined) {
 		| "tools.artifactSpillThreshold"
 		| "tools.artifactTailBytes"
 		| "tools.artifactTailLines"
-		| "tools.artifactHeadBytes";
+		| "tools.artifactHeadBytes"
+		| "tools.maxInlineResultBytes"
+		| "tools.readArtifactSpillThreshold";
 	const get = <P extends Path>(path: P) => s?.get(path) ?? getDefault(path);
 	return {
 		threshold: get("tools.artifactSpillThreshold") * 1024,
+		readThreshold: get("tools.readArtifactSpillThreshold") * 1024,
 		tailBytes: get("tools.artifactTailBytes") * 1024,
 		tailLines: get("tools.artifactTailLines"),
 		headBytes: get("tools.artifactHeadBytes") * 1024,
+		maxInlineBytes: get("tools.maxInlineResultBytes") * 1024,
 	};
 }
 
@@ -596,8 +600,12 @@ async function spillLargeResultToArtifact(
 ): Promise<AgentToolResult> {
 	const sessionManager = context?.sessionManager;
 	if (!sessionManager) return result;
-	if (toolName === "read") return result;
-	const { threshold, tailBytes, tailLines, headBytes } = getSpillConfig(context?.settings);
+	const { threshold, readThreshold, tailBytes, tailLines, headBytes } = getSpillConfig(context?.settings);
+	// `read` manages its own per-range truncation, but the combined multi-range
+	// output has no cap — enforce a read-specific (higher) combined threshold
+	// instead of exempting read entirely. 0 disables read spill (backstop only).
+	const effectiveThreshold = toolName === "read" ? readThreshold : threshold;
+	if (effectiveThreshold <= 0) return result;
 
 	// Skip if tool already saved an artifact
 	const existingMeta: OutputMeta | undefined = result.details?.meta;
@@ -614,7 +622,7 @@ async function spillLargeResultToArtifact(
 
 	const fullText = textParts.length === 1 ? textParts[0] : textParts.join("\n");
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
-	if (totalBytes <= threshold) return result;
+	if (totalBytes <= effectiveThreshold) return result;
 
 	// Save full output as artifact
 	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
@@ -691,6 +699,106 @@ async function spillLargeResultToArtifact(
 	return { ...result, content: newContent, details: newDetails };
 }
 
+/**
+ * Absolute inline-size backstop enforced after {@link spillLargeResultToArtifact}.
+ *
+ * The threshold-based spill above has escape hatches: it early-returns for the
+ * `read` tool and for results that already carry an `artifactId` (a tool may set
+ * partial truncation meta yet still emit oversized inline text). This backstop
+ * closes those gaps: when `tools.maxInlineResultBytes` is configured (> 0), any
+ * final result whose inline text exceeds the cap is force-saved to an artifact
+ * (reusing an existing artifactId to avoid double-artifacting) and truncated to a
+ * head+tail view that fits the cap. Disabled by default (opt-in pending
+ * measurement); a 0 cap returns the result untouched.
+ */
+async function enforceInlineResultBackstop(
+	result: AgentToolResult,
+	toolName: string,
+	context: AgentToolContext | undefined,
+): Promise<AgentToolResult> {
+	const { maxInlineBytes, tailLines, headBytes } = getSpillConfig(context?.settings);
+	if (maxInlineBytes <= 0) return result;
+
+	const textParts: string[] = [];
+	for (const block of result.content) {
+		if (block.type === "text" && block.text) {
+			textParts.push(block.text);
+		}
+	}
+	if (textParts.length === 0) return result;
+
+	const fullText = textParts.length === 1 ? textParts[0] : textParts.join("\n");
+	const totalBytes = Buffer.byteLength(fullText, "utf-8");
+	if (totalBytes <= maxInlineBytes) return result;
+
+	// Reuse an existing artifact (avoid double-artifacting); otherwise save the
+	// full output so the truncated view keeps a reference to the complete text.
+	const existingMeta: OutputMeta | undefined = result.details?.meta;
+	let artifactId = existingMeta?.truncation?.artifactId;
+	if (!artifactId) {
+		artifactId = (await context?.sessionManager?.saveArtifact(fullText, toolName)) ?? undefined;
+	}
+
+	// Budget head+tail below the cap, reserving room for the elision marker so the
+	// composed `<head>\n<marker>\n<tail>` view never exceeds the configured cap.
+	const MARKER_RESERVE = 256;
+	const budget = maxInlineBytes - MARKER_RESERVE;
+	const useMiddle = headBytes > 0 && budget > 0;
+	let truncated = useMiddle
+		? truncateMiddle(fullText, {
+				maxBytes: budget,
+				maxLines: tailLines * 2,
+				maxHeadBytes: Math.min(headBytes, Math.floor(budget / 2)),
+				maxHeadLines: tailLines,
+			})
+		: truncateTail(fullText, { maxBytes: maxInlineBytes, maxLines: tailLines });
+
+	// Defensive clamp: guarantee the contract even for pathological marker sizes.
+	if (Buffer.byteLength(truncated.content, "utf-8") > maxInlineBytes) {
+		truncated = truncateTail(fullText, { maxBytes: maxInlineBytes, maxLines: tailLines });
+	}
+
+	const newContent: (TextContent | ImageContent)[] = [];
+	for (const block of result.content) {
+		if (block.type !== "text") {
+			newContent.push(block);
+		}
+	}
+	newContent.push({ type: "text", text: truncated.content });
+
+	const outputLines = truncated.outputLines ?? truncated.totalLines;
+	const outputBytes = truncated.outputBytes ?? truncated.totalBytes;
+	const truncationMeta: TruncationMeta =
+		truncated.truncatedBy === "middle"
+			? {
+					direction: "middle",
+					truncatedBy: "middle",
+					totalLines: truncated.totalLines,
+					totalBytes: truncated.totalBytes,
+					outputLines,
+					outputBytes,
+					maxBytes: maxInlineBytes,
+					elidedLines: truncated.elidedLines ?? Math.max(0, truncated.totalLines - outputLines),
+					elidedBytes: truncated.elidedBytes ?? Math.max(0, truncated.totalBytes - outputBytes),
+					artifactId,
+				}
+			: {
+					direction: "tail",
+					truncatedBy: truncated.truncatedBy ?? "bytes",
+					totalLines: truncated.totalLines,
+					totalBytes: truncated.totalBytes,
+					outputLines,
+					outputBytes,
+					maxBytes: maxInlineBytes,
+					shownRange: { start: truncated.totalLines - outputLines + 1, end: truncated.totalLines },
+					artifactId,
+				};
+
+	const newMeta: OutputMeta = { ...(existingMeta ?? {}), truncation: truncationMeta };
+	const newDetails = { ...(result.details ?? {}), meta: newMeta };
+	return { ...result, content: newContent, details: newDetails };
+}
+
 // =============================================================================
 // Tool wrapper
 // =============================================================================
@@ -711,6 +819,10 @@ async function wrappedExecute(
 		// Spill large results to artifact, truncate to tail
 		result = await spillLargeResultToArtifact(result, this.name, context);
 
+		// Absolute inline-size backstop: catches oversized text the threshold spill
+		// skipped (read exemption, tools with pre-existing partial artifact meta).
+		result = await enforceInlineResultBackstop(result, this.name, context);
+
 		// Append notices from meta
 		const meta: OutputMeta | undefined = result.details?.meta;
 		if (meta) {

package/src/tools/search.ts

@@ -44,7 +44,10 @@ const searchSchema = z
 		paths: z
 			.array(z.string().describe("file, directory, glob, or internal URL to search"))
 			.min(1)
-			.describe("files, directories, globs, or internal URLs to search"),
+			.optional()
+			.describe(
+				"files, directories, globs, or internal URLs to search (defaults to the working directory when omitted)",
+			),
 		i: z.boolean().optional().describe("case-insensitive search"),
 		gitignore: z.boolean().optional().describe("respect gitignore"),
 		skip: z
@@ -236,7 +239,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 		_onUpdate?: AgentToolUpdateCallback<SearchToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<SearchToolDetails>> {
-		const { pattern, paths, i, gitignore, skip } = params;
+		const { pattern, i, gitignore, skip } = params;
+		// Recurring real-world failure mode: models omit `paths` for repo-wide
+		// searches. Default to the working directory instead of failing the call.
+		const paths = params.paths ?? ["."];
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();

package/src/tools/skill.ts

@@ -37,6 +37,8 @@ function normalizeSkillName(name: string | undefined): string {
 	return (name ?? "").trim();
 }
 
+const SKILL_NAME_GLOB_PATTERN = /[*?[\]{}]/;
+
 type SkillToolInput = z.infer<typeof skillSchema>;
 
 export interface SkillToolDetails {
@@ -87,6 +89,19 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 			if (!requestedName) {
 				throw new ToolError("skill tool: `name` is required");
 			}
+			// Fail fast on glob/wildcard names (e.g. `*`). A model that sees the
+			// `--skills '*'` launch filter may echo the glob into the skill tool.
+			// Without this guard `*` slips through to the generic unknown-skill
+			// path only because no skill is literally named `*`, so a future
+			// odd skill name could get dispatched — and the actionable signal
+			// that names are concrete (not globs) is lost. Reject before any
+			// dispatch or handoff state mutation so the call ends immediately
+			// instead of spawning skill work that burns the whole turn budget.
+			if (SKILL_NAME_GLOB_PATTERN.test(requestedName)) {
+				throw new ToolError(
+					`skill tool: "${requestedName}" is not a valid skill name. The name must be a single concrete skill (e.g. "ralplan"), not a glob or wildcard pattern. Pass one exact skill name as shown in /skill:<name>.`,
+				);
+			}
 			const activeState = this.#session.getActiveSkillState?.();
 			const activeSkill = normalizeSkillName(activeState?.skill);
 			if (activeSkill && requestedName === activeSkill) {

package/src/utils/file-mentions.ts

@@ -159,24 +159,32 @@ async function resolveMentionPath(
 	return best?.candidate.path ?? null;
 }
 
-function buildTextOutput(textContent: string): { output: string; lineCount: number } {
+/**
+ * Default inline cap for auto-read file mentions, deliberately below the
+ * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
+ * injects a smaller snippet than an explicit `read`. Overridable per call.
+ */
+export const DEFAULT_FILE_MENTION_INLINE_BYTES = 20 * 1024;
+
+function buildTextOutput(textContent: string, maxInlineBytes?: number): { output: string; lineCount: number } {
+	const cap = maxInlineBytes && maxInlineBytes > 0 ? maxInlineBytes : DEFAULT_FILE_MENTION_INLINE_BYTES;
 	const allLines = textContent.split("\n");
 	const totalFileLines = allLines.length;
-	const truncation = truncateHead(textContent);
+	const truncation = truncateHead(textContent, { maxBytes: cap });
 
 	if (truncation.firstLineExceedsLimit) {
 		const firstLine = allLines[0] ?? "";
 		const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
-		const snippet = truncateHeadBytes(firstLine, DEFAULT_MAX_BYTES);
+		const snippet = truncateHeadBytes(firstLine, cap);
 		let outputText = snippet.text;
 
 		if (outputText.length > 0) {
 			outputText += `\n\n[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Showing first ${formatBytes(snippet.bytes)} of the line.]`;
 		} else {
 			outputText = `[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Unable to display a valid UTF-8 snippet.]`;
 		}
 
@@ -277,7 +285,18 @@ export function extractFileMentions(text: string): string[] {
 export async function generateFileMentionMessages(
 	filePaths: string[],
 	cwd: string,
-	options?: { autoResizeImages?: boolean; useHashLines?: boolean },
+	options?: {
+		autoResizeImages?: boolean;
+		useHashLines?: boolean;
+		/** Inline byte cap for auto-read text. Default: DEFAULT_FILE_MENTION_INLINE_BYTES. */
+		maxInlineBytes?: number;
+		/**
+		 * Resolved paths already shown (read or mentioned) recently in the
+		 * conversation. A mention of one of these emits a compact duplicate note
+		 * instead of re-injecting the full body.
+		 */
+		recentlyShownPaths?: ReadonlySet<string>;
+	},
 ): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
@@ -290,12 +309,25 @@ export async function generateFileMentionMessages(
 		return mentionCandidatesPromise;
 	};
 
+	const shownInBatch = new Set<string>();
 	for (const filePath of filePaths) {
 		const resolvedPath = await resolveMentionPath(filePath, cwd, getMentionCandidates);
 		if (!resolvedPath) {
 			continue;
 		}
 		const absolutePath = resolveReadPath(resolvedPath, cwd);
+		// Duplicate suppression, keyed by absolute path: same path shown earlier this
+		// batch or recently in the conversation → compact note, no re-read (the path
+		// stays referenced so the model can re-fetch via the read tool).
+		if (shownInBatch.has(absolutePath) || options?.recentlyShownPaths?.has(absolutePath)) {
+			files.push({
+				path: resolvedPath,
+				content: `(already shown in this conversation; not re-read — use the read tool to fetch \`${resolvedPath}\` again)`,
+				duplicate: true,
+			});
+			continue;
+		}
+		shownInBatch.add(absolutePath);
 		try {
 			const stat = await Bun.file(absolutePath).stat();
 			if (stat.isDirectory()) {
@@ -354,7 +386,7 @@ export async function generateFileMentionMessages(
 			}
 
 			const content = await Bun.file(absolutePath).text();
-			let { output, lineCount } = buildTextOutput(content);
+			let { output, lineCount } = buildTextOutput(content, options?.maxInlineBytes);
 			if (options?.useHashLines) {
 				output = formatHashLines(output);
 			}

package/src/utils/git.ts

@@ -1317,6 +1317,79 @@ export async function clean(
 	await runEffect(cwd, args, { signal: options.signal });
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// API: bisect
+// ════════════════════════════════════════════════════════════════════════════
+
+export interface BisectCommitInfo {
+	sha: string;
+	author: string;
+	date: string;
+	subject: string;
+	stat: string;
+}
+
+/**
+ * Thin wrappers over `git bisect`. The marking commands (`good`/`bad`/`skip`)
+ * return the raw {@link GitCommandResult} without throwing so callers can both
+ * detect a genuine failure (non-zero exit) and scan the output for the
+ * "<sha> is the first bad commit" conclusion. `reset` is best-effort and never
+ * throws so it is safe to call from a `finally` block to restore the worktree.
+ */
+export const bisect = {
+	/** Begin a bisect session (does not seed good/bad endpoints). */
+	async start(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runEffect(cwd, ["bisect", "start"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) good. Returns raw output. */
+	async good(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "good", ref] : ["bisect", "good"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) bad. Returns raw output. */
+	async bad(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "bad", ref] : ["bisect", "bad"], { signal });
+	},
+
+	/** Skip the current (untestable) revision. Returns raw output. */
+	async skip(cwd: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ["bisect", "skip"], { signal });
+	},
+
+	/** Read the replayable bisect log for the current session. */
+	async log(cwd: string, signal?: AbortSignal): Promise<string> {
+		return runText(cwd, ["bisect", "log"], { signal });
+	},
+
+	/** End the bisect session, restoring the original HEAD. Never throws. */
+	async reset(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runCommand(cwd, ["bisect", "reset"], { signal });
+	},
+
+	/** True when `ancestor` is a first-parent-or-merge ancestor of `descendant`. */
+	async isAncestor(cwd: string, ancestor: string, descendant: string, signal?: AbortSignal): Promise<boolean> {
+		const result = await runCommand(cwd, ["merge-base", "--is-ancestor", ancestor, descendant], {
+			readOnly: true,
+			signal,
+		});
+		return result.exitCode === 0;
+	},
+
+	/** Resolve author/date/subject and a diffstat for a commit (for the receipt). */
+	async describe(cwd: string, sha: string, signal?: AbortSignal): Promise<BisectCommitInfo> {
+		// Newline-delimited so the format string carries no NUL byte (argv cannot
+		// contain NUL); %s is already a single line, so the four fields never wrap.
+		const meta = await runText(cwd, ["show", "-s", "--format=%H%n%an <%ae>%n%aI%n%s", sha], {
+			readOnly: true,
+			signal,
+		});
+		const [resolvedSha = sha, author = "", date = "", subject = ""] = meta.split("\n");
+		const stat = await runText(cwd, ["show", "--stat", "--format=", sha], { readOnly: true, signal });
+		return { sha: resolvedSha, author, date, subject, stat: stat.trim() };
+	},
+};
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: ls
 // ════════════════════════════════════════════════════════════════════════════

package/src/web/scrapers/youtube.ts

@@ -10,44 +10,56 @@ import { extractWithParallel, findParallelApiKey, getParallelExtractContent } fr
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, formatNumber } from "./types";
 
-interface YouTubeUrl {
+export interface YouTubeUrl {
 	videoId: string;
 	playlistId?: string;
 }
 
+const YOUTUBE_VIDEO_ID_PATTERN = /^[a-zA-Z0-9_-]{11}$/;
+
+function isYouTubeHost(hostname: string): boolean {
+	return hostname === "youtube.com" || hostname === "m.youtube.com" || hostname === "music.youtube.com";
+}
+
+function isYouTubeEmbedHost(hostname: string): boolean {
+	return isYouTubeHost(hostname) || hostname === "youtube-nocookie.com";
+}
+
 /**
  * Parse YouTube URL into components
  */
-function parseYouTubeUrl(url: string): YouTubeUrl | null {
+export function parseYouTubeUrl(url: string): YouTubeUrl | null {
 	try {
 		const parsed = new URL(url);
 		const hostname = parsed.hostname.replace(/^www\./, "");
 
-		// youtube.com/watch?v=VIDEO_ID
-		if ((hostname === "youtube.com" || hostname === "m.youtube.com") && parsed.pathname === "/watch") {
+		// youtube.com/watch?v=VIDEO_ID and music.youtube.com/watch?v=VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname === "/watch") {
 			const videoId = parsed.searchParams.get("v");
 			const playlistId = parsed.searchParams.get("list") || undefined;
-			if (videoId) return { videoId, playlistId };
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) return { videoId, playlistId };
 		}
 
-		// youtube.com/v/VIDEO_ID or youtube.com/embed/VIDEO_ID
-		if (hostname === "youtube.com" || hostname === "m.youtube.com") {
-			const match = parsed.pathname.match(/^\/(v|embed)\/([a-zA-Z0-9_-]{11})/);
+		// youtube.com/v/VIDEO_ID, youtube.com/embed/VIDEO_ID, youtube.com/live/VIDEO_ID,
+		// and youtube-nocookie.com/embed/VIDEO_ID. Require the id segment to end
+		// before matching so malformed overlong ids are not silently truncated.
+		if (isYouTubeEmbedHost(hostname)) {
+			const match = parsed.pathname.match(/^\/(v|embed|live)\/([a-zA-Z0-9_-]{11})(?:$|\/)/);
 			if (match) return { videoId: match[2] };
 		}
 
 		// youtu.be/VIDEO_ID
 		if (hostname === "youtu.be") {
 			const videoId = parsed.pathname.slice(1).split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}
 
-		// youtube.com/shorts/VIDEO_ID
-		if (hostname === "youtube.com" && parsed.pathname.startsWith("/shorts/")) {
+		// youtube.com/shorts/VIDEO_ID and m.youtube.com/shorts/VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname.startsWith("/shorts/")) {
 			const videoId = parsed.pathname.replace("/shorts/", "").split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}