@cjhyy/code-shell 0.3.0 → 0.5.0-rc.2

package/dist/render/useTerminalNotification.d.ts

@@ -1,28 +0,0 @@
-import { type Progress } from './terminal.js';
-type WriteRaw = (data: string) => void;
-export declare const TerminalWriteContext: import("react").Context<WriteRaw | null>;
-export declare const TerminalWriteProvider: import("react").Provider<WriteRaw | null>;
-export type TerminalNotification = {
-    notifyITerm2: (opts: {
-        message: string;
-        title?: string;
-    }) => void;
-    notifyKitty: (opts: {
-        message: string;
-        title: string;
-        id: number;
-    }) => void;
-    notifyGhostty: (opts: {
-        message: string;
-        title: string;
-    }) => void;
-    notifyBell: () => void;
-    /**
-     * Report progress to the terminal via OSC 9;4 sequences.
-     * Supported terminals: ConEmu, Ghostty 1.2.0+, iTerm2 3.6.6+
-     * Pass state=null to clear progress.
-     */
-    progress: (state: Progress['state'] | null, percentage?: number) => void;
-};
-export declare function useTerminalNotification(): TerminalNotification;
-export {};

package/dist/render/warn.d.ts

@@ -1 +0,0 @@
-export declare function ifNotInteger(value: number | undefined, name: string): void;

package/dist/render/widest-line.d.ts

@@ -1 +0,0 @@
-export declare function widestLine(string: string): number;

package/dist/render/wrap-text.d.ts

@@ -1,2 +0,0 @@
-import type { Styles } from './styles.js';
-export default function wrapText(text: string, maxWidth: number, wrapType: Styles['textWrap']): string;

package/dist/render/wrapAnsi.d.ts

@@ -1,7 +0,0 @@
-type WrapAnsiOptions = {
-    hard?: boolean;
-    wordWrap?: boolean;
-    trim?: boolean;
-};
-declare const wrapAnsi: (input: string, columns: number, options?: WrapAnsiOptions) => string;
-export { wrapAnsi };

package/dist/run/ArtifactTracker.d.ts

@@ -1,38 +0,0 @@
-/**
- * ArtifactTracker — records meaningful artifact refs during run execution.
- *
- * Listens to StreamEvents and identifies:
- *   - Files written or edited (Write / Edit tool results)
- *   - Files created by Bash commands (mkdir, touch, cp, git commit, etc.)
- *   - Structured outputs (e.g., generated configs, test results)
- *
- * Design constraint (§14):
- *   - Only record artifacts valuable for recovery, display, evaluation, or audit
- *   - Do NOT record every Read or every tool output
- *   - Judgment: file writes are artifacts, reads are not
- */
-import type { StreamEvent } from "../types.js";
-import type { RunStore } from "./RunStore.js";
-export interface ArtifactTrackerConfig {
-    runId: string;
-    store: RunStore;
-}
-export declare class ArtifactTracker {
-    private readonly config;
-    private readonly pendingCalls;
-    private readonly recordedPaths;
-    constructor(config: ArtifactTrackerConfig);
-    /**
-     * Feed a StreamEvent to the tracker.
-     */
-    onStreamEvent(event: StreamEvent): Promise<void>;
-    /** Get all recorded artifact paths. */
-    getRecordedPaths(): string[];
-    private processToolResult;
-    private recordFileArtifact;
-    /**
-     * Extract artifact refs from Bash commands.
-     * Only track commands that clearly produce files.
-     */
-    private extractBashArtifacts;
-}

package/dist/run/CheckpointWriter.d.ts

@@ -1,53 +0,0 @@
-/**
- * CheckpointWriter — extracts structured checkpoints from Engine execution.
- *
- * Checkpoint sources (per design doc §12):
- *   1. Lifecycle — run started, resumed, completed (handled by RunManager)
- *   2. Phase boundary — detected from assistant messages via keyword heuristics
- *   3. Waiting — entering waiting_input / waiting_approval (handled by RunManager)
- *   4. Final — terminal state (handled by RunManager)
- *
- * This writer handles #2 (phase boundary) and periodic turn-based checkpoints.
- * It listens to StreamEvents and writes checkpoints to RunStore when triggered.
- *
- * Design constraints (§12.1):
- *   - Do NOT checkpoint every tool call
- *   - Do NOT depend on model real-time summarization
- *   - Checkpoint = "state summary + pointers", not "full text copy"
- */
-import type { StreamEvent } from "../types.js";
-import type { RunStore } from "./RunStore.js";
-export interface CheckpointWriterConfig {
-    runId: string;
-    objective: string;
-    store: RunStore;
-    /** Write a periodic checkpoint every N turns. 0 = disabled. Default: 10 */
-    turnInterval?: number;
-}
-export declare class CheckpointWriter {
-    private readonly config;
-    private readonly turnInterval;
-    private currentTurn;
-    private lastCheckpointTurn;
-    private touchedTools;
-    private lastAssistantText;
-    private sessionId;
-    private detectedPhases;
-    constructor(config: CheckpointWriterConfig);
-    /**
-     * Feed a StreamEvent to the writer. Called for every event during execution.
-     */
-    onStreamEvent(event: StreamEvent): Promise<void>;
-    /** Set the linked session ID (called once known after Engine.run starts). */
-    setSessionId(id: string): void;
-    /** Get accumulated touched tools for use in final checkpoint. */
-    getTouchedTools(): string[];
-    private checkPhaseBoundary;
-    private writePeriodicCheckpoint;
-    private writeCheckpoint;
-    /**
-     * Extract a short summary from assistant text.
-     * Takes the first ~300 chars, truncated at sentence boundary.
-     */
-    private extractSummary;
-}

package/dist/run/EngineRunner.d.ts

@@ -1,72 +0,0 @@
-/**
- * EngineRunner — bridges a RunSnapshot into an Engine.run() call.
- *
- * Responsibilities:
- *   - Prepare EngineConfig from run snapshot
- *   - Start or resume a session
- *   - Inject run-aware approval backend and askUser adapter
- *   - Forward stream events to RunManager
- *   - Return execution result (does NOT manage run state transitions)
- */
-import { type EngineConfig, type EngineHookConfig } from "../engine/engine.js";
-import type { LLMConfig, RegisteredTool } from "../types.js";
-import type { RunSnapshot, RunExecutionContext, RunExecutionResult } from "./types.js";
-import { type RunLifecycleHooks } from "./RunApprovalBackend.js";
-/**
- * Handles returned from execute() to allow RunManager to resolve
- * pending approvals and user input while Engine is suspended.
- */
-export interface RunExecutionHandle {
-    /** Resolve a pending tool approval. Returns false if nothing was pending. */
-    resolveApproval: (approved: boolean, reason?: string) => boolean;
-    /** Resolve a pending user input request. Returns false if nothing was pending. */
-    resolveInput: (answer: string) => boolean;
-    /** Check if there's a pending approval. */
-    hasPendingApproval: () => boolean;
-    /** Check if there's a pending input request. */
-    hasPendingInput: () => boolean;
-}
-/**
- * The contract for executing a Run. RunManager delegates to this interface.
- *
- * EngineRunner is the built-in implementation (calls CodeShell's LLM Engine).
- * External services can implement this to plug in any execution backend:
- *   - CI/CD pipeline runners
- *   - ETL orchestrators
- *   - Multi-agent coordinators
- *   - Custom API call chains
- */
-export interface RunExecutor {
-    execute(run: RunSnapshot, context: RunExecutionContext, lifecycleHooks?: RunLifecycleHooks, onHandleReady?: (handle: RunExecutionHandle) => void): Promise<{
-        result: RunExecutionResult;
-        handle: RunExecutionHandle;
-    }>;
-}
-export interface CustomToolEntry {
-    definition: RegisteredTool;
-    execute: (args: Record<string, unknown>) => Promise<string>;
-}
-export interface EngineRunnerConfig {
-    llm: LLMConfig;
-    maxTurns?: number;
-    maxContextTokens?: number;
-    sessionStorageDir?: string;
-    permissionMode?: EngineConfig["permissionMode"];
-    enabledBuiltinTools?: string[];
-    disabledBuiltinTools?: string[];
-    customSystemPrompt?: string;
-    appendSystemPrompt?: string;
-    mcpServers?: EngineConfig["mcpServers"];
-    /** Custom tools registered by the product adapter. */
-    customTools?: CustomToolEntry[];
-    /** Hooks registered into each Engine instance before run execution. */
-    hooks?: EngineHookConfig[];
-}
-export declare class EngineRunner implements RunExecutor {
-    private readonly config;
-    constructor(config: EngineRunnerConfig);
-    execute(run: RunSnapshot, context: RunExecutionContext, lifecycleHooks?: RunLifecycleHooks, onHandleReady?: (handle: RunExecutionHandle) => void): Promise<{
-        result: RunExecutionResult;
-        handle: RunExecutionHandle;
-    }>;
-}

package/dist/run/Evaluator.d.ts

@@ -1,56 +0,0 @@
-/**
- * Evaluator — contract for run completion evaluation.
- *
- * An evaluator inspects a completed (or about-to-complete) run and produces
- * a structured verdict. This enables:
- *   - Automated quality gates before marking a run as "completed"
- *   - Product-specific acceptance criteria
- *   - CI/CD integration for agent-driven workflows
- *
- * The evaluator is intentionally decoupled from the Engine:
- *   - It runs AFTER the Engine finishes, not during the turn loop
- *   - It receives the run snapshot + final checkpoint, not raw messages
- *   - Its result is written into the checkpoint's `evaluator` field
- *
- * Phase 5 provides the contract; concrete implementations are domain-specific.
- */
-import type { RunSnapshot, RunCheckpoint, RunArtifactRef } from "./types.js";
-export type EvaluatorVerdict = "passed" | "failed" | "warning";
-export interface EvaluatorResult {
-    verdict: EvaluatorVerdict;
-    findings: string[];
-    /** Optional structured data for programmatic consumption. */
-    details?: Record<string, unknown>;
-}
-export interface EvaluatorContext {
-    run: RunSnapshot;
-    checkpoint: RunCheckpoint;
-    artifacts: RunArtifactRef[];
-}
-export interface Evaluator {
-    /** Human-readable name for logging and display. */
-    readonly name: string;
-    /**
-     * Evaluate a run's final state.
-     * Should NOT have side effects beyond reading files/state.
-     * Must be safe to call multiple times on the same run.
-     */
-    evaluate(context: EvaluatorContext): Promise<EvaluatorResult>;
-}
-/**
- * Default evaluator that always passes. Used when no evaluator is configured.
- */
-export declare class NoopEvaluator implements Evaluator {
-    readonly name = "noop";
-    evaluate(): Promise<EvaluatorResult>;
-}
-/**
- * Runs multiple evaluators and merges their results.
- * The overall verdict is the worst across all evaluators.
- */
-export declare class CompositeEvaluator implements Evaluator {
-    readonly name: string;
-    private readonly evaluators;
-    constructor(evaluators: Evaluator[]);
-    evaluate(context: EvaluatorContext): Promise<EvaluatorResult>;
-}

package/dist/run/FileRunStore.d.ts

@@ -1,39 +0,0 @@
-/**
- * FileRunStore — local filesystem implementation of RunStore.
- *
- * Layout:
- *   ~/.code-shell/runs/<runId>/
- *     run.json              — current snapshot
- *     events.jsonl          — append-only event log
- *     checkpoints/<id>.json — structured checkpoints
- *     approvals/<id>.json   — approval records
- *     artifacts/refs.jsonl  — artifact reference log
- */
-import type { RunStore } from "./RunStore.js";
-import type { RunSnapshot, RunEvent, RunCheckpoint, RunApproval, RunArtifactRef, ListRunsQuery } from "./types.js";
-export declare class FileRunStore implements RunStore {
-    private readonly runsDir;
-    constructor(storageDir?: string);
-    private runDir;
-    private ensureRunDir;
-    private writeJson;
-    private readJson;
-    /** Serializes concurrent JSONL appends per file path. */
-    private readonly appendLocks;
-    private appendJsonl;
-    private readJsonl;
-    create(snapshot: RunSnapshot): Promise<void>;
-    update(snapshot: RunSnapshot): Promise<void>;
-    get(runId: string): Promise<RunSnapshot | null>;
-    list(query?: ListRunsQuery): Promise<RunSnapshot[]>;
-    delete(runId: string): Promise<void>;
-    appendEvent(event: RunEvent): Promise<void>;
-    listEvents(runId: string): Promise<RunEvent[]>;
-    saveCheckpoint(cp: RunCheckpoint): Promise<void>;
-    getLatestCheckpoint(runId: string): Promise<RunCheckpoint | null>;
-    saveApproval(approval: RunApproval): Promise<void>;
-    getApproval(runId: string, approvalId: string): Promise<RunApproval | null>;
-    getPendingApproval(runId: string): Promise<RunApproval | null>;
-    appendArtifactRef(ref: RunArtifactRef): Promise<void>;
-    listArtifactRefs(runId: string): Promise<RunArtifactRef[]>;
-}

package/dist/run/Heartbeat.d.ts

@@ -1,54 +0,0 @@
-/**
- * Heartbeat — periodic timestamp writer for run liveness detection.
- *
- * While a run is executing, the heartbeat writes a timestamp file at regular
- * intervals. Crash recovery uses this to determine if a "running" run is
- * actually alive or if its process died without cleanup.
- *
- * File: ~/.code-shell/runs/<runId>/heartbeat
- * Content: JSON { pid, timestamp, runId }
- */
-export interface HeartbeatConfig {
-    runsDir?: string;
-    /** Heartbeat interval in ms. Default: 5_000 (5 seconds) */
-    intervalMs?: number;
-}
-export interface HeartbeatData {
-    pid: number;
-    timestamp: number;
-    runId: string;
-}
-export declare class Heartbeat {
-    private readonly runsDir;
-    private readonly intervalMs;
-    private timers;
-    constructor(config?: HeartbeatConfig);
-    /**
-     * Start heartbeat for a run. Writes immediately, then repeats on interval.
-     */
-    start(runId: string): void;
-    /**
-     * Stop heartbeat for a run and remove the heartbeat file.
-     */
-    stop(runId: string): void;
-    /**
-     * Stop all heartbeats.
-     */
-    stopAll(): void;
-    /**
-     * Read the last heartbeat for a run. Returns null if no heartbeat exists.
-     */
-    read(runId: string): HeartbeatData | null;
-    /**
-     * Check if a run's heartbeat is stale (older than threshold).
-     * Returns true if stale or missing, false if recent.
-     */
-    isStale(runId: string, thresholdMs?: number): boolean;
-    /**
-     * Check if the process that wrote the heartbeat is still alive.
-     */
-    isProcessAlive(runId: string): boolean;
-    private write;
-    private remove;
-    private filePath;
-}

package/dist/run/RunApprovalBackend.d.ts

@@ -1,53 +0,0 @@
-/**
- * RunApprovalBackend — bridges Engine's approval system into Run lifecycle.
- *
- * When Engine requests tool approval:
- *   1. Creates a RunApproval record
- *   2. Notifies RunManager to transition the run to waiting_approval
- *   3. Suspends the Engine's promise until the user resumes the run
- *
- * Similarly for AskUser:
- *   1. Notifies RunManager to transition the run to waiting_input
- *   2. Suspends until the user provides input via resume
- */
-import type { ApprovalRequest, ApprovalResult } from "../types.js";
-import type { ApprovalBackend } from "../tool-system/permission.js";
-import type { AskUserFn } from "../tool-system/builtin/ask-user.js";
-export interface PendingApproval {
-    resolve: (result: ApprovalResult) => void;
-    request: ApprovalRequest;
-}
-export interface PendingInput {
-    resolve: (answer: string) => void;
-    question: string;
-}
-export interface RunLifecycleHooks {
-    onApprovalNeeded: (request: ApprovalRequest) => Promise<{
-        approvalId: string;
-    }>;
-    onInputNeeded: (question: string) => Promise<void>;
-    onApprovalResolved?: (approvalId: string, result: ApprovalResult) => void;
-    onInputResolved?: (answer: string) => void;
-}
-export declare class RunApprovalBackend implements ApprovalBackend {
-    private pendingApproval;
-    private hooks;
-    setHooks(hooks: RunLifecycleHooks): void;
-    /** Max time (ms) to wait for approval before auto-rejecting. Default: 24h */
-    private timeoutMs;
-    setTimeout(ms: number): void;
-    requestApproval(request: ApprovalRequest): Promise<ApprovalResult>;
-    /**
-     * Called by RunManager when the user resumes with an approval decision.
-     */
-    resolveApproval(result: ApprovalResult): boolean;
-    hasPendingApproval(): boolean;
-}
-/**
- * Creates an AskUserFn that suspends the run when user input is needed.
- */
-export declare function createRunAskUserFn(hooks: RunLifecycleHooks): {
-    askUserFn: AskUserFn;
-    resolveInput: (answer: string) => boolean;
-    hasPendingInput: () => boolean;
-};

package/dist/run/RunLock.d.ts

@@ -1,40 +0,0 @@
-/**
- * RunLock — file-based locking to prevent multiple workers from executing
- * the same run concurrently.
- *
- * Uses proper-lockfile (via lazy wrapper) for cross-process safe locking.
- * Each run gets a lock on its run.json file.
- */
-export interface RunLockConfig {
-    /** Base directory for runs. Default: ~/.code-shell/runs */
-    runsDir?: string;
-    /** Stale lock timeout in ms. Default: 60_000 (1 minute) */
-    staleMs?: number;
-}
-export declare class RunLock {
-    private readonly runsDir;
-    private readonly staleMs;
-    private readonly releaseFns;
-    constructor(config?: RunLockConfig);
-    /**
-     * Acquire a lock for a run. Returns true if acquired, false if already held.
-     */
-    acquire(runId: string): Promise<boolean>;
-    /**
-     * Release the lock for a run.
-     */
-    release(runId: string): Promise<void>;
-    /**
-     * Check if a run is currently locked by any process.
-     */
-    isLocked(runId: string): Promise<boolean>;
-    /**
-     * Force-unlock a stale lock (e.g., after crash recovery).
-     */
-    forceUnlock(runId: string): Promise<void>;
-    /**
-     * Release all locks held by this instance.
-     */
-    releaseAll(): Promise<void>;
-    private lockTarget;
-}

package/dist/run/RunManager.d.ts

@@ -1,82 +0,0 @@
-/**
- * RunManager — the top-level coordinator for managed agent runs.
- *
- * It does NOT replace Engine. It wraps Engine.run() to provide:
- *   - Submit / queue / start / resume / cancel lifecycle
- *   - State machine validation
- *   - Event sourcing (append-only run events)
- *   - Checkpoint and approval coordination
- *   - Waiting states: waiting_input / waiting_approval with suspend/resume
- *   - Attach (live stream subscription)
- *   - Run locking, heartbeat, and crash recovery (Phase 4)
- */
-import type { RunStore } from "./RunStore.js";
-import { type EngineRunnerConfig, type RunExecutor } from "./EngineRunner.js";
-import { type Evaluator } from "./Evaluator.js";
-import type { RunSnapshot, RunEvent, SubmitRunInput, ResumeRunInput, ListRunsQuery, RunStreamCallback, DetachFn } from "./types.js";
-export interface RunManagerConfig {
-    store: RunStore;
-    /**
-     * Execution backend. Two ways to provide:
-     *   - `EngineRunnerConfig` object → creates built-in EngineRunner (calls LLM Engine)
-     *   - `RunExecutor` instance → custom executor (any backend: CI/CD, ETL, etc.)
-     */
-    executor: RunExecutor | EngineRunnerConfig;
-    concurrency?: number;
-    /** Base directory for runs (used by lock and heartbeat). */
-    runsDir?: string;
-    /** Heartbeat interval in ms. Default: 5000 */
-    heartbeatIntervalMs?: number;
-    /** Stale lock timeout in ms. Default: 60000 */
-    staleLockMs?: number;
-    /** Optional evaluator to run on completion. Default: NoopEvaluator */
-    evaluator?: Evaluator;
-    /** Tags applied to every submitted run unless already present. */
-    defaultTags?: string[];
-    /** Metadata merged into every submitted run. Submit input wins on conflicts. */
-    defaultMetadata?: Record<string, unknown>;
-}
-export declare class RunManager {
-    private readonly store;
-    private readonly queue;
-    private readonly runner;
-    private readonly lock;
-    private readonly heartbeat;
-    private readonly evaluator;
-    private readonly defaultTags;
-    private readonly defaultMetadata;
-    private readonly subscribers;
-    private readonly abortControllers;
-    /** Active execution handles — used to resolve pending approvals/input while Engine is suspended */
-    private readonly executionHandles;
-    constructor(config: RunManagerConfig);
-    submit(input: SubmitRunInput): Promise<RunSnapshot>;
-    start(runId: string): Promise<void>;
-    resume(runId: string, input?: ResumeRunInput): Promise<void>;
-    cancel(runId: string, reason?: string): Promise<void>;
-    get(runId: string): Promise<RunSnapshot | null>;
-    list(query?: ListRunsQuery): Promise<RunSnapshot[]>;
-    getEvents(runId: string): Promise<RunEvent[]>;
-    attach(runId: string, cb: RunStreamCallback): DetachFn;
-    /**
-     * Scan for runs stuck in "running" state and recover them.
-     *
-     * Call this on process startup. For each "running" run:
-     *   - If heartbeat is stale AND process is dead → reset to "queued" or "blocked"
-     *   - If heartbeat is recent OR process is alive → skip (still executing)
-     *
-     * Returns the IDs of recovered runs.
-     */
-    recover(): Promise<string[]>;
-    /**
-     * Graceful shutdown — stop all heartbeats and release all locks.
-     */
-    shutdown(): Promise<void>;
-    private executeRun;
-    private handleApprovalNeeded;
-    private handleInputNeeded;
-    private transition;
-    private emitRunEvent;
-    private notifySubscribers;
-    private getOrThrow;
-}

package/dist/run/RunQueue.d.ts

@@ -1,27 +0,0 @@
-/**
- * RunQueue — simple in-process FIFO queue with configurable concurrency.
- *
- * Phase 1: single-process, no persistence.
- * The queue holds run IDs; the actual execution is delegated to a callback.
- */
-export interface RunQueueConfig {
-    concurrency?: number;
-}
-export type RunQueueExecutor = (runId: string) => Promise<void>;
-export declare class RunQueue {
-    private readonly concurrency;
-    private readonly pending;
-    private readonly active;
-    private executor;
-    private draining;
-    constructor(config?: RunQueueConfig);
-    setExecutor(fn: RunQueueExecutor): void;
-    enqueue(runId: string): void;
-    cancel(runId: string): boolean;
-    isActive(runId: string): boolean;
-    isPending(runId: string): boolean;
-    get activeCount(): number;
-    get pendingCount(): number;
-    private drain;
-    private processNext;
-}

package/dist/run/RunStore.d.ts

@@ -1,25 +0,0 @@
-/**
- * RunStore — persistence interface for Run lifecycle data.
- *
- * Implementations must guarantee:
- *   - Snapshot writes are atomic (no partial state on crash)
- *   - Event appends are append-only and ordered
- *   - Checkpoint / approval reads return the latest version
- */
-import type { RunSnapshot, RunEvent, RunCheckpoint, RunApproval, RunArtifactRef, ListRunsQuery } from "./types.js";
-export interface RunStore {
-    create(snapshot: RunSnapshot): Promise<void>;
-    update(snapshot: RunSnapshot): Promise<void>;
-    get(runId: string): Promise<RunSnapshot | null>;
-    list(query?: ListRunsQuery): Promise<RunSnapshot[]>;
-    delete(runId: string): Promise<void>;
-    appendEvent(event: RunEvent): Promise<void>;
-    listEvents(runId: string): Promise<RunEvent[]>;
-    saveCheckpoint(cp: RunCheckpoint): Promise<void>;
-    getLatestCheckpoint(runId: string): Promise<RunCheckpoint | null>;
-    saveApproval(approval: RunApproval): Promise<void>;
-    getApproval(runId: string, approvalId: string): Promise<RunApproval | null>;
-    getPendingApproval(runId: string): Promise<RunApproval | null>;
-    appendArtifactRef(ref: RunArtifactRef): Promise<void>;
-    listArtifactRefs(runId: string): Promise<RunArtifactRef[]>;
-}

package/dist/run/factory.d.ts

@@ -1,63 +0,0 @@
-/**
- * SDK convenience factory — create a RunManager with sensible defaults.
- *
- * Usage from an external repo:
- * ```ts
- * import { createRunManager } from "code-shell";
- *
- * const manager = createRunManager({
- *   llm: {
- *     provider: "openai",
- *     model: "anthropic/claude-sonnet-4",
- *     apiKey: process.env.OPENROUTER_API_KEY,
- *     baseUrl: "https://openrouter.ai/api/v1",
- *   },
- * });
- *
- * const run = await manager.submit({ objective: "Refactor the auth module" });
- * ```
- */
-import type { LLMConfig, PermissionMode } from "../types.js";
-import type { EngineConfig, EngineHookConfig } from "../engine/engine.js";
-import type { Evaluator } from "./Evaluator.js";
-import { RunManager } from "./RunManager.js";
-export interface CreateRunManagerOptions {
-    /** LLM configuration (required). */
-    llm: LLMConfig;
-    /** Working directory. Default: process.cwd() */
-    cwd?: string;
-    /** Max turns per engine execution. Default: 30 */
-    maxTurns?: number;
-    /** Max context tokens. Default: 200_000 */
-    maxContextTokens?: number;
-    /** Permission mode. Default: "acceptEdits" */
-    permissionMode?: PermissionMode;
-    /** Queue concurrency. Default: 1 */
-    concurrency?: number;
-    /** Custom storage directory for runs. Default: ~/.code-shell/runs */
-    runsDir?: string;
-    /** Custom storage directory for sessions. Default: ~/.code-shell/sessions */
-    sessionStorageDir?: string;
-    /** MCP servers to connect. */
-    mcpServers?: EngineConfig["mcpServers"];
-    /** Enabled builtin tools (add to preset defaults). */
-    enabledBuiltinTools?: string[];
-    /** Disabled builtin tools (remove from preset defaults). */
-    disabledBuiltinTools?: string[];
-    /** Custom system prompt (replaces preset prompt). */
-    customSystemPrompt?: string;
-    /** Append to system prompt (added after preset prompt). */
-    appendSystemPrompt?: string;
-    /** Optional evaluator for run completion. */
-    evaluator?: Evaluator;
-    /** Hooks registered into each Engine instance before run execution. */
-    hooks?: EngineHookConfig[];
-    /** Tags applied to every submitted run unless already present. */
-    defaultTags?: string[];
-    /** Metadata merged into every submitted run. Submit input wins on conflicts. */
-    defaultMetadata?: Record<string, unknown>;
-}
-/**
- * Create a fully configured RunManager with one call.
- */
-export declare function createRunManager(options: CreateRunManagerOptions): RunManager;