@gajae-code/coding-agent 0.11.2 → 0.11.4

package/src/cli/worktree-cli.ts

@@ -1,291 +1,13 @@
 /**
- * CLI handler for `gjc worktree` — list and clean up agent-managed worktrees.
+ * Tombstone for the removed legacy worktree cleanup API.
  *
- * Layout under `~/.gjc/wt/`:
- *
- *   - **PR-checkout worktrees** (`tools/gh.ts`): a regular git worktree dir
- *     containing a `.git` *file* that points back at
- *     `<parent-repo>/.git/worktrees/<name>/`.
- *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
- *     `merged` subdir mounted/cloned by `natives.isoStart`. These are ephemeral
- *     — `ensureIsolation` always `rm -rf`s the base before re-creating it, so
- *     any leftover on disk is a leak from a crashed run.
- *
- * Legacy entries from before the encoding change keep working because git still
- * tracks them by branch name. This command exists to GC them on demand.
+ * The recursive-deletion implementation that previously lived here
+ * (`listWorktrees`/`clearWorktrees`) was deliberately removed and does not
+ * come back through this subpath. This module exists only to fail imports
+ * with actionable migration guidance.
  */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { getWorktreesDir, isEnoent } from "@gajae-code/utils";
-import chalk from "chalk";
-import * as git from "../utils/git";
-
-type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
-
-export interface WorktreeEntry {
-	/** Absolute path to the worktree dir (or stray container) under `~/.gjc/wt/`. */
-	path: string;
-	/** Classification of what we found on disk. */
-	kind: WorktreeKind;
-	/** Parent repo root, when this is a registered git worktree. */
-	parentRepo?: string;
-	/** Branch name extracted from the parent's tracking file, when available. */
-	branch?: string;
-	/** When set, the entry is unhealthy and `gjc worktree clear` will remove it. */
-	orphanReason?: string;
-}
-
-export interface ListWorktreesOptions {
-	json: boolean;
-}
-
-export interface ClearWorktreesOptions {
-	/** Remove every entry, including live PR-checkout worktrees. */
-	all: boolean;
-	/** Print what would be removed without touching the filesystem. */
-	dryRun: boolean;
-	json: boolean;
-}
-
-export async function listWorktrees(options: ListWorktreesOptions): Promise<void> {
-	const entries = await scanWorktrees();
-	if (options.json) {
-		console.log(JSON.stringify(entries, null, 2));
-		return;
-	}
-	if (entries.length === 0) {
-		console.log(chalk.dim(`No agent-managed worktrees found under ${getWorktreesDir()}.`));
-		return;
-	}
-	let live = 0;
-	let orphaned = 0;
-	for (const entry of entries) {
-		const tag = entry.orphanReason ? chalk.yellow("orphaned") : chalk.green("live    ");
-		const detail = formatEntryDetail(entry);
-		console.log(`${tag}  ${entry.path}`);
-		if (detail) console.log(`          ${chalk.dim(detail)}`);
-		if (entry.orphanReason) orphaned += 1;
-		else live += 1;
-	}
-	console.log(chalk.dim(`\n${live} live · ${orphaned} orphaned · ${entries.length} total`));
-}
-
-export async function clearWorktrees(options: ClearWorktreesOptions): Promise<void> {
-	const entries = await scanWorktrees();
-	const targets = options.all ? entries : entries.filter(entry => entry.orphanReason !== undefined);
-
-	if (targets.length === 0) {
-		if (options.json) {
-			console.log(JSON.stringify({ removed: 0, kept: entries.length }));
-		} else {
-			console.log(chalk.dim(options.all ? "No worktrees to remove." : "No orphaned worktrees to remove."));
-		}
-		return;
-	}
-
-	if (options.dryRun) {
-		if (options.json) {
-			console.log(JSON.stringify({ wouldRemove: targets.map(t => t.path) }, null, 2));
-		} else {
-			for (const target of targets) {
-				console.log(`${chalk.yellow("would remove")}  ${target.path}`);
-			}
-			console.log(chalk.dim(`\n${targets.length} dir${targets.length === 1 ? "" : "s"} would be removed.`));
-		}
-		return;
-	}
-
-	const results: { path: string; ok: boolean; error?: string }[] = [];
-	const parentsToPrune = new Set<string>();
-	for (const target of targets) {
-		try {
-			if (target.kind === "pr-checkout" && target.parentRepo && !target.orphanReason) {
-				// Live worktree: ask git to remove it cleanly. If git refuses (locked,
-				// dirty, etc.), fall back to fs.rm and rely on `worktree prune` to
-				// clean the bookkeeping on the parent side.
-				const removed = await git.worktree.tryRemove(target.parentRepo, target.path, { force: true });
-				if (!removed) {
-					await fs.rm(target.path, { recursive: true, force: true });
-					parentsToPrune.add(target.parentRepo);
-				}
-			} else {
-				await fs.rm(target.path, { recursive: true, force: true });
-				if (target.parentRepo) parentsToPrune.add(target.parentRepo);
-			}
-			results.push({ path: target.path, ok: true });
-		} catch (err) {
-			results.push({ path: target.path, ok: false, error: err instanceof Error ? err.message : String(err) });
-		}
-	}
-
-	// Best-effort: drop stale entries from each affected parent's `.git/worktrees/`.
-	for (const parent of parentsToPrune) {
-		try {
-			await git.worktree.prune(parent);
-		} catch {
-			/* parent repo may already be gone or pruned — ignore */
-		}
-	}
-
-	const succeeded = results.filter(r => r.ok).length;
-	const failed = results.length - succeeded;
-
-	if (options.json) {
-		console.log(JSON.stringify({ removed: succeeded, failed, results }, null, 2));
-		if (failed > 0) process.exitCode = 1;
-		return;
-	}
-
-	for (const result of results) {
-		if (result.ok) {
-			console.log(`${chalk.green("removed")}  ${result.path}`);
-		} else {
-			console.log(`${chalk.red("failed ")}  ${result.path}`);
-			if (result.error) console.log(`          ${chalk.dim(result.error)}`);
-		}
-	}
-	console.log(chalk.dim(`\n${succeeded} removed${failed > 0 ? ` · ${chalk.red(`${failed} failed`)}` : ""}`));
-	if (failed > 0) process.exitCode = 1;
-}
-
-// ───────────────────────────────────────────────────────────────────────────
-// Scanner
-// ───────────────────────────────────────────────────────────────────────────
-
-async function scanWorktrees(): Promise<WorktreeEntry[]> {
-	const root = getWorktreesDir();
-	let topLevel: string[];
-	try {
-		topLevel = await fs.readdir(root);
-	} catch (err) {
-		if (isEnoent(err)) return [];
-		throw err;
-	}
-
-	const entries: WorktreeEntry[] = [];
-	for (const name of topLevel) {
-		const dir = path.join(root, name);
-		const stat = await fs.stat(dir).catch(() => null);
-		if (!stat?.isDirectory()) continue;
-
-		const direct = await classifyDir(dir);
-		if (direct) {
-			entries.push(direct);
-			continue;
-		}
-
-		// Legacy nesting: ~/.gjc/wt/<encoded-project>/<branch-or-id>
-		let children: string[];
-		try {
-			children = await fs.readdir(dir);
-		} catch {
-			continue;
-		}
-		let nested = 0;
-		for (const child of children) {
-			const childDir = path.join(dir, child);
-			const childStat = await fs.stat(childDir).catch(() => null);
-			if (!childStat?.isDirectory()) continue;
-			const childClassified = await classifyDir(childDir);
-			if (childClassified) {
-				entries.push(childClassified);
-				nested += 1;
-			}
-		}
-		if (nested === 0) {
-			entries.push({
-				path: dir,
-				kind: children.length === 0 ? "empty" : "stray",
-				orphanReason: children.length === 0 ? "empty directory" : "no recognizable worktree contents",
-			});
-		}
-	}
-	return entries;
-}
-
-async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
-	const gitEntry = path.join(dir, ".git");
-	const gitStat = await fs.stat(gitEntry).catch(() => null);
-	if (gitStat?.isFile()) {
-		return classifyPrCheckout(dir, gitEntry);
-	}
-	const mergedStat = await fs.stat(path.join(dir, "merged")).catch(() => null);
-	if (mergedStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "task-isolation",
-			orphanReason: "task-isolation leftover (no live task owns it)",
-		};
-	}
-	return null;
-}
-
-async function classifyPrCheckout(dir: string, gitEntry: string): Promise<WorktreeEntry> {
-	let contents: string;
-	try {
-		contents = await fs.readFile(gitEntry, "utf8");
-	} catch (err) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			orphanReason: `cannot read .git file: ${err instanceof Error ? err.message : String(err)}`,
-		};
-	}
-	const match = /^gitdir:\s*(.+?)\s*$/m.exec(contents);
-	const parentGitDir = match?.[1];
-	if (!parentGitDir) {
-		return { path: dir, kind: "pr-checkout", orphanReason: "malformed .git file (no gitdir line)" };
-	}
-	// parentGitDir is `<parent-repo>/.git/worktrees/<name>`; back out the repo root.
-	const parentRepo = path.dirname(path.dirname(path.dirname(parentGitDir)));
-	const branch = await readWorktreeBranch(path.join(parentGitDir, "HEAD"));
-
-	const parentDirStat = await fs.stat(parentGitDir).catch(() => null);
-	if (!parentDirStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			parentRepo,
-			branch,
-			orphanReason: "parent repo no longer tracks this worktree",
-		};
-	}
-	const parentRepoStat = await fs.stat(parentRepo).catch(() => null);
-	if (!parentRepoStat?.isDirectory()) {
-		return {
-			path: dir,
-			kind: "pr-checkout",
-			parentRepo,
-			branch,
-			orphanReason: "parent repo missing",
-		};
-	}
-	return { path: dir, kind: "pr-checkout", parentRepo, branch };
-}
-
-async function readWorktreeBranch(headFile: string): Promise<string | undefined> {
-	try {
-		const head = (await fs.readFile(headFile, "utf8")).trim();
-		const refMatch = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
-		return refMatch?.[1];
-	} catch {
-		return undefined;
-	}
-}
+export {};
 
-function formatEntryDetail(entry: WorktreeEntry): string {
-	const parts: string[] = [];
-	if (entry.kind === "pr-checkout") {
-		const repo = entry.parentRepo ? path.basename(entry.parentRepo) : "unknown repo";
-		const branch = entry.branch ?? "unknown branch";
-		parts.push(`${repo} · ${branch}`);
-	} else if (entry.kind === "task-isolation") {
-		parts.push("task-isolation sandbox");
-	} else if (entry.kind === "empty") {
-		parts.push("legacy project shell");
-	} else {
-		parts.push("unrecognized contents");
-	}
-	if (entry.orphanReason) parts.push(entry.orphanReason);
-	return parts.join(" — ");
-}
+throw new Error(
+	"@gajae-code/coding-agent/cli/worktree-cli was deliberately removed: the legacy worktree cleanup API (listWorktrees/clearWorktrees) is gone. Inspect leftover managed worktrees under ~/.gjc/wt manually and use `git worktree remove` or `git worktree prune` instead.",
+);

package/src/cli.ts

@@ -9,6 +9,7 @@ import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@g
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";
 import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./gjc-runtime/tmux-owner-isolation-cli";
+import { smokeTestTabWorker } from "./tools/browser/tab-worker-smoke";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -252,16 +253,15 @@ function isSubcommand(first: string | undefined): boolean {
 }
 
 /**
- * Smoke-test entry. Spawns the stats sync worker, pings it, exits.
+ * Smoke-test entry. Spawns the stats sync worker and the browser tab worker, then verifies their protocol.
  *
- * Purpose: catch the silent worker-load regressions that hit compiled
- * binaries (issues #1011 and #1027). Neither `--version` nor
- * `stats --summary` actually spawns a Worker on a fresh install — the
- * sync path early-returns when no session files exist. This probe is the
- * minimal end-to-end test that proves `new Worker(...)` resolves and the
- * bundled worker module evaluates successfully. Wired into
- * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball
- * installs all exercise it on every CI run.
+ * Purpose: catch silent compiled-worker load regressions (issues #1011,
+ * #1027, and #2598). Neither `--version` nor `stats --summary` spawns both
+ * worker entries on a fresh install. This probe proves each bundled worker
+ * module resolves and evaluates; the tab-worker probe also completes its
+ * bootstrap/closed protocol without launching a browser. Wired into
+ * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball installs
+ * exercise it on every CI run.
  */
 async function runSmokeTest(): Promise<void> {
 	const { smokeTestSyncWorker } = await import("@gajae-code/stats");
@@ -278,6 +278,7 @@ async function runSmokeTest(): Promise<void> {
 	if (typeof h02ScoreSequenceFuzzy !== "function" || typeof h01FindBestFuzzyMatch !== "function") {
 		throw new Error("smoke-test: native fuzzy exports missing from embedded addon");
 	}
+	await smokeTestTabWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 

package/src/commands/gc.ts

@@ -9,9 +9,19 @@ export default class Gc extends Command {
 		prune: Flags.boolean({ description: "Remove stale records (default: report only)", default: false }),
 		force: Flags.boolean({ description: "Alias for --prune (eligible records only)", default: false }),
 		"dry-run": Flags.boolean({ description: "Force report-only mode", default: false }),
+		"repair-session-index": Flags.boolean({
+			description: "Quarantine a corrupt session-index suffix and retain its valid prefix",
+			default: false,
+		}),
 	};
 
-	static examples = ["gjc gc", "gjc gc --json", "gjc gc --prune", "gjc gc --prune --json"];
+	static examples = [
+		"gjc gc",
+		"gjc gc --json",
+		"gjc gc --prune",
+		"gjc gc --prune --json",
+		"gjc gc --repair-session-index --json",
+	];
 
 	async run(): Promise<void> {
 		const result = await runGjcGcCommand(this.argv, process.cwd(), process.env);

package/src/commands/sdk.ts

@@ -7,6 +7,7 @@ import { Settings } from "../config/settings";
 import { applyStartupModelProfiles, createSessionManager } from "../main";
 import { initializeExtensions } from "../modes/runtime-init";
 import { Broker } from "../sdk/broker/broker";
+import { completeBrokerProcess } from "../sdk/broker/internal";
 import {
 	type LifecycleTranscriptEvidence,
 	readSessionLifecycleLaunchRequest,
@@ -439,9 +440,9 @@ export default class Sdk extends Command {
 		});
 		await broker.start();
 		if (!broker.ownsDiscovery) return;
-		const stop = () => void broker.stop().finally(() => process.exit(0));
+		const stop = () => void broker.stop();
 		process.once("SIGTERM", stop);
 		process.once("SIGINT", stop);
-		await new Promise<void>(() => {});
+		await completeBrokerProcess(broker);
 	}
 }

package/src/commands/worktree.ts

@@ -1,56 +1,13 @@
 /**
- * List and clean up agent-managed git worktrees under `~/.gjc/wt`.
+ * Tombstone for the removed legacy `worktree` CLI command module.
+ *
+ * The `gjc worktree`/`wt` command was unregistered during the
+ * workflow-surface narrowing and its implementation was deliberately
+ * removed. This module exists only to fail imports with actionable
+ * migration guidance.
  */
-import { Args, Command, Flags } from "@gajae-code/utils/cli";
-import { clearWorktrees, listWorktrees } from "../cli/worktree-cli";
+export {};
 
-export default class Worktree extends Command {
-	static description = "List or clear agent-managed git worktrees (~/.gjc/wt)";
-
-	static aliases = ["wt"];
-
-	static args = {
-		// `list` (default) inspects the worktree dir; `clear` removes entries.
-		// A positional action keeps `gjc worktree` (the no-arg form) useful.
-		action: Args.string({
-			description: "list (default) or clear",
-			required: false,
-			options: ["list", "clear"],
-			default: "list",
-		}),
-	};
-
-	static flags = {
-		all: Flags.boolean({
-			description: "Clear every entry, including live PR-checkout worktrees (clear)",
-			default: false,
-		}),
-		"dry-run": Flags.boolean({
-			char: "n",
-			description: "Print what would be removed without touching the filesystem (clear)",
-			default: false,
-		}),
-		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
-	};
-
-	static examples = [
-		"gjc worktree",
-		"gjc worktree list --json",
-		"gjc worktree clear",
-		"gjc worktree clear --dry-run",
-		"gjc worktree clear --all",
-	];
-
-	async run(): Promise<void> {
-		const { args, flags } = await this.parse(Worktree);
-		if (args.action === "clear") {
-			await clearWorktrees({
-				all: flags.all ?? false,
-				dryRun: flags["dry-run"] ?? false,
-				json: flags.json ?? false,
-			});
-			return;
-		}
-		await listWorktrees({ json: flags.json ?? false });
-	}
-}
+throw new Error(
+	"@gajae-code/coding-agent/commands/worktree was deliberately removed: the `gjc worktree` command and its cleanup implementation are gone. Inspect leftover managed worktrees under ~/.gjc/wt manually and use `git worktree remove` or `git worktree prune` instead.",
+);

package/src/config/model-profiles.ts

@@ -136,25 +136,25 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "zai/glm-5.2:xhigh",
 	}),
 	profile("kimi-coding-plan-eco", ["kimi-code"], {
-		default: "kimi-code/kimi-k2.7-code:low",
-		executor: "kimi-code/kimi-k2.7-code:minimal",
-		planner: "kimi-code/kimi-k2.7-code:low",
-		critic: "kimi-code/kimi-k2.7-code:medium",
-		architect: "kimi-code/kimi-k2.7-code:high",
+		default: "kimi-code/k3:low",
+		executor: "kimi-code/k3:low",
+		planner: "kimi-code/k3:low",
+		critic: "kimi-code/k3:high",
+		architect: "kimi-code/k3:high",
 	}),
 	profile("kimi-coding-plan-medium", ["kimi-code"], {
-		default: "kimi-code/kimi-k2.7-code:medium",
-		executor: "kimi-code/kimi-k2.7-code:low",
-		planner: "kimi-code/kimi-k2.7-code:medium",
-		critic: "kimi-code/kimi-k2.7-code:high",
-		architect: "kimi-code/kimi-k2.7-code:xhigh",
+		default: "kimi-code/k3:high",
+		executor: "kimi-code/k3:low",
+		planner: "kimi-code/k3:high",
+		critic: "kimi-code/k3:high",
+		architect: "kimi-code/k3:max",
 	}),
 	profile("kimi-coding-plan-pro", ["kimi-code"], {
-		default: "kimi-code/kimi-k2.7-code:xhigh",
-		executor: "kimi-code/kimi-k2.7-code:medium",
-		planner: "kimi-code/kimi-k2.7-code:high",
-		critic: "kimi-code/kimi-k2.7-code:xhigh",
-		architect: "kimi-code/kimi-k2.7-code:xhigh",
+		default: "kimi-code/k3:max",
+		executor: "kimi-code/k3:high",
+		planner: "kimi-code/k3:high",
+		critic: "kimi-code/k3:max",
+		architect: "kimi-code/k3:max",
 	}),
 	profile("mimo-eco", ["xiaomi"], {
 		default: "xiaomi/mimo-v2.5-pro:low",

package/src/config/settings-schema.ts

@@ -669,17 +669,17 @@ export const SETTINGS_SCHEMA = {
 
 	"tools.readArtifactSpillThreshold": {
 		type: "number",
-		default: 0,
+		default: 256,
 		ui: {
 			tab: "tools",
-			label: "Experimental read-tool artifact spill threshold (KB)",
+			label: "Read artifact spill threshold (KB)",
 			description:
-				"Advanced opt-in only: combined-size cap for `read` output across all requested ranges. Above this the full output is saved as an artifact and a bounded head+tail snippet is kept inline. Live layofflabs/gpt-5.5 medium evidence on 2026-07-07 found no token savings and a lower cache-hit rate at 50 KB, so normal coding sessions should leave this Off unless intentionally measuring large-read behavior.",
+				"Explicit large reads above this combined size are saved as an artifact with a bounded head-and-tail snippet inline. Bare reads, directories, and converted-document receipts remain inline.",
 			options: [
-				{ value: "0", label: "Off", description: "Default; no read-specific spill (backstop only)" },
+				{ value: "0", label: "Off", description: "No read-specific spill (backstop only)" },
 				{ value: "50", label: "50 KB", description: "~12.5K tokens" },
 				{ value: "100", label: "100 KB", description: "~25K tokens" },
-				{ value: "256", label: "256 KB", description: "~64K tokens" },
+				{ value: "256", label: "256 KB", description: "Default; ~64K tokens" },
 				{ value: "512", label: "512 KB", description: "~128K tokens" },
 				{ value: "1000", label: "1 MB", description: "~250K tokens" },
 			],
@@ -688,17 +688,17 @@ export const SETTINGS_SCHEMA = {
 
 	"tools.fileMentionInlineBytes": {
 		type: "number",
-		default: 20,
+		default: 10,
 		ui: {
 			tab: "tools",
 			label: "File-mention inline cap (KB)",
 			description:
-				"Inline byte cap for auto-read `@path` file mentions, deliberately below the read-tool cap so an incidental mention injects a smaller snippet than an explicit read. The full file is still available via the read tool.",
+				"Inline byte cap for auto-read `@path` file mentions, aligned with the 10 KiB bare-read receipt so incidental mentions stay within the same bounded context budget. The full file is still available via the read tool.",
 			options: [
 				{ value: "5", label: "5 KB", description: "~1.25K tokens" },
-				{ value: "10", label: "10 KB", description: "~2.5K tokens" },
-				{ value: "20", label: "20 KB", description: "Default; ~5K tokens" },
-				{ value: "50", label: "50 KB", description: "~12.5K tokens (matches read cap)" },
+				{ value: "10", label: "10 KB", description: "Default; ~2.5K tokens" },
+				{ value: "20", label: "20 KB", description: "~5K tokens" },
+				{ value: "50", label: "50 KB", description: "~12.5K tokens (matches bare-read receipt)" },
 			],
 		},
 	},
@@ -2016,6 +2016,51 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"read.receiptBudgetLines": {
+		type: "number",
+		default: 50,
+		ui: {
+			tab: "editing",
+			label: "Read Receipt Line Budget",
+			description: "Maximum lines included in a bare read receipt before a selector footer is shown",
+			options: [
+				{ value: "25", label: "25 lines" },
+				{ value: "50", label: "50 lines", description: "Default" },
+				{ value: "100", label: "100 lines" },
+				{ value: "200", label: "200 lines" },
+			],
+		},
+	},
+	"read.receiptBudgetBytes": {
+		type: "number",
+		default: 10,
+		ui: {
+			tab: "editing",
+			label: "Read Receipt Byte Budget (KB)",
+			description: "Maximum UTF-8 body size for a bare read receipt before a selector footer is shown",
+			options: [
+				{ value: "5", label: "5 KB", description: "~1.25K tokens" },
+				{ value: "10", label: "10 KB", description: "Default; ~2.5K tokens" },
+				{ value: "20", label: "20 KB", description: "~5K tokens" },
+				{ value: "50", label: "50 KB", description: "~12.5K tokens" },
+			],
+		},
+	},
+	"read.summaryMaxBytes": {
+		type: "number",
+		default: 20,
+		ui: {
+			tab: "editing",
+			label: "Read Summary Size Budget (KB)",
+			description: "Maximum UTF-8 size for a structural read summary before additional units are elided",
+			options: [
+				{ value: "10", label: "10 KB", description: "~2.5K tokens" },
+				{ value: "20", label: "20 KB", description: "Default; ~5K tokens" },
+				{ value: "50", label: "50 KB", description: "~12.5K tokens" },
+				{ value: "100", label: "100 KB", description: "~25K tokens" },
+			],
+		},
+	},
 
 	"read.summarize.enabled": {
 		type: "boolean",

package/src/eval/js/shared/runtime.ts

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import * as util from "node:util";
 
-import { logger } from "@gajae-code/utils";
+import * as logger from "@gajae-code/utils/logger";
 
 import { ToolError } from "../../../tools/tool-errors";
 import { createHelpers, type HelperBundle } from "./helpers";

package/src/gjc-runtime/gc-render.ts

@@ -39,7 +39,11 @@ function renderRecord(record: GcRecord): string {
 
 export function buildGcReportText(report: GcReport): string {
 	const lines: string[] = [];
-	lines.push(report.dry_run ? "gjc gc — dry run (no changes made; pass --prune to remove)" : "gjc gc — prune");
+	if (report.operation === "repair_session_index") {
+		lines.push("gjc gc — session-index repair (other stores are report-only)");
+	} else {
+		lines.push(report.dry_run ? "gjc gc — dry run (no changes made; pass --prune to remove)" : "gjc gc — prune");
+	}
 	lines.push("");
 
 	for (const store of GC_STORES) {
@@ -53,6 +57,20 @@ export function buildGcReportText(report: GcReport): string {
 		lines.push("");
 	}
 
+	if (report.session_index) {
+		const index = report.session_index;
+		lines.push(`Session index: ${index.status}; valid prefix sequence=${index.valid_prefix_seq}`);
+		if (index.quarantine_path) lines.push(`  Quarantined suffix: ${index.quarantine_path}`);
+		if (index.reason) lines.push(`  ${index.reason}`);
+		if (index.status === "corrupt")
+			lines.push("  Run `gjc gc --repair-session-index` to quarantine the corrupt suffix.");
+		if (index.status === "unsupported")
+			lines.push("  Upgrade GJC before attempting a repair; no index data was changed.");
+		if (index.status === "repaired")
+			lines.push("  Restart or re-register hosts whose only registration was in the quarantined suffix.");
+		lines.push("");
+	}
+
 	if (report.errors.length > 0) {
 		lines.push(`Errors (${report.errors.length})`);
 		for (const err of report.errors) lines.push(`  [${err.store}/${err.scope}] ${err.message}`);