@sayknow-cli/coding-agent 0.4.1 → 0.4.3

package/dist/types/ssh/connection-manager.d.ts

@@ -0,0 +1,33 @@
+export interface SSHConnectionTarget {
+    name: string;
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    compat?: boolean;
+}
+export type SSHHostOs = "windows" | "linux" | "macos" | "unknown";
+export type SSHHostShell = "cmd" | "powershell" | "bash" | "zsh" | "sh" | "unknown";
+export type SshPlatform = typeof process.platform;
+export declare function supportsSshControlMaster(platform?: SshPlatform): boolean;
+export interface SSHHostInfo {
+    version: number;
+    os: SSHHostOs;
+    shell: SSHHostShell;
+    compatShell?: "bash" | "sh";
+    compatEnabled: boolean;
+}
+interface SSHArgsOptions {
+    platform?: SshPlatform;
+}
+export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
+export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;
+export declare function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo>;
+export declare function buildRemoteCommand(host: SSHConnectionTarget, command: string, options?: SSHArgsOptions): Promise<string[]>;
+export declare function ensureConnection(host: SSHConnectionTarget): Promise<void>;
+export declare function invalidateHostMetadata(hostNames: Iterable<string>): Promise<void>;
+export declare function closeConnection(hostName: string): Promise<void>;
+export declare function closeAllConnections(): Promise<void>;
+export declare function getControlPathTemplate(): string;
+export declare function getControlDir(): string;
+export {};

package/dist/types/ssh/ssh-executor.d.ts

@@ -0,0 +1,37 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export interface SSHExecutorOptions {
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Callback for streaming output chunks (already sanitized) */
+    onChunk?: (chunk: string) => void;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Remote path to mount when sshfs is available */
+    remotePath?: string;
+    /** Wrap commands in a POSIX shell for compat mode */
+    compatEnabled?: boolean;
+    /** Artifact path/id for full output storage */
+    artifactPath?: string;
+    artifactId?: string;
+}
+export interface SSHResult {
+    /** Combined stdout + stderr output (sanitized, possibly truncated) */
+    output: string;
+    /** Process exit code (undefined if killed/cancelled) */
+    exitCode: number | undefined;
+    /** Whether the command was cancelled via signal */
+    cancelled: boolean;
+    /** Whether the output was truncated */
+    truncated: boolean;
+    /** Total number of lines in the output stream */
+    totalLines: number;
+    /** Total number of bytes in the output stream */
+    totalBytes: number;
+    /** Number of lines included in the output text */
+    outputLines: number;
+    /** Number of bytes included in the output text */
+    outputBytes: number;
+    /** Artifact ID if full output was saved to artifact storage */
+    artifactId?: string;
+}
+export declare function executeSSH(host: SSHConnectionTarget, command: string, options?: SSHExecutorOptions): Promise<SSHResult>;

package/dist/types/ssh/sshfs-mount.d.ts

@@ -0,0 +1,6 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export declare function hasSshfs(): boolean;
+export declare function isMounted(path: string): Promise<boolean>;
+export declare function mountRemote(host: SSHConnectionTarget, remotePath?: string): Promise<string | undefined>;
+export declare function unmountRemote(host: SSHConnectionTarget): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;

package/dist/types/ssh/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeHostName(name: string): string;
+export declare function buildSshTarget(username: string | undefined, host: string): string;

package/dist/types/stt/downloader.d.ts

@@ -0,0 +1,9 @@
+export interface DownloadProgress {
+    stage: string;
+    percent?: number;
+}
+export interface EnsureOptions {
+    modelName?: string;
+    onProgress?: (progress: DownloadProgress) => void;
+}
+export declare function ensureSTTDependencies(options?: EnsureOptions): Promise<void>;

package/dist/types/stt/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./downloader";
+export * from "./setup";
+export * from "./stt-controller";

package/dist/types/stt/recorder.d.ts

@@ -0,0 +1,13 @@
+export interface RecordingHandle {
+    stop(): Promise<void>;
+}
+/**
+ * Returns available recording tools in priority order.
+ */
+export declare function detectRecordingTools(): string[];
+export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
+/**
+ * Verify a recorded audio file is usable.
+ * Returns the file size in bytes, or throws.
+ */
+export declare function verifyRecordingFile(filePath: string): Promise<number>;

package/dist/types/stt/setup.d.ts

@@ -0,0 +1,18 @@
+export interface STTDependencyStatus {
+    recorder: {
+        available: boolean;
+        tool: string | null;
+        installHint: string;
+    };
+    python: {
+        available: boolean;
+        path: string | null;
+        installHint: string;
+    };
+    whisper: {
+        available: boolean;
+        installHint: string;
+    };
+}
+export declare function checkDependencies(): Promise<STTDependencyStatus>;
+export declare function formatDependencyStatus(status: STTDependencyStatus): string;

package/dist/types/stt/stt-controller.d.ts

@@ -0,0 +1,16 @@
+export type SttState = "idle" | "recording" | "transcribing";
+interface ToggleOptions {
+    showWarning(msg: string): void;
+    showStatus(msg: string): void;
+    onStateChange(state: SttState): void;
+}
+interface Editor {
+    insertText(text: string): void;
+}
+export declare class STTController {
+    #private;
+    get state(): SttState;
+    toggle(editor: Editor, options: ToggleOptions): Promise<void>;
+    dispose(): void;
+}
+export {};

package/dist/types/stt/transcriber.d.ts

@@ -0,0 +1,16 @@
+export interface TranscribeOptions {
+    modelName?: string;
+    language?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Find a usable Python command.
+ */
+export declare function resolvePython(): string | null;
+/**
+ * Transcribe a WAV file using Python openai-whisper.
+ *
+ * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
+ * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ */
+export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/system-prompt.d.ts

@@ -0,0 +1,109 @@
+/**
+ * System prompt construction and project context loading
+ */
+import type { AgentTool } from "@sayknow-cli/agent-core";
+import type { SkillsSettings } from "./config/settings";
+import type { Skill } from "./extensibility/skills";
+import { type WorkspaceTree } from "./workspace-tree";
+interface AlwaysApplyRule {
+    name: string;
+    content: string;
+    path: string;
+}
+/** Resolve input as file path or literal string */
+export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
+export interface LoadContextFilesOptions {
+    /** Working directory to start walking up from. Default: getProjectDir() */
+    cwd?: string;
+}
+/**
+ * Load all context files using the capability API.
+ * Returns {path, content, depth} entries for all discovered context files.
+ * Native user-global files (`~/.skc/agent/AGENTS.md`) come first, then project
+ * files sorted by depth (descending) so files closer to cwd appear last/more
+ * prominent. User-home files from foreign providers (`~/.claude/CLAUDE.md`,
+ * `~/.codex/AGENTS.md`, …) stay excluded — only skc's own user config applies.
+ */
+export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Load the effective system prompt customization from SYSTEM.md.
+ * Project-level SYSTEM.md overrides user-level SYSTEM.md.
+ */
+export declare function loadSystemPromptFiles(options?: LoadContextFilesOptions): Promise<string | null>;
+export interface SystemPromptToolMetadata {
+    label: string;
+    description: string;
+    /** Tool name the model sees on the provider wire. Defaults to the internal tool name. */
+    wireName?: string;
+}
+export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTool>, overrides?: Partial<Record<string, Partial<SystemPromptToolMetadata>>>): Map<string, SystemPromptToolMetadata>;
+export interface BuildSystemPromptOptions {
+    /** Custom system prompt (replaces default). */
+    customPrompt?: string;
+    /** Tools to include in prompt. */
+    tools?: Map<string, SystemPromptToolMetadata>;
+    /** Tool names to include in prompt. */
+    toolNames?: string[];
+    /** Text to append to system prompt. */
+    appendSystemPrompt?: string;
+    /** Rendered SKC plugin system-appendix blocks (lower-authority, appended last). */
+    pluginAppendices?: string;
+    /** Repeat full tool descriptions in system prompt. Default: false */
+    repeatToolDescriptions?: boolean;
+    /** Skills settings for discovery. */
+    skillsSettings?: SkillsSettings;
+    /** Working directory. Default: getProjectDir() */
+    cwd?: string;
+    /** Pre-loaded context files (skips discovery if provided). */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+        depth?: number;
+    }>;
+    /** Skills provided directly to system prompt construction. */
+    skills?: Skill[];
+    /** Pre-loaded rulebook rules (descriptions, excluding TTSR and always-apply). */
+    rules?: Array<{
+        name: string;
+        description?: string;
+        path: string;
+        globs?: string[];
+    }>;
+    /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
+    intentField?: string;
+    /** Whether built-in tool discovery is active; enables the tool-discovery prompt block. */
+    toolDiscoveryActive?: boolean;
+    /** Encourage the agent to delegate via tasks unless changes are trivial. */
+    eagerTasks?: boolean;
+    /** Rules with alwaysApply=true — their full content is injected into the prompt. */
+    alwaysApplyRules?: AlwaysApplyRule[];
+    /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
+    secretsEnabled?: boolean;
+    /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
+    workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+    /**
+     * Render a trimmed role-agent base prompt for subagent sessions: omits the
+     * workflow-surface/routing/self-awareness (`<skc-runtime>`) and `<soul>` blocks
+     * that only apply to the top-level interactive/print agent. Tool safety, repo
+     * safety, and the completion contract are retained. Default: false.
+     */
+    subagent?: boolean;
+}
+/** Result of building provider-facing system prompt messages. */
+export interface BuildSystemPromptResult {
+    /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
+    systemPrompt: string[];
+}
+export interface BuildVolatileProjectContextOptions {
+    cwd?: string;
+    date?: string;
+    workspaceTree?: WorkspaceTree;
+}
+export declare function buildVolatileProjectContext(options?: BuildVolatileProjectContextOptions): string;
+/** Build the system prompt with tools, guidelines, and context */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export {};

package/dist/types/task/agents.d.ts

@@ -0,0 +1,28 @@
+import type { AgentDefinition, AgentSource } from "./types";
+export declare class AgentParsingError extends Error {
+    readonly source?: unknown | undefined;
+    constructor(error: Error, source?: unknown | undefined);
+    toString(): string;
+}
+/**
+ * Parse an agent from embedded content.
+ */
+export declare function parseAgent(filePath: string, content: string, source: AgentSource, level?: "fatal" | "warn" | "off"): AgentDefinition;
+/**
+ * Load all bundled agents from embedded content.
+ * Results are cached after first load.
+ */
+export declare function loadBundledAgents(): AgentDefinition[];
+/**
+ * Get a bundled agent by name.
+ */
+export declare function getBundledAgent(name: string): AgentDefinition | undefined;
+/**
+ * Get all bundled agents as a map keyed by name.
+ */
+export declare function getBundledAgentsMap(): Map<string, AgentDefinition>;
+/**
+ * Clear the bundled agents cache (for testing).
+ */
+export declare function clearBundledAgentsCache(): void;
+export declare const BUNDLED_AGENTS: typeof loadBundledAgents;

package/dist/types/task/commands.d.ts

@@ -0,0 +1,35 @@
+export declare const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{
+    name: string;
+    content: string;
+}>;
+/** Workflow command definition */
+export interface WorkflowCommand {
+    name: string;
+    description: string;
+    instructions: string;
+    source: "bundled" | "user" | "project";
+    filePath: string;
+}
+/**
+ * Load all bundled commands from embedded content.
+ */
+export declare function loadBundledCommands(): WorkflowCommand[];
+/**
+ * Discover all available commands.
+ *
+ * Precedence (highest wins): .skc project, .skc user, then bundled
+ */
+export declare function discoverCommands(cwd: string): Promise<WorkflowCommand[]>;
+/**
+ * Get a command by name.
+ */
+export declare function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined;
+/**
+ * Expand command instructions with task input.
+ * Replaces $@ with the provided input.
+ */
+export declare function expandCommand(command: WorkflowCommand, input: string): string;
+/**
+ * Clear the bundled commands cache (for testing).
+ */
+export declare function clearBundledCommandsCache(): void;

package/dist/types/task/discovery.d.ts

@@ -0,0 +1,19 @@
+import type { AgentDefinition } from "./types";
+/** Result of agent discovery */
+export interface DiscoveryResult {
+    agents: AgentDefinition[];
+    projectAgentsDir: string | null;
+}
+export declare function filterVisibleAgents(agents: readonly AgentDefinition[]): AgentDefinition[];
+/**
+ * Discover agents from filesystem and merge with bundled agents.
+ *
+ * Precedence (highest wins): .skc project, .skc user, SKC plugins, then bundled
+ *
+ * @param cwd - Current working directory for project agent discovery
+ */
+export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;
+/**
+ * Get an agent by name from discovered agents.
+ */
+export declare function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined;

package/dist/types/task/executor.d.ts

@@ -0,0 +1,138 @@
+/**
+ * In-process execution for subagents.
+ *
+ * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
+ */
+import type { AgentTelemetryConfig, ThinkingLevel } from "@sayknow-cli/agent-core";
+import type { Model, ServiceTier } from "@sayknow-cli/ai";
+import { ModelRegistry } from "../config/model-registry";
+import type { PromptTemplate } from "../config/prompt-templates";
+import { Settings } from "../config/settings";
+import { type Skill } from "../extensibility/skills";
+import type { HindsightSessionState } from "../hindsight/state";
+import type { LocalProtocolOptions } from "../internal-urls";
+import { AgentRegistry } from "../registry/agent-registry";
+import type { ForkContextSeed } from "../session/agent-session";
+import type { ArtifactManager } from "../session/artifacts";
+import type { AuthStorage } from "../session/auth-storage";
+import { SessionManager } from "../session/session-manager";
+import type { ContextFileEntry } from "../tools";
+import type { EventBus } from "../utils/event-bus";
+import type { WorkspaceTree } from "../workspace-tree";
+import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+export declare function trimForkContextSeedForModel(seed: ForkContextSeed, model: Model | undefined): ForkContextSeed;
+/** Options for subagent execution */
+export interface ExecutorOptions {
+    cwd: string;
+    worktree?: string;
+    agent: AgentDefinition;
+    task: string;
+    assignment?: string;
+    context?: string;
+    description?: string;
+    index: number;
+    id: string;
+    modelOverride?: string | string[];
+    runMode?: "initial" | "resume" | "message";
+    resumeMessage?: string;
+    subagentId?: string;
+    /**
+     * Active model selector of the parent session, used as an auth-aware fallback
+     * if the resolved subagent model has no working credentials. See #985.
+     */
+    parentActiveModelPattern?: string;
+    parentSessionId?: string;
+    thinkingLevel?: ThinkingLevel;
+    outputSchema?: unknown;
+    /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
+    taskDepth?: number;
+    enableLsp?: boolean;
+    signal?: AbortSignal;
+    onProgress?: (progress: AgentProgress) => void;
+    sessionFile?: string | null;
+    persistArtifacts?: boolean;
+    artifactsDir?: string;
+    /** Path to parent conversation context file */
+    contextFile?: string;
+    /** Whether the parent runtime actually exposes IRC coordination. */
+    ircAvailable?: boolean;
+    eventBus?: EventBus;
+    contextFiles?: ContextFileEntry[];
+    skills?: Skill[];
+    promptTemplates?: PromptTemplate[];
+    workspaceTree?: WorkspaceTree;
+    authStorage?: AuthStorage;
+    modelRegistry?: ModelRegistry;
+    settings?: Settings;
+    /** Parent session's registry; shared by child sessions for IRC routing and roster visibility. */
+    agentRegistry?: AgentRegistry;
+    /**
+     * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
+     * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the
+     * live value (not the stale settings snapshot) lets a runtime `/fast on` reach
+     * subagents, and a main-model fast-mode auto-disable does not clobber it.
+     */
+    inheritedServiceTier?: ServiceTier;
+    /** Override local:// protocol options so subagent shares parent's local:// root */
+    localProtocolOptions?: LocalProtocolOptions;
+    /**
+     * Parent session's ArtifactManager. Subagent adopts it so artifact IDs are
+     * unique across the whole agent tree and all artifacts land in the parent's
+     * artifacts directory (no per-subagent subdir).
+     */
+    parentArtifactManager?: ArtifactManager;
+    managedPersistence?: ManagedTaskPersistence;
+    parentHindsightSessionState?: HindsightSessionState;
+    /**
+     * Parent agent's OpenTelemetry configuration. When defined, the subagent's
+     * loop is started with the same tracer/hooks but its own agent identity
+     * stamped, so its `invoke_agent` / `chat` / `execute_tool` spans appear as
+     * a sub-tree under the parent's active `execute_tool task` span. A
+     * `handoff` span is emitted on dispatch to mark the parent → subagent
+     * transition explicitly.
+     */
+    parentTelemetry?: AgentTelemetryConfig;
+    /** Skills to autoload via sendCustomMessage before the first prompt */
+    autoloadSkills?: Skill[];
+    forkContextSeed?: ForkContextSeed;
+}
+export declare class ManagedTaskPersistence {
+    #private;
+    constructor(artifacts: ArtifactManager, taskId: string);
+    openSession(): Promise<SessionManager>;
+    publishOutput(rawOutput: string, metadata: Uint8Array): Promise<void>;
+}
+export declare function createManagedTaskPersistence(artifacts: ArtifactManager, taskId: string): ManagedTaskPersistence;
+export declare function renderSubagentUserPrompt(assignment: string, independentMode: boolean): string;
+export interface YieldItem {
+    data?: unknown;
+    status?: "success" | "aborted";
+    error?: string;
+}
+interface FinalizeSubprocessOutputArgs {
+    rawOutput: string;
+    exitCode: number;
+    stderr: string;
+    doneAborted: boolean;
+    signalAborted: boolean;
+    yieldItems?: YieldItem[];
+    reportFindings?: ReviewFinding[];
+    outputSchema: unknown;
+}
+interface FinalizeSubprocessOutputResult {
+    rawOutput: string;
+    exitCode: number;
+    stderr: string;
+    abortedViaYield: boolean;
+    hasYield: boolean;
+}
+export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
+export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
+export declare const SUBAGENT_WARNING_PLACEHOLDER_YIELD = "SYSTEM WARNING: Subagent yield data contains a placeholder instead of the actual result.";
+export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
+export declare function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings;
+/**
+ * Run a single agent in-process.
+ */
+export declare function runSubprocess(options: ExecutorOptions): Promise<SingleResult>;
+export {};

package/dist/types/task/fork-context-advisory.d.ts

@@ -0,0 +1,13 @@
+import type { ForkContextMode } from "./types";
+export interface ForkContextAdvisory {
+    recommendedMode: ForkContextMode;
+    reasons: string[];
+    estimatedClonedTokens: Record<ForkContextMode, number>;
+    callerModeRespected: true;
+}
+export declare function adviseForkContextMode(input: {
+    assignment: string;
+    context?: string;
+    explicitMode?: ForkContextMode;
+    parentContextTokens?: number;
+}): ForkContextAdvisory;

package/dist/types/task/fork-context-budget.d.ts

@@ -0,0 +1,7 @@
+export declare const FORK_CONTEXT_TOKEN_BUDGET_BY_MODE: {
+    readonly none: 0;
+    readonly receipt: 2000;
+    readonly "last-turn": 4000;
+    readonly bounded: 8000;
+    readonly full: 15000;
+};

package/dist/types/task/id.d.ts

@@ -0,0 +1,7 @@
+export declare const TASK_ID_PATTERN: RegExp;
+export declare const TASK_ID_DESCRIPTION = "filesystem-safe identifier matching ^[A-Za-z0-9][A-Za-z0-9_-]{0,47}$";
+export declare function isValidTaskId(id: string): boolean;
+export declare function getTaskIdValidationError(id: unknown): string | undefined;
+export declare function validateTaskId(id: string): string;
+export declare function isValidAllocatedTaskId(id: string): boolean;
+export declare function validateAllocatedTaskId(id: string): string;

package/dist/types/task/index.d.ts

@@ -0,0 +1,43 @@
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Model } from "@sayknow-cli/ai";
+import type { ToolSession } from "..";
+import type { Theme } from "../modes/theme/theme";
+import { type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import "../tools/review";
+import { renderResult, renderCall as renderTaskCall } from "./render";
+export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
+export { discoverCommands, expandCommand, getCommand } from "./commands";
+export { discoverAgents, getAgent } from "./discovery";
+export { isValidAllocatedTaskId, isValidTaskId, TASK_ID_DESCRIPTION, TASK_ID_PATTERN, validateAllocatedTaskId, validateTaskId, } from "./id";
+export { AgentOutputManager } from "./output-manager";
+export type { TaskResultReceipt } from "./receipt";
+export { assertNoRawTaskFields, buildTaskReceipt, buildTaskRoi, buildTaskRoiSummary, findRawTaskLeakKeys, sanitizeTaskToolDetails, } from "./receipt";
+export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
+export declare function resolveForkContextMaxTokens(configured: number, model: Model | undefined): number;
+/**
+ * Task tool - Delegate tasks to specialized agents.
+ *
+ * Requires async initialization to discover available agents.
+ * Use `TaskTool.create(session)` to instantiate.
+ */
+export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetails, Theme> {
+    #private;
+    private readonly session;
+    readonly name = "task";
+    readonly label = "Task";
+    readonly summary = "Spawn a subagent to complete a parallel task";
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly renderResult: typeof renderResult;
+    get parameters(): TaskToolSchemaInstance;
+    renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme): import("@sayknow-cli/tui").Component;
+    /** Dynamic description that reflects current disabled-agent settings */
+    get description(): string;
+    private constructor();
+    /**
+     * Create a TaskTool instance with async agent discovery.
+     */
+    static create(session: ToolSession): Promise<TaskTool>;
+    execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
+}

package/dist/types/task/name-generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generate memorable two-word task identifiers.
+ * Format: AdjectiveNoun (e.g., "SwiftFalcon", "CalmPanda")
+ *
+ * Dictionaries sourced from unique-names-generator (MIT license).
+ * 1202 adjectives × 355 animals = 426,710 combinations.
+ */
+/**
+ * Generate a unique two-word identifier (e.g., "SwiftFalcon").
+ * Falls back to numeric suffix if all combinations exhausted.
+ */
+export declare function generateTaskName(): string;
+/**
+ * Reset name generator state (for testing).
+ */
+export declare function resetTaskNames(): void;

package/dist/types/task/output-manager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Manages agent output ID allocation to ensure uniqueness.
+ *
+ * Each allocated ID gets a numeric prefix based on allocation order.
+ * If configured with a parent prefix, the numeric prefix is appended after
+ * the parent (e.g., "0-Parent.0-Child").
+ * On resume, scans existing files to find the next available index.
+ */
+export declare class AgentOutputManager {
+    #private;
+    constructor(getArtifactsDir: () => string | null, options?: {
+        parentPrefix?: string;
+    });
+    /**
+     * Allocate a unique ID with numeric prefix.
+     *
+     * @param id Requested ID (e.g., "AuthProvider")
+     * @returns Unique ID with prefix (e.g., "0-AuthProvider")
+     */
+    allocate(id: string): Promise<string>;
+    /**
+     * Allocate unique IDs for a batch of tasks.
+     *
+     * @param ids Array of requested IDs
+     * @returns Array of unique IDs in same order
+     */
+    allocateBatch(ids: string[]): Promise<string[]>;
+    /**
+     * Get the next ID that would be allocated (without allocating).
+     */
+    peekNextIndex(): Promise<number>;
+    /**
+     * Reset state (primarily for testing).
+     */
+    reset(): void;
+}