@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/tool-system/builtin/add-marketplace.js

@@ -0,0 +1,76 @@
+/**
+ * Built-in AddMarketplace tool — register a plugin marketplace source so the
+ * user can browse/install plugins from it in the UI. The tool only *adds the
+ * source* (git clone + validate marketplace.json via core's addMarketplace);
+ * which plugin to install is left to the user. Pairs with WebSearch/WebFetch:
+ * the model can discover a marketplace repo, then add it.
+ *
+ * Side effects (network + git clone + disk write) → permissionDefault "ask".
+ */
+import { addMarketplace } from "../../plugins/marketplaceManager.js";
+export const addMarketplaceToolDef = {
+    name: "AddMarketplace",
+    description: "Register a plugin marketplace source so the user can browse and install " +
+        "plugins from it. Provide a short name and a source: either a GitHub repo " +
+        "(owner/name) or a git URL. This only ADDS the source — it does not install " +
+        "any plugin. Use WebSearch/WebFetch first to find a marketplace repo if you " +
+        "don't already have one.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Short local name for this marketplace (e.g. 'official').",
+            },
+            source_type: {
+                type: "string",
+                enum: ["github", "git"],
+                description: "'github' for an owner/name repo, 'git' for a clone URL.",
+            },
+            repo: {
+                type: "string",
+                description: "GitHub repo in owner/name form (required when source_type='github').",
+            },
+            url: {
+                type: "string",
+                description: "Git clone URL (required when source_type='git').",
+            },
+        },
+        required: ["name", "source_type"],
+    },
+};
+export async function addMarketplaceTool(args) {
+    const name = args.name;
+    if (typeof name !== "string" || !name.trim()) {
+        return "Error: name is required";
+    }
+    const sourceType = args.source_type;
+    let source;
+    if (sourceType === "github") {
+        const repo = args.repo;
+        if (typeof repo !== "string" || !repo.includes("/")) {
+            return "Error: github source requires repo in owner/name form";
+        }
+        source = { source: "github", repo };
+    }
+    else if (sourceType === "git") {
+        const url = args.url;
+        if (typeof url !== "string" || !url.trim()) {
+            return "Error: git source requires a url";
+        }
+        source = { source: "git", url };
+    }
+    else {
+        return "Error: source_type must be 'github' or 'git'";
+    }
+    try {
+        const result = await addMarketplace(name, source);
+        if (!result.ok) {
+            return `Error adding marketplace ${name}: ${result.error}`;
+        }
+        return `Marketplace '${name}' added. The user can now browse and install plugins from it in the Extensions → Market UI.`;
+    }
+    catch (err) {
+        return `Error adding marketplace ${name}: ${err.message}`;
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * AgentHeartbeatPinger (B: background-agent visibility) — while background
+ * sub-agents are running, emit a periodic `agent_heartbeat` per parent session
+ * so the UI knows they're alive even during long LLM-request silence (no
+ * tool_use / no text for minutes). Decided over mtime/event-stream liveness
+ * because the worker KNOWS an agent is mid-request and can keep reporting it,
+ * whereas a quiet event stream looks dead.
+ *
+ * Liveness model deliberately NOT a separate heartbeat-file here — the file +
+ * pid (Heartbeat.ts / isProcessAlive) is for cross-restart interrupted
+ * detection (phase C). This pinger is the live "still working" UI signal only.
+ *
+ * Lifecycle (anti-leak): single timer, stored + cleared; `unref()` so it never
+ * pins the process open; `start()` idempotent; self-stops emitting when no
+ * agent runs but keeps the (unref'd) tick cheap. Mirrors the proven
+ * Heartbeat.ts / chat-session-manager sweeper pattern.
+ */
+import type { StreamEvent } from "../../types.js";
+/** Default 30s — user-chosen. Stale threshold downstream is 3× (90s). */
+export declare const DEFAULT_HEARTBEAT_INTERVAL_MS = 30000;
+export interface AgentHeartbeatConfig {
+    intervalMs?: number;
+    /** Sink for each heartbeat event (server forwards to the client). */
+    publish: (sessionId: string, event: StreamEvent) => void;
+    /** Injectable clock for tests. */
+    now?: () => number;
+}
+export declare class AgentHeartbeatPinger {
+    private readonly intervalMs;
+    private readonly publish;
+    private readonly now;
+    private timer;
+    constructor(config: AgentHeartbeatConfig);
+    /** Begin periodic heartbeats. Idempotent — a second call is a no-op. */
+    start(): void;
+    stop(): void;
+    /** One heartbeat cycle: group running agents by session and publish. */
+    private tick;
+}
+/**
+ * Process-wide pinger that publishes to the agentNotificationBus (the same
+ * channel background-agent completions use → the protocol server forwards each
+ * event to the client). `ensureRunning()` is called when an agent backgrounds;
+ * the pinger self-stops once no agent is running, so a fresh handoff re-arms it.
+ */
+export declare const agentHeartbeatPinger: AgentHeartbeatPinger;
+/** Start the shared pinger if not already ticking (idempotent). Call when an
+ *  agent enters the background. */
+export declare function ensureAgentHeartbeat(): void;

package/dist/tool-system/builtin/agent-heartbeat.js

@@ -0,0 +1,89 @@
+/**
+ * AgentHeartbeatPinger (B: background-agent visibility) — while background
+ * sub-agents are running, emit a periodic `agent_heartbeat` per parent session
+ * so the UI knows they're alive even during long LLM-request silence (no
+ * tool_use / no text for minutes). Decided over mtime/event-stream liveness
+ * because the worker KNOWS an agent is mid-request and can keep reporting it,
+ * whereas a quiet event stream looks dead.
+ *
+ * Liveness model deliberately NOT a separate heartbeat-file here — the file +
+ * pid (Heartbeat.ts / isProcessAlive) is for cross-restart interrupted
+ * detection (phase C). This pinger is the live "still working" UI signal only.
+ *
+ * Lifecycle (anti-leak): single timer, stored + cleared; `unref()` so it never
+ * pins the process open; `start()` idempotent; self-stops emitting when no
+ * agent runs but keeps the (unref'd) tick cheap. Mirrors the proven
+ * Heartbeat.ts / chat-session-manager sweeper pattern.
+ */
+import { asyncAgentRegistry } from "./agent-registry.js";
+import { agentNotificationBus } from "./agent-notifications.js";
+/** Default 30s — user-chosen. Stale threshold downstream is 3× (90s). */
+export const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+export class AgentHeartbeatPinger {
+    intervalMs;
+    publish;
+    now;
+    timer = null;
+    constructor(config) {
+        this.intervalMs = config.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+        this.publish = config.publish;
+        this.now = config.now ?? Date.now;
+    }
+    /** Begin periodic heartbeats. Idempotent — a second call is a no-op. */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.tick(), this.intervalMs);
+        // Never keep the process alive just for heartbeats.
+        if (typeof this.timer === "object" && "unref" in this.timer) {
+            this.timer.unref();
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** One heartbeat cycle: group running agents by session and publish. */
+    tick() {
+        const running = asyncAgentRegistry.getSnapshot().filter((e) => e.status === "running");
+        if (running.length === 0) {
+            // Nothing left to ping — self-stop so the timer doesn't tick forever
+            // after the last background agent finishes. start() re-arms on the next
+            // handoff. (Idempotent stop.)
+            this.stop();
+            return;
+        }
+        const bySession = new Map();
+        for (const e of running) {
+            // Background agents always carry their spawning sessionId; skip any
+            // legacy/ad-hoc entry without one (can't address a heartbeat to nobody).
+            if (!e.sessionId)
+                continue;
+            const list = bySession.get(e.sessionId);
+            if (list)
+                list.push(e.agentId);
+            else
+                bySession.set(e.sessionId, [e.agentId]);
+        }
+        const ts = this.now();
+        for (const [sessionId, agentIds] of bySession) {
+            this.publish(sessionId, { type: "agent_heartbeat", agentIds, ts });
+        }
+    }
+}
+/**
+ * Process-wide pinger that publishes to the agentNotificationBus (the same
+ * channel background-agent completions use → the protocol server forwards each
+ * event to the client). `ensureRunning()` is called when an agent backgrounds;
+ * the pinger self-stops once no agent is running, so a fresh handoff re-arms it.
+ */
+export const agentHeartbeatPinger = new AgentHeartbeatPinger({
+    publish: (sessionId, event) => agentNotificationBus.publish(sessionId, event),
+});
+/** Start the shared pinger if not already ticking (idempotent). Call when an
+ *  agent enters the background. */
+export function ensureAgentHeartbeat() {
+    agentHeartbeatPinger.start();
+}

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

@@ -1,4 +1,4 @@
-import type { BackgroundAgentCompletedEvent } from "../../types.js";
+import type { BackgroundAgentCompletedEvent, StreamEvent } from "../../types.js";
 /**
  * Background-agent completion notification queue.
  *
@@ -30,8 +30,17 @@ export type NotificationItem = {
     name?: string;
     description: string;
     status: "completed" | "failed";
+    /** What kind of background work this was (lets UIs localize the toast). */
+    workKind?: "agent" | "shell" | "video" | "cc";
+    /** For workKind === "shell": the command that ran. */
+    command?: string;
     /** Final assistant text (completed only). */
     finalText?: string;
+    /** For workKind === "cc": the external claude session id this drove, so the
+     *  result is recoverable from ~/.claude/projects/.../<ccSessionId>.jsonl even
+     *  if this notification is lost, and the user sees a real session id (not just
+     *  an opaque background jobId). */
+    ccSessionId?: string;
     /** Error message (failed only). */
     error?: string;
     enqueuedAt: number;
@@ -53,10 +62,10 @@ declare class NotificationQueue {
     private notify;
 }
 export declare const notificationQueue: NotificationQueue;
-type BusHandler = (sessionId: string, event: BackgroundAgentCompletedEvent) => void;
+type BusHandler = (sessionId: string, event: StreamEvent) => void;
 declare class AgentNotificationBus {
     private handlers;
-    publish(sessionId: string, event: BackgroundAgentCompletedEvent): void;
+    publish(sessionId: string, event: StreamEvent): void;
     subscribe(handler: BusHandler): () => void;
 }
 export declare const agentNotificationBus: AgentNotificationBus;

package/dist/tool-system/builtin/agent-notifications.js

@@ -94,8 +94,7 @@ class AgentNotificationBus {
             // Mirrors NotificationQueue.enqueue — refuse undefined / "" so the
             // server-side subscriber never has to defend against it.
             logger.warn("agent_notification_bus.invalid_session_id", {
-                agentId: event.agentId,
-                status: event.status,
+                eventType: event.type,
                 sessionIdType: typeof sessionId,
             });
             return;
@@ -132,6 +131,10 @@ export function notificationItemToStreamEvent(item) {
     };
     if (item.name !== undefined)
         event.name = item.name;
+    if (item.workKind !== undefined)
+        event.workKind = item.workKind;
+    if (item.command !== undefined)
+        event.command = item.command;
     if (item.finalText !== undefined)
         event.finalText = item.finalText;
     if (item.error !== undefined)
@@ -163,7 +166,10 @@ export function buildNotificationMessage(items) {
     const agents = items
         .map((item) => {
         const nameAttr = item.name ? ` name="${escapeXmlAttr(item.name)}"` : "";
-        const opening = `  <agent id="${escapeXmlAttr(item.agentId)}"${nameAttr} status="${item.status}">`;
+        // For DriveClaudeCode jobs, expose the real claude session id so the model
+        // can cite it / recover the full result from disk if needed.
+        const ccAttr = item.ccSessionId ? ` ccSessionId="${escapeXmlAttr(item.ccSessionId)}"` : "";
+        const opening = `  <agent id="${escapeXmlAttr(item.agentId)}"${nameAttr} status="${item.status}"${ccAttr}>`;
         const desc = `    <description>${escapeXmlText(item.description)}</description>`;
         const body = item.status === "completed"
             ? `    <result>\n${escapeXmlText(item.finalText ?? "")}\n    </result>`

package/dist/tool-system/builtin/agent-output-file.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Background-agent output files. When an async (run_in_background) agent
+ * finishes, we mirror its final text to `~/.code-shell/agents/<agentId>.txt`
+ * so it can be tailed from outside the process or read back in a later session
+ * — the notificationQueue re-injection remains the PRIMARY path that feeds the
+ * result to the parent agent; this file is just an external-readable copy.
+ *
+ * All writes are best-effort: a failure here must never break the agent
+ * completion path, so callers fire-and-forget and we swallow errors (logging
+ * via the provided logger when present).
+ */
+/** Directory holding per-agent output files. */
+export declare function agentOutputDir(): string;
+/** Absolute path of a given agent's output file. */
+export declare function agentOutputPath(agentId: string): string;
+interface WriteOpts {
+    status: "completed" | "failed";
+    /** Final text (completed) or error message (failed). */
+    body: string;
+    description?: string;
+    name?: string;
+    /** Optional logger.warn for swallowed errors. */
+    onError?: (msg: string, meta: Record<string, unknown>) => void;
+}
+/**
+ * Write (overwrite) an agent's output file. Best-effort: resolves even on
+ * failure. The body is prefixed with a small header so a human tailing the
+ * file sees what it is.
+ */
+export declare function writeAgentOutputFile(agentId: string, opts: WriteOpts): Promise<void>;
+/** Delete a single agent's output file (best-effort). */
+export declare function removeAgentOutputFile(agentId: string): Promise<void>;
+/**
+ * Remove every agent output file. Called on app exit / full registry reset so
+ * the directory doesn't accumulate stale files across runs.
+ */
+export declare function clearAgentOutputFiles(): Promise<void>;
+export {};

package/dist/tool-system/builtin/agent-output-file.js

@@ -0,0 +1,72 @@
+/**
+ * Background-agent output files. When an async (run_in_background) agent
+ * finishes, we mirror its final text to `~/.code-shell/agents/<agentId>.txt`
+ * so it can be tailed from outside the process or read back in a later session
+ * — the notificationQueue re-injection remains the PRIMARY path that feeds the
+ * result to the parent agent; this file is just an external-readable copy.
+ *
+ * All writes are best-effort: a failure here must never break the agent
+ * completion path, so callers fire-and-forget and we swallow errors (logging
+ * via the provided logger when present).
+ */
+import { join } from "node:path";
+import { mkdir, writeFile, rm, readdir } from "node:fs/promises";
+import { userHome } from "../../settings/manager.js";
+/** Directory holding per-agent output files. */
+export function agentOutputDir() {
+    return join(userHome(), ".code-shell", "agents");
+}
+/** Absolute path of a given agent's output file. */
+export function agentOutputPath(agentId) {
+    // agentId is internally generated (`agent-<n>` / uuid-ish) — no separators —
+    // but guard anyway so a hostile id can't escape the directory.
+    const safe = agentId.replace(/[^A-Za-z0-9._-]/g, "_");
+    return join(agentOutputDir(), `${safe}.txt`);
+}
+/**
+ * Write (overwrite) an agent's output file. Best-effort: resolves even on
+ * failure. The body is prefixed with a small header so a human tailing the
+ * file sees what it is.
+ */
+export async function writeAgentOutputFile(agentId, opts) {
+    try {
+        await mkdir(agentOutputDir(), { recursive: true });
+        const header = `# agent ${agentId}` +
+            (opts.name ? ` (${opts.name})` : "") +
+            `\n# status: ${opts.status}` +
+            (opts.description ? `\n# task: ${opts.description}` : "") +
+            `\n\n`;
+        await writeFile(agentOutputPath(agentId), header + (opts.body ?? ""), "utf8");
+    }
+    catch (e) {
+        opts.onError?.("agent_output_file_write_failed", {
+            agentId,
+            error: String(e instanceof Error ? e.message : e),
+        });
+    }
+}
+/** Delete a single agent's output file (best-effort). */
+export async function removeAgentOutputFile(agentId) {
+    try {
+        await rm(agentOutputPath(agentId), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+/**
+ * Remove every agent output file. Called on app exit / full registry reset so
+ * the directory doesn't accumulate stale files across runs.
+ */
+export async function clearAgentOutputFiles() {
+    try {
+        const dir = agentOutputDir();
+        const names = await readdir(dir);
+        await Promise.all(names
+            .filter((n) => n.endsWith(".txt"))
+            .map((n) => rm(join(dir, n), { force: true })));
+    }
+    catch {
+        // dir may not exist yet — fine
+    }
+}

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

@@ -29,7 +29,21 @@ export interface AsyncAgentEntry {
     agentId: string;
     /** Short kind label shown in the dock (e.g. "Explore", "Plan"). */
     name?: string;
+    /** Dispatched role (e.g. "general-purpose", "explorer"); shown in the dock
+     *  so you can see what kind of agent is running. */
+    agentType?: string;
     description: string;
+    /** Session that spawned this background agent. Lets the spawning
+     *  Engine.run wait only on ITS OWN background agents (hasRunningForSession),
+     *  not every concurrent session's. Undefined only for legacy/ad-hoc callers
+     *  outside Engine.run. */
+    sessionId?: string;
+    /** The sub-agent's OWN child session id (distinct from the parent
+     *  `sessionId` above). AgentSendInput resumes this to continue the agent
+     *  with full transcript replay. With the agent_id===childSid convention
+     *  this equals `agentId`, but it is stored explicitly so the contract is
+     *  not coupled to that identity. Undefined for legacy entries. */
+    childSessionId?: string;
     status: AsyncAgentStatus;
     startedAt: number;
     finishedAt?: number;
@@ -46,6 +60,9 @@ declare class AsyncAgentRegistry {
     subscribe: (cb: () => void) => (() => void);
     getSnapshot: () => AsyncAgentEntry[];
     hasRunning: () => boolean;
+    /** True if any background agent spawned by `sessionId` is still running.
+     *  Drives Engine.run's "wait for my background agents before resolving". */
+    hasRunningForSession: (sessionId: string) => boolean;
     /** Count of agents currently in the "running" state (cap enforcement). */
     runningCount(): number;
     private notify;
@@ -60,6 +77,12 @@ declare class AsyncAgentRegistry {
     touchTranscript(agentId: string): void;
     get(agentId: string): AsyncAgentEntry | undefined;
     list(): AsyncAgentEntry[];
+    /**
+     * Agents spawned by a given session. Drives AgentStatus's default view so a
+     * background-agent listing doesn't surface every concurrent session's agents.
+     * Legacy entries with no sessionId are excluded from a session-scoped query.
+     */
+    listForSession(sessionId: string): AsyncAgentEntry[];
     private markFinished;
     markCompleted(agentId: string): void;
     markFailed(agentId: string): void;

package/dist/tool-system/builtin/agent-registry.js

@@ -30,6 +30,11 @@ class AsyncAgentRegistry {
     hasRunning = () => {
         return this.snapshot.some((e) => e.status === "running");
     };
+    /** True if any background agent spawned by `sessionId` is still running.
+     *  Drives Engine.run's "wait for my background agents before resolving". */
+    hasRunningForSession = (sessionId) => {
+        return this.snapshot.some((e) => e.status === "running" && e.sessionId === sessionId);
+    };
     /** Count of agents currently in the "running" state (cap enforcement). */
     runningCount() {
         return this.snapshot.filter((e) => e.status === "running").length;
@@ -76,6 +81,14 @@ class AsyncAgentRegistry {
     list() {
         return [...this.agents.values()];
     }
+    /**
+     * Agents spawned by a given session. Drives AgentStatus's default view so a
+     * background-agent listing doesn't surface every concurrent session's agents.
+     * Legacy entries with no sessionId are excluded from a session-scoped query.
+     */
+    listForSession(sessionId) {
+        return [...this.agents.values()].filter((e) => e.sessionId === sessionId);
+    }
     markFinished(agentId, status) {
         const e = this.agents.get(agentId);
         if (!e)
@@ -108,10 +121,9 @@ class AsyncAgentRegistry {
         catch {
             // ignore abort errors — we still mark cancelled
         }
-        e.status = "cancelled";
-        e.finishedAt = Date.now();
-        e.finishedFadeAt = e.finishedAt + 30_000;
-        this.notify();
+        // Reuse markFinished for the status/timestamp/notify bookkeeping rather
+        // than duplicating it (the entry is still "running" after abort()).
+        this.markFinished(agentId, "cancelled");
         return true;
     }
     reset() {

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

@@ -9,19 +9,64 @@
 import type { ToolDefinition } from "../../types.js";
 import type { ToolContext } from "../context.js";
 import type { AgentDefinitionRegistry } from "../../agent/agent-definition-registry.js";
+import type { AgentDefinition } from "../../agent/agent-definition.js";
 import type { HookRegistry } from "../../hooks/registry.js";
 export interface AgentTypeOverrides {
+    resolvedType?: string;
     model?: string;
     maxTurns?: number;
     toolAllowlist?: string[];
+    skillAllowlist?: string[];
     appendSystemPrompt?: string;
 }
 /**
  * Resolve an `agent_type` against the role registry into spawn overrides.
- * Omitted type → empty overrides (ephemeral mode). Unknown type → throw, so
- * the LLM gets a clear correction instead of silently running a generic agent.
+ *
+ * - Omitted type + non-empty registry → fall back to a configured role
+ *   ("general-purpose" if present, else the first available) instead of
+ *   running a nameless ephemeral agent. Relaxed from the earlier "throw when
+ *   agent_type omitted": the model habitually omits it, and a hard error just
+ *   turned every spawn into a failure. Falling back to a real role keeps the
+ *   tool-allowlist / system-prompt benefits without breaking the call.
+ * - Omitted type + empty registry → empty overrides (true ephemeral; nothing
+ *   to fall back to).
+ * - Unknown explicit type → throw, so the LLM gets a clear correction rather
+ *   than silently running a generic agent.
  */
 export declare function resolveAgentTypeOverrides(agentType: string | undefined, registry: AgentDefinitionRegistry | undefined): AgentTypeOverrides;
+/**
+ * A plugin-bundled agent's frontmatter lists its own skills by BARE name
+ * (`skills: director-skill`), matching Claude Code's convention where a
+ * plugin agent references same-plugin skills unqualified. But the skill
+ * scanner registers plugin skills under their NAMESPACED name
+ * (`mimi-video:director-skill`), and the allowlist filter is an exact match —
+ * so a bare entry never matches and the sub-agent reports the skill "not
+ * found", forcing it to fall back to reading SKILL.md by hand.
+ *
+ * Bridge the two conventions: for a plugin-source agent, rewrite each bare
+ * skill name to `<pluginName>:<skill>`. Names that already carry a namespace
+ * (contain ":") are left untouched, so an agent may still reference another
+ * plugin's skill explicitly. undefined (inherit full pool) and [] (no skills)
+ * pass through unchanged. Non-plugin agents are never rewritten.
+ */
+export declare function namespacePluginSkills(skills: string[] | undefined, source: AgentDefinition["source"], pluginName: string | undefined): string[] | undefined;
+/**
+ * Render the "Available agent types" block injected into the Agent tool's
+ * description, listing the roles defined in .code-shell/agents/*.md so the
+ * model knows it can pass `agent_type` instead of hand-rolling an ad-hoc
+ * agent. Without this the model never sees the registry (it lives per-engine,
+ * not in the static tool def) and falls back to nameless ephemeral agents —
+ * see the Core A/B/C incident. Returns "" when no roles are defined, so the
+ * base description is left untouched.
+ */
+export declare function buildAgentTypesBlock(registry: AgentDefinitionRegistry | undefined): string;
+/**
+ * Produce an Agent tool definition whose description ends with the live
+ * available-agent-types listing. Pure: takes the registry, returns a new def
+ * (the base `agentToolDef` const is never mutated). When no roles exist the
+ * base def is returned unchanged.
+ */
+export declare function agentToolDefWithTypes(registry: AgentDefinitionRegistry | undefined): ToolDefinition;
 type SubAgentLifecycle = "subagent_start" | "subagent_finish" | "subagent_error";
 /**
  * Emit a sub-agent lifecycle event via the existing `notification` hook,
@@ -35,18 +80,12 @@ export declare function emitSubAgentHook(hooks: HookRegistry | undefined, kind:
     text?: string;
     error?: string;
 }): void;
-/** Default per-sub-agent wall-clock timeout (5 minutes). */
-export declare const DEFAULT_SUBAGENT_TIMEOUT_MS: number;
-/**
- * Run `work()` with a timeout. On expiry, calls `onTimeout` (to abort the
- * child) and rejects with a timeout error. The child's own abort handling
- * unwinds its resources.
- */
-export declare function runWithTimeout<T>(work: () => Promise<T>, timeoutMs: number, onTimeout: () => void): Promise<T>;
 export declare const agentToolDef: ToolDefinition;
 export declare function agentTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const agentStatusToolDef: ToolDefinition;
-export declare function agentStatusTool(args: Record<string, unknown>): Promise<string>;
+export declare function agentStatusTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export declare const agentCancelToolDef: ToolDefinition;
 export declare function agentCancelTool(args: Record<string, unknown>): Promise<string>;
+export declare const agentSendInputToolDef: ToolDefinition;
+export declare function agentSendInputTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 export {};