@gajae-code/coding-agent 0.11.3 → 0.11.4

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

@@ -44,11 +44,25 @@ export interface ResourceGcRegistration {
 export declare function registerResourceGcSession(reg: ResourceGcRegistration): () => void;
 export declare function sweepOnce(d?: ResourceGcDeps): Promise<void>;
 export declare function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>): void;
+export declare function __setResourceGcSchedulerNowForTest(now: () => number): void;
 export declare function __runResourceGcTickForTest(): Promise<void>;
+export declare function __runResourceGcTimerCallbackForTest(owner: {
+    generation: number;
+    token: number;
+}, deadline: number): Promise<void>;
 export declare function __getResourceGcStateForTest(): {
     timerActive: boolean;
     sessionCount: number;
     rssWarningActive: boolean;
     inProgress: boolean;
+    generation: number;
+    pendingDeadline: number | null;
+    pendingOwner: {
+        generation: number;
+        token: number;
+    } | null;
+    deferredDeadline: number | null;
+    deferredGeneration: number | null;
+    activeGeneration: number | null;
 };
 export declare function __resetResourceGcForTest(): void;

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

@@ -8,6 +8,24 @@ export interface LoadImageInputOptions {
     maxBytes?: number;
     resolvedPath?: string;
     detectedMimeType?: string;
+    signal?: AbortSignal;
+}
+export interface LoadImageInputBytesOptions {
+    inputBuffer: Buffer;
+    resolvedPath: string;
+    mimeType: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    maxOutputBytes?: number;
+    signal?: AbortSignal;
+}
+export interface TransformedImageInput {
+    resolvedPath: string;
+    mimeType: string;
+    buffer: Uint8Array;
+    textNote: string;
+    dimensionNote?: string;
+    bytes: number;
 }
 export interface LoadedImageInput {
     resolvedPath: string;
@@ -23,4 +41,9 @@ export declare class ImageInputTooLargeError extends Error {
     constructor(bytes: number, maxBytes: number);
 }
 export declare function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null>;
+/** Transform trusted source bytes without materializing a base64 payload. */
+export declare function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput>;
+export declare function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput;
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export declare function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput>;
 export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;

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

@@ -16,6 +16,7 @@ export interface ResizedImage {
     wasResized: boolean;
     get data(): string;
 }
+export declare const DEFAULT_IMAGE_RESIZE_MAX_BYTES: number;
 /**
  * Resize and recompress an image to fit within the specified max dimensions and file size.
  *
@@ -31,6 +32,7 @@ export interface ResizedImage {
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
+export declare function resizeImageBuffer(inputBuffer: Buffer, inputMimeType: string, options?: ImageResizeOptions): Promise<ResizedImage>;
 export declare function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage>;
 /**
  * Format a dimension note for resized images.

package/dist/types/utils/pasted-image-loading.d.ts

@@ -0,0 +1,39 @@
+import type { ImageContent } from "@gajae-code/ai";
+import { type LoadedImageInput, transformImageInputBytes } from "./image-loading";
+export declare const MAX_PASTED_IMAGE_SOURCE_BYTES: number;
+export declare const MAX_PASTED_IMAGE_OUTPUT_BYTES: number;
+export declare const MAX_PASTED_IMAGE_DIMENSION = 20000;
+export declare const MAX_PASTED_IMAGE_PIXELS = 40000000;
+export declare const MAX_PASTED_IMAGE_DECODED_BYTES: number;
+export type PastedImageBatchErrorCode = "too-many" | "unsafe-path" | "unsupported-image" | "source-aggregate-too-large" | "output-aggregate-too-large" | "dimensions-too-large";
+export declare class PastedImageBatchError extends Error {
+    readonly code: PastedImageBatchErrorCode;
+    readonly imagePath?: string | undefined;
+    constructor(code: PastedImageBatchErrorCode, message: string, imagePath?: string | undefined);
+}
+export interface LoadedPastedImageBatch {
+    images: ImageContent[];
+    loadedInputs: LoadedImageInput[];
+    sourcePaths: string[];
+}
+export interface PastedImageLoadingDependencies {
+    /** Synchronization hook used to exercise pathname swaps after descriptor open. */
+    afterDescriptorOpen?: (imagePath: string, index: number) => Promise<void> | void;
+    beforeDescriptorRead?: (imagePath: string, index: number) => Promise<void> | void;
+    transformImageBytes?: typeof transformImageInputBytes;
+}
+export type PastedImageSourcePolicy = "confirmed" | "automatic-temp";
+export interface LoadPastedImageBatchOptions {
+    paths: readonly string[];
+    autoResize: boolean;
+    signal: AbortSignal;
+    sourcePolicy?: PastedImageSourcePolicy;
+    maxImageBytes?: number;
+    maxSourceBytes?: number;
+    maxOutputBytes?: number;
+    maxDimension?: number;
+    maxPixels?: number;
+    maxDecodedBytes?: number;
+    dependencies?: PastedImageLoadingDependencies;
+}
+export declare function loadPastedImageBatch(options: LoadPastedImageBatchOptions): Promise<LoadedPastedImageBatch>;

package/dist/types/utils/pasted-image-path.d.ts

@@ -1,9 +1,8 @@
+export declare const MAX_PASTED_IMAGE_COUNT = 16;
+export declare const MAX_PASTED_IMAGE_PASTE_CHARACTERS: number;
+export declare const MAX_PASTED_IMAGE_PATH_CHARACTERS: number;
 export interface DecodePastedPathOptions {
-    /**
-     * Platform whose path semantics apply when decoding (shell unescaping,
-     * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
-     * injectable so tests can pin the win32 contract from any host.
-     */
+    /** Platform whose path and shell semantics apply. Defaults to `process.platform`. */
     platform?: NodeJS.Platform;
     /** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
     homedir?: string;
@@ -12,21 +11,24 @@ export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
     /** Base directory for relative paths. Defaults to `process.cwd()`. */
     cwd?: string;
 }
-/**
- * Decode pasted text into a filesystem path candidate. No filesystem access.
- *
- * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
- * win32 where `\` is the path separator), quoted paths, `file://` URIs
- * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
- * expansion. Returns `undefined` when the text is empty, spans multiple
- * lines, or is an invalid `file://` URI.
- */
+export type PastedImagePathParseResult = {
+    kind: "paths";
+    paths: string[];
+    requiresConfirmation: boolean;
+} | {
+    kind: "too-many";
+    maxCandidates: number;
+};
+/** Decode one pasted path candidate without filesystem access. */
 export declare function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined;
+/** Tokenize a bounded complete path list without filesystem access. */
+export declare function decodePastedPathCandidates(text: string, options?: DecodePastedPathOptions, maxCandidates?: number): string[] | undefined;
+/** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
+export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;
 /**
- * Returns the resolved path when the whole pasted text is a recognized clipboard
- * temp path to an existing image file, otherwise `undefined` (the paste is
- * inserted as text). Arbitrary saved image paths are not auto-attached here;
- * users attach them explicitly with `@path/to/image.png`.
+ * Parse a complete image path paste without filesystem access. A single path
+ * keeps the clipboard-temp-only policy; multi-path saved-image pastes require
+ * explicit confirmation before any path is opened.
  */
-export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;
+export declare function parsePastedImagePaths(text: string, options?: ResolvePastedImagePathOptions): PastedImagePathParseResult | undefined;
 export declare function formatPastedImageReference(placeholder: string, imagePath: string): string;

package/dist/types/web/scrapers/html-to-markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert HTML to markdown using Turndown with GFM support.
+ * Strips script/style tags before conversion.
+ */
+export declare function htmlToBasicMarkdown(html: string): Promise<string>;

package/dist/types/web/scrapers/types.d.ts

@@ -44,11 +44,7 @@ export interface LoadPageResult {
  * Fetch a page with timeout and size limit
  */
 export declare function loadPage(url: string, options?: LoadPageOptions): Promise<LoadPageResult>;
-/**
- * Convert HTML to markdown using Turndown with GFM support.
- * Strips script/style tags before conversion.
- */
-export declare function htmlToBasicMarkdown(html: string): Promise<string>;
+export { htmlToBasicMarkdown } from "./html-to-markdown";
 /**
  * Build a RenderResult from markdown content. Calls finalizeOutput internally.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.3",
+	"version": "0.11.4",
 	"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",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.3",
-		"@gajae-code/agent-core": "0.11.3",
-		"@gajae-code/ai": "0.11.3",
-		"@gajae-code/bridge-client": "0.11.3",
-		"@gajae-code/natives": "0.11.3",
-		"@gajae-code/tui": "0.11.3",
-		"@gajae-code/utils": "0.11.3",
+		"@gajae-code/stats": "0.11.4",
+		"@gajae-code/agent-core": "0.11.4",
+		"@gajae-code/ai": "0.11.4",
+		"@gajae-code/bridge-client": "0.11.4",
+		"@gajae-code/natives": "0.11.4",
+		"@gajae-code/tui": "0.11.4",
+		"@gajae-code/utils": "0.11.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -171,6 +171,14 @@
 			"types": "./dist/types/capability/*.d.ts",
 			"import": "./src/capability/*.ts"
 		},
+		"./cli/worktree-cli": {
+			"types": "./dist/types/cli/worktree-cli.d.ts",
+			"import": "./src/cli/worktree-cli.ts"
+		},
+		"./cli/worktree-cli.js": {
+			"types": "./dist/types/cli/worktree-cli.d.ts",
+			"import": "./src/cli/worktree-cli.ts"
+		},
 		"./cli/*": {
 			"types": "./dist/types/cli/*.d.ts",
 			"import": "./src/cli/*.ts"
@@ -187,6 +195,14 @@
 		"./commands/ultraqa": null,
 		"./commands/ultrawork": null,
 		"./commands/performance-goal": null,
+		"./commands/worktree": {
+			"types": "./dist/types/commands/worktree.d.ts",
+			"import": "./src/commands/worktree.ts"
+		},
+		"./commands/worktree.js": {
+			"types": "./dist/types/commands/worktree.d.ts",
+			"import": "./src/commands/worktree.ts"
+		},
 		"./commands/*": {
 			"types": "./dist/types/commands/*.d.ts",
 			"import": "./src/commands/*.ts"

package/scripts/run-threat-model-check.ts

@@ -14,6 +14,61 @@ function assert(condition: unknown, message: string): asserts condition {
 	if (!condition) throw new Error(message);
 }
 
+async function sourceFiles(root: string): Promise<string[]> {
+	const files: string[] = [];
+	for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+		const file = path.join(root, entry.name);
+		if (entry.isDirectory()) files.push(...(await sourceFiles(file)));
+		else if (/\.(?:ts|tsx|js|mjs|cjs)$/.test(entry.name)) files.push(file);
+	}
+	return files;
+}
+
+function hasDiscoverySignalAuthority(source: string): boolean {
+	return /(?:process\.)?kill\s*\(\s*(?:discovery|brokerDiscovery|record)\.pid\s*,\s*["']SIG(?:TERM|KILL)["']/m.test(
+		source,
+	);
+}
+
+async function assertNoDiscoverySignalAuthority(): Promise<void> {
+	const roots = [path.resolve(import.meta.dir, "../src/sdk"), path.resolve(import.meta.dir, "../test")];
+	const offenders: string[] = [];
+	for (const root of roots) {
+		for (const file of await sourceFiles(root)) {
+			if (hasDiscoverySignalAuthority(await fs.readFile(file, "utf8")))
+				offenders.push(path.relative(process.cwd(), file));
+		}
+	}
+	assert(offenders.length === 0, `Discovery-derived TERM/KILL authority remains in: ${offenders.join(", ")}`);
+	assert(
+		hasDiscoverySignalAuthority('process.kill(discovery.pid, "SIGTERM")'),
+		"Synthetic forbidden discovery signal was not detected",
+	);
+	assert(
+		!hasDiscoverySignalAuthority("process.kill(discovery.pid, 0)"),
+		"PID-zero observation was escalated to signal authority",
+	);
+}
+
+async function assertFixtureControlsStayTestOnly(): Promise<void> {
+	const productionRoot = path.resolve(import.meta.dir, "../src");
+	const offenders: string[] = [];
+	for (const file of await sourceFiles(productionRoot)) {
+		const source = await fs.readFile(file, "utf8");
+		if (/\b(?:GSF1|SSH1)\b/.test(source)) offenders.push(path.relative(process.cwd(), file));
+	}
+	assert(
+		offenders.length === 0,
+		`Fixture control frames are reachable from production source: ${offenders.join(", ")}`,
+	);
+	const ensureSource = await fs.readFile(path.resolve(import.meta.dir, "../src/sdk/broker/ensure.ts"), "utf8");
+	assert(
+		ensureSource.includes("startFixtureBrokerCommandWithLeaseForTest"),
+		"Dedicated fixture launch boundary is missing its explicit ForTest label",
+	);
+	assert(!/GJC_.*(?:GSF1|SSH1|SELF_REAP)/.test(ensureSource), "Production environment can select fixture controls");
+}
+
 async function rejectedWebSocket(url: string): Promise<void> {
 	const ws = new WebSocket(url);
 	await new Promise<void>((resolve, reject) => {
@@ -132,6 +187,11 @@ async function main(): Promise<void> {
 				assert(!discovery.url.includes("0.0.0.0"), "non-loopback broker URL exists");
 				await rejectedWebSocket(`${discovery.url}/?token=wrong-token`);
 			},
+			"broker-discovery-derived-signal-authority-forbidden": assertNoDiscoverySignalAuthority,
+			"broker-pid-zero-observation-allowed": async () => {
+				assert(!hasDiscoverySignalAuthority("process.kill(discovery.pid, 0)"), "PID-zero observation was rejected");
+			},
+			"broker-fixture-control-nonproduction-reachability": assertFixtureControlsStayTestOnly,
 		};
 		for (const check of manifest.checks) {
 			try {

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");
 }