@sayknow-cli/coding-agent 0.3.6 → 0.3.7

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

@@ -0,0 +1,102 @@
+/**
+ * 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 project context files using the capability API.
+ * Returns {path, content, depth} entries for all discovered context files.
+ * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ */
+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 MCP tool discovery is active for this prompt build. */
+    mcpDiscoveryMode?: boolean;
+    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
+    mcpDiscoveryServerSummaries?: string[];
+    /** Whether built-in tool discovery ("all" mode) is active; enables the tool-discovery prompt block. */
+    toolDiscoveryActive?: boolean;
+    /** Hidden discoverable tools to advertise (name + one-line summary) when tool discovery is active. */
+    discoverableTools?: Array<{
+        name: string;
+        summary: string;
+    }>;
+    /** 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>;
+}
+/** 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[];
+}
+/** 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;
+    constructor(error: Error, source?: unknown);
+    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,121 @@
+/**
+ * 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 { 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 type { ForkContextSeed } from "../session/agent-session";
+import type { ArtifactManager } from "../session/artifacts";
+import type { AuthStorage } from "../session/auth-storage";
+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";
+/** 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;
+    eventBus?: EventBus;
+    contextFiles?: ContextFileEntry[];
+    skills?: Skill[];
+    promptTemplates?: PromptTemplate[];
+    workspaceTree?: WorkspaceTree;
+    authStorage?: AuthStorage;
+    modelRegistry?: ModelRegistry;
+    settings?: Settings;
+    /**
+     * 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;
+    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 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 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/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;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Parallel execution with concurrency control.
+ */
+/** Result of parallel execution */
+export interface ParallelResult<R> {
+    /** Results array - undefined entries indicate tasks that were skipped due to abort */
+    results: (R | undefined)[];
+    /** Whether execution was aborted before all tasks completed */
+    aborted: boolean;
+}
+/**
+ * Execute items with a concurrency limit using a worker pool pattern.
+ * Results are returned in the same order as input items.
+ *
+ * On abort: returns partial results with `aborted: true`. Completed tasks are preserved,
+ * in-progress tasks will complete with their abort handling, skipped tasks are `undefined`.
+ *
+ * On error: fails fast - does not wait for other workers to complete.
+ *
+ * @param items - Items to process
+ * @param concurrency - Maximum concurrent operations
+ * @param fn - Async function to execute for each item
+ * @param signal - Optional abort signal to stop scheduling new work
+ */
+export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
+/**
+ * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ */
+export declare class Semaphore {
+    #private;
+    constructor(max: number);
+    acquire(): Promise<void>;
+    release(): void;
+}

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

@@ -0,0 +1,87 @@
+import type { SingleResult, TaskToolDetails } from "./types";
+export interface TaskRoi {
+    tokens: number;
+    contextTokens?: number;
+    clonedTokens?: number;
+    costTotal?: number;
+    outputBytes?: number;
+    outputLines?: number;
+    producedChanges: boolean;
+    materialContribution: boolean;
+    lowRoi: boolean;
+}
+export interface TaskResultReceipt {
+    index: number;
+    id: string;
+    agent: string;
+    agentSource: SingleResult["agentSource"];
+    task: string;
+    assignment?: string;
+    description?: string;
+    status: "completed" | "failed" | "aborted" | "merge_failed" | "paused";
+    exitCode: number;
+    aborted?: boolean;
+    paused?: boolean;
+    truncated: boolean;
+    durationMs: number;
+    tokens: number;
+    contextTokens?: number;
+    contextWindow?: number;
+    modelOverride?: string | string[];
+    modelSubstitutionWarning?: SingleResult["modelSubstitutionWarning"];
+    usage?: SingleResult["usage"];
+    cost?: number;
+    branchName?: string;
+    retryFailure?: {
+        attempt: number;
+        errorSummary: string;
+    };
+    errorSummary?: string;
+    abortSummary?: string;
+    preview: string;
+    previewTruncated: boolean;
+    outputRef?: {
+        uri: string;
+        sizeBytes: number;
+        lineCount: number;
+        sha256?: string;
+    };
+    outputUnavailable?: boolean;
+    review?: {
+        overallCorrectness?: string;
+        findingCount: number;
+        findings?: Array<{
+            severity?: string;
+            summary: string;
+        }>;
+    };
+    extractedToolCounts?: Record<string, number>;
+    forkContext?: SingleResult["forkContext"];
+    forkContextAdvisory?: SingleResult["forkContextAdvisory"];
+    roi?: TaskRoi;
+}
+/**
+ * Heuristic task ROI signal built only from receipt-safe accounting fields.
+ * Advisory only: these flags never change task success/failure semantics.
+ */
+export declare function buildTaskRoi(raw: SingleResult): TaskRoi;
+export declare function buildTaskRoiSummary(receipts: readonly TaskResultReceipt[]): TaskToolDetails["roiSummary"];
+export declare function buildTaskReceipt(raw: SingleResult): TaskResultReceipt;
+/**
+ * Raw, pre-sanitization task details: the internal shape produced during task
+ * execution, where `results` are full `SingleResult` objects. The public
+ * `TaskToolDetails` exposes only receipts.
+ */
+export interface RawTaskToolDetails {
+    projectAgentsDir: string | null;
+    results: SingleResult[];
+    totalDurationMs: number;
+    usage?: TaskToolDetails["usage"];
+    async?: TaskToolDetails["async"];
+    forkContextClonedTokens?: number;
+    roiSummary?: TaskToolDetails["roiSummary"];
+}
+/** Central converter from raw task details to receipt-only public details. */
+export declare function sanitizeTaskToolDetails(raw: RawTaskToolDetails): TaskToolDetails;
+export declare function findRawTaskLeakKeys(value: unknown): string[];
+export declare function assertNoRawTaskFields(value: unknown, surface: string): void;

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

@@ -0,0 +1,28 @@
+import type { Component } from "@sayknow-cli/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { AgentProgress, TaskParams, TaskToolDetails } from "./types";
+/**
+ * Render the tool call arguments.
+ */
+export declare function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component;
+/**
+ * Public wrapper to render a single subagent's live `AgentProgress` for the
+ * `subagent` await panel. Reuses the internal task-progress renderer so the
+ * await panel stays at parity with the inline task panel.
+ */
+export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number, staticTime?: boolean): string[];
+/**
+ * Render the tool result.
+ */
+export declare function renderResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: TaskToolDetails;
+}, options: RenderResultOptions, theme: Theme): Component;
+export declare const taskToolRenderer: {
+    renderCall: typeof renderCall;
+    renderResult: typeof renderResult;
+};

package/dist/types/task/roi-reconciliation.d.ts

@@ -0,0 +1,27 @@
+import type { TaskResultReceipt } from "./receipt";
+import type { SpawnPlanReceipt } from "./spawn-gate";
+/**
+ * Pure, advisory-only reconciliation between a spawn plan's inline-token promise
+ * and receipt-safe child outputs. These signals never change task success/failure
+ * semantics or runtime behavior; they only describe budget/ROI observations for
+ * model-facing summaries.
+ */
+export interface SpawnRoiChildReconciliation {
+    id: string;
+    inlineTokens: number;
+    maxInlineTokens: number;
+    overBudget: boolean;
+    overageTokens: number;
+    lowRoi: boolean;
+}
+export interface SpawnRoiReconciliation {
+    childCount: number;
+    promisedMaxInlineTokens: number;
+    children: SpawnRoiChildReconciliation[];
+    overBudgetChildIds: string[];
+    lowRoiChildIds: string[];
+    totalInlineTokens: number;
+    totalOverageTokens: number;
+    advisoryFlags: string[];
+}
+export declare function reconcileSpawnRoi(plan: SpawnPlanReceipt | undefined, receipts: readonly TaskResultReceipt[]): SpawnRoiReconciliation | undefined;

package/dist/types/task/simple-mode.d.ts

@@ -0,0 +1,8 @@
+export declare const TASK_SIMPLE_MODES: readonly ["default", "schema-free", "independent"];
+export type TaskSimpleMode = (typeof TASK_SIMPLE_MODES)[number];
+interface TaskSimpleModeCapabilities {
+    contextEnabled: boolean;
+    customSchemaEnabled: boolean;
+}
+export declare function getTaskSimpleModeCapabilities(mode: TaskSimpleMode): TaskSimpleModeCapabilities;
+export {};

package/dist/types/task/skc-command.d.ts

@@ -0,0 +1,7 @@
+interface SkcCommand {
+    cmd: string;
+    args: string[];
+    shell: boolean;
+}
+export declare function resolveSkcCommand(): SkcCommand;
+export {};

package/dist/types/task/spawn-gate.d.ts

@@ -0,0 +1,29 @@
+/** The hard, locked batch threshold enforced by the runtime gate. */
+export declare const DEFAULT_SPAWN_THRESHOLD = 4;
+/** The justification a large batch must supply to pass the hard gate. */
+export interface SpawnPlanReceipt {
+    whyParallel: string;
+    whyNotLocal: string;
+    independence: string;
+    expectedReceiptShape: string;
+    maxInlineTokens: number;
+}
+export interface SpawnGateRequest {
+    /** Number of children the batch wants to spawn. */
+    childCount: number;
+    /** The spawn-plan receipt, when provided. */
+    plan?: SpawnPlanReceipt;
+}
+export type SpawnGateOutcome = "allowed" | "rejected";
+export interface SpawnGateDecision {
+    outcome: SpawnGateOutcome;
+    /** Human-readable reason, suitable for a blocked-result message. */
+    reason: string;
+    /** Whether a plan was required for this request. */
+    planRequired: boolean;
+    /** Missing plan field names when rejected for an incomplete plan. */
+    missingFields: readonly string[];
+}
+export declare function findMissingPlanFields(plan: SpawnPlanReceipt | undefined): string[];
+export declare function decide(childCount: number, threshold: number, plan: SpawnPlanReceipt | undefined): SpawnGateDecision;
+export declare function evaluateSpawnGate(request: SpawnGateRequest): SpawnGateDecision;