@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/modes/components/model-selector.ts

@@ -1721,9 +1721,13 @@ export class ModelSelectorComponent extends Container {
 			: choice.role === null
 				? "temporary model"
 				: GJC_MODEL_ASSIGNMENT_TARGETS[choice.role].name;
+		// Show the highlighted reasoning level — never the model id (that mislabel
+		// made "Reasoning for Default: gpt-5.6-luna" look like a level).
+		const selectedLevel = choice.levels[this.#selectedThinkingIndex];
+		const selectedLevelLabel = selectedLevel ? getThinkingLevelMetadata(selectedLevel).label : "—";
 		this.#listContainer.addChild(new Spacer(1));
 		this.#listContainer.addChild(
-			new Text(theme.fg("muted", `  Reasoning for ${targetLabel}: ${choice.item.model.id}`), 0, 0),
+			new Text(theme.fg("muted", `  Reasoning for ${targetLabel}: ${selectedLevelLabel}`), 0, 0),
 		);
 		this.#listContainer.addChild(new Spacer(1));
 		for (let i = 0; i < choice.levels.length; i++) {
@@ -2079,8 +2083,13 @@ export class ModelSelectorComponent extends Container {
 			this.#updateList();
 		}
 	}
-	#getInitialThinkingChoiceIndex(item: ModelItem | CanonicalModelItem, levels: ThinkingLevel[]): number {
-		const preferred = this.#getPreferredThinkingLevel(item);
+	#getInitialThinkingChoiceIndex(
+		item: ModelItem | CanonicalModelItem,
+		levels: ThinkingLevel[],
+		role: GjcModelAssignmentTargetId | null = null,
+		roles?: readonly GjcModelAssignmentTargetId[],
+	): number {
+		const preferred = this.#getPreferredThinkingLevel(item, role, roles);
 		if (preferred && preferred !== ThinkingLevel.Inherit) {
 			const index = levels.indexOf(preferred);
 			if (index !== -1) return index;
@@ -2088,13 +2097,51 @@ export class ModelSelectorComponent extends Container {
 		return 0;
 	}
 
-	#getPreferredThinkingLevel(item: ModelItem | CanonicalModelItem): ThinkingLevel | undefined {
+	/**
+	 * Prefer the role binding the user is editing when it already points at this
+	 * model so the reasoning menu opens on the level role badges already show
+	 * (e.g. EXECUTOR (xhigh) must not leave the cursor on "off").
+	 */
+	#getPreferredThinkingLevel(
+		item: ModelItem | CanonicalModelItem,
+		role: GjcModelAssignmentTargetId | null = null,
+		roles?: readonly GjcModelAssignmentTargetId[],
+	): ThinkingLevel | undefined {
+		const roleThinking = this.#getAssignedThinkingLevelForModel(item.model, role, roles);
+		if (roleThinking && roleThinking !== ThinkingLevel.Inherit) {
+			return roleThinking;
+		}
 		if (item.thinkingLevel && item.thinkingLevel !== ThinkingLevel.Inherit) {
 			return item.thinkingLevel;
 		}
 		return undefined;
 	}
 
+	#getAssignedThinkingLevelForModel(
+		model: Model,
+		role: GjcModelAssignmentTargetId | null,
+		roles?: readonly GjcModelAssignmentTargetId[],
+	): ThinkingLevel | undefined {
+		if (roles && roles.length > 0) {
+			const assignedLevels = roles
+				.map(targetRole => this.#roles[targetRole])
+				.filter(
+					(assigned): assigned is RoleAssignment =>
+						assigned !== undefined &&
+						modelsAreEqual(assigned.model, model) &&
+						assigned.thinkingLevel !== ThinkingLevel.Inherit,
+				)
+				.map(assigned => assigned.thinkingLevel);
+			if (assignedLevels.length === 0) return undefined;
+			const first = assignedLevels[0];
+			return assignedLevels.every(level => level === first) ? first : undefined;
+		}
+		if (role === null) return undefined;
+		const assigned = this.#roles[role];
+		if (!assigned || !modelsAreEqual(assigned.model, model)) return undefined;
+		return assigned.thinkingLevel;
+	}
+
 	#handleSelect(
 		item: ModelItem | CanonicalModelItem,
 		role: GjcModelAssignmentTargetId | null,
@@ -2109,7 +2156,7 @@ export class ModelSelectorComponent extends Container {
 		if (!hasExplicitThinkingChoice && needsExplicitThinkingChoice) {
 			const levels = getSelectableThinkingLevels(item.model);
 			this.#pendingThinkingChoice = { item, role, roles, levels };
-			this.#selectedThinkingIndex = this.#getInitialThinkingChoiceIndex(item, levels);
+			this.#selectedThinkingIndex = this.#getInitialThinkingChoiceIndex(item, levels, role, roles);
 			this.#updateList();
 			return;
 		}

package/src/modes/components/session-selector.ts

@@ -197,7 +197,7 @@ export class SessionSelectorComponent extends Container {
 
 	constructor(
 		sessions: SessionInfo[],
-		private readonly onSelect: (sessionPath: string) => void,
+		private readonly onSelect: (sessionPath: string) => void | Promise<void>,
 		private readonly onCancel: () => void,
 		private readonly onExit: () => void,
 		private readonly onDelete?: (session: SessionInfo) => Promise<boolean>,
@@ -214,7 +214,7 @@ export class SessionSelectorComponent extends Container {
 		this.#sessionList = new SessionList(sessions);
 		this.#sessionList.onSelect = session => {
 			if (this.inspector) void this.#inspect(session);
-			else this.onSelect(session.path);
+			else this.#dispatchSelect(session.path);
 		};
 		this.#sessionList.onCancel = () => this.#cancel();
 		this.#sessionList.onExit = () => this.#exit();
@@ -241,6 +241,29 @@ export class SessionSelectorComponent extends Container {
 		this.#onRequestRender?.();
 	}
 
+	/**
+	 * Observe async `onSelect` handlers. Callers (e.g. resume) may return a
+	 * Promise; leaving it unobserved turns preparation/switch failures into
+	 * process-killing unhandled rejections. Inline recovery keeps the picker
+	 * usable when the host has not already closed it.
+	 */
+	#dispatchSelect(sessionPath: string): void {
+		void Promise.resolve(this.onSelect(sessionPath)).catch((error: unknown) => {
+			if (this.#state.kind === "settled") {
+				// Host already closed the picker (interactive resume path). Surface the
+				// message only if we still have a render surface; controller catch is
+				// the primary recovery path after `done()`.
+				this.#showError(error instanceof Error ? error.message : String(error));
+				this.#requestRender();
+				return;
+			}
+			this.#state = { kind: "browsing" };
+			this.#sessionList.setInputFrozen(false);
+			this.#showError(error instanceof Error ? error.message : String(error));
+			this.#requestRender();
+		});
+	}
+
 	#settle(selection: SessionSelectionResult): void {
 		if (this.#state.kind === "settled") return;
 		this.#state = { kind: "settled" };
@@ -249,7 +272,7 @@ export class SessionSelectorComponent extends Container {
 		this.#confirmationDialog = null;
 		if (dialog) this.removeChild(dialog);
 		if (this.onSelection) this.onSelection(selection);
-		else if (selection.kind === "selected") this.onSelect(selection.path);
+		else if (selection.kind === "selected") this.#dispatchSelect(selection.path);
 		else this.onCancel();
 	}
 	#cancel(): void {

package/src/modes/components/status-line/gh.ts

@@ -1,6 +1,26 @@
 import { type RunGh, runGhDefault } from "../../../utils/gh";
 
 const STATUS_LINE_GH_TIMEOUT_MS = 5_000;
+const C0_C1_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/;
+
+function canonicalPrUrl(value: unknown, number: number): string | null {
+	if (typeof value !== "string" || C0_C1_CONTROL_CHARACTERS.test(value)) return null;
+
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+		if (!url.hostname || url.username || url.password || url.search || url.hash) return null;
+
+		const suffix = `/pull/${number}`;
+		if (!url.pathname.endsWith(suffix)) return null;
+		const repositoryPath = url.pathname.slice(1, -suffix.length).split("/");
+		if (repositoryPath.length !== 2 || repositoryPath.some(component => component === "")) return null;
+
+		return url.href;
+	} catch {
+		return null;
+	}
+}
 
 export async function lookupCurrentPr(runGh: RunGh = runGhDefault): Promise<{ number: number; url: string } | null> {
 	try {
@@ -8,8 +28,9 @@ export async function lookupCurrentPr(runGh: RunGh = runGhDefault): Promise<{ nu
 		if (result.exitCode !== 0 || result.timedOut) return null;
 
 		const pr = JSON.parse(result.stdout) as { number?: unknown; url?: unknown };
-		if (typeof pr.number !== "number" || typeof pr.url !== "string") return null;
-		return { number: pr.number, url: pr.url };
+		if (typeof pr.number !== "number" || !Number.isSafeInteger(pr.number) || pr.number <= 0) return null;
+		const url = canonicalPrUrl(pr.url, pr.number);
+		return url ? { number: pr.number, url } : null;
 	} catch {
 		return null;
 	}

package/src/modes/controllers/event-controller.ts

@@ -32,6 +32,7 @@ import { computeIrcSplitWidths, getIrcSidebarSemanticToken } from "../components
 import type { IrcObservationRecord } from "../irc-observation-ledger";
 import { interruptHint } from "../shared";
 import { buildAbortDisplayMessage } from "../utils/abort-message";
+import { emitHostStatus } from "../utils/host-status";
 import { consumeInjectedOptimisticSignature } from "../utils/injected-user-submission";
 import { parseIrcMessage } from "../utils/irc-message";
 import { ringTerminalBell } from "../utils/terminal-bell";
@@ -298,6 +299,7 @@ export class EventController {
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
+		emitHostStatus("working");
 		this.ctx.promptSuggestion?.onAgentStart();
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
@@ -924,6 +926,7 @@ export class EventController {
 		this.ctx.updateEditorBorderColor();
 		this.ctx.ui.requestRender();
 		this.#scheduleIdleCompaction();
+		emitHostStatus("finished");
 		this.sendCompletionNotification();
 		this.ctx.promptSuggestion?.onAgentEnd();
 	}

package/src/modes/controllers/extension-ui-controller.ts

@@ -40,6 +40,7 @@ import { createReadonlySessionManager } from "../../session/session-manager";
 import { parseThinkingLevel } from "../../thinking";
 import type { TodoPhase } from "../../tools/todo-write";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
+import { emitHostStatus } from "../utils/host-status";
 import { applyInjectedUserSubmission } from "../utils/injected-user-submission";
 import { classifyHookSelectorBellEvent, ringTerminalBell } from "../utils/terminal-bell";
 import { prepareTranscriptRebuild } from "../utils/ui-helpers";
@@ -1258,6 +1259,7 @@ export class ExtensionUiController {
 			computeBudget();
 
 		ringTerminalBell(classifyHookSelectorBellEvent(title));
+		emitHostStatus("attention");
 
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,

package/src/modes/controllers/input-controller.ts

@@ -822,6 +822,17 @@ export class InputController {
 		if (runner?.hasHandlers("input")) {
 			const result = await runner.emitInput(text, inputImages, "interactive");
 			if (result?.handled) {
+				const handledText = result.text === undefined ? "" : sanitizeText(result.text).trim();
+				if (handledText) {
+					this.ctx.addMessageToChat({
+						role: "custom",
+						customType: "extension-input-result",
+						content: handledText,
+						display: true,
+						timestamp: Date.now(),
+					});
+					this.ctx.ui.requestRender();
+				}
 				if (this.#canModifyComposer(composer)) {
 					this.ctx.editor.setText("");
 				}

package/src/modes/controllers/selector-controller.ts

@@ -2638,9 +2638,15 @@ export class SelectorController {
 		this.showSelector(done => {
 			const selector = new SessionSelectorComponent(
 				sessions,
-				async sessionPath => {
+				sessionPath => {
+					// `onSelect` is a void dispatch boundary: close the picker first, then
+					// observe resume failures so a managed-candidate race (or any other
+					// preparation/switch rejection) surfaces as UI error instead of an
+					// unhandled rejection that can kill the process. Do not auto-retry.
 					done();
-					await this.handleResumeSession(sessionPath);
+					void this.handleResumeSession(sessionPath).catch(error => {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					});
 				},
 				() => {
 					done();

package/src/modes/interactive-mode.ts

@@ -1036,9 +1036,15 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (this.session.getGoalModeState()?.mode === "exiting") {
 			await this.#goalModeController.beforeGetUserInput();
 		}
-		const { promise, resolve } = Promise.withResolvers<SubmittedUserInput>();
+		const { promise, resolve, reject } = Promise.withResolvers<SubmittedUserInput>();
+		let unsubscribeStop = () => {};
+		unsubscribeStop = this.onStop(() => {
+			this.onInputCallback = undefined;
+			reject(Object.assign(new Error("Interactive mode stopped"), { code: "cancelled" }));
+		});
 		this.onInputCallback = input => {
 			this.onInputCallback = undefined;
+			unsubscribeStop();
 			resolve(input);
 		};
 		this.#goalModeController.scheduleContinuation();

package/src/modes/print-mode.ts

@@ -7,6 +7,7 @@
  */
 import { type AssistantMessage, type ImageContent, isContextOverflow } from "@gajae-code/ai";
 import { isKnownSinkPeerClosedError, logger, sanitizeText } from "@gajae-code/utils";
+import { loadSlashCommands } from "../extensibility/slash-commands";
 import type { AgentSession } from "../session/agent-session";
 import { isSilentAbort } from "../session/messages";
 import { initializeExtensions } from "./runtime-init";
@@ -207,6 +208,15 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			if (header) stdout.write(`${JSON.stringify(header)}\n`);
 		}
 
+		// Bundled and file-based slash commands (`/init`, project `commands/*.md`, …) expand
+		// inside AgentSession#prompt from the list handed over by setSlashCommands. Interactive
+		// mode loads it while building its autocomplete; print mode has no autocomplete, so
+		// without this the list stays empty and a leading-slash prompt reaches the model as
+		// literal prose — no expansion, no error, and an answer that looks like the command ran.
+		await logger.time("print:slash-commands", async () => {
+			session.setSlashCommands(await loadSlashCommands({ cwd: session.sessionManager.getCwd() }));
+		});
+
 		// Set up extensions for print mode (no UI, no command context).
 		await initializeExtensions(session, {
 			reportSendError: (action, err) => {

package/src/modes/utils/host-status.ts

@@ -0,0 +1,38 @@
+/**
+ * Host-terminal agent status markers.
+ *
+ * Interactive turns announce their state as an OSC 777 sequence:
+ *
+ *     ESC ] 777 ; notify;Terax;gjc;<event> BEL
+ *
+ * A terminal that understands the sequence (Terax reads it to drive its per-tab
+ * agent status and header bell) reacts; every other terminal discards the OSC
+ * as unknown, exactly like the OSC 133 prompt marks and OSC 7 cwd reports that
+ * shells emit unconditionally. So there is no host sniffing and no env gate:
+ * any host that wants agent status can parse the stream without gjc knowing it
+ * exists.
+ *
+ * `notify;Terax;` is the wire identifier of the only protocol that currently
+ * carries per-turn agent state, not a host check - the payload names gjc as the
+ * reporting agent.
+ *
+ * Interactive TUI only. Print and RPC mode stdout stays byte-for-byte parseable
+ * because they never reach these controllers.
+ */
+
+export type HostStatusEvent = "working" | "attention" | "finished";
+
+function marker(event: HostStatusEvent): string {
+	return `\x1b]777;notify;Terax;gjc;${event}\x07`;
+}
+
+export function emitHostStatus(
+	event: HostStatusEvent,
+	output: Pick<NodeJS.WriteStream, "write"> = process.stdout,
+): void {
+	try {
+		output.write(marker(event));
+	} catch {
+		// Best-effort host integration only.
+	}
+}

package/src/prompts/system/project-prompt.md

@@ -21,6 +21,25 @@ MUST read before making changes within:
 {{#list agentsMdSearch.files join="\n"}}- {{this}}{{/list}}
 </dir-context>
 {{/if}}
+
+{{#if alwaysApplyRules.length}}
+{{#each alwaysApplyRules}}
+{{content}}
+{{/each}}
+{{/if}}
+{{#if rules.length}}
+Rules are local constraints. You MUST read `rule://<name>` when working in that domain.
+<rules>
+{{#list rules join="\n"}}
+<rule name="{{name}}">
+{{description}}
+{{#if globs.length}}
+{{#list globs join="\n"}}<glob>{{this}}</glob>{{/list}}
+{{/if}}
+</rule>
+{{/list}}
+</rules>
+{{/if}}
 <critical>
 - Each response MUST advance the task. There is no stopping condition other than completion.
 - You MUST default to informed action; do not ask for confirmation when tools or repo context can answer.

package/src/runtime-mcp/types.ts

@@ -217,6 +217,8 @@ export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
 export interface MCPToolCallResult {
 	content: MCPContent[];
 	isError?: boolean;
+	/** MCP result metadata, encoded as `_meta` on the wire. */
+	_meta?: Record<string, unknown>;
 }
 
 // =============================================================================

package/src/sdk/broker/lifecycle.ts

@@ -31,6 +31,7 @@ import {
 } from "../../session/session-storage";
 import type { SessionLifecycleMcpServer } from "../acp/mcp";
 import { SdkClient, SdkClientError } from "../client/client";
+import { SESSION_PREPARED_EVENT } from "../host/host";
 import {
 	type LogicalSessionCandidate,
 	listManagedSessionCandidates,
@@ -202,6 +203,16 @@ export interface SessionLifecycleTranscriptIdentity {
 	sha256: string;
 }
 
+/**
+ * When a lifecycle-managed session publishes its replayable readiness signal.
+ *
+ * `immediate` is the stock contract. `deferred` prepares the session instead:
+ * the child publishes a distinct prepared signal, keeps `session_ready`
+ * withheld, and stays unusable for input until it is explicitly activated. It
+ * is broker-issued and session-scoped precisely so a prepared session can never
+ * be produced by an inherited process-global flag.
+ */
+export type SessionLifecycleReadiness = "immediate" | "deferred";
 export interface SessionLifecycleLaunchRequest {
 	operation: "session.create" | "session.fork" | "session.resume";
 	sessionId: string;
@@ -218,6 +229,8 @@ export interface SessionLifecycleLaunchRequest {
 	modelPreset?: string;
 	mcpServers?: SessionLifecycleMcpServer[];
 	worktree?: SessionLifecycleWorktreeTarget;
+	/** Absent means the stock immediate contract; `deferred` prepares the session. */
+	readiness?: SessionLifecycleReadiness;
 	receivedAt: number;
 	requestedReadinessTimeoutMs: number;
 	semanticReadyDeadlineAt: number;
@@ -363,6 +376,8 @@ export function readSessionLifecycleLaunchRequest(
 			now,
 		) ||
 		(request.worktree !== undefined && !isLifecycleWorktreeTarget(request.worktree)) ||
+		(request.readiness !== undefined && request.readiness !== "immediate" && request.readiness !== "deferred") ||
+		(request.readiness === "deferred" && request.operation !== "session.create") ||
 		(request.operation === "session.resume" &&
 			!hasValidTranscriptAuthority(request.sessionPath, request.sessionIdentity)) ||
 		(request.operation === "session.fork" &&
@@ -386,6 +401,7 @@ type SessionLaunch = {
 	modelPreset?: string;
 	mcpServers?: SessionLifecycleMcpServer[];
 	worktree?: SessionLifecycleWorktreeTarget;
+	readiness?: SessionLifecycleReadiness;
 	worktreePlan?: GjcLaunchWorktreePlan;
 };
 
@@ -2294,6 +2310,16 @@ function sameReadyAuthority(left: ReadyAuthority, right: ReadyAuthority): boolea
 	);
 }
 
+/**
+ * Wait for the child's semantic completion signal at exactly this endpoint.
+ *
+ * `session_ready` is the stock signal. A deferred launch waits on
+ * `session_prepared` instead: it is the same authenticated, replayable proof
+ * that the child finished initializing and owns its endpoint, minus the
+ * readiness no consumer may act on yet. Both are additionally bound to the
+ * owner-proved lifecycle receipt through `currentReadyAuthority`, so an
+ * endpoint file appearing on its own never satisfies either wait.
+ */
 async function waitForReady(
 	broker: Broker,
 	id: string,
@@ -2301,6 +2327,7 @@ async function waitForReady(
 	deadline: number,
 	expected: EffectMarker,
 	timing: LifecycleTiming,
+	signal: "session_ready" | typeof SESSION_PREPARED_EVENT = "session_ready",
 ): Promise<ReadinessResult> {
 	while (timing.now() < deadline) {
 		const startupFailure = await readSessionLifecycleFailure(root, id, expected);
@@ -2349,7 +2376,7 @@ async function waitForReady(
 						const frame = event as Record<string, unknown>;
 						return (
 							frame.type === "event" &&
-							frame.name === "session_ready" &&
+							frame.name === signal &&
 							frame.sessionId === id &&
 							frame.generation === authority.endpointGeneration
 						);
@@ -2446,8 +2473,28 @@ async function launchInput(
 		return fail("invalid_input", "mcpServers must contain unique valid stdio, HTTP, or SSE server definitions.");
 	const mcpServers = input.mcpServers as SessionLifecycleMcpServer[] | undefined;
 
+	/**
+	 * Prepared readiness is an explicit creation-only intent. Only the two exact
+	 * enum values are admissible, and a foreign value is refused rather than
+	 * collapsed into the stock immediate contract.
+	 */
+	if (input.readiness !== undefined && input.readiness !== "immediate" && input.readiness !== "deferred")
+		return fail("invalid_input", "readiness must be either immediate or deferred.");
+	const readiness = input.readiness as SessionLifecycleReadiness | undefined;
+	if (readiness === "deferred" && operation !== "session.create")
+		return fail("invalid_input", "readiness deferred is only supported for session.create.");
+
 	if (operation === "session.create")
-		return { id: randomUUID(), cwd, root: resolvedRoot, modelPreset, mcpServers, worktree, worktreePlan };
+		return {
+			id: randomUUID(),
+			cwd,
+			root: resolvedRoot,
+			modelPreset,
+			mcpServers,
+			worktree,
+			worktreePlan,
+			...(readiness ? { readiness } : {}),
+		};
 	if (operation === "session.resume") {
 		if (!requested) return fail("invalid_input", "sessionId is required to resume a saved session.");
 		const savedPath = text(input.sessionPath);
@@ -3107,6 +3154,7 @@ async function executeLifecycleResponse(
 			...(launch.modelPreset ? { modelPreset: launch.modelPreset } : {}),
 			...(launch.mcpServers ? { mcpServers: launch.mcpServers } : {}),
 			...(launch.worktree ? { worktree: launch.worktree } : {}),
+			...(launch.readiness ? { readiness: launch.readiness } : {}),
 		};
 		let child: ChildProcess | undefined;
 		let spawnedAuthority: EffectMarker | undefined;
@@ -3161,7 +3209,15 @@ async function executeLifecycleResponse(
 		if (!child || !spawnedAuthority)
 			return fail("spawn_failed", "Unable to retain the spawned session process identity.");
 		await broker.ledger.transition(identity, "awaiting_ready", { intendedSessionId: launch.id, effectMarker });
-		const readiness = await waitForReady(broker, launch.id, launch.root, readinessDeadline, spawnedAuthority, timing);
+		const readiness = await waitForReady(
+			broker,
+			launch.id,
+			launch.root,
+			readinessDeadline,
+			spawnedAuthority,
+			timing,
+			launch.readiness === "deferred" ? SESSION_PREPARED_EVENT : "session_ready",
+		);
 
 		if (readiness.kind !== "ready") {
 			const terminated = await terminateSpawnedChild(
@@ -3220,6 +3276,7 @@ async function executeLifecycleResponse(
 				sessionId: launch.id,
 				cwd: launch.cwd,
 				endpoint: verified.endpoint,
+				...(launch.readiness === "deferred" ? { readiness: "prepared" as const } : {}),
 				...(worktreeReceipt ? { worktree: worktreeReceipt } : {}),
 			},
 		};

package/src/sdk/bus/chat-daemon-cli.ts

@@ -1,9 +1,16 @@
 import * as crypto from "node:crypto";
 import * as path from "node:path";
+import {
+	type ChatDaemonCommandBindInput,
+	type ChatDaemonCommandOutcome,
+	serveChatDaemonCommandsOnce,
+} from "./chat-daemon-command-channel";
 import {
 	acquireChatDaemonOwnership,
 	type ChatDaemonKind,
+	chatDaemonGeneration,
 	clearChatDaemonControlRequest,
+	hasSafeChatDaemonStateShape,
 	readChatDaemonControlRequest,
 	readChatDaemonState,
 	releaseChatDaemonOwnership,
@@ -22,6 +29,8 @@ export interface ChatDaemonRuntimeHandle {
 	start(): Promise<void>;
 	stop(): Promise<void>;
 	transportHealthy?(): boolean;
+	/** Executes operator commands that must run inside the owning daemon. */
+	bindExistingRoot?(request: ChatDaemonCommandBindInput): Promise<ChatDaemonCommandOutcome>;
 }
 
 export interface RunChatDaemonInternalDeps {
@@ -212,12 +221,45 @@ export async function runChatDaemonInternal(
 				}
 			})();
 		}, 5_000);
+		const ownedIncarnation = incarnation;
+		const stillOwner = async (): Promise<boolean> => {
+			const current = await readChatDaemonState(agentDir, kind);
+			return (
+				hasSafeChatDaemonStateShape(current) &&
+				current.kind === kind &&
+				current.ownerId === ownerId &&
+				current.pid === daemonPid &&
+				current.incarnation === ownedIncarnation &&
+				current.generation === chatDaemonGeneration(kind) &&
+				current.stoppedAt === undefined
+			);
+		};
+		const bindExistingRoot = activeRuntime.bindExistingRoot?.bind(activeRuntime);
 		while (!stopping) {
 			const request = await readChatDaemonControlRequest(agentDir, kind);
 			if (request?.ownerId === ownerId && request.incarnation === incarnation) {
 				await clearChatDaemonControlRequest(agentDir, kind, request.requestId);
 				break;
 			}
+			// Operator commands are served in place: unlike a lifecycle request they
+			// must never end this loop. A serving failure degrades to the caller's
+			// timeout rather than terminating a healthy transport.
+			if (bindExistingRoot) {
+				try {
+					await serveChatDaemonCommandsOnce({
+						agentDir,
+						kind,
+						ownerId,
+						pid: daemonPid,
+						incarnation: ownedIncarnation,
+						generation: chatDaemonGeneration(kind),
+						handler: { bindExistingRoot },
+						verifyOwnership: stillOwner,
+					});
+				} catch {
+					// Retried on the next poll; the submitter observes a timeout.
+				}
+			}
 			await new Promise(resolve => setTimeout(resolve, 100));
 		}
 	} finally {