@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/slash-commands/builtin-registry.ts

@@ -34,6 +34,7 @@ import {
 // import graph; the /notify handlers import them lazily at first use.
 import type { NotificationProvider } from "../sdk/bus/config";
 import { computeCacheMissCostSummary, formatCacheMissSummaryLines } from "../session/cache-economics";
+import { formatProviderSessionImportSummary, runSessionImportCommand } from "../session-import";
 import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
 import {
 	addApiCompatibleProvider,
@@ -44,6 +45,7 @@ import {
 import { parseThinkingLevel } from "../thinking";
 import { getDisplayChangelogEntries } from "../utils/changelog";
 import { buildContextReportText } from "./helpers/context-report";
+import { switchSessionCredentialCommand } from "./helpers/credential-switch";
 import { buildFastStatusReport } from "./helpers/fast-status-report";
 import { formatDuration } from "./helpers/format";
 import { commandConsumed, errorMessage, parseSlashCommand, parseSubcommand, usage } from "./helpers/parse";
@@ -91,7 +93,12 @@ const PET_COMMAND_DEPRECATED_INPUTS: Readonly<Record<string, PetMode>> = {
 type GjcModelBatchAssignmentTargetId = "all-role-agents" | "all-targets";
 type ParsedModelCommandArgs =
 	| { kind: "summary" }
-	| { kind: "assign"; targetId: GjcModelAssignmentTargetId | GjcModelBatchAssignmentTargetId; selector: string };
+	| {
+			kind: "assign";
+			targetId: GjcModelAssignmentTargetId | GjcModelBatchAssignmentTargetId;
+			selector: string;
+			hasExplicitTarget: boolean;
+	  };
 
 const GJC_MODEL_ROLE_AGENT_TARGET_IDS: GjcModelAssignmentTargetId[] = ["executor", "architect", "planner", "critic"];
 
@@ -234,19 +241,19 @@ function parseModelCommandArgs(args: string): ParsedModelCommandArgs {
 
 	if (first === "assign") {
 		const targetId = parseTarget(tokens[1]);
-		if (targetId) return { kind: "assign", targetId, selector: tokens.slice(2).join(" ") };
-		return { kind: "assign", targetId: "default", selector: tokens.slice(1).join(" ") };
+		if (targetId) return { kind: "assign", targetId, selector: tokens.slice(2).join(" "), hasExplicitTarget: true };
+		return { kind: "assign", targetId: "default", selector: tokens.slice(1).join(" "), hasExplicitTarget: false };
 	}
 
 	const explicitTarget = parseTarget(first);
 	if (explicitTarget) {
-		return { kind: "assign", targetId: explicitTarget, selector: tokens.slice(1).join(" ") };
+		return { kind: "assign", targetId: explicitTarget, selector: tokens.slice(1).join(" "), hasExplicitTarget: true };
 	}
 	if (first === "set") {
 		const targetId = parseTarget(tokens[1]);
-		if (targetId) return { kind: "assign", targetId, selector: tokens.slice(2).join(" ") };
+		if (targetId) return { kind: "assign", targetId, selector: tokens.slice(2).join(" "), hasExplicitTarget: true };
 	}
-	return { kind: "assign", targetId: "default", selector: args.trim() };
+	return { kind: "assign", targetId: "default", selector: args.trim(), hasExplicitTarget: false };
 }
 /**
  * Optional namespace prefix accepted on `/model <preset>` selectors so users
@@ -597,7 +604,28 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 	return commandConsumed();
 };
 
+const IMPORT_SESSION_RETAINED_DESCRIPTOR_AUTHORITY_AVAILABLE = process.platform === "linux";
+
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
+	{
+		name: "import-session",
+		priority: 29,
+		description: "Import a Codex or Claude transcript into native GJC history",
+		inlineHint: "<transcript-file> [--provider codex|claude]",
+		allowArgs: true,
+		acp: false,
+		localHeadless: true,
+		handle: async (command, runtime) => {
+			if (runtime.session?.isStreaming) return usage("Cannot import a session while streaming.", runtime);
+			const outcome = await runSessionImportCommand(command.args, runtime.cwd);
+			if (outcome.kind === "error") {
+				await runtime.output(outcome.message);
+				return { consumed: true, exitCode: 1 };
+			}
+			await runtime.output(formatProviderSessionImportSummary(outcome.result));
+			return { consumed: true };
+		},
+	},
 	{
 		name: "notify",
 		priority: 30,
@@ -840,11 +868,11 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 					);
 				}
 				// Preset shortcut: when the selector names a known model profile
-				// (optionally `gajae-code/`-prefixed) and no explicit role target
-				// was given, activate the profile immediately instead of treating
-				// the preset name as a model id and failing with "Unknown model".
-				// `/model <role> <preset>` keeps assigning to the named role.
-				if (parsedArgs.targetId === "default") {
+				// (optionally `gajae-code/`-prefixed) and the target is implicit,
+				// activate the profile immediately instead of treating the preset name
+				// as a model id and failing with "Unknown model". Explicit targets,
+				// including `/model default <preset>`, remain ordinary assignments.
+				if (parsedArgs.targetId === "default" && !parsedArgs.hasExplicitTarget) {
 					const presetName = resolvePresetSelector(modelId, runtime.session.modelRegistry);
 					if (presetName) {
 						try {
@@ -1304,12 +1332,43 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "usage",
 		description: "Show provider usage and limits",
 		acpDescription: "Show token usage",
-		handle: async (_command, runtime) => {
-			await runtime.output(await buildUsageReportText(runtime));
+		subcommands: [{ name: "check", description: "Explicitly check account health and usage" }],
+		inlineHint: "[check]",
+		acpInputHint: "[check]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const args = command.args.trim().toLowerCase();
+			if (args !== "" && args !== "check") return usage("Usage: /usage [check]", runtime);
+			await runtime.output(await buildUsageReportText(runtime, { check: args === "check" }));
 			return commandConsumed();
 		},
-		handleTui: async (_command, runtime) => {
-			await runtime.ctx.handleUsageCommand();
+		handleTui: async (command, runtime) => {
+			const args = command.args.trim().toLowerCase();
+			if (args !== "" && args !== "check") {
+				runtime.ctx.showError("Usage: /usage [check]");
+			} else {
+				const adapted = toSlashCommandRuntime(runtime);
+				await adapted.output(await buildUsageReportText(adapted, { check: args === "check" }));
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "credential",
+		aliases: ["account"],
+		description: "Switch this session's active stored account, or list accounts",
+		acpDescription: "Switch or list stored credentials for this session",
+		inlineHint: "[email:<addr>|id:<n>|account:<id>|project:<id>|provider/<selector>]",
+		acpInputHint: "[selector]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.output(await switchSessionCredentialCommand(runtime, command.args));
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const result = await switchSessionCredentialCommand(toSlashCommandRuntime(runtime), command.args);
+			refreshStatusLine(runtime.ctx);
+			runtime.ctx.showStatus(result);
 			runtime.ctx.editor.setText("");
 		},
 	},
@@ -1380,6 +1439,15 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+
+	{
+		name: "extensions",
+		description: "Configure skills, hooks, and MCPs.",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showCustomizationDashboard();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "monitors",
 		description: "Open the monitor/cron jobs overlay",
@@ -1938,7 +2006,9 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 const QUARANTINED_UTILITY_SLASH_COMMANDS = new Set(["agents"]);
 
 const ACTIVE_BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = BUILTIN_SLASH_COMMAND_REGISTRY.filter(
-	command => !QUARANTINED_UTILITY_SLASH_COMMANDS.has(command.name),
+	command =>
+		!QUARANTINED_UTILITY_SLASH_COMMANDS.has(command.name) &&
+		(command.name !== "import-session" || IMPORT_SESSION_RETAINED_DESCRIPTOR_AUTHORITY_AVAILABLE),
 );
 
 const BUILTIN_SLASH_COMMAND_LOOKUP = new Map<string, SlashCommandSpec>();
@@ -2021,6 +2091,18 @@ export async function executeBuiltinSlashCommand(
 	return false;
 }
 
+/** Dispatch a command explicitly authorized for trusted local non-interactive mode. */
+export async function executeLocalHeadlessBuiltinSlashCommand(
+	text: string,
+	runtime: SlashCommandRuntime,
+): Promise<false | Exclude<SlashCommandResult, undefined>> {
+	const parsed = parseSlashCommand(text);
+	if (!parsed) return false;
+	const command = BUILTIN_SLASH_COMMAND_LOOKUP.get(parsed.name);
+	if (!command?.handle || command.localHeadless !== true) return false;
+	if (parsed.args.length > 0 && !command.allowArgs) return false;
+	return (await command.handle(parsed, runtime)) ?? { consumed: true };
+}
 /** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
 export function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined {
 	return BUILTIN_SLASH_COMMAND_LOOKUP.get(name);

package/src/slash-commands/helpers/credential-switch.ts

@@ -0,0 +1,143 @@
+import type { AuthCredentialSelector, AuthCredentialSnapshotEntry } from "@gajae-code/ai/core";
+import { parseCliCredentialSelector } from "../../runtime-credential-selector";
+import type { SlashCommandRuntime } from "../types";
+
+/** Human-readable label for one stored OAuth credential row. */
+function describeCredentialRow(entry: AuthCredentialSnapshotEntry): string {
+	if (entry.credential.type !== "oauth") return `id:${entry.id} (api key)`;
+	const email = entry.credential.email;
+	const accountId = entry.credential.accountId;
+	const label = email ?? accountId ?? `row ${entry.id}`;
+	return `id:${entry.id} — ${label}`;
+}
+
+function formatProviderName(provider: string): string {
+	return provider
+		.split(/[-_]/g)
+		.map(part => (part ? part[0].toUpperCase() + part.slice(1) : ""))
+		.join(" ");
+}
+
+/** Whether a stored OAuth snapshot row matches a credential selector. */
+function selectorMatchesRow(selector: AuthCredentialSelector, entry: AuthCredentialSnapshotEntry): boolean {
+	if (entry.credential.type !== "oauth") return false;
+	switch (selector.kind) {
+		case "id":
+			return String(entry.id) === selector.value;
+		case "email":
+			return (
+				typeof entry.credential.email === "string" &&
+				entry.credential.email.toLowerCase() === selector.value.toLowerCase()
+			);
+		case "account":
+			return entry.credential.accountId === selector.value;
+		case "project":
+			return entry.credential.projectId === selector.value;
+	}
+}
+
+/**
+ * Resolve which provider a bare (unqualified) `/credential <selector>`
+ * targets. Prefers the current session model's provider when it actually has
+ * a matching OAuth row (the common case: switching among a provider's own
+ * accounts while that provider is active). Falls back to scanning every
+ * provider's stored OAuth rows for a unique match, so `/credential
+ * email:me@example.com` still works when the selector uniquely matches a
+ * provider other than the active one. Ambiguous or absent matches return an
+ * explanatory string instead of a provider id.
+ */
+function inferProvider(
+	runtime: SlashCommandRuntime,
+	oauthRows: AuthCredentialSnapshotEntry[],
+	selector: AuthCredentialSelector,
+	selectorRaw: string,
+): { provider: string } | { error: string } {
+	const currentProvider = runtime.session.model?.provider;
+	if (
+		currentProvider &&
+		oauthRows.some(entry => entry.provider === currentProvider && selectorMatchesRow(selector, entry))
+	) {
+		return { provider: currentProvider };
+	}
+	const matchingProviders = [
+		...new Set(oauthRows.filter(entry => selectorMatchesRow(selector, entry)).map(entry => entry.provider)),
+	];
+	if (matchingProviders.length === 1) return { provider: matchingProviders[0]! };
+	if (oauthRows.length === 0) {
+		return { error: "No provider has any stored OAuth credentials to switch between." };
+	}
+	if (matchingProviders.length === 0) {
+		return { error: `No stored OAuth credential matches ${selector.kind}:${selector.value}.` };
+	}
+	return {
+		error: `"${selectorRaw}" is ambiguous across providers (${matchingProviders.join(", ")}). Use provider/${selectorRaw}.`,
+	};
+}
+
+/**
+ * List every provider's stored OAuth accounts, marking which row each
+ * currently-tracked session is using.
+ */
+export async function buildCredentialListText(runtime: SlashCommandRuntime): Promise<string> {
+	const authStorage = runtime.session.modelRegistry.authStorage;
+	const snapshot = authStorage.exportSnapshot();
+	const oauthRows = snapshot.credentials.filter(entry => entry.credential.type === "oauth");
+	if (oauthRows.length === 0) {
+		return "No stored OAuth credentials. Use /login <provider> to add one.";
+	}
+	const grouped = new Map<string, AuthCredentialSnapshotEntry[]>();
+	for (const entry of oauthRows) {
+		const rows = grouped.get(entry.provider) ?? [];
+		rows.push(entry);
+		grouped.set(entry.provider, rows);
+	}
+	const lines = ["Stored accounts (/credential <selector> to switch this session):"];
+	for (const [provider, rows] of [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+		lines.push("", formatProviderName(provider));
+		const activeRowId = authStorage.getSessionCredentialRowId(provider, runtime.session.credentialSessionId);
+		for (const entry of rows) {
+			const active = entry.id === activeRowId ? " (active this session)" : "";
+			lines.push(`- ${describeCredentialRow(entry)}${active}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+/**
+ * Switch the running session's stored OAuth credential for a provider,
+ * independent of quota state. Returns the confirmation/error text to show
+ * the user; never throws.
+ */
+export async function switchSessionCredentialCommand(runtime: SlashCommandRuntime, args: string): Promise<string> {
+	const trimmed = args.trim();
+	if (!trimmed) return await buildCredentialListText(runtime);
+
+	let parsed: ReturnType<typeof parseCliCredentialSelector>;
+	try {
+		parsed = parseCliCredentialSelector(trimmed);
+	} catch {
+		return `Invalid selector "${trimmed}". Use email:name@example.com, id:15, account:<id>, project:<id>, or provider/<selector>.`;
+	}
+
+	const authStorage = runtime.session.modelRegistry.authStorage;
+	const snapshot = authStorage.exportSnapshot();
+	const oauthRows = snapshot.credentials.filter(entry => entry.credential.type === "oauth");
+
+	let provider = parsed.provider;
+	if (!provider) {
+		const inferred = inferProvider(runtime, oauthRows, parsed.selector, trimmed);
+		if ("error" in inferred) return inferred.error;
+		provider = inferred.provider;
+	}
+
+	try {
+		authStorage.switchSessionCredential(provider, runtime.session.credentialSessionId, parsed.selector);
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+
+	const rowId = authStorage.getSessionCredentialRowId(provider, runtime.session.credentialSessionId);
+	const matchedRow = oauthRows.find(entry => entry.id === rowId);
+	const label = matchedRow ? describeCredentialRow(matchedRow) : `${provider} (${trimmed})`;
+	return `Switched this session to ${label}. Takes effect on the next request to ${formatProviderName(provider)}.`;
+}

package/src/slash-commands/helpers/mcp.ts

@@ -351,7 +351,11 @@ async function handleListCommand(runtime: SlashCommandRuntime): Promise<SlashCom
 			readMCPConfigFile(userPath),
 			readMCPConfigFile(projectPath),
 		]);
-		const disabledSet = new Set(await readDisabledServers(userPath));
+		const [userDisabled, projectDisabled] = await Promise.all([
+			readDisabledServers(userPath),
+			readDisabledServers(projectPath),
+		]);
+		const disabledSet = new Set([...userDisabled, ...projectDisabled]);
 		const entries: Array<{ name: string; config: MCPServerConfig; scope: string }> = [];
 		for (const [name, config] of Object.entries(userConfig.mcpServers ?? {})) {
 			entries.push({ name, config, scope: "user" });
@@ -367,7 +371,9 @@ async function handleListCommand(runtime: SlashCommandRuntime): Promise<SlashCom
 			entries
 				.map(({ name, config, scope }) => {
 					const type = config.type ?? "stdio";
-					const enabled = config.enabled !== false && !disabledSet.has(name) ? "enabled" : "disabled";
+					const disabled = config.enabled === false || disabledSet.has(name);
+					const autoloadOff = !disabled && config.autoload === false;
+					const status = disabled ? "disabled" : autoloadOff ? "autoload-off" : "autoload";
 					let location: string | undefined;
 					if (config.type === "http" || config.type === "sse") {
 						// Strip query string and userinfo from URLs to avoid leaking
@@ -388,7 +394,7 @@ async function handleListCommand(runtime: SlashCommandRuntime): Promise<SlashCom
 					} else {
 						location = (config as { command: string }).command;
 					}
-					return `${name} | ${type} | ${enabled} | ${location ?? "(unknown)"} [${scope}]`;
+					return `${name} | ${type} | ${status} | ${location ?? "(unknown)"} [${scope}]`;
 				})
 				.join("\n"),
 		);

package/src/slash-commands/helpers/usage-report.ts

@@ -1,12 +1,17 @@
-import type { UsageLimit, UsageReport } from "@gajae-code/ai/core";
+import type { UsageLimit } from "@gajae-code/ai/core";
+import { sanitizeText } from "@gajae-code/utils";
+import {
+	type AccountInventoryRow,
+	buildAccountInventorySnapshot,
+	checkAccountInventory,
+} from "../../session/account-inventory";
+import { truncateHead } from "../../session/streaming-output";
 import type { SlashCommandRuntime } from "../types";
-import { formatDuration, renderAsciiBar } from "./format";
+import { formatDuration } from "./format";
 
-function formatProviderName(provider: string): string {
-	return provider
-		.split(/[-_]/g)
-		.map(part => (part ? part[0].toUpperCase() + part.slice(1) : ""))
-		.join(" ");
+function sanitizeAndTruncateOutput(text: string): string {
+	const sanitized = sanitizeText(text);
+	return truncateHead(sanitized, { maxBytes: 32_768, maxLines: 1_000 }).content;
 }
 
 function formatUsageAmount(limit: UsageLimit): string {
@@ -21,63 +26,40 @@ function formatUsageAmount(limit: UsageLimit): string {
 	return `${usedText}${remainingText}`;
 }
 
-function formatUsageReportAccount(report: UsageReport, limit: UsageLimit, index: number): string {
-	const email = report.metadata?.email;
-	if (typeof email === "string" && email) return email;
-	const accountId = report.metadata?.accountId ?? limit.scope.accountId;
-	if (typeof accountId === "string" && accountId) return accountId;
-	return `account ${index + 1}`;
+function healthLabel(row: AccountInventoryRow): string {
+	if (row.disabled) return `disabled${row.disabledCause ? `: ${row.disabledCause}` : ""}`;
+	if (row.health.status === "ok") return "ok";
+	if (row.health.status === "failed") return `failed${row.health.reason ? `: ${row.health.reason}` : ""}`;
+	if (row.health.status === "unverifiable") return `unverifiable${row.health.reason ? `: ${row.health.reason}` : ""}`;
+	return "unknown";
 }
 
-function renderUsageReports(reports: UsageReport[], nowMs: number): string {
-	const latestFetchedAt = Math.max(...reports.map(report => report.fetchedAt ?? 0));
-	const lines = [`Usage${latestFetchedAt ? ` (${formatDuration(nowMs - latestFetchedAt)} ago)` : ""}`];
-	const grouped = new Map<string, UsageReport[]>();
-	for (const report of reports) {
-		const providerReports = grouped.get(report.provider) ?? [];
-		providerReports.push(report);
-		grouped.set(report.provider, providerReports);
+function renderAccountRows(rows: AccountInventoryRow[], nowMs: number, checked: boolean): string {
+	const lines = [`Accounts${checked ? " (checked)" : " (cache only)"}`];
+	if (rows.length === 0) {
+		lines.push("No configured accounts or API-key sources discovered.");
+		return lines.join("\n");
 	}
-
-	for (const [provider, providerReports] of [...grouped.entries()].sort(([left], [right]) =>
-		left.localeCompare(right),
-	)) {
-		lines.push("", formatProviderName(provider));
-		for (const report of providerReports) {
-			if (report.limits.length === 0) {
-				const email = typeof report.metadata?.email === "string" ? report.metadata.email : "account";
-				lines.push(`- ${email}: no limits reported`);
-				continue;
-			}
-			for (let index = 0; index < report.limits.length; index++) {
-				const limit = report.limits[index]!;
-				const window = limit.window?.label ?? limit.scope.windowId;
-				const tier = limit.scope.tier ? ` (${limit.scope.tier})` : "";
-				lines.push(`- ${limit.label}${tier}${window ? ` — ${window}` : ""}`);
-				lines.push(`  ${formatUsageReportAccount(report, limit, index)}: ${formatUsageAmount(limit)}`);
-				lines.push(`  ${renderAsciiBar(limit.amount.usedFraction)}`);
-				if (limit.window?.resetsAt) lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
-				if (limit.notes && limit.notes.length > 0) lines.push(`  ${limit.notes.join(" • ")}`);
+	for (const row of rows) {
+		const identity = row.identityLabel ? ` — ${row.identityLabel}` : "";
+		const marker =
+			row.routing.marker === "active" ? " [active]" : row.routing.marker === "selected" ? " [selected]" : "";
+		const cache = row.usage
+			? `, usage ${row.usage.freshness}${formatDuration(Math.max(0, nowMs - row.usage.fetchedAt)) ? ` ${formatDuration(Math.max(0, nowMs - row.usage.fetchedAt))} ago` : ""}`
+			: "";
+		lines.push(
+			`- ${row.id}: ${row.provider}/${row.credentialKind} (${row.sourceLabel})${identity}${marker} — ${healthLabel(row)}${cache}`,
+		);
+		if (row.usage?.report.limits.length) {
+			for (const limit of row.usage.report.limits.slice(0, 8)) {
+				lines.push(`  ${sanitizeText(limit.label)}: ${formatUsageAmount(limit)}`);
 			}
 		}
 	}
-	return ["```", ...lines, "```"].join("\n");
+	return lines.join("\n");
 }
 
-/**
- * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
- * session exposes `fetchUsageReports`; otherwise falls back to the local
- * session-manager tallies.
- */
-export async function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string> {
-	const provider = runtime.session as SlashCommandRuntime["session"] & {
-		fetchUsageReports?: () => Promise<UsageReport[] | null>;
-	};
-	if (provider.fetchUsageReports) {
-		const reports = await provider.fetchUsageReports();
-		if (reports && reports.length > 0) return renderUsageReports(reports, Date.now());
-	}
-
+function buildLegacyUsage(runtime: SlashCommandRuntime): string {
 	const stats = runtime.session.sessionManager.getUsageStatistics();
 	return [
 		"Usage",
@@ -89,3 +71,26 @@ export async function buildUsageReportText(runtime: SlashCommandRuntime): Promis
 		`Cost: $${stats.cost.toFixed(6)}`,
 	].join("\n");
 }
+
+export interface UsageReportOptions {
+	check?: boolean;
+}
+
+/** Build `/usage`; plain mode is cache-only and never fetches or probes. */
+export async function buildUsageReportText(
+	runtime: SlashCommandRuntime,
+	options: UsageReportOptions = {},
+): Promise<string> {
+	const session = runtime.session;
+	const modelRegistry = session.modelRegistry;
+	const input = {
+		authStorage: modelRegistry.authStorage,
+		modelRegistry,
+		sessionId: session.credentialSessionId ?? session.sessionId,
+	};
+	const snapshot = options.check ? await checkAccountInventory(input) : buildAccountInventorySnapshot(input);
+	const report = renderAccountRows(snapshot.rows, Date.now(), options.check === true);
+	const legacy = buildLegacyUsage(runtime);
+
+	return sanitizeAndTruncateOutput(`${report}\n\n${legacy}`);
+}

package/src/slash-commands/types.ts

@@ -34,11 +34,12 @@ export interface ParsedSlashCommand {
  * Result returned by a slash-command handler.
  *
  * - `void` / `undefined` — command was handled and consumed; no further input.
- * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ consumed: true, exitCode?: number }` — explicit equivalent of the above;
+ *   trusted local headless mode applies an optional non-zero process status.
  * - `{ prompt: string }` — command handled, pass `prompt` through as the new
  *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
  */
-export type SlashCommandResult = undefined | { consumed: true } | { prompt: string };
+export type SlashCommandResult = undefined | { consumed: true; exitCode?: number } | { prompt: string };
 
 /**
  * Runtime visible to slash-command handlers that run in text/ACP mode.
@@ -98,6 +99,10 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
 	 * not silently drop it from `available_commands_update`.
 	 */
 	acpInputHint?: string;
+	/** Set false for trusted local commands that must never be advertised or dispatched through ACP. */
+	acp?: boolean;
+	/** Explicitly authorizes this handler in trusted local non-interactive print mode. */
+	localHeadless?: boolean;
 	/**
 	 * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
 	 * and, via the TUI adapter, when no `handleTui` override is provided.

package/src/task/executor.ts

@@ -24,6 +24,7 @@ import {
 	type ServiceTier,
 } from "@gajae-code/ai/core";
 import { type JsonSchemaValidationIssue, validateJsonSchemaValue } from "@gajae-code/ai/utils/schema";
+import * as canonicalSdk from "@gajae-code/coding-agent/sdk";
 import { logger, prompt, untilAborted } from "@gajae-code/utils";
 import { AsyncJobManager } from "../async";
 import { ModelRegistry } from "../config/model-registry";
@@ -42,7 +43,7 @@ import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prom
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
 import submitReminderTemplate from "../prompts/system/subagent-yield-reminder.md" with { type: "text" };
 import { AgentRegistry } from "../registry/agent-registry";
-import { createAgentSession, discoverAuthStorage } from "../sdk";
+import { discoverAuthStorage } from "../sdk";
 import type { AgentSession, AgentSessionEvent, ForkContextSeed } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
@@ -269,6 +270,15 @@ export interface ExecutorOptions {
 	 */
 	parentArtifactManager?: ArtifactManager;
 	managedPersistence?: ManagedTaskPersistence;
+	/**
+	 * The parent session's ENDPOINT-owned AsyncJobManager (resolved by the
+	 * TaskTool via forEndpoint(sessionId) ?? instance()). Model metadata and
+	 * live-handle state for THIS subagent are recorded in the SAME manager the
+	 * task job runs in — with concurrent top-level sessions the process-global
+	 * instance belongs to a different session and would surface this subagent
+	 * under the wrong session's record (review thread P1).
+	 */
+	asyncJobManager?: AsyncJobManager;
 	parentHindsightSessionState?: HindsightSessionState;
 	/**
 	 * Parent agent's OpenTelemetry configuration. When defined, the subagent's
@@ -1560,7 +1570,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// Record which model the subagent actually runs on (and any auth fallback,
 			// see #985) so the subagent panel can surface it to the user.
 			if (model) {
-				AsyncJobManager.instance()?.updateSubagentModel?.(options.subagentId ?? id, {
+				(options.asyncJobManager ?? AsyncJobManager.instance())?.updateSubagentModel?.(options.subagentId ?? id, {
 					requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
 					effectiveModel: resolvedModelString,
 					modelFellBack: authFallbackUsed === true,
@@ -1676,7 +1686,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 
 			const { session } = await awaitAbortable(
-				createAgentSession({
+				canonicalSdk.createAgentSession({
 					cwd: worktree ?? cwd,
 					authStorage,
 					modelRegistry,
@@ -1738,6 +1748,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					},
 					parentHindsightSessionState: options.parentHindsightSessionState,
 					parentTaskPrefix: id,
+					inheritedAsyncJobManager: options.asyncJobManager,
 					inheritedMcpManager: options.parentMcpManager,
 					agentId: id,
 					agentDisplayName: agent.name,
@@ -1761,7 +1772,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				session.seedDefaultFallbackResolution(activeIndex ?? 0, skips);
 			}
 			const liveSubagentId = options.subagentId ?? id;
-			const manager = AsyncJobManager.instance();
+			const manager = options.asyncJobManager ?? AsyncJobManager.instance();
 			if (manager) {
 				manager.registerLiveHandle(liveSubagentId, {
 					requestPause: () => {
@@ -1964,12 +1975,20 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				if (event.type === "model_fallback_switched") {
 					activeProviderModelString = event.to;
 					progress.fastMode = isFastForModel(session.model);
-					AsyncJobManager.instance()?.updateSubagentModel?.(options.subagentId ?? id, {
-						requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
-						effectiveModel: event.to,
-						modelFellBack: true,
-						fastMode: progress.fastMode,
-					});
+					// Keep the fallback metadata on the SAME manager the initial
+					// update used: another session may have become the
+					// process-global instance, and writing to it would leave this
+					// session's subagent metadata stale or overwrite an unrelated
+					// same-ID record (review thread P2).
+					(options.asyncJobManager ?? AsyncJobManager.instance())?.updateSubagentModel?.(
+						options.subagentId ?? id,
+						{
+							requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
+							effectiveModel: event.to,
+							modelFellBack: true,
+							fastMode: progress.fastMode,
+						},
+					);
 					scheduleProgress(true);
 					forwardSubagentEvent(event);
 					return;
@@ -2108,7 +2127,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				if (exitCode === 0) exitCode = 1;
 			}
 			sessionAbortController.abort();
-			AsyncJobManager.instance()?.removeLiveHandle(options.subagentId ?? id);
+			(options.asyncJobManager ?? AsyncJobManager.instance())?.removeLiveHandle(options.subagentId ?? id);
 			if (unsubscribe) {
 				try {
 					unsubscribe();