@cjhyy/code-shell 0.2.0 → 0.3.0

package/dist/settings/schema.d.ts

@@ -186,21 +186,21 @@ export declare const SettingsSchema: z.ZodObject<{
             argsPattern?: Record<string, string> | undefined;
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
+        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
         rules: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[];
-        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
     }, {
+        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
         rules?: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[] | undefined;
-        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
     }>>;
     context: z.ZodDefault<z.ZodObject<{
         maxTokens: z.ZodDefault<z.ZodNumber>;
@@ -345,6 +345,35 @@ export declare const SettingsSchema: z.ZodObject<{
         deniedReads?: string[] | undefined;
         network?: "allow" | "deny" | undefined;
     }>>;
+    /**
+     * Shell-hook configuration. Each entry binds a HookEventName to a
+     * shell command; the command receives ctx JSON on stdin and returns
+     * a HookResult JSON on stdout (or exit 2 = deny with stderr as
+     * reason). See src/hooks/shell-runner.ts for the wire protocol.
+     *
+     * The event field is loose-typed here (z.string()) because adding
+     * new lifecycle events shouldn't force a schema bump; the runner
+     * silently ignores entries whose event isn't registered.
+     */
+    hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        command: z.ZodString;
+        matcher: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }>, "many">>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     agent: z.ZodDefault<z.ZodObject<{
         preset: z.ZodDefault<z.ZodString>;
@@ -529,21 +558,21 @@ export declare const SettingsSchema: z.ZodObject<{
             argsPattern?: Record<string, string> | undefined;
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
+        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
         rules: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[];
-        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
     }, {
+        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
         rules?: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[] | undefined;
-        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
     }>>;
     context: z.ZodDefault<z.ZodObject<{
         maxTokens: z.ZodDefault<z.ZodNumber>;
@@ -688,6 +717,35 @@ export declare const SettingsSchema: z.ZodObject<{
         deniedReads?: string[] | undefined;
         network?: "allow" | "deny" | undefined;
     }>>;
+    /**
+     * Shell-hook configuration. Each entry binds a HookEventName to a
+     * shell command; the command receives ctx JSON on stdin and returns
+     * a HookResult JSON on stdout (or exit 2 = deny with stderr as
+     * reason). See src/hooks/shell-runner.ts for the wire protocol.
+     *
+     * The event field is loose-typed here (z.string()) because adding
+     * new lifecycle events shouldn't force a schema bump; the runner
+     * silently ignores entries whose event isn't registered.
+     */
+    hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        command: z.ZodString;
+        matcher: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }>, "many">>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     agent: z.ZodDefault<z.ZodObject<{
         preset: z.ZodDefault<z.ZodString>;
@@ -872,21 +930,21 @@ export declare const SettingsSchema: z.ZodObject<{
             argsPattern?: Record<string, string> | undefined;
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
+        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
         rules: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[];
-        defaultMode: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan";
     }, {
+        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
         rules?: {
             tool: string;
             decision: "allow" | "deny" | "ask";
             reason?: string | undefined;
             argsPattern?: Record<string, string> | undefined;
         }[] | undefined;
-        defaultMode?: "default" | "acceptEdits" | "dontAsk" | "bypassPermissions" | "auto" | "plan" | undefined;
     }>>;
     context: z.ZodDefault<z.ZodObject<{
         maxTokens: z.ZodDefault<z.ZodNumber>;
@@ -1031,6 +1089,35 @@ export declare const SettingsSchema: z.ZodObject<{
         deniedReads?: string[] | undefined;
         network?: "allow" | "deny" | undefined;
     }>>;
+    /**
+     * Shell-hook configuration. Each entry binds a HookEventName to a
+     * shell command; the command receives ctx JSON on stdin and returns
+     * a HookResult JSON on stdout (or exit 2 = deny with stderr as
+     * reason). See src/hooks/shell-runner.ts for the wire protocol.
+     *
+     * The event field is loose-typed here (z.string()) because adding
+     * new lifecycle events shouldn't force a schema bump; the runner
+     * silently ignores entries whose event isn't registered.
+     */
+    hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        command: z.ZodString;
+        matcher: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }, {
+        command: string;
+        event: string;
+        cwd?: string | undefined;
+        matcher?: string | undefined;
+        timeout_ms?: number | undefined;
+    }>, "many">>;
 }, z.ZodTypeAny, "passthrough">>;
 export type ValidatedSettings = z.infer<typeof SettingsSchema>;
 export declare function validateSettings(raw: unknown): ValidatedSettings;

package/dist/skills/frontmatter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Frontmatter parser for SKILL.md files. Byte-compatible with Claude Code's
+ * `utils/frontmatterParser.ts` so community skill repositories can be reused
+ * without modification.
+ */
+export declare const FRONTMATTER_REGEX: RegExp;
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export declare function parseFrontmatter(raw: string): ParsedFrontmatter;
+export declare function quoteProblematicValues(frontmatterText: string): string;
+export declare function coerceDescription(value: unknown): string;

package/dist/skills/index.d.ts

@@ -1,7 +1,7 @@
 /**
- * Skills system — scan, match, and inject skills into prompts.
+ * Skills barrel. Phase A keeps the scanner only. Listing rendering lives in
+ * src/tool-system/builtin/skill-prompt.ts so the prompt-formatting layer can
+ * grow token-budget logic later without churn here.
  */
-export { scanSkills } from "./scanner.js";
+export { scanSkills, invalidateSkillCache } from "./scanner.js";
 export type { SkillDefinition } from "./scanner.js";
-export { matchSkillsByInput, matchSkillsByTool, buildSkillListing } from "./matcher.js";
-export type { MatchResult } from "./matcher.js";

package/dist/skills/scanner.d.ts

@@ -1,30 +1,20 @@
 /**
- * Skills scanner — discovers SKILL.md files and parses their metadata.
- *
- * Skills are markdown files with YAML frontmatter:
- * ---
- * name: skill-name
- * description: what it does
- * triggers:
- *   keywords: [word1, word2]
- *   tools: [ToolName]
- * when_to_use: description of when to invoke
- * ---
- * <skill content>
+ * Skill scanner — discovers <base>/<name>/SKILL.md files from project + user
+ * directories AND from installed plugins. Mirrors Claude Code's
+ * `loadSkillsFromSkillsDir` (skills/loadSkillsDir.ts:407) plus plugin
+ * integration (utils/plugins/pluginLoader.ts).
  */
 export interface SkillDefinition {
+    /** Directory name; authoritative regardless of frontmatter.name. */
     name: string;
+    /** From frontmatter.description, coerced. Empty string if absent or invalid. */
     description: string;
-    triggers: {
-        keywords?: string[];
-        tools?: string[];
-        intents?: string[];
-    };
-    whenToUse: string;
+    /** SKILL.md body with frontmatter stripped. */
     content: string;
+    /** Absolute path to the SKILL.md file. */
     filePath: string;
+    /** Where the skill was loaded from. */
+    source: "project" | "user" | "plugin";
 }
-/**
- * Scan for SKILL.md files in standard locations.
- */
 export declare function scanSkills(cwd: string): SkillDefinition[];
+export declare function invalidateSkillCache(): void;

package/dist/tool-summary-HJX6RHG4.js

@@ -0,0 +1,2 @@
+import {d as d$1}from'./chunk-DI26OUIU.js';import {h,a}from'./chunk-3QP5BQ3L.js';h();var p='Generate a very brief (under 40 chars) summary of what these tools did. Use past tense, commit-subject style. Examples: "Read 3 config files", "Fixed import in auth.ts", "Searched for API endpoints". Respond with ONLY the summary text, nothing else.';async function d(r,a,l){if(r.length===0)return null;try{let e=[];for(let t=0;t<r.length;t++){let s=r[t],o=a[t],u=JSON.stringify(s.args).slice(0,200),c=(o?.result??o?.error??"").slice(0,300);e.push(`Tool: ${s.toolName}(${u}) \u2192 ${c}`);}return (await l(p,e.join(`
+`)))?.trim()||null}catch(e){return d$1.warn("tool_summary.failed",{error:e.message}),null}}a(d,"generateToolUseSummary");export{d as generateToolUseSummary};

package/dist/tool-system/builtin/agent-notifications.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Background-agent completion notification queue.
+ *
+ * Mirrors Claude Code's `commandQueue` with `mode: 'task-notification'`. A
+ * background sub-agent that finishes (completed | failed) enqueues an item
+ * here; the UI layer subscribes and, when the main agent is idle, drains
+ * the queue and submits the formatted XML as a new user turn so the LLM
+ * sees the result. Cancellation does NOT enqueue (user explicitly stopped
+ * the agent; no follow-up needed).
+ *
+ * The result text lives only in this queue + the eventual user message —
+ * not in `asyncAgentRegistry`. Registry stays metadata-only.
+ *
+ * Process-local singleton; same lifetime contract as `asyncAgentRegistry`.
+ */
+export type NotificationItem = {
+    agentId: string;
+    name?: string;
+    description: string;
+    status: "completed" | "failed";
+    /** Final assistant text (completed only). */
+    finalText?: string;
+    /** Error message (failed only). */
+    error?: string;
+    enqueuedAt: number;
+};
+type Listener = () => void;
+declare class NotificationQueue {
+    private items;
+    private listeners;
+    enqueue(item: NotificationItem): void;
+    subscribe: (cb: Listener) => (() => void);
+    getSnapshot: () => NotificationItem[];
+    /** Atomic: returns all items and clears in one shot. */
+    drainAll(): NotificationItem[];
+    reset(): void;
+    private notify;
+}
+export declare const notificationQueue: NotificationQueue;
+/**
+ * Render a batch of completion notifications as the XML user-message
+ * body that the main agent's LLM will see. Format is stable — main
+ * agent prompts can rely on the `<background-agents-completed>` root
+ * tag as a signal that this turn is a system-injected notification,
+ * not a real user message.
+ */
+export declare function buildNotificationMessage(items: NotificationItem[]): string;
+/**
+ * One-line-per-agent human summary for the chat feed. The full result
+ * body goes to the LLM via buildNotificationMessage; the user sees only
+ * this terse marker plus an optional inline error preview, and can
+ * switch to the sub-agent's dock view if they want details.
+ */
+export declare function buildNotificationSummary(items: NotificationItem[]): string;
+export {};

package/dist/tool-system/builtin/agent-registry.d.ts

@@ -12,23 +12,54 @@
  * RunManager, not here.
  */
 export type AsyncAgentStatus = "running" | "completed" | "failed" | "cancelled";
+/**
+ * Minimal structural shape for an entry in an agent's transcript. We avoid
+ * importing the UI's `ChatEntry` here to prevent a tool-system → ui import
+ * direction. Consumers (the UI dock) widen this type via `as ChatEntry[]`
+ * at their boundary.
+ */
+export interface AgentTranscriptEntry {
+    id: string;
+    type: string;
+    [key: string]: unknown;
+}
 export interface AsyncAgentEntry {
     agentId: string;
+    /** Short kind label shown in the dock (e.g. "Explore", "Plan"). */
+    name?: string;
     description: string;
     status: AsyncAgentStatus;
     startedAt: number;
     finishedAt?: number;
-    result?: string;
-    error?: string;
+    /** finishedAt + 30_000. Dock filters rows past this. */
+    finishedFadeAt?: number;
     abort: () => void;
+    /** Stream events recorded by run_in_background agents for UI view-switching. */
+    transcript?: AgentTranscriptEntry[];
 }
 declare class AsyncAgentRegistry {
     private agents;
+    private listeners;
+    private snapshot;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => AsyncAgentEntry[];
+    hasRunning: () => boolean;
+    private notify;
     register(entry: AsyncAgentEntry): void;
+    appendToTranscript(agentId: string, entry: AgentTranscriptEntry): void;
+    /**
+     * Re-emit the registry change signal after callers mutate an agent's
+     * transcript array in place (patching or filtering entries). Required
+     * because `notify` rebuilds the snapshot and tells React subscribers to
+     * re-read.
+     */
+    touchTranscript(agentId: string): void;
     get(agentId: string): AsyncAgentEntry | undefined;
     list(): AsyncAgentEntry[];
-    markCompleted(agentId: string, result: string): void;
-    markFailed(agentId: string, error: string): void;
+    private markFinished;
+    markCompleted(agentId: string): void;
+    markFailed(agentId: string): void;
+    markCancelled(agentId: string): void;
     cancel(agentId: string): boolean;
     reset(): void;
 }

package/dist/tool-system/builtin/agent-transcript-translator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Translate child Engine StreamEvents into ChatEntry-shaped objects so the
+ * AgentDock detail view (which reuses App.renderEntry) can show a sub-agent's
+ * conversation in the same visual language as the main feed.
+ *
+ * The transcript is the canonical record for one background sub-agent. State
+ * (current thinking entry, currently-streaming assistant_text, in-flight
+ * tool_start map) lives in a per-agent translator. Each translator instance
+ * appends ChatEntry-shaped objects via `append` and mutates them via `update`,
+ * mirroring how App.tsx's handleStreamEvent talks to chatStore but isolated to
+ * a single agent's transcript.
+ *
+ * The output shapes intentionally match `src/ui/store.ts#ChatEntryData` so the
+ * existing renderEntry switch picks them up without code changes.
+ */
+import type { StreamEvent } from "../../types.js";
+/**
+ * Create a transcript translator scoped to one background sub-agent. Returned
+ * function is a StreamCallback drop-in: feed it the child Engine's events and
+ * it maintains the agent's transcript in `asyncAgentRegistry`.
+ */
+export declare function createTranscriptTranslator(agentId: string): (event: StreamEvent) => void;

package/dist/tool-system/builtin/skill-prompt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Skill listing renderer for the system prompt. Mirrors Claude Code's split
+ * between scan/data layer (skills/scanner.ts) and render layer (this file),
+ * matching tools/SkillTool/prompt.ts in CC.
+ */
+import type { SkillDefinition } from "../../skills/scanner.js";
+export declare function buildSkillListing(skills: SkillDefinition[]): string;

package/dist/tool-system/builtin/skill.d.ts

@@ -1,5 +1,7 @@
 /**
- * SkillTool — invoke custom skills/plugins by name.
+ * SkillTool — load a skill's SKILL.md body and return it as the tool result.
+ * The scanner is the single source of truth; this tool never reads the disk
+ * directly. Matches Claude Code's tools/SkillTool/SkillTool.ts pattern.
  */
 import type { ToolDefinition } from "../../types.js";
 export declare const skillToolDef: ToolDefinition;

package/dist/tool-system/context.d.ts

@@ -17,6 +17,7 @@ import type { ModelPool } from "../llm/model-pool.js";
 import type { ToolRegistry } from "./registry.js";
 import type { AgentPresetName } from "../preset/index.js";
 import type { SandboxBackend } from "./sandbox/index.js";
+import type { HookRegistry } from "../hooks/registry.js";
 /** One choice in a multiple-choice AskUserQuestion. */
 export interface AskUserChoice {
     label: string;
@@ -55,6 +56,14 @@ export interface SubAgentSpawnRequest {
     prompt: string;
     maxTurns: number;
     signal: AbortSignal;
+    /**
+     * Per-call override for where the spawned child Engine's stream events go.
+     * Defaults to `spawner.parentStream` (the parent UI). Background sub-agents
+     * pass a transcriptSink here so per-event detail is captured in the agent's
+     * transcript instead of leaking into the main feed; the main feed still
+     * gets `agent_start` / `agent_end` markers via `spawner.parentStream`.
+     */
+    streamOverride?: StreamCallback;
 }
 export interface SubAgentSpawner {
     /** Run a sub-agent synchronously and return its text output. */
@@ -87,6 +96,13 @@ export interface ToolContext {
     askUser?: AskUserFn;
     /** Sub-agent spawner (Agent tool). Undefined → Agent tool unavailable. */
     subAgentSpawner?: SubAgentSpawner;
+    /**
+     * True when this Engine is itself a sub-agent. Set from EngineConfig.
+     * The Agent tool refuses to spawn when this is true — runtime check
+     * layered on top of the tool-list strip in Engine.spawn so a registry
+     * regression can't leak nested spawns.
+     */
+    isSubAgent?: boolean;
     /**
      * Active sandbox backend for the Bash tool. Undefined falls back to "off"
      * (plain spawn). Headless runs default to an OS-level sandbox; the REPL
@@ -95,6 +111,13 @@ export interface ToolContext {
     sandbox?: SandboxBackend;
     /** Optional cancellation signal for the whole turn. */
     signal?: AbortSignal;
+    /**
+     * Engine-owned HookRegistry. Tools that emit lifecycle hooks
+     * (notification, file_changed for non-Write/Edit paths, custom
+     * tool-defined events) use this. Undefined for legacy callers /
+     * standalone tests; tools must tolerate absence.
+     */
+    hooks?: HookRegistry;
 }
 /**
  * Per-Engine container that produces a fresh ToolContext on demand.

package/dist/tool-system/executor.d.ts

@@ -38,7 +38,7 @@ export declare class ToolExecutor {
     setLogger(log: Logger): void;
     /** Check if a tool is safe for concurrent execution (read-only). */
     isConcurrencySafe(toolName: string): boolean;
-    executeSingle(call: ToolCall): Promise<ToolResult>;
+    executeSingle(callIn: ToolCall): Promise<ToolResult>;
     private isReadOnlyBashCommand;
     executeAll(calls: ToolCall[]): Promise<ToolResult[]>;
     /**

package/dist/tool-system/permission.d.ts

@@ -88,7 +88,7 @@ export declare class PermissionClassifier {
     reconfigure(mode: PermissionMode, approvalBackend: ApprovalBackend, rules?: PermissionRule[]): void;
     getMode(): PermissionMode;
     classify(toolName: string, args: Record<string, unknown>): PermissionDecision;
-    handleAsk(toolName: string, args: Record<string, unknown>): Promise<boolean>;
+    handleAsk(toolName: string, args: Record<string, unknown>, reason?: string): Promise<boolean>;
     /** Get denial warning message if the model keeps getting denied. */
     getDenialWarning(toolName: string): string | undefined;
     private matchesRule;

package/dist/types.d.ts

@@ -217,11 +217,14 @@ export type StreamEvent = {
 } | {
     type: "agent_start";
     agentId: string;
+    name?: string;
     description: string;
 } | {
     type: "agent_end";
     agentId: string;
+    name?: string;
     description: string;
+    text?: string;
     error?: string;
 } | {
     type: "tool_summary";
@@ -288,6 +291,32 @@ export interface MCPServerConfig {
     transport?: MCPTransport;
     headers?: Record<string, string>;
 }
+/**
+ * Shell-hook configuration entry from settings.json. Each entry binds
+ * a hook event to a shell command. The command runs as a child process
+ * on every emit (filtered by `matcher` when present), receives ctx
+ * JSON on stdin, and returns a HookResult JSON on stdout. See
+ * src/hooks/shell-runner.ts for the protocol spec.
+ */
+export interface SettingsHookConfig {
+    event: string;
+    command: string;
+    /**
+     * Optional regex (matched with new RegExp(matcher).test(toolName)) to
+     * filter which tools fire this hook. Currently honored for
+     * pre_tool_use / post_tool_use / on_tool_start / on_tool_end /
+     * on_permission_check / file_changed. Ignored for events without a
+     * meaningful toolName (session/turn/prompt/notification/compact).
+     */
+    matcher?: string;
+    /** Per-hook timeout in milliseconds. Defaults to 60_000. */
+    timeout_ms?: number;
+    /**
+     * Optional working directory for the spawned command. Defaults to
+     * Engine.cwd. Useful for hooks that need to run in a sibling repo.
+     */
+    cwd?: string;
+}
 export interface Settings {
     model: {
         provider: string;
@@ -318,4 +347,10 @@ export interface Settings {
     output: {
         format: "text" | "json" | "jsonl" | "stream-json";
     };
+    /**
+     * Optional shell-hook entries. Engine reads on construction and
+     * registers a wrapper handler per entry that spawns the command and
+     * parses the HookResult. Empty / missing = no shell hooks.
+     */
+    hooks?: SettingsHookConfig[];
 }

package/dist/ui/components/AgentBlock.d.ts

@@ -11,17 +11,20 @@
  */
 import React from "react";
 interface AgentBlockStartProps {
+    name?: string;
     description: string;
     running?: boolean;
     isLast?: boolean;
 }
-export declare function AgentBlockStart({ description, running, isLast }: AgentBlockStartProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentBlockStart({ name, description, running, isLast }: AgentBlockStartProps): import("react/jsx-runtime").JSX.Element;
 interface AgentBlockEndProps {
+    name?: string;
     description: string;
+    text?: string;
     error?: string;
     isLast?: boolean;
 }
-export declare function AgentBlockEnd({ description, error, isLast }: AgentBlockEndProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentBlockEnd({ name, description, text, error, isLast }: AgentBlockEndProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Tree line prefix for nested content under an agent.
  */

package/dist/ui/components/AgentDock.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+import { type AsyncAgentEntry } from "../../tool-system/builtin/agent-registry.js";
+export declare const MAX_VISIBLE = 5;
+export type DockViewMode = {
+    kind: "main";
+} | {
+    kind: "agent";
+    agentId: string;
+};
+export interface AgentDockProps {
+    viewMode: DockViewMode;
+    /** null = dock is not the keyboard target; integer = focused row index. */
+    focusedIndex: number | null;
+}
+/**
+ * AgentDock — vertical list of running and recently-finished sub-agents,
+ * pinned at the very bottom of the UI. Updates elapsed text once per
+ * second; redraws are local to this subtree (no app-wide re-render).
+ *
+ * See docs/superpowers/specs/2026-05-18-subagent-dock-revisions-design.md.
+ */
+export declare function AgentDock({ viewMode, focusedIndex, }: AgentDockProps): React.ReactElement | null;
+/**
+ * Filter the registry snapshot down to rows the dock should show:
+ * running agents + recently-finished agents still inside the fade window.
+ * Successful completions are dropped immediately — their final text already
+ * surfaced via agent_end in the main feed, so the dock row is redundant.
+ * Failures and cancellations linger so the user can investigate.
+ *
+ * Exported so App.tsx's keyboard handler shares the same predicate.
+ */
+export declare function getVisibleAgents(all: AsyncAgentEntry[], now: number): AsyncAgentEntry[];
+/**
+ * Format an elapsed-millisecond duration as "23s" / "4m 23s" / "1h 4m 23s".
+ */
+export declare function formatElapsed(ms: number): string;

package/dist/ui/components/CommandInput.d.ts

@@ -1,6 +1,10 @@
 interface CommandDef {
     name: string;
     description: string;
+    /** Optional usage string like "/fullscreen [on|off|toggle]" — the
+     *  bracketed portion is rendered dim after the command name once the
+     *  user has finished typing it. */
+    usage?: string;
 }
 interface CommandInputProps {
     value: string;
@@ -8,6 +12,13 @@ interface CommandInputProps {
     onSubmit: (value: string) => void;
     commands: CommandDef[];
     placeholder?: string;
+    /** Fired when ↓ is pressed and input is empty and history is exhausted.
+     *  Used by App.tsx to move keyboard focus into the AgentDock.  */
+    onArrowOut?: (direction: "down") => void;
+    /** When true, skip ALL key handling. Used while another part of the UI
+     *  (e.g. the AgentDock) owns the keyboard. The text input still renders;
+     *  only the useInput body short-circuits. */
+    disabled?: boolean;
 }
-export declare function CommandInput({ value, onChange, onSubmit, commands, placeholder, }: CommandInputProps): import("react/jsx-runtime").JSX.Element;
+export declare function CommandInput({ value, onChange, onSubmit, commands, placeholder, onArrowOut, disabled, }: CommandInputProps): import("react/jsx-runtime").JSX.Element;
 export {};