Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
145 kB · 922 lines
TSX
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922import { feature } from 'bun:bundle';import type { ContentBlockParam, TextBlockParam } from '@anthropic-ai/sdk/resources';import { randomUUID } from 'crypto';import { setPromptId } from 'src/bootstrap/state.js';import { builtInCommandNames, type Command, type CommandBase, findCommand, getCommand, getCommandName, hasCommand, type PromptCommand } from 'src/commands.js';import { NO_CONTENT_MESSAGE } from 'src/constants/messages.js';import type { SetToolJSXFn, ToolUseContext } from 'src/Tool.js';import type { AssistantMessage, AttachmentMessage, Message, NormalizedUserMessage, ProgressMessage, UserMessage } from 'src/types/message.js';import { addInvokedSkill, getSessionId } from '../../bootstrap/state.js';import { COMMAND_MESSAGE_TAG, COMMAND_NAME_TAG } from '../../constants/xml.js';import type { CanUseToolFn } from '../../hooks/useCanUseTool.js';import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, logEvent } from '../../services/analytics/index.js';import { getDumpPromptsPath } from '../../services/api/dumpPrompts.js';import { buildPostCompactMessages } from '../../services/compact/compact.js';import { resetMicrocompactState } from '../../services/compact/microCompact.js';import type { Progress as AgentProgress } from '../../tools/AgentTool/AgentTool.js';import { runAgent } from '../../tools/AgentTool/runAgent.js';import { renderToolUseProgressMessage } from '../../tools/AgentTool/UI.js';import type { CommandResultDisplay } from '../../types/command.js';import { createAbortController } from '../abortController.js';import { getAgentContext } from '../agentContext.js';import { createAttachmentMessage, getAttachmentMessages } from '../attachments.js';import { logForDebugging } from '../debug.js';import { isEnvTruthy } from '../envUtils.js';import { AbortError, MalformedCommandError } from '../errors.js';import { getDisplayPath } from '../file.js';import { extractResultText, prepareForkedCommandContext } from '../forkedAgent.js';import { getFsImplementation } from '../fsOperations.js';import { isFullscreenEnvEnabled } from '../fullscreen.js';import { toArray } from '../generators.js';import { registerSkillHooks } from '../hooks/registerSkillHooks.js';import { logError } from '../log.js';import { enqueuePendingNotification } from '../messageQueueManager.js';import { createCommandInputMessage, createSyntheticUserCaveatMessage, createSystemMessage, createUserInterruptionMessage, createUserMessage, formatCommandInputTags, isCompactBoundaryMessage, isSystemLocalCommandMessage, normalizeMessages, prepareUserContent } from '../messages.js';import type { ModelAlias } from '../model/aliases.js';import { parseToolListFromCLI } from '../permissions/permissionSetup.js';import { hasPermissionsToUseTool } from '../permissions/permissions.js';import { isOfficialMarketplaceName, parsePluginIdentifier } from '../plugins/pluginIdentifier.js';import { isRestrictedToPluginOnly, isSourceAdminTrusted } from '../settings/pluginOnlyPolicy.js';import { parseSlashCommand } from '../slashCommandParsing.js';import { sleep } from '../sleep.js';import { recordSkillUsage } from '../suggestions/skillUsageTracking.js';import { logOTelEvent, redactIfDisabled } from '../telemetry/events.js';import { buildPluginCommandTelemetryFields } from '../telemetry/pluginTelemetry.js';import { getAssistantMessageContentLength } from '../tokens.js';import { createAgentId } from '../uuid.js';import { getWorkload } from '../workloadContext.js';import type { ProcessUserInputBaseResult, ProcessUserInputContext } from './processUserInput.js';type SlashCommandResult = ProcessUserInputBaseResult & { command: Command;};
// Poll interval and deadline for MCP settle before launching a background// forked subagent. MCP servers typically connect within 1-3s of startup;// 10s headroom covers slow SSE handshakes.const MCP_SETTLE_POLL_MS = 200;const MCP_SETTLE_TIMEOUT_MS = 10_000;
/** * Executes a slash command with context: fork in a sub-agent. */async function executeForkedSlashCommand(command: CommandBase & PromptCommand, args: string, context: ProcessUserInputContext, precedingInputBlocks: ContentBlockParam[], setToolJSX: SetToolJSXFn, canUseTool: CanUseToolFn): Promise<SlashCommandResult> { const agentId = createAgentId(); const pluginMarketplace = command.pluginInfo ? parsePluginIdentifier(command.pluginInfo.repository).marketplace : undefined; logEvent('tengu_slash_command_forked', { command_name: command.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, invocation_trigger: 'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, ...(command.pluginInfo && { _PROTO_plugin_name: command.pluginInfo.pluginManifest.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED, ...(pluginMarketplace && { _PROTO_marketplace_name: pluginMarketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED }), ...buildPluginCommandTelemetryFields(command.pluginInfo) }) }); const { skillContent, modifiedGetAppState, baseAgent, promptMessages } = await prepareForkedCommandContext(command, args, context);
// Merge skill's effort into the agent definition so runAgent applies it const agentDefinition = command.effort !== undefined ? { ...baseAgent, effort: command.effort } : baseAgent; logForDebugging(`Executing forked slash command /${command.name} with agent ${agentDefinition.agentType}`);
// Assistant mode: fire-and-forget. Launch subagent in background, return // immediately, re-enqueue the result as an isMeta prompt when done. // Without this, N scheduled tasks on startup = N serial (subagent + main // agent turn) cycles blocking user input. With this, N subagents run in // parallel and results trickle into the queue as they finish. // // Gated on kairosEnabled (not CLAUDE_CODE_BRIEF) because the closed loop // depends on assistant-mode invariants: scheduled_tasks.json exists, // the main agent knows to pipe results through SendUserMessage, and // isMeta prompts are hidden. Outside assistant mode, context:fork commands // are user-invoked skills (/commit etc.) that should run synchronously // with the progress UI. if (feature('KAIROS') && (await context.getAppState()).kairosEnabled) { // Standalone abortController — background subagents survive main-thread // ESC (same policy as AgentTool's async path). They're cron-driven; if // killed mid-run they just re-fire on the next schedule. const bgAbortController = createAbortController(); const commandName = getCommandName(command);
// Workload: handlePromptSubmit wraps the entire turn in runWithWorkload // (AsyncLocalStorage). ALS context is captured when this `void` fires // and survives every await inside — isolated from the parent's // continuation. The detached closure's runAgent calls see the cron tag // automatically. We still capture the value here ONLY for the // re-enqueued result prompt below: that second turn runs in a fresh // handlePromptSubmit → fresh runWithWorkload boundary (which always // establishes a new context, even for `undefined`) → so it needs its // own QueuedCommand.workload tag to preserve attribution. const spawnTimeWorkload = getWorkload();
// Re-enter the queue as a hidden prompt. isMeta: hides from queue // preview + placeholder + transcript. skipSlashCommands: prevents // re-parsing if the result text happens to start with '/'. When // drained, this triggers a main-agent turn that sees the result and // decides whether to SendUserMessage. Propagate workload so that // second turn is also tagged. const enqueueResult = (value: string): void => enqueuePendingNotification({ value, mode: 'prompt', priority: 'later', isMeta: true, skipSlashCommands: true, workload: spawnTimeWorkload }); void (async () => { // Wait for MCP servers to settle. Scheduled tasks fire at startup and // all N drain within ~1ms (since we return immediately), capturing // context.options.tools before MCP connects. The sync path // accidentally avoided this — tasks serialized, so task N's drain // happened after task N-1's 30s run, by which time MCP was up. // Poll until no 'pending' clients remain, then refresh. const deadline = Date.now() + MCP_SETTLE_TIMEOUT_MS; while (Date.now() < deadline) { const s = context.getAppState(); if (!s.mcp.clients.some(c => c.type === 'pending')) break; await sleep(MCP_SETTLE_POLL_MS); } const freshTools = context.options.refreshTools?.() ?? context.options.tools; const agentMessages: Message[] = []; for await (const message of runAgent({ agentDefinition, promptMessages, toolUseContext: { ...context, getAppState: modifiedGetAppState, abortController: bgAbortController }, canUseTool, isAsync: true, querySource: 'agent:custom', model: command.model as ModelAlias | undefined, availableTools: freshTools, override: { agentId } })) { agentMessages.push(message); } const resultText = extractResultText(agentMessages, 'Command completed'); logForDebugging(`Background forked command /${commandName} completed (agent ${agentId})`); enqueueResult(`<scheduled-task-result command="/${commandName}">\n${resultText}\n</scheduled-task-result>`); })().catch(err => { logError(err); enqueueResult(`<scheduled-task-result command="/${commandName}" status="failed">\n${err instanceof Error ? err.message : String(err)}\n</scheduled-task-result>`); });
// Nothing to render, nothing to query — the background runner re-enters // the queue on its own schedule. return { messages: [], shouldQuery: false, command }; }
// Collect messages from the forked agent const agentMessages: Message[] = [];
// Build progress messages for the agent progress UI const progressMessages: ProgressMessage<AgentProgress>[] = []; const parentToolUseID = `forked-command-${command.name}`; let toolUseCounter = 0;
// Helper to create a progress message from an agent message const createProgressMessage = (message: AssistantMessage | NormalizedUserMessage): ProgressMessage<AgentProgress> => { toolUseCounter++; return { type: 'progress', data: { message, type: 'agent_progress', prompt: skillContent, agentId }, parentToolUseID, toolUseID: `${parentToolUseID}-${toolUseCounter}`, timestamp: new Date().toISOString(), uuid: randomUUID() }; };
// Helper to update progress display using agent progress UI const updateProgress = (): void => { setToolJSX({ jsx: renderToolUseProgressMessage(progressMessages, { tools: context.options.tools, verbose: false }), shouldHidePromptInput: false, shouldContinueAnimation: true, showSpinner: true }); };
// Show initial "Initializing…" state updateProgress();
// Run the sub-agent try { for await (const message of runAgent({ agentDefinition, promptMessages, toolUseContext: { ...context, getAppState: modifiedGetAppState }, canUseTool, isAsync: false, querySource: 'agent:custom', model: command.model as ModelAlias | undefined, availableTools: context.options.tools })) { agentMessages.push(message); const normalizedNew = normalizeMessages([message]);
// Add progress message for assistant messages (which contain tool uses) if (message.type === 'assistant') { // Increment token count in spinner for assistant messages const contentLength = getAssistantMessageContentLength(message); if (contentLength > 0) { context.setResponseLength(len => len + contentLength); } const normalizedMsg = normalizedNew[0]; if (normalizedMsg && normalizedMsg.type === 'assistant') { progressMessages.push(createProgressMessage(message)); updateProgress(); } }
// Add progress message for user messages (which contain tool results) if (message.type === 'user') { const normalizedMsg = normalizedNew[0]; if (normalizedMsg && normalizedMsg.type === 'user') { progressMessages.push(createProgressMessage(normalizedMsg)); updateProgress(); } } } } finally { // Clear the progress display setToolJSX(null); } let resultText = extractResultText(agentMessages, 'Command completed'); logForDebugging(`Forked slash command /${command.name} completed with agent ${agentId}`);
// Prepend debug log for ant users so it appears inside the command output if ("external" === 'ant') { resultText = `[ANT-ONLY] API calls: ${getDisplayPath(getDumpPromptsPath(agentId))}\n${resultText}`; }
// Return the result as a user message (simulates the agent's output) const messages: UserMessage[] = [createUserMessage({ content: prepareUserContent({ inputString: `/${getCommandName(command)} ${args}`.trim(), precedingInputBlocks }) }), createUserMessage({ content: `<local-command-stdout>\n${resultText}\n</local-command-stdout>` })]; return { messages, shouldQuery: false, command, resultText };}
/** * Determines if a string looks like a valid command name. * Valid command names only contain letters, numbers, colons, hyphens, and underscores. * * @param commandName - The potential command name to check * @returns true if it looks like a command name, false if it contains non-command characters */export function looksLikeCommand(commandName: string): boolean { // Command names should only contain [a-zA-Z0-9:_-] // If it contains other characters, it's probably a file path or other input return !/[^a-zA-Z0-9:\-_]/.test(commandName);}export async function processSlashCommand(inputString: string, precedingInputBlocks: ContentBlockParam[], imageContentBlocks: ContentBlockParam[], attachmentMessages: AttachmentMessage[], context: ProcessUserInputContext, setToolJSX: SetToolJSXFn, uuid?: string, isAlreadyProcessing?: boolean, canUseTool?: CanUseToolFn): Promise<ProcessUserInputBaseResult> { const parsed = parseSlashCommand(inputString); if (!parsed) { logEvent('tengu_input_slash_missing', {}); const errorMessage = 'Commands are in the form `/command [args]`'; return { messages: [createSyntheticUserCaveatMessage(), ...attachmentMessages, createUserMessage({ content: prepareUserContent({ inputString: errorMessage, precedingInputBlocks }) })], shouldQuery: false, resultText: errorMessage }; } const { commandName, args: parsedArgs, isMcp } = parsed; const sanitizedCommandName = isMcp ? 'mcp' : !builtInCommandNames().has(commandName) ? 'custom' : commandName;
// Check if it's a real command before processing if (!hasCommand(commandName, context.options.commands)) { // Check if this looks like a command name vs a file path or other input // Also check if it's an actual file path that exists let isFilePath = false; try { await getFsImplementation().stat(`/${commandName}`); isFilePath = true; } catch { // Not a file path — treat as command name } if (looksLikeCommand(commandName) && !isFilePath) { logEvent('tengu_input_slash_invalid', { input: commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }); const unknownMessage = `Unknown skill: ${commandName}`; return { messages: [createSyntheticUserCaveatMessage(), ...attachmentMessages, createUserMessage({ content: prepareUserContent({ inputString: unknownMessage, precedingInputBlocks }) }), // gh-32591: preserve args so the user can copy/resubmit without // retyping. System warning is UI-only (filtered before API). ...(parsedArgs ? [createSystemMessage(`Args from unknown skill: ${parsedArgs}`, 'warning')] : [])], shouldQuery: false, resultText: unknownMessage }; } const promptId = randomUUID(); setPromptId(promptId); logEvent('tengu_input_prompt', {}); // Log user prompt event for OTLP void logOTelEvent('user_prompt', { prompt_length: String(inputString.length), prompt: redactIfDisabled(inputString), 'prompt.id': promptId }); return { messages: [createUserMessage({ content: prepareUserContent({ inputString, precedingInputBlocks }), uuid: uuid }), ...attachmentMessages], shouldQuery: true }; }
// Track slash command usage for feature discovery
const { messages: newMessages, shouldQuery: messageShouldQuery, allowedTools, model, effort, command: returnedCommand, resultText, nextInput, submitNextInput } = await getMessagesForSlashCommand(commandName, parsedArgs, setToolJSX, context, precedingInputBlocks, imageContentBlocks, isAlreadyProcessing, canUseTool, uuid);
// Local slash commands that skip messages if (newMessages.length === 0) { const eventData: Record<string, boolean | number | undefined> = { input: sanitizedCommandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS };
// Add plugin metadata if this is a plugin command if (returnedCommand.type === 'prompt' && returnedCommand.pluginInfo) { const { pluginManifest, repository } = returnedCommand.pluginInfo; const { marketplace } = parsePluginIdentifier(repository); const isOfficial = isOfficialMarketplaceName(marketplace); // _PROTO_* routes to PII-tagged plugin_name/marketplace_name BQ columns // (unredacted, all users); plugin_name/plugin_repository stay in // additional_metadata as redacted variants for general-access dashboards. eventData._PROTO_plugin_name = pluginManifest.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED; if (marketplace) { eventData._PROTO_marketplace_name = marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED; } eventData.plugin_repository = (isOfficial ? repository : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; eventData.plugin_name = (isOfficial ? pluginManifest.name : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; if (isOfficial && pluginManifest.version) { eventData.plugin_version = pluginManifest.version as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; } Object.assign(eventData, buildPluginCommandTelemetryFields(returnedCommand.pluginInfo)); } logEvent('tengu_input_command', { ...eventData, invocation_trigger: 'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, ...("external" === 'ant' && { skill_name: commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, ...(returnedCommand.type === 'prompt' && { skill_source: returnedCommand.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }), ...(returnedCommand.loadedFrom && { skill_loaded_from: returnedCommand.loadedFrom as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }), ...(returnedCommand.kind && { skill_kind: returnedCommand.kind as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }) }) }); return { messages: [], shouldQuery: false, model, nextInput, submitNextInput }; }
// For invalid commands, preserve both the user message and error if (newMessages.length === 2 && newMessages[1]!.type === 'user' && typeof newMessages[1]!.message.content === 'string' && newMessages[1]!.message.content.startsWith('Unknown command:')) { // Don't log as invalid if it looks like a common file path const looksLikeFilePath = inputString.startsWith('/var') || inputString.startsWith('/tmp') || inputString.startsWith('/private'); if (!looksLikeFilePath) { logEvent('tengu_input_slash_invalid', { input: commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }); } return { messages: [createSyntheticUserCaveatMessage(), ...newMessages], shouldQuery: messageShouldQuery, allowedTools, model }; }
// A valid command const eventData: Record<string, boolean | number | undefined> = { input: sanitizedCommandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS };
// Add plugin metadata if this is a plugin command if (returnedCommand.type === 'prompt' && returnedCommand.pluginInfo) { const { pluginManifest, repository } = returnedCommand.pluginInfo; const { marketplace } = parsePluginIdentifier(repository); const isOfficial = isOfficialMarketplaceName(marketplace); eventData._PROTO_plugin_name = pluginManifest.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED; if (marketplace) { eventData._PROTO_marketplace_name = marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED; } eventData.plugin_repository = (isOfficial ? repository : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; eventData.plugin_name = (isOfficial ? pluginManifest.name : 'third-party') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; if (isOfficial && pluginManifest.version) { eventData.plugin_version = pluginManifest.version as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS; } Object.assign(eventData, buildPluginCommandTelemetryFields(returnedCommand.pluginInfo)); } logEvent('tengu_input_command', { ...eventData, invocation_trigger: 'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, ...("external" === 'ant' && { skill_name: commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, ...(returnedCommand.type === 'prompt' && { skill_source: returnedCommand.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }), ...(returnedCommand.loadedFrom && { skill_loaded_from: returnedCommand.loadedFrom as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }), ...(returnedCommand.kind && { skill_kind: returnedCommand.kind as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS }) }) });
// Check if this is a compact result which handle their own synthetic caveat message ordering const isCompactResult = newMessages.length > 0 && newMessages[0] && isCompactBoundaryMessage(newMessages[0]); return { messages: messageShouldQuery || newMessages.every(isSystemLocalCommandMessage) || isCompactResult ? newMessages : [createSyntheticUserCaveatMessage(), ...newMessages], shouldQuery: messageShouldQuery, allowedTools, model, effort, resultText, nextInput, submitNextInput };}async function getMessagesForSlashCommand(commandName: string, args: string, setToolJSX: SetToolJSXFn, context: ProcessUserInputContext, precedingInputBlocks: ContentBlockParam[], imageContentBlocks: ContentBlockParam[], _isAlreadyProcessing?: boolean, canUseTool?: CanUseToolFn, uuid?: string): Promise<SlashCommandResult> { const command = getCommand(commandName, context.options.commands);
// Track skill usage for ranking (only for prompt commands that are user-invocable) if (command.type === 'prompt' && command.userInvocable !== false) { recordSkillUsage(commandName); }
// Check if the command is user-invocable // Skills with userInvocable === false can only be invoked by the model via SkillTool if (command.userInvocable === false) { return { messages: [createUserMessage({ content: prepareUserContent({ inputString: `/${commandName}`, precedingInputBlocks }) }), createUserMessage({ content: `This skill can only be invoked by Claude, not directly by users. Ask Claude to use the "${commandName}" skill for you.` })], shouldQuery: false, command }; } try { switch (command.type) { case 'local-jsx': { return new Promise<SlashCommandResult>(resolve => { let doneWasCalled = false; const onDone = (result?: string, options?: { display?: CommandResultDisplay; shouldQuery?: boolean; metaMessages?: string[]; nextInput?: string; submitNextInput?: boolean; }) => { doneWasCalled = true; // If display is 'skip', don't add any messages to the conversation if (options?.display === 'skip') { void resolve({ messages: [], shouldQuery: false, command, nextInput: options?.nextInput, submitNextInput: options?.submitNextInput }); return; }
// Meta messages are model-visible but hidden from the user const metaMessages = (options?.metaMessages ?? []).map((content: string) => createUserMessage({ content, isMeta: true }));
// In fullscreen the command just showed as a centered modal // pane — the transient notification is enough feedback. The // "❯ /config" + "⎿ dismissed" transcript entries are // type:system subtype:local_command (user-visible but NOT sent // to the model), so skipping them doesn't affect model context. // Outside fullscreen keep them so scrollback shows what ran. // Only skip "<Name> dismissed" modal-close notifications — // commands that early-exit before showing a modal (/ultraplan // usage, /rename, /proactive) use display:system for actual // output that must reach the transcript. const skipTranscript = isFullscreenEnvEnabled() && typeof result === 'string' && result.endsWith(' dismissed'); void resolve({ messages: options?.display === 'system' ? skipTranscript ? metaMessages : [createCommandInputMessage(formatCommandInput(command, args)), createCommandInputMessage(`<local-command-stdout>${result}</local-command-stdout>`), ...metaMessages] : [createUserMessage({ content: prepareUserContent({ inputString: formatCommandInput(command, args), precedingInputBlocks }) }), result ? createUserMessage({ content: `<local-command-stdout>${result}</local-command-stdout>` }) : createUserMessage({ content: `<local-command-stdout>${NO_CONTENT_MESSAGE}</local-command-stdout>` }), ...metaMessages], shouldQuery: options?.shouldQuery ?? false, command, nextInput: options?.nextInput, submitNextInput: options?.submitNextInput }); }; void command.load().then(mod => mod.call(onDone, { ...context, canUseTool }, args)).then(jsx => { if (jsx == null) return; if (context.options.isNonInteractiveSession) { void resolve({ messages: [], shouldQuery: false, command }); return; } // Guard: if onDone fired during mod.call() (early-exit path // that calls onDone then returns JSX), skip setToolJSX. This // chain is fire-and-forget — the outer Promise resolves when // onDone is called, so executeUserInput may have already run // its setToolJSX({clearLocalJSX: true}) before we get here. // Setting isLocalJSXCommand after clear leaves it stuck true, // blocking useQueueProcessor and TextInput focus. if (doneWasCalled) return; setToolJSX({ jsx, shouldHidePromptInput: true, showSpinner: false, isLocalJSXCommand: true, isImmediate: command.immediate === true }); }).catch(e => { // If load()/call() throws and onDone never fired, the outer // Promise hangs forever, leaving queryGuard stuck in // 'dispatching' and deadlocking the queue processor. logError(e); if (doneWasCalled) return; doneWasCalled = true; setToolJSX({ jsx: null, shouldHidePromptInput: false, clearLocalJSX: true }); void resolve({ messages: [], shouldQuery: false, command }); }); }); } case 'local': { const displayArgs = command.isSensitive && args.trim() ? '***' : args; const userMessage = createUserMessage({ content: prepareUserContent({ inputString: formatCommandInput(command, displayArgs), precedingInputBlocks }) }); try { const syntheticCaveatMessage = createSyntheticUserCaveatMessage(); const mod = await command.load(); const result = await mod.call(args, context); if (result.type === 'skip') { return { messages: [], shouldQuery: false, command }; }
// Use discriminated union to handle different result types if (result.type === 'compact') { // Append slash command messages to messagesToKeep so that // attachments and hookResults come after user messages const slashCommandMessages = [syntheticCaveatMessage, userMessage, ...(result.displayText ? [createUserMessage({ content: `<local-command-stdout>${result.displayText}</local-command-stdout>`, // --resume looks at latest timestamp message to determine which message to resume from // This is a perf optimization to avoid having to recaculcate the leaf node every time // Since we're creating a bunch of synthetic messages for compact, it's important to set // the timestamp of the last message to be slightly after the current time // This is mostly important for sdk / -p mode timestamp: new Date(Date.now() + 100).toISOString() })] : [])]; const compactionResultWithSlashMessages = { ...result.compactionResult, messagesToKeep: [...(result.compactionResult.messagesToKeep ?? []), ...slashCommandMessages] }; // Reset microcompact state since full compact replaces all // messages — old tool IDs are no longer relevant. Budget state // (on toolUseContext) needs no reset: stale entries are inert // (UUIDs never repeat, so they're never looked up). resetMicrocompactState(); return { messages: buildPostCompactMessages(compactionResultWithSlashMessages), shouldQuery: false, command }; }
// Text result — use system message so it doesn't render as a user bubble return { messages: [userMessage, createCommandInputMessage(`<local-command-stdout>${result.value}</local-command-stdout>`)], shouldQuery: false, command, resultText: result.value }; } catch (e) { logError(e); return { messages: [userMessage, createCommandInputMessage(`<local-command-stderr>${String(e)}</local-command-stderr>`)], shouldQuery: false, command }; } } case 'prompt': { try { // Check if command should run as forked sub-agent if (command.context === 'fork') { return await executeForkedSlashCommand(command, args, context, precedingInputBlocks, setToolJSX, canUseTool ?? hasPermissionsToUseTool); } return await getMessagesForPromptSlashCommand(command, args, context, precedingInputBlocks, imageContentBlocks, uuid); } catch (e) { // Handle abort errors specially to show proper "Interrupted" message if (e instanceof AbortError) { return { messages: [createUserMessage({ content: prepareUserContent({ inputString: formatCommandInput(command, args), precedingInputBlocks }) }), createUserInterruptionMessage({ toolUse: false })], shouldQuery: false, command }; } return { messages: [createUserMessage({ content: prepareUserContent({ inputString: formatCommandInput(command, args), precedingInputBlocks }) }), createUserMessage({ content: `<local-command-stderr>${String(e)}</local-command-stderr>` })], shouldQuery: false, command }; } } } } catch (e) { if (e instanceof MalformedCommandError) { return { messages: [createUserMessage({ content: prepareUserContent({ inputString: e.message, precedingInputBlocks }) })], shouldQuery: false, command }; } throw e; }}function formatCommandInput(command: CommandBase, args: string): string { return formatCommandInputTags(getCommandName(command), args);}
/** * Formats the metadata for a skill loading message. * Used by the Skill tool and for subagent skill preloading. */export function formatSkillLoadingMetadata(skillName: string, _progressMessage: string = 'loading'): string { // Use skill name only - UserCommandMessage renders as "Skill(name)" return [`<${COMMAND_MESSAGE_TAG}>${skillName}</${COMMAND_MESSAGE_TAG}>`, `<${COMMAND_NAME_TAG}>${skillName}</${COMMAND_NAME_TAG}>`, `<skill-format>true</skill-format>`].join('\n');}
/** * Formats the metadata for a slash command loading message. */function formatSlashCommandLoadingMetadata(commandName: string, args?: string): string { return [`<${COMMAND_MESSAGE_TAG}>${commandName}</${COMMAND_MESSAGE_TAG}>`, `<${COMMAND_NAME_TAG}>/${commandName}</${COMMAND_NAME_TAG}>`, args ? `<command-args>${args}</command-args>` : null].filter(Boolean).join('\n');}
/** * Formats the loading metadata for a command (skill or slash command). * User-invocable skills use slash command format (/name), while model-only * skills use the skill format ("The X skill is running"). */function formatCommandLoadingMetadata(command: CommandBase & PromptCommand, args?: string): string { // Use command.name (the qualified name including plugin prefix, e.g. // "product-management:feature-spec") instead of userFacingName() which may // strip the plugin prefix via displayName fallback. // User-invocable skills should show as /command-name like regular slash commands if (command.userInvocable !== false) { return formatSlashCommandLoadingMetadata(command.name, args); } // Model-only skills (userInvocable: false) show as "The X skill is running" if (command.loadedFrom === 'skills' || command.loadedFrom === 'plugin' || command.loadedFrom === 'mcp') { return formatSkillLoadingMetadata(command.name, command.progressMessage); } return formatSlashCommandLoadingMetadata(command.name, args);}export async function processPromptSlashCommand(commandName: string, args: string, commands: Command[], context: ToolUseContext, imageContentBlocks: ContentBlockParam[] = []): Promise<SlashCommandResult> { const command = findCommand(commandName, commands); if (!command) { throw new MalformedCommandError(`Unknown command: ${commandName}`); } if (command.type !== 'prompt') { throw new Error(`Unexpected ${command.type} command. Expected 'prompt' command. Use /${commandName} directly in the main conversation.`); } return getMessagesForPromptSlashCommand(command, args, context, [], imageContentBlocks);}async function getMessagesForPromptSlashCommand(command: CommandBase & PromptCommand, args: string, context: ToolUseContext, precedingInputBlocks: ContentBlockParam[] = [], imageContentBlocks: ContentBlockParam[] = [], uuid?: string): Promise<SlashCommandResult> { // In coordinator mode (main thread only), skip loading the full skill content // and permissions. The coordinator only has Agent + TaskStop tools, so the // skill content and allowedTools are useless. Instead, send a brief summary // telling the coordinator how to delegate this skill to a worker. // // Workers run in-process and inherit CLAUDE_CODE_COORDINATOR_MODE from the // parent env, so we also check !context.agentId: agentId is only set for // subagents, letting workers fall through to getPromptForCommand and receive // the real skill content when they invoke the Skill tool. if (feature('COORDINATOR_MODE') && isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) && !context.agentId) { const metadata = formatCommandLoadingMetadata(command, args); const parts: string[] = [`Skill "/${command.name}" is available for workers.`]; if (command.description) { parts.push(`Description: ${command.description}`); } if (command.whenToUse) { parts.push(`When to use: ${command.whenToUse}`); } const skillAllowedTools = command.allowedTools ?? []; if (skillAllowedTools.length > 0) { parts.push(`This skill grants workers additional tool permissions: ${skillAllowedTools.join(', ')}`); } parts.push(`\nInstruct a worker to use this skill by including "Use the /${command.name} skill" in your Agent prompt. The worker has access to the Skill tool and will receive the skill's content and permissions when it invokes it.`); const summaryContent: ContentBlockParam[] = [{ type: 'text', text: parts.join('\n') }]; return { messages: [createUserMessage({ content: metadata, uuid }), createUserMessage({ content: summaryContent, isMeta: true })], shouldQuery: true, model: command.model, effort: command.effort, command }; } const result = await command.getPromptForCommand(args, context);
// Register skill hooks if defined. Under ["hooks"]-only (skills not locked), // user skills still load and reach this point — block hook REGISTRATION here // where source is known. Mirrors the agent frontmatter gate in runAgent.ts. const hooksAllowedForThisSkill = !isRestrictedToPluginOnly('hooks') || isSourceAdminTrusted(command.source); if (command.hooks && hooksAllowedForThisSkill) { const sessionId = getSessionId(); registerSkillHooks(context.setAppState, sessionId, command.hooks, command.name, command.type === 'prompt' ? command.skillRoot : undefined); }
// Record skill invocation for compaction preservation, scoped by agent context. // Skills are tagged with their agentId so only skills belonging to the current // agent are restored during compaction (preventing cross-agent leaks). const skillPath = command.source ? `${command.source}:${command.name}` : command.name; const skillContent = result.filter((b): b is TextBlockParam => b.type === 'text').map(b => b.text).join('\n\n'); addInvokedSkill(command.name, skillPath, skillContent, getAgentContext()?.agentId ?? null); const metadata = formatCommandLoadingMetadata(command, args); const additionalAllowedTools = parseToolListFromCLI(command.allowedTools ?? []);
// Create content for the main message, including any pasted images const mainMessageContent: ContentBlockParam[] = imageContentBlocks.length > 0 || precedingInputBlocks.length > 0 ? [...imageContentBlocks, ...precedingInputBlocks, ...result] : result;
// Extract attachments from command arguments (@-mentions, MCP resources, // agent mentions in SKILL.md). skipSkillDiscovery prevents the SKILL.md // content itself from triggering discovery — it's meta-content, not user // intent, and a large SKILL.md (e.g. 110KB) would fire chunked AKI queries // adding seconds of latency to every skill invocation. const attachmentMessages = await toArray(getAttachmentMessages(result.filter((block): block is TextBlockParam => block.type === 'text').map(block => block.text).join(' '), context, null, [], // queuedCommands - handled by query.ts for mid-turn attachments context.messages, 'repl_main_thread', { skipSkillDiscovery: true })); const messages = [createUserMessage({ content: metadata, uuid }), createUserMessage({ content: mainMessageContent, isMeta: true }), ...attachmentMessages, createAttachmentMessage({ type: 'command_permissions', allowedTools: additionalAllowedTools, model: command.model })]; return { messages, shouldQuery: true, allowedTools: additionalAllowedTools, model: command.model, effort: command.effort, command };}//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","ContentBlockParam","TextBlockParam","randomUUID","setPromptId","builtInCommandNames","Command","CommandBase","findCommand","getCommand","getCommandName","hasCommand","PromptCommand","NO_CONTENT_MESSAGE","SetToolJSXFn","ToolUseContext","AssistantMessage","AttachmentMessage","Message","NormalizedUserMessage","ProgressMessage","UserMessage","addInvokedSkill","getSessionId","COMMAND_MESSAGE_TAG","COMMAND_NAME_TAG","CanUseToolFn","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED","logEvent","getDumpPromptsPath","buildPostCompactMessages","resetMicrocompactState","Progress","AgentProgress","runAgent","renderToolUseProgressMessage","CommandResultDisplay","createAbortController","getAgentContext","createAttachmentMessage","getAttachmentMessages","logForDebugging","isEnvTruthy","AbortError","MalformedCommandError","getDisplayPath","extractResultText","prepareForkedCommandContext","getFsImplementation","isFullscreenEnvEnabled","toArray","registerSkillHooks","logError","enqueuePendingNotification","createCommandInputMessage","createSyntheticUserCaveatMessage","createSystemMessage","createUserInterruptionMessage","createUserMessage","formatCommandInputTags","isCompactBoundaryMessage","isSystemLocalCommandMessage","normalizeMessages","prepareUserContent","ModelAlias","parseToolListFromCLI","hasPermissionsToUseTool","isOfficialMarketplaceName","parsePluginIdentifier","isRestrictedToPluginOnly","isSourceAdminTrusted","parseSlashCommand","sleep","recordSkillUsage","logOTelEvent","redactIfDisabled","buildPluginCommandTelemetryFields","getAssistantMessageContentLength","createAgentId","getWorkload","ProcessUserInputBaseResult","ProcessUserInputContext","SlashCommandResult","command","MCP_SETTLE_POLL_MS","MCP_SETTLE_TIMEOUT_MS","executeForkedSlashCommand","args","context","precedingInputBlocks","setToolJSX","canUseTool","Promise","agentId","pluginMarketplace","pluginInfo","repository","marketplace","undefined","command_name","name","invocation_trigger","_PROTO_plugin_name","pluginManifest","_PROTO_marketplace_name","skillContent","modifiedGetAppState","baseAgent","promptMessages","agentDefinition","effort","agentType","getAppState","kairosEnabled","bgAbortController","commandName","spawnTimeWorkload","enqueueResult","value","mode","priority","isMeta","skipSlashCommands","workload","deadline","Date","now","s","mcp","clients","some","c","type","freshTools","options","refreshTools","tools","agentMessages","message","toolUseContext","abortController","isAsync","querySource","model","availableTools","override","push","resultText","catch","err","Error","String","messages","shouldQuery","progressMessages","parentToolUseID","toolUseCounter","createProgressMessage","data","prompt","toolUseID","timestamp","toISOString","uuid","updateProgress","jsx","verbose","shouldHidePromptInput","shouldContinueAnimation","showSpinner","normalizedNew","contentLength","setResponseLength","len","normalizedMsg","content","inputString","trim","looksLikeCommand","test","processSlashCommand","imageContentBlocks","attachmentMessages","isAlreadyProcessing","parsed","errorMessage","parsedArgs","isMcp","sanitizedCommandName","has","commands","isFilePath","stat","input","unknownMessage","promptId","prompt_length","length","newMessages","messageShouldQuery","allowedTools","returnedCommand","nextInput","submitNextInput","getMessagesForSlashCommand","eventData","Record","isOfficial","plugin_repository","plugin_name","version","plugin_version","Object","assign","skill_name","skill_source","source","loadedFrom","skill_loaded_from","kind","skill_kind","startsWith","looksLikeFilePath","isCompactResult","every","_isAlreadyProcessing","userInvocable","resolve","doneWasCalled","onDone","result","display","metaMessages","map","skipTranscript","endsWith","formatCommandInput","load","then","mod","call","isNonInteractiveSession","isLocalJSXCommand","isImmediate","immediate","e","clearLocalJSX","displayArgs","isSensitive","userMessage","syntheticCaveatMessage","slashCommandMessages","displayText","compactionResultWithSlashMessages","compactionResult","messagesToKeep","getMessagesForPromptSlashCommand","toolUse","formatSkillLoadingMetadata","skillName","_progressMessage","join","formatSlashCommandLoadingMetadata","filter","Boolean","formatCommandLoadingMetadata","progressMessage","processPromptSlashCommand","process","env","CLAUDE_CODE_COORDINATOR_MODE","metadata","parts","description","whenToUse","skillAllowedTools","summaryContent","text","getPromptForCommand","hooksAllowedForThisSkill","hooks","sessionId","setAppState","skillRoot","skillPath","b","additionalAllowedTools","mainMessageContent","block","skipSkillDiscovery"],"sources":["processSlashCommand.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport type {\n  ContentBlockParam,\n  TextBlockParam,\n} from '@anthropic-ai/sdk/resources'\nimport { randomUUID } from 'crypto'\nimport { setPromptId } from 'src/bootstrap/state.js'\nimport {\n  builtInCommandNames,\n  type Command,\n  type CommandBase,\n  findCommand,\n  getCommand,\n  getCommandName,\n  hasCommand,\n  type PromptCommand,\n} from 'src/commands.js'\nimport { NO_CONTENT_MESSAGE } from 'src/constants/messages.js'\nimport type { SetToolJSXFn, ToolUseContext } from 'src/Tool.js'\nimport type {\n  AssistantMessage,\n  AttachmentMessage,\n  Message,\n  NormalizedUserMessage,\n  ProgressMessage,\n  UserMessage,\n} from 'src/types/message.js'\nimport { addInvokedSkill, getSessionId } from '../../bootstrap/state.js'\nimport { COMMAND_MESSAGE_TAG, COMMAND_NAME_TAG } from '../../constants/xml.js'\nimport type { CanUseToolFn } from '../../hooks/useCanUseTool.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n  logEvent,\n} from '../../services/analytics/index.js'\nimport { getDumpPromptsPath } from '../../services/api/dumpPrompts.js'\nimport { buildPostCompactMessages } from '../../services/compact/compact.js'\nimport { resetMicrocompactState } from '../../services/compact/microCompact.js'\nimport type { Progress as AgentProgress } from '../../tools/AgentTool/AgentTool.js'\nimport { runAgent } from '../../tools/AgentTool/runAgent.js'\nimport { renderToolUseProgressMessage } from '../../tools/AgentTool/UI.js'\nimport type { CommandResultDisplay } from '../../types/command.js'\nimport { createAbortController } from '../abortController.js'\nimport { getAgentContext } from '../agentContext.js'\nimport {\n  createAttachmentMessage,\n  getAttachmentMessages,\n} from '../attachments.js'\nimport { logForDebugging } from '../debug.js'\nimport { isEnvTruthy } from '../envUtils.js'\nimport { AbortError, MalformedCommandError } from '../errors.js'\nimport { getDisplayPath } from '../file.js'\nimport {\n  extractResultText,\n  prepareForkedCommandContext,\n} from '../forkedAgent.js'\nimport { getFsImplementation } from '../fsOperations.js'\nimport { isFullscreenEnvEnabled } from '../fullscreen.js'\nimport { toArray } from '../generators.js'\nimport { registerSkillHooks } from '../hooks/registerSkillHooks.js'\nimport { logError } from '../log.js'\nimport { enqueuePendingNotification } from '../messageQueueManager.js'\nimport {\n  createCommandInputMessage,\n  createSyntheticUserCaveatMessage,\n  createSystemMessage,\n  createUserInterruptionMessage,\n  createUserMessage,\n  formatCommandInputTags,\n  isCompactBoundaryMessage,\n  isSystemLocalCommandMessage,\n  normalizeMessages,\n  prepareUserContent,\n} from '../messages.js'\nimport type { ModelAlias } from '../model/aliases.js'\nimport { parseToolListFromCLI } from '../permissions/permissionSetup.js'\nimport { hasPermissionsToUseTool } from '../permissions/permissions.js'\nimport {\n  isOfficialMarketplaceName,\n  parsePluginIdentifier,\n} from '../plugins/pluginIdentifier.js'\nimport {\n  isRestrictedToPluginOnly,\n  isSourceAdminTrusted,\n} from '../settings/pluginOnlyPolicy.js'\nimport { parseSlashCommand } from '../slashCommandParsing.js'\nimport { sleep } from '../sleep.js'\nimport { recordSkillUsage } from '../suggestions/skillUsageTracking.js'\nimport { logOTelEvent, redactIfDisabled } from '../telemetry/events.js'\nimport { buildPluginCommandTelemetryFields } from '../telemetry/pluginTelemetry.js'\nimport { getAssistantMessageContentLength } from '../tokens.js'\nimport { createAgentId } from '../uuid.js'\nimport { getWorkload } from '../workloadContext.js'\nimport type {\n  ProcessUserInputBaseResult,\n  ProcessUserInputContext,\n} from './processUserInput.js'\n\ntype SlashCommandResult = ProcessUserInputBaseResult & {\n  command: Command\n}\n\n// Poll interval and deadline for MCP settle before launching a background\n// forked subagent. MCP servers typically connect within 1-3s of startup;\n// 10s headroom covers slow SSE handshakes.\nconst MCP_SETTLE_POLL_MS = 200\nconst MCP_SETTLE_TIMEOUT_MS = 10_000\n\n/**\n * Executes a slash command with context: fork in a sub-agent.\n */\nasync function executeForkedSlashCommand(\n  command: CommandBase & PromptCommand,\n  args: string,\n  context: ProcessUserInputContext,\n  precedingInputBlocks: ContentBlockParam[],\n  setToolJSX: SetToolJSXFn,\n  canUseTool: CanUseToolFn,\n): Promise<SlashCommandResult> {\n  const agentId = createAgentId()\n\n  const pluginMarketplace = command.pluginInfo\n    ? parsePluginIdentifier(command.pluginInfo.repository).marketplace\n    : undefined\n  logEvent('tengu_slash_command_forked', {\n    command_name:\n      command.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    invocation_trigger:\n      'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    ...(command.pluginInfo && {\n      _PROTO_plugin_name: command.pluginInfo.pluginManifest\n        .name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n      ...(pluginMarketplace && {\n        _PROTO_marketplace_name:\n          pluginMarketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n      }),\n      ...buildPluginCommandTelemetryFields(command.pluginInfo),\n    }),\n  })\n\n  const { skillContent, modifiedGetAppState, baseAgent, promptMessages } =\n    await prepareForkedCommandContext(command, args, context)\n\n  // Merge skill's effort into the agent definition so runAgent applies it\n  const agentDefinition =\n    command.effort !== undefined\n      ? { ...baseAgent, effort: command.effort }\n      : baseAgent\n\n  logForDebugging(\n    `Executing forked slash command /${command.name} with agent ${agentDefinition.agentType}`,\n  )\n\n  // Assistant mode: fire-and-forget. Launch subagent in background, return\n  // immediately, re-enqueue the result as an isMeta prompt when done.\n  // Without this, N scheduled tasks on startup = N serial (subagent + main\n  // agent turn) cycles blocking user input. With this, N subagents run in\n  // parallel and results trickle into the queue as they finish.\n  //\n  // Gated on kairosEnabled (not CLAUDE_CODE_BRIEF) because the closed loop\n  // depends on assistant-mode invariants: scheduled_tasks.json exists,\n  // the main agent knows to pipe results through SendUserMessage, and\n  // isMeta prompts are hidden. Outside assistant mode, context:fork commands\n  // are user-invoked skills (/commit etc.) that should run synchronously\n  // with the progress UI.\n  if (feature('KAIROS') && (await context.getAppState()).kairosEnabled) {\n    // Standalone abortController — background subagents survive main-thread\n    // ESC (same policy as AgentTool's async path). They're cron-driven; if\n    // killed mid-run they just re-fire on the next schedule.\n    const bgAbortController = createAbortController()\n    const commandName = getCommandName(command)\n\n    // Workload: handlePromptSubmit wraps the entire turn in runWithWorkload\n    // (AsyncLocalStorage). ALS context is captured when this `void` fires\n    // and survives every await inside — isolated from the parent's\n    // continuation. The detached closure's runAgent calls see the cron tag\n    // automatically. We still capture the value here ONLY for the\n    // re-enqueued result prompt below: that second turn runs in a fresh\n    // handlePromptSubmit → fresh runWithWorkload boundary (which always\n    // establishes a new context, even for `undefined`) → so it needs its\n    // own QueuedCommand.workload tag to preserve attribution.\n    const spawnTimeWorkload = getWorkload()\n\n    // Re-enter the queue as a hidden prompt. isMeta: hides from queue\n    // preview + placeholder + transcript. skipSlashCommands: prevents\n    // re-parsing if the result text happens to start with '/'. When\n    // drained, this triggers a main-agent turn that sees the result and\n    // decides whether to SendUserMessage. Propagate workload so that\n    // second turn is also tagged.\n    const enqueueResult = (value: string): void =>\n      enqueuePendingNotification({\n        value,\n        mode: 'prompt',\n        priority: 'later',\n        isMeta: true,\n        skipSlashCommands: true,\n        workload: spawnTimeWorkload,\n      })\n\n    void (async () => {\n      // Wait for MCP servers to settle. Scheduled tasks fire at startup and\n      // all N drain within ~1ms (since we return immediately), capturing\n      // context.options.tools before MCP connects. The sync path\n      // accidentally avoided this — tasks serialized, so task N's drain\n      // happened after task N-1's 30s run, by which time MCP was up.\n      // Poll until no 'pending' clients remain, then refresh.\n      const deadline = Date.now() + MCP_SETTLE_TIMEOUT_MS\n      while (Date.now() < deadline) {\n        const s = context.getAppState()\n        if (!s.mcp.clients.some(c => c.type === 'pending')) break\n        await sleep(MCP_SETTLE_POLL_MS)\n      }\n      const freshTools =\n        context.options.refreshTools?.() ?? context.options.tools\n\n      const agentMessages: Message[] = []\n      for await (const message of runAgent({\n        agentDefinition,\n        promptMessages,\n        toolUseContext: {\n          ...context,\n          getAppState: modifiedGetAppState,\n          abortController: bgAbortController,\n        },\n        canUseTool,\n        isAsync: true,\n        querySource: 'agent:custom',\n        model: command.model as ModelAlias | undefined,\n        availableTools: freshTools,\n        override: { agentId },\n      })) {\n        agentMessages.push(message)\n      }\n      const resultText = extractResultText(agentMessages, 'Command completed')\n      logForDebugging(\n        `Background forked command /${commandName} completed (agent ${agentId})`,\n      )\n      enqueueResult(\n        `<scheduled-task-result command=\"/${commandName}\">\\n${resultText}\\n</scheduled-task-result>`,\n      )\n    })().catch(err => {\n      logError(err)\n      enqueueResult(\n        `<scheduled-task-result command=\"/${commandName}\" status=\"failed\">\\n${err instanceof Error ? err.message : String(err)}\\n</scheduled-task-result>`,\n      )\n    })\n\n    // Nothing to render, nothing to query — the background runner re-enters\n    // the queue on its own schedule.\n    return { messages: [], shouldQuery: false, command }\n  }\n\n  // Collect messages from the forked agent\n  const agentMessages: Message[] = []\n\n  // Build progress messages for the agent progress UI\n  const progressMessages: ProgressMessage<AgentProgress>[] = []\n  const parentToolUseID = `forked-command-${command.name}`\n  let toolUseCounter = 0\n\n  // Helper to create a progress message from an agent message\n  const createProgressMessage = (\n    message: AssistantMessage | NormalizedUserMessage,\n  ): ProgressMessage<AgentProgress> => {\n    toolUseCounter++\n    return {\n      type: 'progress',\n      data: {\n        message,\n        type: 'agent_progress',\n        prompt: skillContent,\n        agentId,\n      },\n      parentToolUseID,\n      toolUseID: `${parentToolUseID}-${toolUseCounter}`,\n      timestamp: new Date().toISOString(),\n      uuid: randomUUID(),\n    }\n  }\n\n  // Helper to update progress display using agent progress UI\n  const updateProgress = (): void => {\n    setToolJSX({\n      jsx: renderToolUseProgressMessage(progressMessages, {\n        tools: context.options.tools,\n        verbose: false,\n      }),\n      shouldHidePromptInput: false,\n      shouldContinueAnimation: true,\n      showSpinner: true,\n    })\n  }\n\n  // Show initial \"Initializing…\" state\n  updateProgress()\n\n  // Run the sub-agent\n  try {\n    for await (const message of runAgent({\n      agentDefinition,\n      promptMessages,\n      toolUseContext: {\n        ...context,\n        getAppState: modifiedGetAppState,\n      },\n      canUseTool,\n      isAsync: false,\n      querySource: 'agent:custom',\n      model: command.model as ModelAlias | undefined,\n      availableTools: context.options.tools,\n    })) {\n      agentMessages.push(message)\n      const normalizedNew = normalizeMessages([message])\n\n      // Add progress message for assistant messages (which contain tool uses)\n      if (message.type === 'assistant') {\n        // Increment token count in spinner for assistant messages\n        const contentLength = getAssistantMessageContentLength(message)\n        if (contentLength > 0) {\n          context.setResponseLength(len => len + contentLength)\n        }\n\n        const normalizedMsg = normalizedNew[0]\n        if (normalizedMsg && normalizedMsg.type === 'assistant') {\n          progressMessages.push(createProgressMessage(message))\n          updateProgress()\n        }\n      }\n\n      // Add progress message for user messages (which contain tool results)\n      if (message.type === 'user') {\n        const normalizedMsg = normalizedNew[0]\n        if (normalizedMsg && normalizedMsg.type === 'user') {\n          progressMessages.push(createProgressMessage(normalizedMsg))\n          updateProgress()\n        }\n      }\n    }\n  } finally {\n    // Clear the progress display\n    setToolJSX(null)\n  }\n\n  let resultText = extractResultText(agentMessages, 'Command completed')\n\n  logForDebugging(\n    `Forked slash command /${command.name} completed with agent ${agentId}`,\n  )\n\n  // Prepend debug log for ant users so it appears inside the command output\n  if (\"external\" === 'ant') {\n    resultText = `[ANT-ONLY] API calls: ${getDisplayPath(getDumpPromptsPath(agentId))}\\n${resultText}`\n  }\n\n  // Return the result as a user message (simulates the agent's output)\n  const messages: UserMessage[] = [\n    createUserMessage({\n      content: prepareUserContent({\n        inputString: `/${getCommandName(command)} ${args}`.trim(),\n        precedingInputBlocks,\n      }),\n    }),\n    createUserMessage({\n      content: `<local-command-stdout>\\n${resultText}\\n</local-command-stdout>`,\n    }),\n  ]\n\n  return {\n    messages,\n    shouldQuery: false,\n    command,\n    resultText,\n  }\n}\n\n/**\n * Determines if a string looks like a valid command name.\n * Valid command names only contain letters, numbers, colons, hyphens, and underscores.\n *\n * @param commandName - The potential command name to check\n * @returns true if it looks like a command name, false if it contains non-command characters\n */\nexport function looksLikeCommand(commandName: string): boolean {\n  // Command names should only contain [a-zA-Z0-9:_-]\n  // If it contains other characters, it's probably a file path or other input\n  return !/[^a-zA-Z0-9:\\-_]/.test(commandName)\n}\n\nexport async function processSlashCommand(\n  inputString: string,\n  precedingInputBlocks: ContentBlockParam[],\n  imageContentBlocks: ContentBlockParam[],\n  attachmentMessages: AttachmentMessage[],\n  context: ProcessUserInputContext,\n  setToolJSX: SetToolJSXFn,\n  uuid?: string,\n  isAlreadyProcessing?: boolean,\n  canUseTool?: CanUseToolFn,\n): Promise<ProcessUserInputBaseResult> {\n  const parsed = parseSlashCommand(inputString)\n  if (!parsed) {\n    logEvent('tengu_input_slash_missing', {})\n    const errorMessage = 'Commands are in the form `/command [args]`'\n    return {\n      messages: [\n        createSyntheticUserCaveatMessage(),\n        ...attachmentMessages,\n        createUserMessage({\n          content: prepareUserContent({\n            inputString: errorMessage,\n            precedingInputBlocks,\n          }),\n        }),\n      ],\n      shouldQuery: false,\n      resultText: errorMessage,\n    }\n  }\n\n  const { commandName, args: parsedArgs, isMcp } = parsed\n\n  const sanitizedCommandName = isMcp\n    ? 'mcp'\n    : !builtInCommandNames().has(commandName)\n      ? 'custom'\n      : commandName\n\n  // Check if it's a real command before processing\n  if (!hasCommand(commandName, context.options.commands)) {\n    // Check if this looks like a command name vs a file path or other input\n    // Also check if it's an actual file path that exists\n    let isFilePath = false\n    try {\n      await getFsImplementation().stat(`/${commandName}`)\n      isFilePath = true\n    } catch {\n      // Not a file path — treat as command name\n    }\n    if (looksLikeCommand(commandName) && !isFilePath) {\n      logEvent('tengu_input_slash_invalid', {\n        input:\n          commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      const unknownMessage = `Unknown skill: ${commandName}`\n      return {\n        messages: [\n          createSyntheticUserCaveatMessage(),\n          ...attachmentMessages,\n          createUserMessage({\n            content: prepareUserContent({\n              inputString: unknownMessage,\n              precedingInputBlocks,\n            }),\n          }),\n          // gh-32591: preserve args so the user can copy/resubmit without\n          // retyping. System warning is UI-only (filtered before API).\n          ...(parsedArgs\n            ? [\n                createSystemMessage(\n                  `Args from unknown skill: ${parsedArgs}`,\n                  'warning',\n                ),\n              ]\n            : []),\n        ],\n        shouldQuery: false,\n        resultText: unknownMessage,\n      }\n    }\n\n    const promptId = randomUUID()\n    setPromptId(promptId)\n    logEvent('tengu_input_prompt', {})\n    // Log user prompt event for OTLP\n    void logOTelEvent('user_prompt', {\n      prompt_length: String(inputString.length),\n      prompt: redactIfDisabled(inputString),\n      'prompt.id': promptId,\n    })\n    return {\n      messages: [\n        createUserMessage({\n          content: prepareUserContent({ inputString, precedingInputBlocks }),\n          uuid: uuid,\n        }),\n        ...attachmentMessages,\n      ],\n      shouldQuery: true,\n    }\n  }\n\n  // Track slash command usage for feature discovery\n\n  const {\n    messages: newMessages,\n    shouldQuery: messageShouldQuery,\n    allowedTools,\n    model,\n    effort,\n    command: returnedCommand,\n    resultText,\n    nextInput,\n    submitNextInput,\n  } = await getMessagesForSlashCommand(\n    commandName,\n    parsedArgs,\n    setToolJSX,\n    context,\n    precedingInputBlocks,\n    imageContentBlocks,\n    isAlreadyProcessing,\n    canUseTool,\n    uuid,\n  )\n\n  // Local slash commands that skip messages\n  if (newMessages.length === 0) {\n    const eventData: Record<string, boolean | number | undefined> = {\n      input:\n        sanitizedCommandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    }\n\n    // Add plugin metadata if this is a plugin command\n    if (returnedCommand.type === 'prompt' && returnedCommand.pluginInfo) {\n      const { pluginManifest, repository } = returnedCommand.pluginInfo\n      const { marketplace } = parsePluginIdentifier(repository)\n      const isOfficial = isOfficialMarketplaceName(marketplace)\n      // _PROTO_* routes to PII-tagged plugin_name/marketplace_name BQ columns\n      // (unredacted, all users); plugin_name/plugin_repository stay in\n      // additional_metadata as redacted variants for general-access dashboards.\n      eventData._PROTO_plugin_name =\n        pluginManifest.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED\n      if (marketplace) {\n        eventData._PROTO_marketplace_name =\n          marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED\n      }\n      eventData.plugin_repository = (\n        isOfficial ? repository : 'third-party'\n      ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n      eventData.plugin_name = (\n        isOfficial ? pluginManifest.name : 'third-party'\n      ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n      if (isOfficial && pluginManifest.version) {\n        eventData.plugin_version =\n          pluginManifest.version as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n      }\n      Object.assign(\n        eventData,\n        buildPluginCommandTelemetryFields(returnedCommand.pluginInfo),\n      )\n    }\n\n    logEvent('tengu_input_command', {\n      ...eventData,\n      invocation_trigger:\n        'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      ...(\"external\" === 'ant' && {\n        skill_name:\n          commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        ...(returnedCommand.type === 'prompt' && {\n          skill_source:\n            returnedCommand.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        }),\n        ...(returnedCommand.loadedFrom && {\n          skill_loaded_from:\n            returnedCommand.loadedFrom as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        }),\n        ...(returnedCommand.kind && {\n          skill_kind:\n            returnedCommand.kind as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n        }),\n      }),\n    })\n    return {\n      messages: [],\n      shouldQuery: false,\n\n      model,\n      nextInput,\n      submitNextInput,\n    }\n  }\n\n  // For invalid commands, preserve both the user message and error\n  if (\n    newMessages.length === 2 &&\n    newMessages[1]!.type === 'user' &&\n    typeof newMessages[1]!.message.content === 'string' &&\n    newMessages[1]!.message.content.startsWith('Unknown command:')\n  ) {\n    // Don't log as invalid if it looks like a common file path\n    const looksLikeFilePath =\n      inputString.startsWith('/var') ||\n      inputString.startsWith('/tmp') ||\n      inputString.startsWith('/private')\n\n    if (!looksLikeFilePath) {\n      logEvent('tengu_input_slash_invalid', {\n        input:\n          commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n    }\n\n    return {\n      messages: [createSyntheticUserCaveatMessage(), ...newMessages],\n      shouldQuery: messageShouldQuery,\n      allowedTools,\n\n      model,\n    }\n  }\n\n  // A valid command\n  const eventData: Record<string, boolean | number | undefined> = {\n    input:\n      sanitizedCommandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  }\n\n  // Add plugin metadata if this is a plugin command\n  if (returnedCommand.type === 'prompt' && returnedCommand.pluginInfo) {\n    const { pluginManifest, repository } = returnedCommand.pluginInfo\n    const { marketplace } = parsePluginIdentifier(repository)\n    const isOfficial = isOfficialMarketplaceName(marketplace)\n    eventData._PROTO_plugin_name =\n      pluginManifest.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED\n    if (marketplace) {\n      eventData._PROTO_marketplace_name =\n        marketplace as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED\n    }\n    eventData.plugin_repository = (\n      isOfficial ? repository : 'third-party'\n    ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n    eventData.plugin_name = (\n      isOfficial ? pluginManifest.name : 'third-party'\n    ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n    if (isOfficial && pluginManifest.version) {\n      eventData.plugin_version =\n        pluginManifest.version as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS\n    }\n    Object.assign(\n      eventData,\n      buildPluginCommandTelemetryFields(returnedCommand.pluginInfo),\n    )\n  }\n\n  logEvent('tengu_input_command', {\n    ...eventData,\n    invocation_trigger:\n      'user-slash' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    ...(\"external\" === 'ant' && {\n      skill_name:\n        commandName as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      ...(returnedCommand.type === 'prompt' && {\n        skill_source:\n          returnedCommand.source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      ...(returnedCommand.loadedFrom && {\n        skill_loaded_from:\n          returnedCommand.loadedFrom as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n      ...(returnedCommand.kind && {\n        skill_kind:\n          returnedCommand.kind as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      }),\n    }),\n  })\n\n  // Check if this is a compact result which handle their own synthetic caveat message ordering\n  const isCompactResult =\n    newMessages.length > 0 &&\n    newMessages[0] &&\n    isCompactBoundaryMessage(newMessages[0])\n\n  return {\n    messages:\n      messageShouldQuery ||\n      newMessages.every(isSystemLocalCommandMessage) ||\n      isCompactResult\n        ? newMessages\n        : [createSyntheticUserCaveatMessage(), ...newMessages],\n    shouldQuery: messageShouldQuery,\n    allowedTools,\n    model,\n    effort,\n    resultText,\n    nextInput,\n    submitNextInput,\n  }\n}\n\nasync function getMessagesForSlashCommand(\n  commandName: string,\n  args: string,\n  setToolJSX: SetToolJSXFn,\n  context: ProcessUserInputContext,\n  precedingInputBlocks: ContentBlockParam[],\n  imageContentBlocks: ContentBlockParam[],\n  _isAlreadyProcessing?: boolean,\n  canUseTool?: CanUseToolFn,\n  uuid?: string,\n): Promise<SlashCommandResult> {\n  const command = getCommand(commandName, context.options.commands)\n\n  // Track skill usage for ranking (only for prompt commands that are user-invocable)\n  if (command.type === 'prompt' && command.userInvocable !== false) {\n    recordSkillUsage(commandName)\n  }\n\n  // Check if the command is user-invocable\n  // Skills with userInvocable === false can only be invoked by the model via SkillTool\n  if (command.userInvocable === false) {\n    return {\n      messages: [\n        createUserMessage({\n          content: prepareUserContent({\n            inputString: `/${commandName}`,\n            precedingInputBlocks,\n          }),\n        }),\n        createUserMessage({\n          content: `This skill can only be invoked by Claude, not directly by users. Ask Claude to use the \"${commandName}\" skill for you.`,\n        }),\n      ],\n      shouldQuery: false,\n      command,\n    }\n  }\n\n  try {\n    switch (command.type) {\n      case 'local-jsx': {\n        return new Promise<SlashCommandResult>(resolve => {\n          let doneWasCalled = false\n          const onDone = (\n            result?: string,\n            options?: {\n              display?: CommandResultDisplay\n              shouldQuery?: boolean\n              metaMessages?: string[]\n              nextInput?: string\n              submitNextInput?: boolean\n            },\n          ) => {\n            doneWasCalled = true\n            // If display is 'skip', don't add any messages to the conversation\n            if (options?.display === 'skip') {\n              void resolve({\n                messages: [],\n                shouldQuery: false,\n                command,\n                nextInput: options?.nextInput,\n                submitNextInput: options?.submitNextInput,\n              })\n              return\n            }\n\n            // Meta messages are model-visible but hidden from the user\n            const metaMessages = (options?.metaMessages ?? []).map(\n              (content: string) => createUserMessage({ content, isMeta: true }),\n            )\n\n            // In fullscreen the command just showed as a centered modal\n            // pane — the transient notification is enough feedback. The\n            // \"❯ /config\" + \"⎿ dismissed\" transcript entries are\n            // type:system subtype:local_command (user-visible but NOT sent\n            // to the model), so skipping them doesn't affect model context.\n            // Outside fullscreen keep them so scrollback shows what ran.\n            // Only skip \"<Name> dismissed\" modal-close notifications —\n            // commands that early-exit before showing a modal (/ultraplan\n            // usage, /rename, /proactive) use display:system for actual\n            // output that must reach the transcript.\n            const skipTranscript =\n              isFullscreenEnvEnabled() &&\n              typeof result === 'string' &&\n              result.endsWith(' dismissed')\n\n            void resolve({\n              messages:\n                options?.display === 'system'\n                  ? skipTranscript\n                    ? metaMessages\n                    : [\n                        createCommandInputMessage(\n                          formatCommandInput(command, args),\n                        ),\n                        createCommandInputMessage(\n                          `<local-command-stdout>${result}</local-command-stdout>`,\n                        ),\n                        ...metaMessages,\n                      ]\n                  : [\n                      createUserMessage({\n                        content: prepareUserContent({\n                          inputString: formatCommandInput(command, args),\n                          precedingInputBlocks,\n                        }),\n                      }),\n                      result\n                        ? createUserMessage({\n                            content: `<local-command-stdout>${result}</local-command-stdout>`,\n                          })\n                        : createUserMessage({\n                            content: `<local-command-stdout>${NO_CONTENT_MESSAGE}</local-command-stdout>`,\n                          }),\n                      ...metaMessages,\n                    ],\n              shouldQuery: options?.shouldQuery ?? false,\n              command,\n              nextInput: options?.nextInput,\n              submitNextInput: options?.submitNextInput,\n            })\n          }\n\n          void command\n            .load()\n            .then(mod => mod.call(onDone, { ...context, canUseTool }, args))\n            .then(jsx => {\n              if (jsx == null) return\n              if (context.options.isNonInteractiveSession) {\n                void resolve({\n                  messages: [],\n                  shouldQuery: false,\n                  command,\n                })\n                return\n              }\n              // Guard: if onDone fired during mod.call() (early-exit path\n              // that calls onDone then returns JSX), skip setToolJSX. This\n              // chain is fire-and-forget — the outer Promise resolves when\n              // onDone is called, so executeUserInput may have already run\n              // its setToolJSX({clearLocalJSX: true}) before we get here.\n              // Setting isLocalJSXCommand after clear leaves it stuck true,\n              // blocking useQueueProcessor and TextInput focus.\n              if (doneWasCalled) return\n              setToolJSX({\n                jsx,\n                shouldHidePromptInput: true,\n                showSpinner: false,\n                isLocalJSXCommand: true,\n                isImmediate: command.immediate === true,\n              })\n            })\n            .catch(e => {\n              // If load()/call() throws and onDone never fired, the outer\n              // Promise hangs forever, leaving queryGuard stuck in\n              // 'dispatching' and deadlocking the queue processor.\n              logError(e)\n              if (doneWasCalled) return\n              doneWasCalled = true\n              setToolJSX({\n                jsx: null,\n                shouldHidePromptInput: false,\n                clearLocalJSX: true,\n              })\n              void resolve({ messages: [], shouldQuery: false, command })\n            })\n        })\n      }\n      case 'local': {\n        const displayArgs = command.isSensitive && args.trim() ? '***' : args\n        const userMessage = createUserMessage({\n          content: prepareUserContent({\n            inputString: formatCommandInput(command, displayArgs),\n            precedingInputBlocks,\n          }),\n        })\n\n        try {\n          const syntheticCaveatMessage = createSyntheticUserCaveatMessage()\n          const mod = await command.load()\n          const result = await mod.call(args, context)\n\n          if (result.type === 'skip') {\n            return {\n              messages: [],\n              shouldQuery: false,\n              command,\n            }\n          }\n\n          // Use discriminated union to handle different result types\n          if (result.type === 'compact') {\n            // Append slash command messages to messagesToKeep so that\n            // attachments and hookResults come after user messages\n            const slashCommandMessages = [\n              syntheticCaveatMessage,\n              userMessage,\n              ...(result.displayText\n                ? [\n                    createUserMessage({\n                      content: `<local-command-stdout>${result.displayText}</local-command-stdout>`,\n                      // --resume looks at latest timestamp message to determine which message to resume from\n                      // This is a perf optimization to avoid having to recaculcate the leaf node every time\n                      // Since we're creating a bunch of synthetic messages for compact, it's important to set\n                      // the timestamp of the last message to be slightly after the current time\n                      // This is mostly important for sdk / -p mode\n                      timestamp: new Date(Date.now() + 100).toISOString(),\n                    }),\n                  ]\n                : []),\n            ]\n            const compactionResultWithSlashMessages = {\n              ...result.compactionResult,\n              messagesToKeep: [\n                ...(result.compactionResult.messagesToKeep ?? []),\n                ...slashCommandMessages,\n              ],\n            }\n            // Reset microcompact state since full compact replaces all\n            // messages — old tool IDs are no longer relevant. Budget state\n            // (on toolUseContext) needs no reset: stale entries are inert\n            // (UUIDs never repeat, so they're never looked up).\n            resetMicrocompactState()\n            return {\n              messages: buildPostCompactMessages(\n                compactionResultWithSlashMessages,\n              ),\n              shouldQuery: false,\n              command,\n            }\n          }\n\n          // Text result — use system message so it doesn't render as a user bubble\n          return {\n            messages: [\n              userMessage,\n              createCommandInputMessage(\n                `<local-command-stdout>${result.value}</local-command-stdout>`,\n              ),\n            ],\n            shouldQuery: false,\n            command,\n            resultText: result.value,\n          }\n        } catch (e) {\n          logError(e)\n          return {\n            messages: [\n              userMessage,\n              createCommandInputMessage(\n                `<local-command-stderr>${String(e)}</local-command-stderr>`,\n              ),\n            ],\n            shouldQuery: false,\n            command,\n          }\n        }\n      }\n      case 'prompt': {\n        try {\n          // Check if command should run as forked sub-agent\n          if (command.context === 'fork') {\n            return await executeForkedSlashCommand(\n              command,\n              args,\n              context,\n              precedingInputBlocks,\n              setToolJSX,\n              canUseTool ?? hasPermissionsToUseTool,\n            )\n          }\n\n          return await getMessagesForPromptSlashCommand(\n            command,\n            args,\n            context,\n            precedingInputBlocks,\n            imageContentBlocks,\n            uuid,\n          )\n        } catch (e) {\n          // Handle abort errors specially to show proper \"Interrupted\" message\n          if (e instanceof AbortError) {\n            return {\n              messages: [\n                createUserMessage({\n                  content: prepareUserContent({\n                    inputString: formatCommandInput(command, args),\n                    precedingInputBlocks,\n                  }),\n                }),\n                createUserInterruptionMessage({ toolUse: false }),\n              ],\n              shouldQuery: false,\n              command,\n            }\n          }\n          return {\n            messages: [\n              createUserMessage({\n                content: prepareUserContent({\n                  inputString: formatCommandInput(command, args),\n                  precedingInputBlocks,\n                }),\n              }),\n              createUserMessage({\n                content: `<local-command-stderr>${String(e)}</local-command-stderr>`,\n              }),\n            ],\n            shouldQuery: false,\n            command,\n          }\n        }\n      }\n    }\n  } catch (e) {\n    if (e instanceof MalformedCommandError) {\n      return {\n        messages: [\n          createUserMessage({\n            content: prepareUserContent({\n              inputString: e.message,\n              precedingInputBlocks,\n            }),\n          }),\n        ],\n        shouldQuery: false,\n        command,\n      }\n    }\n    throw e\n  }\n}\n\nfunction formatCommandInput(command: CommandBase, args: string): string {\n  return formatCommandInputTags(getCommandName(command), args)\n}\n\n/**\n * Formats the metadata for a skill loading message.\n * Used by the Skill tool and for subagent skill preloading.\n */\nexport function formatSkillLoadingMetadata(\n  skillName: string,\n  _progressMessage: string = 'loading',\n): string {\n  // Use skill name only - UserCommandMessage renders as \"Skill(name)\"\n  return [\n    `<${COMMAND_MESSAGE_TAG}>${skillName}</${COMMAND_MESSAGE_TAG}>`,\n    `<${COMMAND_NAME_TAG}>${skillName}</${COMMAND_NAME_TAG}>`,\n    `<skill-format>true</skill-format>`,\n  ].join('\\n')\n}\n\n/**\n * Formats the metadata for a slash command loading message.\n */\nfunction formatSlashCommandLoadingMetadata(\n  commandName: string,\n  args?: string,\n): string {\n  return [\n    `<${COMMAND_MESSAGE_TAG}>${commandName}</${COMMAND_MESSAGE_TAG}>`,\n    `<${COMMAND_NAME_TAG}>/${commandName}</${COMMAND_NAME_TAG}>`,\n    args ? `<command-args>${args}</command-args>` : null,\n  ]\n    .filter(Boolean)\n    .join('\\n')\n}\n\n/**\n * Formats the loading metadata for a command (skill or slash command).\n * User-invocable skills use slash command format (/name), while model-only\n * skills use the skill format (\"The X skill is running\").\n */\nfunction formatCommandLoadingMetadata(\n  command: CommandBase & PromptCommand,\n  args?: string,\n): string {\n  // Use command.name (the qualified name including plugin prefix, e.g.\n  // \"product-management:feature-spec\") instead of userFacingName() which may\n  // strip the plugin prefix via displayName fallback.\n  // User-invocable skills should show as /command-name like regular slash commands\n  if (command.userInvocable !== false) {\n    return formatSlashCommandLoadingMetadata(command.name, args)\n  }\n  // Model-only skills (userInvocable: false) show as \"The X skill is running\"\n  if (\n    command.loadedFrom === 'skills' ||\n    command.loadedFrom === 'plugin' ||\n    command.loadedFrom === 'mcp'\n  ) {\n    return formatSkillLoadingMetadata(command.name, command.progressMessage)\n  }\n  return formatSlashCommandLoadingMetadata(command.name, args)\n}\n\nexport async function processPromptSlashCommand(\n  commandName: string,\n  args: string,\n  commands: Command[],\n  context: ToolUseContext,\n  imageContentBlocks: ContentBlockParam[] = [],\n): Promise<SlashCommandResult> {\n  const command = findCommand(commandName, commands)\n  if (!command) {\n    throw new MalformedCommandError(`Unknown command: ${commandName}`)\n  }\n  if (command.type !== 'prompt') {\n    throw new Error(\n      `Unexpected ${command.type} command. Expected 'prompt' command. Use /${commandName} directly in the main conversation.`,\n    )\n  }\n  return getMessagesForPromptSlashCommand(\n    command,\n    args,\n    context,\n    [],\n    imageContentBlocks,\n  )\n}\n\nasync function getMessagesForPromptSlashCommand(\n  command: CommandBase & PromptCommand,\n  args: string,\n  context: ToolUseContext,\n  precedingInputBlocks: ContentBlockParam[] = [],\n  imageContentBlocks: ContentBlockParam[] = [],\n  uuid?: string,\n): Promise<SlashCommandResult> {\n  // In coordinator mode (main thread only), skip loading the full skill content\n  // and permissions. The coordinator only has Agent + TaskStop tools, so the\n  // skill content and allowedTools are useless. Instead, send a brief summary\n  // telling the coordinator how to delegate this skill to a worker.\n  //\n  // Workers run in-process and inherit CLAUDE_CODE_COORDINATOR_MODE from the\n  // parent env, so we also check !context.agentId: agentId is only set for\n  // subagents, letting workers fall through to getPromptForCommand and receive\n  // the real skill content when they invoke the Skill tool.\n  if (\n    feature('COORDINATOR_MODE') &&\n    isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) &&\n    !context.agentId\n  ) {\n    const metadata = formatCommandLoadingMetadata(command, args)\n    const parts: string[] = [\n      `Skill \"/${command.name}\" is available for workers.`,\n    ]\n    if (command.description) {\n      parts.push(`Description: ${command.description}`)\n    }\n    if (command.whenToUse) {\n      parts.push(`When to use: ${command.whenToUse}`)\n    }\n    const skillAllowedTools = command.allowedTools ?? []\n    if (skillAllowedTools.length > 0) {\n      parts.push(\n        `This skill grants workers additional tool permissions: ${skillAllowedTools.join(', ')}`,\n      )\n    }\n    parts.push(\n      `\\nInstruct a worker to use this skill by including \"Use the /${command.name} skill\" in your Agent prompt. The worker has access to the Skill tool and will receive the skill's content and permissions when it invokes it.`,\n    )\n    const summaryContent: ContentBlockParam[] = [\n      { type: 'text', text: parts.join('\\n') },\n    ]\n    return {\n      messages: [\n        createUserMessage({ content: metadata, uuid }),\n        createUserMessage({ content: summaryContent, isMeta: true }),\n      ],\n      shouldQuery: true,\n      model: command.model,\n      effort: command.effort,\n      command,\n    }\n  }\n\n  const result = await command.getPromptForCommand(args, context)\n\n  // Register skill hooks if defined. Under [\"hooks\"]-only (skills not locked),\n  // user skills still load and reach this point — block hook REGISTRATION here\n  // where source is known. Mirrors the agent frontmatter gate in runAgent.ts.\n  const hooksAllowedForThisSkill =\n    !isRestrictedToPluginOnly('hooks') || isSourceAdminTrusted(command.source)\n  if (command.hooks && hooksAllowedForThisSkill) {\n    const sessionId = getSessionId()\n    registerSkillHooks(\n      context.setAppState,\n      sessionId,\n      command.hooks,\n      command.name,\n      command.type === 'prompt' ? command.skillRoot : undefined,\n    )\n  }\n\n  // Record skill invocation for compaction preservation, scoped by agent context.\n  // Skills are tagged with their agentId so only skills belonging to the current\n  // agent are restored during compaction (preventing cross-agent leaks).\n  const skillPath = command.source\n    ? `${command.source}:${command.name}`\n    : command.name\n  const skillContent = result\n    .filter((b): b is TextBlockParam => b.type === 'text')\n    .map(b => b.text)\n    .join('\\n\\n')\n  addInvokedSkill(\n    command.name,\n    skillPath,\n    skillContent,\n    getAgentContext()?.agentId ?? null,\n  )\n\n  const metadata = formatCommandLoadingMetadata(command, args)\n\n  const additionalAllowedTools = parseToolListFromCLI(\n    command.allowedTools ?? [],\n  )\n\n  // Create content for the main message, including any pasted images\n  const mainMessageContent: ContentBlockParam[] =\n    imageContentBlocks.length > 0 || precedingInputBlocks.length > 0\n      ? [...imageContentBlocks, ...precedingInputBlocks, ...result]\n      : result\n\n  // Extract attachments from command arguments (@-mentions, MCP resources,\n  // agent mentions in SKILL.md). skipSkillDiscovery prevents the SKILL.md\n  // content itself from triggering discovery — it's meta-content, not user\n  // intent, and a large SKILL.md (e.g. 110KB) would fire chunked AKI queries\n  // adding seconds of latency to every skill invocation.\n  const attachmentMessages = await toArray(\n    getAttachmentMessages(\n      result\n        .filter((block): block is TextBlockParam => block.type === 'text')\n        .map(block => block.text)\n        .join(' '),\n      context,\n      null,\n      [], // queuedCommands - handled by query.ts for mid-turn attachments\n      context.messages,\n      'repl_main_thread',\n      { skipSkillDiscovery: true },\n    ),\n  )\n\n  const messages = [\n    createUserMessage({\n      content: metadata,\n      uuid,\n    }),\n    createUserMessage({\n      content: mainMessageContent,\n      isMeta: true,\n    }),\n    ...attachmentMessages,\n    createAttachmentMessage({\n      type: 'command_permissions',\n      allowedTools: additionalAllowedTools,\n      model: command.model,\n    }),\n  ]\n\n  return {\n    messages,\n    shouldQuery: true,\n    allowedTools: additionalAllowedTools,\n    model: command.model,\n    effort: command.effort,\n    command,\n  }\n}\n"],"mappings":"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","ignoreList":[]}