@gajae-code/coding-agent 0.11.11 → 0.12.1

package/dist/types/tools/read-internals.d.ts

@@ -0,0 +1,12 @@
+import type { Settings } from "../config/settings";
+import type { TruncationDirection } from "../session/streaming-output";
+/**
+ * Read execution routes that have distinct truncation-default contracts.
+ * Routes that share the same default are grouped only when their truncation
+ * policy is identical; selection and rendering remain owned by read.ts.
+ */
+export type ReadRoute = "local-bare-stream" | "local-bare-acp" | "archive-member-bare" | "local-range" | "local-multi-range" | "local-raw" | "local-summary" | "url-reader" | "url-cache-page" | "dir-local" | "dir-archive" | "sqlite-list" | "sqlite-rows" | "converted";
+/** Resolve the configured default for a route; explicit parameters bypass it. */
+export declare function pathDefault(route: ReadRoute, settings: Settings): TruncationDirection;
+/** Resolve the effective caller-facing direction with explicit precedence. */
+export declare function resolveEffectiveDirection(explicitParam: TruncationDirection | undefined, route: ReadRoute, settings: Settings): TruncationDirection;

package/dist/types/tools/read.d.ts

@@ -4,10 +4,49 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
-import { type TruncationResult } from "../session/streaming-output";
+import type { ReadWindow, TruncationResult } from "../session/streaming-output";
 import { type OutputMeta } from "./output-meta";
+export declare function streamLinesFromFile(filePath: string, startLine: number, maxLinesToCollect: number, maxBytes: number, selectedLineLimit: number | null, signal?: AbortSignal, collect?: "head" | "tail" | "both", collectEndExclusive?: number | null): Promise<{
+    lines: string[];
+    totalFileLines: number;
+    collectedBytes: number;
+    stoppedByByteLimit: boolean;
+    firstLinePreview?: {
+        text: string;
+        bytes: number;
+    };
+    firstLineByteLength?: number;
+    selectedBytesTotal: number;
+    windowBytesTotal: number;
+    windowLinesTotal: number;
+    windowStartIndex: number;
+    tailPartial?: {
+        text: string;
+        bytes: number;
+        sourceIndex: number;
+        sourceLineBytes: number;
+    };
+    maxBytes: number;
+    headLines?: string[];
+    headBytes?: number;
+    headStartIndex?: number;
+    degenerateTailBudget: boolean;
+    degenerateHeadBudget: boolean;
+    headStoppedByBytes: boolean;
+    headStoppedByLines: boolean;
+    ringBudgetLines: number;
+    ringEvictedForBytes: boolean;
+    ringEvictedForLines: boolean;
+    tailDroppedForBytes: boolean;
+}>;
+export declare function streamResultWindow(result: Awaited<ReturnType<typeof streamLinesFromFile>>, collect: "tail" | "both", startLine: number, collectEndExclusive: number | null): ReadWindow;
 declare const readSchema: z.ZodObject<{
     path: z.ZodString;
+    truncation: z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        head: "head";
+        last: "last";
+    }>>;
 }, z.core.$strict>;
 export type ReadToolInput = z.infer<typeof readSchema>;
 /** Project paths and output sizes without exposing read content or remote URLs. */
@@ -45,12 +84,6 @@ export interface ReadToolDetails {
     conflictCount?: number;
 }
 type ReadParams = ReadToolInput;
-/**
- * Read tool implementation.
- *
- * Reads files with support for images, converted documents (via markit), and text.
- * Directories return a formatted listing with modification times.
- */
 export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
     #private;
     private readonly session;
@@ -60,6 +93,11 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly description: string;
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
+        truncation: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            head: "head";
+            last: "last";
+        }>>;
     }, z.core.$strict>;
     readonly nonAbortable = true;
     readonly strict = true;

package/dist/types/tools/resource-gc.d.ts

@@ -1,5 +1,6 @@
 import type { WindowsJobMemoryProbeResult } from "@gajae-code/natives";
 import type { Settings } from "../config/settings";
+import type { MemoryGuardWorkerSample } from "../runtime/memory-guard-contract";
 import { type TabGcSnapshot } from "./browser/tab-supervisor";
 export interface BrowserGcPolicy {
     enabled: boolean;
@@ -35,10 +36,13 @@ export interface ResourceGcDeps {
         removed: number;
     }>;
     screenshotArmed: () => boolean;
+    listTeamWorkers?: (cwd: string, sessionId: string) => Promise<MemoryGuardWorkerSample[]>;
+    applyTeamWorkerGuard?: (cwd: string, sessionId: string, workerId: string, excessBytes: number, incidentId: string) => Promise<void>;
 }
 export interface ResourceGcRegistration {
     sessionId: string;
     settings: Settings;
+    cwd?: string | (() => string);
 }
 /**
  * Register a session with the resource GC. Starts the single shared timer on the first

package/dist/types/tools/review.d.ts

@@ -50,14 +50,12 @@ export interface SubmitReviewDetails {
 }
 export type { ReportFindingDetails };
 /**
- * Coerce a tool-side `ReportFindingDetails` into the cross-boundary
- * `ReviewFinding` shape consumed by the reviewer agent's JTD output schema.
+ * Convert tool-side `ReportFindingDetails` into the numeric-priority
+ * `ReviewFinding` shape used by caller-owned reviewer payloads.
  *
  * The `report_finding` tool exposes `priority` as a string enum (`"P0".."P3"`)
- * for ergonomics, but the bundled reviewer schema (and every custom review
- * agent that mirrors it) declares `priority: number`. Without this coercion
- * the auto-populated `findings[]` fails JTD validation and every review run
- * that surfaces a finding is rejected with `findings.0.priority: expected
- * number, received string`.
+ * for ergonomics, while reviewer schemas may explicitly declare numeric
+ * priorities. This pure conversion does not add findings to completion data;
+ * callers that include `findings` own both that field and its output schema.
  */
 export declare function toReviewFinding(details: ReportFindingDetails): ReviewFinding;

package/dist/types/tools/subagent.d.ts

@@ -38,6 +38,8 @@ export interface SubagentSnapshot {
     durationMs: number;
     resultText?: string;
     errorText?: string;
+    /** Safe setup failure cause retained from the executor launch path. */
+    setupFailureSummary?: string;
     resultPreview?: string;
     outputRef?: string;
     truncated?: boolean;

package/dist/types/tools/tool-result.d.ts

@@ -1,6 +1,6 @@
 import type { AgentToolResult } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent } from "@gajae-code/ai";
-import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputSummary, ReadWindow, TruncationResult } from "../session/streaming-output";
 import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
 type ToolContent = Array<TextContent | ImageContent>;
 type DetailsWithMeta = {
@@ -12,6 +12,12 @@ export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
     text(text: string): this;
     content(content: ToolContent): this;
     truncation(result: TruncationResult, options: TruncationOptions): this;
+    truncationWindows(windows: ReadWindow, options?: {
+        artifactId?: string;
+        noticeOwner?: "body";
+        maxBytes?: number;
+        rangeBase?: "file" | "window";
+    }): this;
     truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
     truncationFromText(text: string, options: TruncationTextOptions): this;
     limits(limits: {

package/dist/types/utils/gh.d.ts

@@ -0,0 +1,13 @@
+export interface GhResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut?: boolean;
+}
+export type RunGh = (args: string[], options?: {
+    timeoutMs?: number;
+}) => Promise<GhResult>;
+/** Run GitHub CLI without allowing it to consume the parent terminal's input. */
+export declare function runGhDefault(args: string[], options?: {
+    timeoutMs?: number;
+}): Promise<GhResult>;

package/dist/types/utils/image-resize.d.ts

@@ -5,6 +5,7 @@ export interface ImageResizeOptions {
     maxBytes?: number;
     jpegQuality?: number;
     excludeWebP?: boolean;
+    forceReencode?: boolean;
 }
 export interface ResizedImage {
     buffer: Uint8Array;

package/dist/types/web/search/providers/kimi.d.ts

@@ -16,6 +16,8 @@ export interface KimiSearchParams {
     authStorage: AuthStorage;
     sessionId?: string;
 }
+/** Test seam: the Kimi search base URL as resolved from trusted env. */
+export declare function resolveKimiSearchBaseUrlForTest(): string;
 /** Execute Kimi web search. */
 export declare function searchKimi(params: KimiSearchParams): Promise<SearchResponse>;
 /** Search provider for Kimi web search. */

package/dist/types/web/search/providers/searxng.d.ts

@@ -28,6 +28,13 @@ import type { AuthStorage } from "@gajae-code/ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+/** Test seam: the SearXNG endpoint and auth material as resolved from trusted env. */
+export declare function resolveSearxngConfigForTest(): {
+    endpoint: string | null;
+    token: string | null;
+    basicUsername: string | null;
+    basicPassword: string | null;
+};
 /** Execute SearXNG web search. */
 export declare function searchSearXNG(params: {
     query: string;

package/dist/types/web/search/providers/xai.d.ts

@@ -32,6 +32,8 @@ export interface XaiSearchParams {
     authStorage: AuthStorage;
     sessionId?: string;
 }
+/** Test seam: the xAI search base URL as resolved from trusted env. */
+export declare function resolveXaiSearchBaseUrlForTest(): string;
 export declare function buildXaiRequestBody(params: {
     query: string;
     systemPrompt: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.11",
+	"version": "0.12.1",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -50,16 +50,16 @@
 		"check:sdk-closure": "bun ../../scripts/telegram-daemon-generation-guard.ts --validate-current-tree && bun test ../../scripts/telegram-daemon-generation-guard.test.ts && bun scripts/generate-sdk-operation-inventory.ts --check && bun scripts/generate-sdk-adapter-parity-manifest.ts --check && bun scripts/run-test-manifest.ts test/manifests/sdk-adapter-parity-v1.json && bun scripts/generate-telegram-baseline-manifest.ts --check && bun scripts/run-test-manifest.ts test/manifests/telegram-baseline-v1.json && bun test test/sdk-downgrade-rollback.test.ts test/sdk-downgrade-unknown-version.test.ts && bun scripts/verify-gjc-sdk-canonicalization.ts --self-test && bun scripts/verify-gjc-sdk-canonicalization.ts && bun scripts/verify-gjc-sdk-rename.ts"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "1.2.1",
+		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.11",
-		"@gajae-code/agent-core": "0.11.11",
-		"@gajae-code/ai": "0.11.11",
-		"@gajae-code/bridge-client": "0.11.11",
-		"@gajae-code/natives": "0.11.11",
-		"@gajae-code/tui": "0.11.11",
-		"@gajae-code/utils": "0.11.11",
+		"@gajae-code/stats": "0.12.1",
+		"@gajae-code/agent-core": "0.12.1",
+		"@gajae-code/ai": "0.12.1",
+		"@gajae-code/bridge-client": "0.12.1",
+		"@gajae-code/natives": "0.12.1",
+		"@gajae-code/tui": "0.12.1",
+		"@gajae-code/utils": "0.12.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -327,6 +327,8 @@
 			"types": "./dist/types/export/html/*.d.ts",
 			"import": "./src/export/html/*.ts"
 		},
+		"./extensibility/gjc-plugins/installer": null,
+		"./extensibility/gjc-plugins/registry": null,
 		"./extensibility/*": {
 			"types": "./dist/types/extensibility/*.d.ts",
 			"import": "./src/extensibility/*.ts"
@@ -343,10 +345,6 @@
 			"types": "./dist/types/extensibility/custom-commands/bundled/ci-green/index.d.ts",
 			"import": "./src/extensibility/custom-commands/bundled/ci-green/index.ts"
 		},
-		"./extensibility/custom-commands/bundled/review": {
-			"types": "./dist/types/extensibility/custom-commands/bundled/review/index.d.ts",
-			"import": "./src/extensibility/custom-commands/bundled/review/index.ts"
-		},
 		"./extensibility/custom-tools": {
 			"types": "./dist/types/extensibility/custom-tools/index.d.ts",
 			"import": "./src/extensibility/custom-tools/index.ts"

package/scripts/acp-conformance-agent.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+
+/**
+ * Credential-free ACP fixture launcher. The loopback endpoint is deliberately
+ * deterministic; the child remains the production `gjc --mode acp` surface.
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const root = path.resolve(import.meta.dir, "..", "..", "..");
+const agentDir = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-acp-conformance-"));
+let child: ReturnType<typeof Bun.spawn> | undefined;
+let server: ReturnType<typeof Bun.serve> | undefined;
+
+/**
+ * Deterministic replies for the pinned `acp-core-v1` corpus. Each branch mirrors one
+ * upstream case expectation; nothing here reaches the network.
+ */
+function response(prompt: string): string {
+	if (prompt.includes("inspect-prompt")) return `received blocks: {"type":"resource"}`;
+	if (prompt.includes("this-command-does-not-exist")) return "unrecognized prompt";
+	if (/^\s*read\b/m.test(prompt)) return "read README.md: acpx";
+	if (/^\s*write\b/m.test(prompt)) {
+		const target = /write\s+(\S+)/.exec(prompt)?.[1] ?? "file";
+		return `wrote ${target}`;
+	}
+	const echo = /^\s*echo\s*(.*)$/m.exec(prompt);
+	if (echo) return echo[1] || "echo";
+	return "ok";
+}
+
+function sse(value: unknown): string {
+	return `data: ${JSON.stringify(value)}\n\n`;
+}
+
+function completion(delta: Record<string, unknown>, finishReason: string | null = null): string {
+	return sse({ id: "gjc-conformance", choices: [{ delta, finish_reason: finishReason }] });
+}
+
+function toolCall(name: "read" | "write", arguments_: Record<string, string>): string {
+	return completion(
+		{
+			tool_calls: [
+				{
+					index: 0,
+					id: `conformance-${name}`,
+					type: "function",
+					function: { name, arguments: JSON.stringify(arguments_) },
+				},
+			],
+		},
+		"tool_calls",
+	);
+}
+
+function textCompletion(text: string): string {
+	return `${completion({ content: text })}${completion({}, "stop")}data: [DONE]\n\n`;
+}
+
+async function cleanup(code = 0): Promise<never> {
+	server?.stop(true);
+	if (child && child.exitCode === null) child.kill();
+	await fs.rm(agentDir, { recursive: true, force: true });
+	process.exit(code);
+}
+
+server = Bun.serve({
+	hostname: "127.0.0.1",
+	port: 0,
+	async fetch(request) {
+		const body = (await request.json().catch(() => ({}))) as {
+			messages?: Array<{ role?: string; content?: unknown }>;
+		};
+		// OpenAI-style content is either a plain string or an array of typed blocks.
+		const textOf = (content: unknown): string =>
+			typeof content === "string"
+				? content
+				: Array.isArray(content)
+					? content
+							.map(block =>
+								typeof block === "object" &&
+								block !== null &&
+								typeof (block as { text?: unknown }).text === "string"
+									? (block as { text: string }).text
+									: "",
+							)
+							.join("")
+					: "";
+		const messages = body.messages ?? [];
+		const prompt =
+			[...messages]
+				.reverse()
+				.filter(message => message.role === "user")
+				.map(message => textOf(message.content))
+				.find(text => text.length > 0) ?? "";
+		const hasToolResult = messages.some(message => message.role === "tool");
+		const isRead = /^\s*read\b/m.test(prompt);
+		const isWrite = /^\s*write\b/m.test(prompt);
+		const isLateTool = prompt.includes("late-tool 40 follow-up");
+
+		if (prompt.includes("sleep")) {
+			const requested = Number(/\bsleep\s+(\d+)/.exec(prompt)?.[1] ?? 0);
+			const delay = Math.min(Math.max(requested, 0), 30_000);
+			const stream = new ReadableStream<Uint8Array>({
+				start(controller) {
+					let closed = false;
+					const close = () => {
+						if (closed) return;
+						closed = true;
+						controller.close();
+					};
+					request.signal.addEventListener("abort", close, { once: true });
+					void Bun.sleep(delay).then(() => {
+						if (closed) return;
+						controller.enqueue(new TextEncoder().encode(textCompletion("slept")));
+						close();
+					});
+				},
+			});
+			return new Response(stream, { headers: { "content-type": "text/event-stream" } });
+		}
+
+		if ((isRead || isWrite || isLateTool) && !hasToolResult) {
+			if (isLateTool) {
+				const prefix = `${completion({ content: "preparing" })}${completion({ content: " writing now" })}${completion({ content: " before tool" })}`;
+				return new Response(
+					`${prefix}${toolCall("write", { path: ".acpx-conformance-late.txt", content: "late" })}data: [DONE]\n\n`,
+					{
+						headers: { "content-type": "text/event-stream" },
+					},
+				);
+			}
+			// Neutral pre-tool text: every corpus assertion below must come from the real
+			// tool result, never from a marker announced before the tool ran.
+			const provisional = isRead ? "checking the requested file" : "applying the requested write";
+			return new Response(
+				`${completion({ content: provisional })}${toolCall(
+					isRead ? "read" : "write",
+					isRead
+						? { path: "README.md" }
+						: {
+								path: /write\s+(\S+)/.exec(prompt)?.[1] ?? "file",
+								content: /write\s+\S+\s*(.*)/.exec(prompt)?.[1] ?? "",
+							},
+				)}data: [DONE]\n\n`,
+				{ headers: { "content-type": "text/event-stream" } },
+			);
+		}
+
+		// Derive the reply from what the tool actually returned so a broken permission
+		// bridge, filesystem bridge, or tool result cannot still satisfy the corpus.
+		const toolText = messages
+			.filter(message => message.role === "tool")
+			.map(message => textOf(message.content))
+			.join("\n");
+		const toolDenied = /rejected by user|permission denied|not permitted/i.test(toolText);
+		const reply = toolDenied
+			? `permission denied: ${toolText.slice(0, 200)}`
+			: isRead
+				? `read README.md: ${toolText.trim().slice(0, 200)}`
+				: isWrite
+					? `wrote ${/write\s+(\S+)/.exec(prompt)?.[1] ?? "file"}: ${toolText.trim().slice(0, 120)}`
+					: isLateTool
+						? `writing now: ${toolText.trim().slice(0, 120)}`
+						: response(prompt);
+		return new Response(textCompletion(reply), { headers: { "content-type": "text/event-stream" } });
+	},
+});
+
+await Bun.write(
+	path.join(agentDir, "models.json"),
+	JSON.stringify({
+		providers: {
+			conformance: {
+				api: "openai-completions",
+				baseUrl: `http://127.0.0.1:${server.port}/v1`,
+				auth: "none",
+				models: [{ id: "fixture", name: "fixture", input: ["text"], contextWindow: 1_000_000, maxTokens: 8192 }],
+			},
+		},
+	}),
+);
+
+// The pinned corpus reads `README.md` from the session cwd the runner passes on
+// `session/new`. The runner creates that directory but seeds no content, so seed it
+// here (never inside the upstream corpus) when the harness names it.
+const scratchCwd = process.env.GJC_ACP_CONFORMANCE_CWD?.trim();
+if (scratchCwd) {
+	const scratchReadme = path.join(scratchCwd, "README.md");
+	if (!(await Bun.file(scratchReadme).exists())) await Bun.write(scratchReadme, "acpx conformance workspace\n");
+}
+
+child = Bun.spawn(
+	[
+		"bun",
+		path.join(root, "packages", "coding-agent", "src", "cli.ts"),
+		"--mode",
+		"acp",
+		"--model",
+		"conformance/fixture",
+	],
+	{
+		cwd: root,
+		env: { ...process.env, GJC_CODING_AGENT_DIR: agentDir, PI_CODING_AGENT_DIR: agentDir },
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	},
+);
+process.once("SIGTERM", () => {
+	void cleanup(0);
+});
+process.once("SIGINT", () => {
+	void cleanup(0);
+});
+await child.exited;
+await cleanup(child.exitCode ?? 1);