@gajae-code/coding-agent 0.11.3 → 0.11.5

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/notify-cli.ts

@@ -7,6 +7,7 @@ import { createInterface } from "node:readline/promises";
 import { APP_NAME } from "@gajae-code/utils/dirs";
 import chalk from "chalk";
 import { Settings, type SettingsAtomicPatch } from "../config/settings";
+import { isProcessIncarnation, processIncarnation } from "../sdk/broker/process-incarnation";
 import { type EnsureChatDaemonResult, ensureDiscordDaemon, ensureSlackDaemon } from "../sdk/bus/chat-daemon-control";
 import { getNotificationConfig, maskToken, tokenFingerprint } from "../sdk/bus/config";
 import {
@@ -29,7 +30,11 @@ import {
 	sanitizeDiagnostic,
 	sendNotificationTest,
 } from "../sdk/bus/notification-service";
-import { ensureTelegramDaemonRunningDetailed, readDaemonState } from "../sdk/bus/telegram-daemon";
+import {
+	type EnsureTelegramDaemonDetailedResult,
+	ensureTelegramDaemonRunningDetailed,
+	readDaemonState,
+} from "../sdk/bus/telegram-daemon";
 import { runDaemonInternal } from "../sdk/bus/telegram-daemon-cli";
 import {
 	runTelegramSetup as runTelegramPairingSetup,
@@ -82,10 +87,10 @@ export interface NotifyCommandDeps {
 	setupTimers?: TelegramSetupTimers;
 	setupAbortSignal?: AbortSignal;
 	setupPidAlive?: (pid: number) => boolean;
-	ensureProviderDaemon?: (
-		provider: "discord" | "slack",
-		settings: Settings,
-	) => Promise<EnsureChatDaemonResult | "failed">;
+	/** Injectable process-start provenance reader for ambient Telegram setup preflight. */
+	setupPidIncarnation?: (pid: number) => string | undefined;
+	ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<EnsureChatDaemonResult>;
+	ensureTelegramDaemon?: (settings: Settings) => Promise<EnsureTelegramDaemonDetailedResult>;
 }
 
 export function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined {
@@ -313,12 +318,22 @@ async function ensureConfiguredProviderDaemon(
 	provider: "discord" | "slack",
 	settings: Settings,
 	deps: NotifyCommandDeps,
-): Promise<EnsureChatDaemonResult | "failed"> {
+): Promise<EnsureChatDaemonResult> {
 	try {
 		if (deps.ensureProviderDaemon) return await deps.ensureProviderDaemon(provider, settings);
 		return provider === "discord" ? await ensureDiscordDaemon(settings) : await ensureSlackDaemon(settings);
-	} catch {
-		return "failed";
+	} catch (error) {
+		const cfg = getNotificationConfig(settings);
+		const detail = sanitizeDiagnostic(
+			sanitizeDiagnostic(
+				error instanceof Error ? error.message : String(error),
+				provider === "discord" ? cfg.discord.botToken : cfg.slack.appToken,
+			),
+			provider === "discord" ? cfg.discord.botToken : cfg.slack.botToken,
+		);
+		throw new Error(`${provider === "discord" ? "Discord" : "Slack"} daemon did not become ready: ${detail}`, {
+			cause: error,
+		});
 	}
 }
 
@@ -393,11 +408,13 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 					reconcileCurrentSession: async () => undefined,
 				},
 				reconnect: async () =>
-					await ensureTelegramDaemonRunningDetailed({
-						settings,
-						cwd: process.cwd(),
-						sessionId: `notify-cli-${process.pid}`,
-					}),
+					deps.ensureTelegramDaemon
+						? await deps.ensureTelegramDaemon(settings)
+						: await ensureTelegramDaemonRunningDetailed({
+								settings,
+								cwd: process.cwd(),
+								sessionId: `notify-cli-${process.pid}`,
+							}),
 				persistInactive: async marker => await persistTelegramActivationMarker(settings, marker),
 				clearInactive: async marker => await clearTelegramActivationMarker(settings, marker),
 				marker: activationMarker,
@@ -446,14 +463,19 @@ async function resolveSetupPreflight(settings: Settings, deps: NotifyCommandDeps
 		const state = await readDaemonState(settings);
 		if (!state) return { storedChatId: cfg.chatId };
 		const validPid = Number.isSafeInteger(state.pid) && state.pid > 0;
-		// Owner-proof: only block discovery for a daemon we can positively prove is
-		// live (present state with a valid, alive pid). A malformed/no-pid record is
-		// not evidence of a live poller, mirroring recoverNotifications' semantics.
-		if (!validPid) return { storedChatId: cfg.chatId };
+		if (!validPid || !(deps.setupPidAlive ?? daemonPidAlive)(state.pid)) return { storedChatId: cfg.chatId };
+		const persistedIncarnation = state.incarnation;
+		const currentIncarnation = (deps.setupPidIncarnation ?? processIncarnation)(state.pid);
+		if (
+			!isProcessIncarnation(persistedIncarnation) ||
+			!isProcessIncarnation(currentIncarnation) ||
+			persistedIncarnation !== currentIncarnation
+		)
+			return { storedChatId: cfg.chatId };
 		return {
 			storedChatId: cfg.chatId,
 			daemon: {
-				live: (deps.setupPidAlive ?? daemonPidAlive)(state.pid),
+				live: true,
 				tokenFingerprint: typeof state.tokenFingerprint === "string" ? state.tokenFingerprint : undefined,
 				chatId: typeof state.chatId === "string" ? state.chatId : undefined,
 			},

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,
@@ -166,7 +167,7 @@ export async function openLifecycleSessionManager(
 	if (request.operation === "session.resume") {
 		const opened = await SessionManager.openExistingStrict(
 			snapshot.identity,
-			parsed.sessionDir,
+			SessionManager.managedDestination(cwd, agentDir),
 			undefined,
 			migrationPolicy,
 		);
@@ -180,7 +181,12 @@ export async function openLifecycleSessionManager(
 			throw error;
 		}
 	} else {
-		const forked = await SessionManager.forkFromCaptured(snapshot, cwd, parsed.sessionDir, migrationPolicy);
+		const forked = await SessionManager.forkFromCaptured(
+			snapshot,
+			cwd,
+			SessionManager.managedDestination(cwd, agentDir),
+			migrationPolicy,
+		);
 		if (forked.kind === "error")
 			throw new Error("Lifecycle saved session authority changed while the session host forked it.");
 		sessionManager = forked.manager;
@@ -439,9 +445,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.",
+);