@gajae-code/coding-agent 0.17.1 → 0.17.4

package/src/coordinator-mcp/session-reaper.ts

@@ -57,10 +57,12 @@ export function selectReapableSessions(
 /**
  * Only a stale/absent endpoint makes a session permanently unreapable, so it is
  * the sole failure that advances the force-eviction counter. Every other reap
- * failure (close_failed, broker unavailability, filesystem errors) is transient
- * and must keep retrying without ever escalating to force eviction. The server
- * wires `reapSession` to throw `new Error(reason)`, so the reason code is the
- * error message here.
+ * failure (a close_failed without a stale endpoint, broker unavailability,
+ * filesystem errors) is transient and must keep retrying without ever escalating
+ * to force eviction. The server wires `reapSession` to throw `new Error(reason)`,
+ * except that a close the broker answered with endpoint_stale (close_failed with
+ * that detail) is thrown as endpoint_stale, so the reason code is the error
+ * message here.
  */
 function isEndpointStaleReapError(err: unknown): boolean {
 	return (err instanceof Error ? err.message : String(err)) === "endpoint_stale";

package/src/crash/record-loader.ts

@@ -17,6 +17,7 @@ import {
 	type CrashFingerprint,
 	type CrashProvenance,
 	computeCrashFingerprint,
+	computeHandledErrorFingerprint,
 	parseCrashRecordMarker,
 } from "@gajae-code/utils";
 
@@ -60,8 +61,11 @@ function findBoundFingerprint(
 			// suffix omission against the marker rather than trusting its syntax.
 			if (remaining.length > 0) stackCandidates.push(remaining.slice(0, -1).join("\n").trimEnd());
 			for (const stack of stackCandidates) {
-				const fingerprint = computeCrashFingerprint({ name, message, stack });
-				if (fingerprint.fingerprint === markerFingerprint) return fingerprint;
+				const input = { name, message, stack };
+				const fatalFingerprint = computeCrashFingerprint(input);
+				if (fatalFingerprint.fingerprint === markerFingerprint) return fatalFingerprint;
+				const handledFingerprint = computeHandledErrorFingerprint(input);
+				if (handledFingerprint.fingerprint === markerFingerprint) return handledFingerprint;
 			}
 		}
 	}

package/src/daemon/operator-contract.ts

@@ -12,6 +12,8 @@
  * (automation); the default human output stays a concise per-daemon result.
  */
 
+import { replaceTabs, truncateToWidth } from "@gajae-code/tui";
+import { sanitizeDisplayLine } from "@gajae-code/utils";
 import type { DaemonAction, DaemonOperationResult, DaemonRecovery, DaemonStatus } from "./control-types";
 
 /** Canonical daemon actions accepted as the leading verb. */
@@ -39,8 +41,14 @@ export function resolveDaemonAction(token: string | undefined): DaemonAction | u
 	return DAEMON_ACTION_ALIASES[token];
 }
 
-/** Exit codes for `gjc daemon`. Backward compatible: success 0, any failure 1. */
-export const DAEMON_EXIT = { ok: 0, failure: 1 } as const;
+/** Public input failures exit 2; operational failures retain exit 1. */
+export const DAEMON_EXIT = { ok: 0, failure: 1, usage: 2 } as const;
+
+/** A refused result may follow a successful stop or spawn; snapshots and prose
+ * do not prove that no effect occurred. Only completed results prove applied. */
+export function daemonOperationOutcome(result: DaemonOperationResult): "applied" | "unknown" {
+	return result.ok ? "applied" : "unknown";
+}
 
 /** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
 export const OWNERSHIP_MISMATCH_MESSAGE =
@@ -59,6 +67,10 @@ export function ownershipMismatchRecovery(): DaemonRecovery {
 	};
 }
 
+function safeDaemonText(value: string): string {
+	return truncateToWidth(replaceTabs(sanitizeDisplayLine(value).replaceAll(/[\u2028\u2029]/gu, " ")), 512);
+}
+
 function timestamp(ms: number | undefined): string | undefined {
 	if (ms === undefined) return undefined;
 	const date = new Date(ms);
@@ -73,31 +85,31 @@ export function formatDaemonStatus(status: DaemonStatus, opts: { verbose?: boole
 	const lines: string[] = [];
 	if (!status.configured) {
 		lines.push(`${status.kind}: not configured`);
-		if (status.runtime.warning) lines.push(`  warning: ${status.runtime.warning}`);
+		if (status.runtime.warning) lines.push(`  warning: ${safeDaemonText(status.runtime.warning)}`);
 		return lines.join("\n");
 	}
 
 	const meta: string[] = [];
 	if (status.pid !== undefined) meta.push(`pid ${status.pid}`);
-	if (status.ownerId) meta.push(`owner ${status.ownerId}`);
+	if (status.ownerId) meta.push(`owner ${safeDaemonText(status.ownerId)}`);
 	const rootCount = status.rootCount ?? status.roots?.length ?? 0;
 	if (rootCount > 0) meta.push(`${rootCount} root${rootCount === 1 ? "" : "s"}`);
 
 	let head = `${status.kind}: ${status.health}`;
 	if (meta.length > 0) head += ` (${meta.join(", ")})`;
-	if (status.detail) head += ` — ${status.detail}`;
+	if (status.detail) head += ` — ${safeDaemonText(status.detail)}`;
 	lines.push(head);
-	if (status.runtime.warning) lines.push(`  warning: ${status.runtime.warning}`);
+	if (status.runtime.warning) lines.push(`  warning: ${safeDaemonText(status.runtime.warning)}`);
 
 	if (opts.verbose) {
-		lines.push(`  runtime: ${status.runtime.mode} (${status.runtime.execPath})`);
+		lines.push(`  runtime: ${status.runtime.mode} (${safeDaemonText(status.runtime.execPath)})`);
 		const started = timestamp(status.startedAt);
 		if (started) lines.push(`  started: ${started}`);
 		const heartbeat = timestamp(status.heartbeatAt);
 		if (heartbeat) lines.push(`  heartbeat: ${heartbeat}`);
 		const roots = status.roots ?? [];
 		lines.push(`  roots: ${rootCount}`);
-		for (const root of roots) lines.push(`    - ${root}`);
+		for (const root of roots) lines.push(`    - ${safeDaemonText(root)}`);
 	}
 
 	return lines.join("\n");
@@ -108,13 +120,15 @@ export function formatDaemonStatus(status: DaemonStatus, opts: { verbose?: boole
  * <message>` head line, then any warnings, then actionable recovery steps.
  */
 export function formatDaemonResult(result: DaemonOperationResult): string {
-	const lines = [`${result.kind} ${result.action}: ${result.ok ? "ok" : "failed"} — ${result.message}`];
-	for (const warning of result.warnings) lines.push(`  warning: ${warning}`);
+	const lines = [
+		`${result.kind} ${result.action}: ${result.ok ? "ok" : "failed"} — ${safeDaemonText(result.message)}`,
+	];
+	for (const warning of result.warnings) lines.push(`  warning: ${safeDaemonText(warning)}`);
 	if (result.recovery) {
-		lines.push(`  ${result.recovery.summary}`);
+		lines.push(`  ${safeDaemonText(result.recovery.summary)}`);
 		lines.push("  to recover:");
 		result.recovery.steps.forEach((step, i) => {
-			lines.push(`    ${i + 1}. ${step}`);
+			lines.push(`    ${i + 1}. ${safeDaemonText(step)}`);
 		});
 	}
 	return lines.join("\n");

package/src/debug/report-bundle.ts

@@ -6,7 +6,16 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { WorkProfile } from "@gajae-code/natives";
-import { APP_NAME, getLogPath, getLogsDir, getReportsDir, isEnoent } from "@gajae-code/utils";
+import {
+	APP_NAME,
+	getEffectiveLogPath,
+	getEffectiveLogsDir,
+	getLogPath,
+	getLogsDir,
+	getReportsDir,
+	isEnoent,
+	resolveEquivalentPath,
+} from "@gajae-code/utils";
 import type { CpuProfile, HeapSnapshot } from "./profiler";
 import { collectSystemInfo, sanitizeEnv } from "./system-info";
 
@@ -34,6 +43,70 @@ async function readLastLines(filePath: string, n: number, maxBytes = MAX_LOG_BYT
 	}
 }
 
+/**
+ * Both log directories can legitimately hold dated `gjc.<date>.log` files, and a
+ * reader that consults only one of them is wrong in one direction or the other.
+ *
+ * The *effective* directory is where this process writes — a trusted
+ * `GJC_LOG_DIR` pin, which the test preload sets to a per-process temp sink
+ * (issue #5618). The *canonical* directory is the config root, which carries
+ * history: previous runs, other processes, and anything written through
+ * `getLogsDir()` before this process pinned anything.
+ *
+ * Deduplicated by equivalent path, effective first. In production — and in any
+ * process that never pinned `GJC_LOG_DIR` — the two resolve to the same
+ * directory and this collapses to the single entry these readers have always
+ * used, so nothing is listed twice and no ordering changes.
+ */
+function logSearchDirs(): string[] {
+	const dirs: string[] = [];
+	for (const resolve of [getEffectiveLogsDir, getLogsDir]) {
+		const resolved = attemptPath(resolve);
+		if (resolved !== undefined && !dirs.includes(resolved)) dirs.push(resolved);
+	}
+	return dirs;
+}
+
+/**
+ * Resolve a log path, or `undefined` when it is unavailable.
+ *
+ * `getLogsDir()`/`getLogPath()` throw when there is no trustworthy home. That
+ * must not deny the caller the *other* directory, which a pinned `GJC_LOG_DIR`
+ * can still supply.
+ */
+function attemptPath(resolve: () => string): string | undefined {
+	try {
+		return resolveEquivalentPath(resolve());
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Today's log text, oldest content first.
+ *
+ * Concatenated canonical-then-effective so the tail stays chronological, and the
+ * line cap is applied to the COMBINED result: capping per file would let a large
+ * history file push this process's own entries out of a bundle that still looks
+ * complete. When the two paths are the same file — production, and any process
+ * without a `GJC_LOG_DIR` pin — this is a single read of exactly the bytes the
+ * previous single-path implementation returned.
+ */
+async function readTodayLogText(maxLines: number): Promise<string> {
+	const parts: string[] = [];
+	const seen = new Set<string>();
+	for (const resolve of [getLogPath, getEffectiveLogPath]) {
+		const candidate = attemptPath(resolve);
+		if (candidate === undefined || seen.has(candidate)) continue;
+		seen.add(candidate);
+		const text = await readLastLines(candidate, maxLines);
+		if (text.length > 0) parts.push(text);
+	}
+	const combined = parts.join("\n");
+	const lines = combined.split("\n");
+	return lines.length > maxLines ? lines.slice(-maxLines).join("\n") : combined;
+}
+
 export interface ReportBundleOptions {
 	/** Session file path */
 	sessionFile: string | undefined;
@@ -101,9 +174,8 @@ export async function createReportBundle(options: ReportBundleOptions): Promise<
 		files.push("config.json");
 	}
 
-	// Recent logs (last 1000 lines)
-	const logPath = getLogPath();
-	const logs = await readLastLines(logPath, 1000);
+	// Recent logs (last 1000 lines, across both log directories)
+	const logs = await readTodayLogText(1000);
 	if (logs) {
 		data["logs.txt"] = logs;
 		files.push("logs.txt");
@@ -228,31 +300,50 @@ async function addSubagentSessions(
 
 /** Get recent log entries for display (tail-limited to avoid OOM on large files). */
 export async function getLogText(): Promise<string> {
-	return readLastLines(getLogPath(), MAX_LOG_LINES);
+	return readTodayLogText(MAX_LOG_LINES);
 }
 
 const LOG_FILE_PATTERN = new RegExp(`^${APP_NAME}\\.(\\d{4}-\\d{2}-\\d{2})\\.log$`);
 
+/**
+ * Today's log file: the one this process is writing when it exists, else the
+ * canonical one. Both spellings share a basename, so the "is this today's file"
+ * filter below is unaffected by which is chosen.
+ */
+async function resolveTodayLogPath(): Promise<string> {
+	const effective = getEffectiveLogPath();
+	if (await Bun.file(effective).exists()) return effective;
+	const canonical = attemptPath(getLogPath);
+	if (canonical !== undefined && (await Bun.file(canonical).exists())) return canonical;
+	return effective;
+}
+
 export async function createDebugLogSource(): Promise<DebugLogSource> {
-	const logsDir = getLogsDir();
-	const todayPath = getLogPath();
+	const todayPath = await resolveTodayLogPath();
 	const todayName = path.basename(todayPath);
-	let olderFiles: string[] = [];
-	try {
-		const entries = await fs.readdir(logsDir, { withFileTypes: true });
-		const datedFiles = entries
-			.filter(entry => entry.isFile())
-			.map(entry => {
-				const match = LOG_FILE_PATTERN.exec(entry.name);
-				return match ? { name: entry.name, date: match[1] } : undefined;
-			})
-			.filter((entry): entry is { name: string; date: string } => entry !== undefined)
-			.filter(entry => entry.name !== todayName)
-			.sort((a, b) => b.date.localeCompare(a.date));
-		olderFiles = datedFiles.map(entry => entry.name);
-	} catch {
-		olderFiles = [];
+	// Absolute paths, not bare names: entries can come from either log directory
+	// (see {@link logSearchDirs}), so the name alone no longer locates the file.
+	const olderFiles: string[] = [];
+	const dated: { path: string; date: string }[] = [];
+	const seen = new Set<string>();
+	for (const dir of logSearchDirs()) {
+		// A missing directory contributes nothing; the other one may still exist.
+		const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const match = LOG_FILE_PATTERN.exec(entry.name);
+			if (!match || entry.name === todayName) continue;
+			const filePath = path.join(dir, entry.name);
+			if (seen.has(filePath)) continue;
+			seen.add(filePath);
+			dated.push({ path: filePath, date: match[1]! });
+		}
 	}
+	// Newest first. `sort` is stable, so same-date files keep the directory order
+	// above (effective before canonical) and the single-directory case is ordered
+	// exactly as it was before the second directory was added.
+	dated.sort((a, b) => b.date.localeCompare(a.date));
+	olderFiles.push(...dated.map(entry => entry.path));
 
 	let cursor = 0;
 
@@ -270,8 +361,7 @@ export async function createDebugLogSource(): Promise<DebugLogSource> {
 		const slice = olderFiles.slice(cursor, cursor + count);
 		cursor += slice.length;
 		const chunks: string[] = [];
-		for (const filename of slice.reverse()) {
-			const filePath = path.join(logsDir, filename);
+		for (const filePath of slice.reverse()) {
 			try {
 				const content = await readLastLines(filePath, MAX_LOG_LINES);
 				if (content.length > 0) {

package/src/defaults/gjc/skills/ultragoal/SKILL.md

@@ -458,7 +458,7 @@ Because unselected goals stay schedulable, ordinary source progress moves whole-
 
 `adopt` runs in the target repository and starts a genuinely fresh run: new pending goals, fresh timestamps, the target repository's own binding, and no inherited receipts, quality gates, validation batches, steering or activated objective. The source brief and every selected objective are carried verbatim, together with the unresolved obligations recorded against those goals — requirements are carried forward in full, never summarized down. Dependency groups travel as explicit obligations with source-to-target id mapping: the source's batch metadata and receipts are not inherited, but the requirement to validate those goals together is.
 
-Selection and authorization must be explicit. Only unfinished goals (`pending`, `failed`, `blocked`, `review_blocked`) may be handed off; the source run must be quiescent with no `active` goal; there is no implicit or wildcard selection; and a selection that takes only part of a validation batch, or splits a review blocker from the goal it still blocks, is rejected rather than silently dropping that obligation. Adoption fails closed on changed offered work, an altered or unfenced offer, an offer path that escapes the source worktree, a target the offer does not name, a linked worktree that is not the exact named target, an occupied target session, and any duplicate or simultaneous adoption anywhere in the target repository. A retry reconciles the exact recorded operation or fails closed — a matching operation id is never authority to overwrite target work it did not write, and a published plan that has disappeared is never reconstructed.
+Selection and authorization must be explicit. Only unfinished goals (`pending`, `failed`, `blocked`, `review_blocked`) may be handed off; the source run must be quiescent with no `active` goal; there is no implicit or wildcard selection; and a selection that takes only part of a validation batch, or splits a review blocker from the goal it still blocks, is rejected rather than silently dropping that obligation. Adoption fails closed on changed offered work, an altered or unfenced offer, an offer path that escapes the source worktree, a target the offer does not name, a different linked worktree from the exact named target, an occupied target session, and any duplicate or simultaneous adoption anywhere in the target repository. A linked worktree is a valid target when the offer names that exact worktree; the source and target may therefore be sibling worktrees, but aliases of the same source worktree remain self-transfers and are rejected using physical path identity, and an unavailable bound worktree root is refused rather than compared lexically. A retry reconciles the exact recorded operation or fails closed — a matching operation id is never authority to overwrite target work it did not write, and a published plan that has disappeared is never reconstructed.
 
 Until publication completes, the target refuses to execute: a visible `goals.json` is not admission evidence, the adoption record is. `start`/`complete-goals` and `checkpoint` reject while an adoption remains pending.
 

package/src/eval/js/context-manager.ts

@@ -1,4 +1,5 @@
 import { isCompiledBinary, logger, Snowflake } from "@gajae-code/utils";
+import { isDesignedError } from "@gajae-code/utils/error-classification";
 import { registerResourceOwner } from "../../runtime/process-lifecycle";
 import type { ToolSession } from "../../tools";
 import { ToolAbortError, ToolError } from "../../tools/tool-errors";
@@ -460,13 +461,11 @@ function reasonToError(reason: unknown, fallback: string): Error {
 }
 
 function errorFromPayload(payload: RunErrorPayload): Error {
-	if (payload.isAbort) {
-		const err = new ToolAbortError(payload.message || "Execution aborted");
-		if (payload.stack) err.stack = payload.stack;
-		return err;
-	}
-	const ctor = payload.isToolError ? ToolError : Error;
-	const error = new ctor(payload.message);
+	const error = payload.isDesigned
+		? payload.isAbort
+			? new ToolAbortError(payload.message || "Execution aborted")
+			: new ToolError(payload.message)
+		: new Error(payload.message);
 	if (payload.name) error.name = payload.name;
 	if (payload.stack) error.stack = payload.stack;
 	return error;
@@ -479,7 +478,8 @@ function toErrorPayload(error: unknown): RunErrorPayload {
 			message: error.message,
 			stack: error.stack,
 			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
-			isToolError: error instanceof ToolError || error.name === "ToolError",
+			isToolError: error instanceof ToolError,
+			isDesigned: isDesignedError(error),
 		};
 	}
 	return { message: String(error) };

package/src/eval/js/worker-core.ts

@@ -1,4 +1,5 @@
-import { ToolError } from "../../tools/tool-errors";
+import { isDesignedError } from "@gajae-code/utils/error-classification";
+import { ToolAbortError, ToolError } from "../../tools/tool-errors";
 import { JsRuntime, type RuntimeHooks } from "./shared/runtime";
 import type { RunErrorPayload, SessionSnapshot, ToolReply, Transport, WorkerInbound } from "./worker-protocol";
 
@@ -24,15 +25,19 @@ function errorPayload(error: unknown): RunErrorPayload {
 			message: error.message,
 			stack: error.stack,
 			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
-			isToolError: error.name === "ToolError" || error instanceof ToolError,
+			isToolError: error instanceof ToolError,
+			isDesigned: isDesignedError(error),
 		};
 	}
 	return { message: String(error) };
 }
 
 function errorFromPayload(payload: RunErrorPayload): Error {
-	const ctor = payload.isToolError ? ToolError : Error;
-	const error = new ctor(payload.message);
+	const error = payload.isDesigned
+		? payload.isAbort
+			? new ToolAbortError(payload.message)
+			: new ToolError(payload.message)
+		: new Error(payload.message);
 	if (payload.name) error.name = payload.name;
 	if (payload.stack) error.stack = payload.stack;
 	return error;

package/src/eval/js/worker-protocol.ts

@@ -13,6 +13,8 @@ export interface RunErrorPayload {
 	stack?: string;
 	isAbort?: boolean;
 	isToolError?: boolean;
+	/** Set only when the originating error carried the trusted designed marker. */
+	isDesigned?: boolean;
 }
 
 export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunErrorPayload };

package/src/extensibility/extensions/runner.ts

@@ -192,6 +192,7 @@ type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends { type: "
 type Handler = Extension["handlers"] extends Map<string, Array<infer T>> ? T : never;
 type IndexedHandler = { ext: Extension; handler: Handler; registrationOrder: number };
 type IndexedFunctionHook = IndexedHandler & { registration: FunctionHookRegistration };
+type CommandAliasTarget = { extensionPath: string; commandName: string };
 
 export type FunctionHookDispatchResult<TEvent extends ExtensionEvent> =
 	| { action: "continue"; event: TEvent; transformed?: boolean }
@@ -272,6 +273,7 @@ export class ExtensionRunner {
 	#getCredentialSessionId: () => string = () => "";
 	#isIdleFn: () => boolean = () => true;
 	#getActivePromptHandleFn: () => string | undefined = () => undefined;
+	#getSessionWorkLeaseFn: ExtensionContextActions["getSessionWorkLease"] = undefined;
 	#waitForIdleFn: () => Promise<void> = async () => {};
 	#abortFn: () => void | Promise<void> = () => {};
 	#abortPromptAndWaitFn: NonNullable<ExtensionContextActions["abortPromptAndWait"]> = async () => {
@@ -328,6 +330,9 @@ export class ExtensionRunner {
 	#reloadHandler: () => Promise<void> = async () => {};
 	#shutdownHandler: ShutdownHandler = () => {};
 	#commandDiagnostics: Array<{ type: string; message: string; path: string }> = [];
+	#commandAliases = new Map<string, RegisteredCommand>();
+	#commandAliasAssignments = new Map<string, string>();
+	#commandAliasTargets = new Map<string, CommandAliasTarget>();
 	#initialized = false;
 	/**
 	 * Buffer for `credential_disabled` events received via {@link emitCredentialDisabled}
@@ -424,6 +429,7 @@ export class ExtensionRunner {
 		this.#getCredentialSessionId = contextActions.getCredentialSessionId ?? (() => "");
 		this.#isIdleFn = contextActions.isIdle;
 		this.#getActivePromptHandleFn = contextActions.getActivePromptHandle ?? (() => undefined);
+		this.#getSessionWorkLeaseFn = contextActions.getSessionWorkLease;
 		this.#abortFn = contextActions.abort;
 		this.#abortPromptAndWaitFn =
 			contextActions.abortPromptAndWait ??
@@ -701,16 +707,49 @@ export class ExtensionRunner {
 
 	getRegisteredCommands(reserved?: Set<string>): RegisteredCommand[] {
 		this.#commandDiagnostics = [];
+		this.#commandAliases.clear();
 
 		const commands = new Map<string, RegisteredCommand>();
 		for (const ext of this.extensions) {
 			for (const command of ext.commands.values()) {
 				if (reserved?.has(command.name)) {
-					const message = `Extension command '${command.name}' from ${ext.path} conflicts with built-in commands. Skipping.`;
-					this.#commandDiagnostics.push({ type: "warning", message, path: ext.path });
-					if (!this.hasUI()) {
-						logger.warn(message);
+					const assignmentKey = `${ext.path}\u0000${command.name}`;
+					let alias = this.#commandAliasAssignments.get(assignmentKey);
+					const aliasTarget = alias ? this.#commandAliasTargets.get(alias) : undefined;
+					const aliasOwnedByCommand =
+						aliasTarget?.extensionPath === ext.path && aliasTarget.commandName === command.name;
+					if (
+						!alias ||
+						reserved.has(alias) ||
+						commands.has(alias) ||
+						(aliasTarget !== undefined && !aliasOwnedByCommand)
+					) {
+						let candidate = alias ?? `extension:${command.name}`;
+						while (
+							reserved.has(candidate) ||
+							commands.has(candidate) ||
+							this.#commandAliases.has(candidate) ||
+							(this.#commandAliasTargets.has(candidate) &&
+								(this.#commandAliasTargets.get(candidate)?.extensionPath !== ext.path ||
+									this.#commandAliasTargets.get(candidate)?.commandName !== command.name))
+						)
+							candidate = `extension:${candidate}`;
+						if (
+							alias &&
+							this.#commandAliasTargets.get(alias)?.extensionPath === ext.path &&
+							this.#commandAliasTargets.get(alias)?.commandName === command.name
+						) {
+							this.#commandAliasTargets.delete(alias);
+						}
+						alias = candidate;
+						this.#commandAliasAssignments.set(assignmentKey, alias);
 					}
+					this.#commandAliasTargets.set(alias, { extensionPath: ext.path, commandName: command.name });
+					const namespaced = { ...command, name: alias };
+					this.#commandAliases.set(alias, namespaced);
+					commands.set(alias, namespaced);
+					const message = `Extension command '${command.name}' from ${ext.path} was renamed to '${alias}' to avoid a built-in command collision.`;
+					this.#commandDiagnostics.push({ type: "info", message, path: ext.path });
 					continue;
 				}
 
@@ -725,6 +764,14 @@ export class ExtensionRunner {
 	}
 
 	getCommand(name: string): RegisteredCommand | undefined {
+		const aliased = this.#commandAliases.get(name);
+		if (aliased) return aliased;
+		const aliasTarget = this.#commandAliasTargets.get(name);
+		if (aliasTarget) {
+			const extension = this.extensions.find(ext => ext.path === aliasTarget.extensionPath);
+			const command = extension?.commands.get(aliasTarget.commandName);
+			if (command) return { ...command, name };
+		}
 		for (let index = this.extensions.length - 1; index >= 0; index -= 1) {
 			const command = this.extensions[index]?.commands.get(name);
 			if (command) {
@@ -754,6 +801,7 @@ export class ExtensionRunner {
 				return getModel();
 			},
 			getActivePromptHandle: () => this.#getActivePromptHandleFn(),
+			getSessionWorkLease: () => this.#getSessionWorkLeaseFn?.(),
 			isIdle: () => this.#isIdleFn(),
 			abort: () => this.#abortFn(),
 			abortPromptAndWait: (handle, options) => this.#abortPromptAndWaitFn(handle, options),

package/src/extensibility/extensions/types.ts

@@ -58,6 +58,7 @@ import type {
 } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
+import type { SessionWorkLease } from "../../session/session-work-lease";
 import type {
 	BashToolDetails,
 	BashToolInput,
@@ -482,6 +483,8 @@ export interface ExtensionContext {
 	isIdle(): boolean;
 	/** Stable resource ownership identifier for the active prompt run. */
 	getActivePromptHandle(): string | undefined;
+	/** The session's authoritative host-liveness lease. */
+	getSessionWorkLease?(): SessionWorkLease | undefined;
 	/** Abort the current agent operation */
 	abort(): void | Promise<void>;
 	/** Abort and prove whether resources for a specific prompt settled. */
@@ -1569,6 +1572,11 @@ export type SendUserMessageHandler = (
 		 * grants root abort ownership.
 		 */
 		onQueuedPromoted?: (promotion: { startsOwnRun?: boolean; removed?: boolean }) => void;
+		/**
+		 * Fired synchronously when a plain prompt's dispatch resolves at queue
+		 * time instead of run end (diverted into an in-flight run's steering).
+		 */
+		onDispatchDisposition?: (promotion: { startsOwnRun: boolean }) => void;
 		preflightSignal?: AbortSignal;
 		/** Internal SDK correlation owner for an exact queued follow-up. */
 	},
@@ -1660,6 +1668,8 @@ export interface ExtensionContextActions {
 	isIdle: () => boolean;
 	/** Stable resource ownership identifier for the active prompt run. */
 	getActivePromptHandle?: () => string | undefined;
+	/** The session's authoritative host-liveness lease. */
+	getSessionWorkLease?: () => SessionWorkLease | undefined;
 	abort: () => void | Promise<void>;
 	abortPromptAndWait?: (handle: string, options: { graceMs: number }) => Promise<RunSettlementProof>;