@bluecopa/harness 1.0.0 → 2.0.0

package/dist/arc/index.d.ts

@@ -0,0 +1,796 @@
+import { A as AnyTool, T as ToolProvider, a as ToolResult, M as ModelFactory, b as ToolResultArtifact } from '../shared-types-DRxnerLT.js';
+export { c as ActionType, B as BashOptions, d as BatchOp, e as BatchResult, G as GlobOptions, f as GrepOptions, R as ReadOptions, g as TextEditorRequest, h as ThreadStatus, i as ToolProviderCapabilities, W as WebFetchOptions } from '../shared-types-DRxnerLT.js';
+import 'ai';
+
+interface ToolCallInfo {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    /** Provider-specific metadata preserved across round-trips (e.g., Gemini thought signatures). */
+    providerMetadata?: Record<string, unknown>;
+}
+interface ToolResultInfo {
+    toolCallId: string;
+    toolName: string;
+    result: string;
+    isError?: boolean;
+    durationMs?: number;
+}
+type ContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    image: Buffer | Uint8Array;
+    mimeType: string;
+};
+interface AgentMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentPart[];
+    toolCalls?: ToolCallInfo[];
+    toolResults?: ToolResultInfo[];
+    /** Provider-specific metadata preserved across round-trips (e.g., Gemini thought signatures). */
+    providerMetadata?: Record<string, unknown>;
+}
+
+/**
+ * Tool registry: the Tool contract and schema extraction.
+ *
+ * Agent tool definitions (Bash, Read, Write, etc.) live in the consumer
+ * (truecode). The harness only provides the Tool contract and helpers.
+ */
+
+/** A registered tool: schema for the model, execute for the worker */
+interface Tool {
+    name: string;
+    /** AI SDK tool schema. Optional for ARC-internal tools (ReadEpisode, LCM_*, ScratchPad_*). */
+    schema?: AnyTool | undefined;
+    /** Execute using the ToolProvider. If not set, tool is handled externally (e.g. ARC tools). */
+    execute?: (provider: ToolProvider, args: Record<string, unknown>, workDir: string) => Promise<ToolResult>;
+}
+
+interface StoredMessage {
+    id: string;
+    conversationId: string;
+    index: number;
+    role: "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: ToolCallInfo[];
+    toolResults?: ToolResultInfo[];
+    timestamp: number;
+}
+interface GrepResult {
+    messageId: string;
+    conversationId: string;
+    messageIndex: number;
+    excerpt: string;
+    matchContext: string;
+}
+interface MessageStore {
+    append(message: StoredMessage): void;
+    getConversation(conversationId: string): StoredMessage[];
+    getMessage(conversationId: string, index: number): StoredMessage | null;
+    grep(pattern: string, opts?: {
+        conversationId?: string;
+        maxResults?: number;
+    }): GrepResult[];
+    /** Serialize all messages for session persistence. */
+    serialize(): StoredMessage[];
+    /** Load serialized messages into this store (for session hydration). */
+    loadFrom(messages: StoredMessage[]): void;
+}
+declare class MemoryMessageStore implements MessageStore {
+    private messages;
+    private byConversation;
+    append(message: StoredMessage): void;
+    getConversation(conversationId: string): StoredMessage[];
+    getMessage(conversationId: string, index: number): StoredMessage | null;
+    serialize(): StoredMessage[];
+    loadFrom(messages: StoredMessage[]): void;
+    static hydrate(messages: StoredMessage[]): MemoryMessageStore;
+    grep(pattern: string, opts?: {
+        conversationId?: string;
+        maxResults?: number;
+    }): GrepResult[];
+}
+
+interface SummaryNode {
+    id: string;
+    depth: number;
+    sourceIds: string[];
+    sourceConversationIds: string[];
+    summary: string;
+    artifacts: string[];
+    operations: string[];
+    outcome: string;
+    tokenCount: number;
+    createdAt: number;
+}
+interface CompactionOpts {
+    /** Minimum number of uncovered children before compaction triggers (default: 4) */
+    minChildren?: number;
+    /** Soft token budget — compact when total tokens at a depth exceed this (default: 8000) */
+    softTokenBudget?: number;
+}
+interface SummaryDAG {
+    addLeaf(node: SummaryNode): void;
+    compact(opts?: CompactionOpts): SummaryNode[];
+    getNode(id: string): SummaryNode | null;
+    getLineage(id: string, visited?: Set<string>): string[];
+    getFrontier(budget: number): {
+        frontier: SummaryNode[];
+        coveredIds: Set<string>;
+    };
+    getAllNodes(): SummaryNode[];
+    /** Serialize DAG state for session persistence. */
+    serialize(): {
+        nodes: SummaryNode[];
+        coveredBy: [string, string][];
+    };
+    /** Load serialized DAG state into this instance (for session hydration). */
+    loadFrom(data: {
+        nodes: SummaryNode[];
+        coveredBy: [string, string][];
+    }): void;
+}
+declare class MemorySummaryDAG implements SummaryDAG {
+    private nodes;
+    /** Tracks which source IDs have been covered by a parent node */
+    private coveredBy;
+    serialize(): {
+        nodes: SummaryNode[];
+        coveredBy: [string, string][];
+    };
+    loadFrom(data: {
+        nodes: SummaryNode[];
+        coveredBy: [string, string][];
+    }): void;
+    static hydrate(data: {
+        nodes: SummaryNode[];
+        coveredBy: [string, string][];
+    }): MemorySummaryDAG;
+    addLeaf(node: SummaryNode): void;
+    compact(opts?: CompactionOpts): SummaryNode[];
+    getNode(id: string): SummaryNode | null;
+    getLineage(id: string, visited?: Set<string>): string[];
+    getFrontier(budget: number): {
+        frontier: SummaryNode[];
+        coveredIds: Set<string>;
+    };
+    getAllNodes(): SummaryNode[];
+}
+
+interface GhostCue {
+    summaryId: string;
+    conversationIds: string[];
+    depth: number;
+    label: string;
+}
+interface AssembledContext {
+    messages: AgentMessage[];
+    ghostCues: GhostCue[];
+    tokenEstimate: number;
+    /** Structured sections for downstream consumers (avoids string matching) */
+    frontierText?: string;
+    ghostCueText?: string;
+}
+
+type HookEventName = 'PreToolUse' | 'PostToolUse' | 'BeforeWorker' | 'AfterWorker';
+interface HookContext {
+    event: HookEventName;
+    toolName?: string;
+    input?: Record<string, unknown>;
+    output?: ToolResult;
+    metadata?: Record<string, unknown>;
+}
+interface HookDecision {
+    allow: boolean;
+    reason?: string;
+}
+type HookCallback = (context: HookContext) => Promise<HookDecision | void>;
+
+declare class HookRunner {
+    private readonly hooks;
+    register(event: HookContext['event'], callback: HookCallback): void;
+    run(context: HookContext): Promise<HookDecision>;
+}
+
+/** Raw worker transcript, append-only storage */
+interface Transcript {
+    id: string;
+    tupleId: string;
+    instruction: string;
+    messages: AgentMessage[];
+    timestamp: number;
+}
+/** Artifact produced by a worker dispatch */
+interface Artifact {
+    id: string;
+    tupleId: string;
+    /** File path or returned value */
+    output: string | null;
+    /** Full textual worker result, preserved even when expected file artifacts are missing */
+    textOutput?: string | undefined;
+    status: "complete" | "incomplete" | "failed" | "interrupted";
+    /** One-line summary from worker's final message */
+    summary: string;
+    stepsUsed: number;
+    /** Tool calls with results (for orchestrator reasoning) */
+    actions?: string[];
+    /** The dispatch instruction that produced this artifact */
+    instruction?: string;
+}
+interface ExpectedArtifact {
+    type: "file" | "directory" | "value" | "unknown";
+    path?: string | undefined;
+    description?: string | undefined;
+}
+interface ExpectedOutputContract {
+    artifacts: ExpectedArtifact[];
+    successCriteria?: string[] | undefined;
+    verification?: string | undefined;
+    description?: string | undefined;
+}
+/** Worker model tier for dispatch routing. */
+type DispatchTier = "fast" | "strong";
+/** Worker instruction tuple */
+interface Tuple {
+    id: string;
+    instruction: string;
+    /** Artifact IDs to provide as input */
+    inputs: string[];
+    /** Structured contract for what the worker should produce */
+    expectedOutput: ExpectedOutputContract;
+    /** Tool names available to worker */
+    tools: string[];
+    /** Step budget (1-10) */
+    steps: number;
+    /** Worker model tier — 'fast' for simple tasks, 'strong' (default) for complex reasoning. */
+    tier?: DispatchTier | undefined;
+    /** Public orchestrator rationale that preceded this dispatch */
+    orchestratorContext?: string | undefined;
+}
+interface DispatchRecord {
+    tuple: Tuple;
+    artifact: Artifact;
+    /** Reference to transcript in TranscriptStore — NOT the full transcript body. */
+    transcriptId: string;
+    progress: WorkerProgressEvent[];
+    completedAt: number;
+    /** Worker execution result (artifacts, actions, status) */
+    workerResult?: WorkerResult | undefined;
+}
+interface OodaSnapshot {
+    observations: string[];
+    beliefs: string[];
+    disprovenApproaches: string[];
+    blockers: string[];
+    decisionPressure: {
+        turn: number;
+        maxTurns: number;
+        turnsRemaining: number;
+        dispatchCount: number;
+        allIncomplete: boolean;
+    };
+}
+type ReadEpisodeDetail = "summary" | "trace" | "artifacts";
+interface ReadEpisodeArgs {
+    id: string;
+    detail?: ReadEpisodeDetail | undefined;
+    artifactKey?: string | undefined;
+    maxTokens?: number | undefined;
+}
+interface TraceToolCall {
+    toolName: string;
+    toolCallId?: string | undefined;
+    args: Record<string, unknown>;
+}
+type ArcTraceEvent = {
+    scope: "orchestrator";
+    phase: "model_input";
+    turn: number;
+    model: string;
+    system: string;
+    /** Full AgentMessage context before SDK conversion. */
+    messages: AgentMessage[];
+    /** Full SDK-facing messages after conversion. */
+    modelMessages: unknown[];
+    toolNames: string[];
+} | {
+    scope: "orchestrator";
+    phase: "model_output";
+    turn: number;
+    text: string;
+    toolCalls: TraceToolCall[];
+} | {
+    scope: "orchestrator";
+    phase: "public_rationale_missing";
+    turn: number;
+    toolCalls: TraceToolCall[];
+} | {
+    scope: "orchestrator";
+    phase: "tool_call";
+    turn: number;
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    scope: "orchestrator";
+    phase: "tool_result";
+    turn: number;
+    toolName: string;
+    args: Record<string, unknown>;
+    result: unknown;
+} | {
+    scope: "worker";
+    phase: "model_input";
+    tupleId: string;
+    step: number;
+    model: string;
+    system: string;
+    messages: AgentMessage[];
+    toolNames: string[];
+} | {
+    scope: "worker";
+    phase: "model_output";
+    tupleId: string;
+    step: number;
+    action: unknown;
+} | {
+    scope: "worker";
+    phase: "public_rationale_missing";
+    tupleId: string;
+    step: number;
+    toolNames: string[];
+} | {
+    scope: "worker";
+    phase: "tool_call";
+    tupleId: string;
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    scope: "worker";
+    phase: "tool_result";
+    tupleId: string;
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    resultText: string;
+} | {
+    scope: "worker";
+    phase: "worker_result";
+    tupleId: string;
+    result: unknown;
+};
+interface TranscriptStore {
+    append(transcript: Transcript): Promise<void>;
+    getAll(): Promise<Transcript[]>;
+    get(id: string): Promise<Transcript | null>;
+}
+interface VectorIndex {
+    add(id: string, text: string): Promise<void>;
+    search(query: string, k: number): Promise<string[]>;
+    load(): Promise<void>;
+    save(): Promise<void>;
+}
+interface ArtifactStore {
+    set(id: string, artifact: Artifact): Promise<void>;
+    get(id: string): Promise<Artifact | null>;
+    getAll(): Promise<Record<string, Artifact>>;
+}
+interface ScratchPad {
+    write(key: string, content: string): Promise<void>;
+    read(key: string): Promise<string | null>;
+    list(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/** Serialized session state — everything needed to hydrate an ArcLoop. */
+interface SessionSnapshot {
+    messages: StoredMessage[];
+    dispatches: DispatchRecord[];
+    dagNodes: SummaryNode[];
+    dagCoveredBy: [string, string][];
+    turn: number;
+    dispatchCount: number;
+    orchestratorMessageIndex: number;
+}
+/** Lightweight session metadata for listing/picking. */
+interface SessionMeta {
+    id: string;
+    slug: string;
+    createdAt: number;
+    lastActiveAt: number;
+    taskCount?: number;
+    summary: string;
+}
+interface SessionStore {
+    load(id: string): Promise<SessionSnapshot | null>;
+    save(id: string, snapshot: SessionSnapshot): Promise<void>;
+    getMeta(id: string): Promise<SessionMeta | null>;
+    saveMeta(id: string, meta: SessionMeta): Promise<void>;
+    list(): Promise<SessionMeta[]>;
+}
+/** What the orchestrator sees each turn */
+interface OrchestratorContext {
+    task: string;
+    artifacts: Record<string, Artifact>;
+    lastResult: Artifact | null;
+    /** Rolling window of recent orchestrator messages */
+    recentTurns: AgentMessage[];
+    /** Current turn number */
+    turn: number;
+    /** Max turns allowed */
+    maxTurns: number;
+    /** Turns remaining after the current turn */
+    turnsRemaining: number;
+    /** Number of dispatches so far */
+    dispatchCount: number;
+    /** Artifact status counts across all completed dispatches */
+    artifactStatusCounts: Record<Artifact["status"], number>;
+    /** True when no dispatch artifact has reached complete status */
+    allIncomplete: boolean;
+    /** Completed dispatches in chronological order */
+    dispatches: DispatchRecord[];
+    /** Current observe/orient state rendered into the orchestrator prompt */
+    ooda: OodaSnapshot;
+    /** LCM message store (all conversations) */
+    messageStore?: MessageStore | undefined;
+    /** LCM summary DAG */
+    summaryDAG?: SummaryDAG | undefined;
+}
+
+interface ArcConfig {
+    task: string;
+    workDir: string;
+    /** Model ID for the orchestrator */
+    model: string;
+    /** Model ID for workers */
+    workerModel: string;
+    /** Optional per-tier worker model overrides. Falls back to workerModel when a tier is missing. */
+    workerModelMap?: Partial<Record<DispatchTier, string>> | undefined;
+    createModel?: ModelFactory;
+    toolProvider: ToolProvider;
+    /** Agent-provided tool definitions (Bash, Read, Write, etc.) with schemas, execute, and artifact metadata. Harness adds ARC framework tools internally. */
+    tools?: Map<string, Tool> | undefined;
+    /** Max orchestrator turns before stopping (default: 12) */
+    maxTurns?: number;
+    /** Max steps per worker (default: 5, max: 10) */
+    maxStepsPerWorker?: number;
+    /** Rolling window size for orchestrator context (default: 10) */
+    orchestratorWindowSize?: number;
+    /** Directory where agent memory lives (default: workDir/.arc) */
+    memDir?: string;
+    /** Injected vector index (default: in-memory for tests) */
+    vectorIndex?: VectorIndex;
+    /** Injected scratch pad for inter-worker note sharing (default: in-memory for tests) */
+    scratchPad?: ScratchPad;
+    /** Injected transcript store (default: in-memory) */
+    transcriptStore?: TranscriptStore;
+    /** Injected artifact store (default: in-memory) */
+    artifactStore?: ArtifactStore;
+    /** Custom worker system prompt (appended to default) */
+    workerSystemPromptSuffix?: string | undefined;
+    /** Custom messages after the core task/budget block */
+    formatOrchestratorContext?: ((context: OrchestratorContext) => AgentMessage[]) | undefined;
+    /** Provider options passed to generateText (e.g. reasoningEffort for OpenAI). */
+    providerOptions?: Record<string, unknown> | undefined;
+    /** Optional hook runner for PreToolUse/PostToolUse/BeforeWorker/AfterWorker events */
+    hookRunner?: HookRunner | undefined;
+    /** Callback for AskUser orchestrator tool. If provided, AskUser is available to the orchestrator. */
+    askUser?: ((question: string, options?: string[]) => Promise<string>) | undefined;
+    /** Session store for persistence across restarts. */
+    sessionStore?: SessionStore | undefined;
+    /** Session ID to resume. If provided with sessionStore, loop hydrates from saved state. */
+    sessionId?: string | undefined;
+}
+type ArcEvent = {
+    type: "orchestrator_turn";
+    turn: number;
+    contextTokens: number;
+} | {
+    type: "trace";
+    trace: ArcTraceEvent;
+} | {
+    type: "dispatch";
+    tupleId: string;
+    instruction: string;
+} | {
+    type: "dispatch_full";
+    tuple: Tuple;
+} | {
+    type: "worker_progress";
+    tupleId: string;
+    progress: WorkerProgressEvent;
+} | {
+    type: "worker_complete";
+    tupleId: string;
+    status: Artifact["status"];
+    summary: string;
+    stepsUsed: number;
+    actions?: string[] | undefined;
+} | {
+    type: "recall";
+    query: string;
+    answer: string;
+} | {
+    type: "read_episode";
+    id: string;
+    detail: ReadEpisodeDetail;
+    output: string;
+} | {
+    type: "ask_user";
+    question: string;
+    options?: string[] | undefined;
+} | {
+    type: "orchestrator_usage";
+    turn: number;
+    inputTokens?: number;
+    outputTokens?: number;
+} | {
+    type: "done";
+    output: string;
+} | {
+    type: "session_saved";
+    sessionId: string;
+} | {
+    type: "text_delta";
+    text: string;
+};
+type WorkerProgressEvent = {
+    kind: "model_start";
+    step: number;
+    maxSteps: number;
+} | {
+    kind: "model_complete";
+    step: number;
+    actionType: "final" | "tool" | "tool_batch";
+    durationMs: number;
+    toolNames?: string[] | undefined;
+    publicRationale?: string | undefined;
+    missingPublicRationale?: boolean | undefined;
+    outputSummary?: string | undefined;
+    inputTokens?: number | undefined;
+    outputTokens?: number | undefined;
+} | {
+    kind: "model_error";
+    step: number;
+    durationMs: number;
+    error: string;
+} | {
+    kind: "tool_start";
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    argsSummary?: string | undefined;
+} | {
+    kind: "tool_complete";
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    success: boolean;
+    durationMs: number;
+    outputSummary: string;
+    output?: string | undefined;
+    exitCode?: unknown;
+} | {
+    kind: "tool_error";
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    durationMs: number;
+    error: string;
+} | {
+    kind: "worker_result";
+    status: "complete" | "incomplete" | "failed" | "interrupted";
+    stepsUsed: number;
+    summary: string;
+};
+interface RunWorkerConfig {
+    /** Original top-level task */
+    task?: string | undefined;
+    instruction: string;
+    /** Structured contract for this dispatch */
+    expectedOutput?: ExpectedOutputContract | undefined;
+    /** LCM-assembled context for this worker */
+    lcmContext?: AssembledContext | undefined;
+    /** Artifact ID -> file content */
+    inputArtifacts: Map<string, string>;
+    tools: Record<string, AnyTool>;
+    /** Tool registry with execute/artifact metadata for dispatch and episode projection */
+    toolRegistry: Map<string, Tool>;
+    maxSteps: number;
+    toolProvider: ToolProvider;
+    createModel: ModelFactory;
+    model: string;
+    workDir: string;
+    signal?: AbortSignal | undefined;
+    /** Extra text prefixed to worker system prompt */
+    systemPromptPrefix?: string | undefined;
+    /** Extra text appended to worker system prompt */
+    systemPromptSuffix?: string | undefined;
+    /** Provider options passed to generateText (e.g. reasoning config). */
+    providerOptions?: Record<string, unknown> | undefined;
+    /** Public orchestrator rationale that preceded this dispatch */
+    orchestratorContext?: string | undefined;
+    /** Tuple id for full-fidelity trace events */
+    tupleId?: string | undefined;
+    /** Optional diagnostic hook for streaming worker internals to the caller */
+    onProgress?: ((event: WorkerProgressEvent) => void) | undefined;
+    /** Optional full-fidelity trace hook for raw model/tool IO */
+    onTrace?: ((event: ArcTraceEvent) => void) | undefined;
+    /** Optional hook runner for PreToolUse/PostToolUse events */
+    hookRunner?: HookRunner | undefined;
+}
+interface WorkerResult {
+    transcript: AgentMessage[];
+    output: string | null;
+    status: "complete" | "incomplete" | "failed" | "interrupted";
+    stepsUsed: number;
+    /** Last message content for summary */
+    lastMessage: string;
+    /** All tool calls with results for orchestrator visibility */
+    actions: string[];
+    /** Artifacts touched during execution (from ToolResult.artifact) */
+    artifacts: ToolResultArtifact[];
+}
+
+interface ArcRunResult {
+    output: string;
+    events: ArcEvent[];
+}
+declare class ArcLoop {
+    private config;
+    private readonly transcriptStore;
+    private readonly vectorIndex;
+    private readonly scratchPad;
+    private readonly artifactStore;
+    private messageStore;
+    private summaryDAG;
+    private readonly createModel;
+    private readonly windowSize;
+    private readonly model;
+    /** Orchestrator tool schemas (for the model) */
+    private readonly orchestratorToolSchemas;
+    /** Orchestrator tool registry (for execute) — excludes dispatch/done (control flow) */
+    private readonly orchestratorToolRegistry;
+    /** Dispatcher deps + mutable state — shared with dispatcher.ts functions */
+    private readonly dispatchDeps;
+    private readonly dispatchState;
+    private orchestratorMessageIndex;
+    private turn;
+    private maxTurns;
+    /** Per-turn abort controller — cancelled by interrupt(), refreshed each turn. */
+    private turnController;
+    /** Resolver for the next task — set when the loop is waiting between tasks. */
+    private taskResolve;
+    constructor(config: ArcConfig);
+    /**
+     * Interrupt the current turn — cancels in-flight model calls and workers.
+     * The orchestrator loop stays alive and will prompt for user steering.
+     */
+    interrupt(): void;
+    /** True when the loop is waiting for the next task (between done boundaries). */
+    get idle(): boolean;
+    /**
+     * Push a follow-up task into the loop. The orchestrator sees it as
+     * a new user message with full conversational context from prior tasks.
+     */
+    pushTask(task: string): boolean;
+    private waitForNextTask;
+    /** Save session snapshot + update meta if a session store is configured. */
+    private saveSession;
+    /** Reset per-task state while keeping full conversation history. */
+    private resetForNewTask;
+    /**
+     * Stream events from the orchestration loop.
+     */
+    stream(signal?: AbortSignal): AsyncGenerator<ArcEvent>;
+    /**
+     * Run a single task to completion (for headless/test use).
+     * Breaks after the first `done` event — does not wait for follow-up tasks.
+     */
+    run(signal?: AbortSignal): Promise<ArcRunResult>;
+    /** Append a message to the LCM message store (single source of truth) */
+    private appendOrchestratorMessage;
+    private findEpisodeRecordBySummaryId;
+    private buildContext;
+    private buildOrchestratorMessages;
+    private buildTaskContextText;
+    private readEpisode;
+    /**
+     * Handle a turn interrupt: prompt user for steering, inject into context.
+     */
+    private handleInterrupt;
+}
+
+/**
+ * Episode projection: minimal formatting for orchestrator context.
+ *
+ * The worker collects artifacts and actions during execution.
+ * This module just formats DispatchRecords for the orchestrator prompt.
+ */
+
+/** Format a single dispatch record for the orchestrator prompt */
+declare function formatDispatchForPrompt(record: DispatchRecord, options?: {
+    compact?: boolean;
+    maxChars?: number;
+}): string;
+
+declare function cloneForTrace<T>(value: T): T;
+
+/** In-memory transcript store for testing */
+declare class MemoryTranscriptStore implements TranscriptStore {
+    private transcripts;
+    private byId;
+    append(transcript: Transcript): Promise<void>;
+    getAll(): Promise<Transcript[]>;
+    get(id: string): Promise<Transcript | null>;
+}
+/** In-memory vector index for testing (no actual embeddings) */
+declare class MemoryVectorIndex implements VectorIndex {
+    private entries;
+    add(id: string, text: string): Promise<void>;
+    search(query: string, k: number): Promise<string[]>;
+    load(): Promise<void>;
+    save(): Promise<void>;
+}
+/** In-memory scratch pad for testing */
+declare class MemoryScratchPad implements ScratchPad {
+    private entries;
+    write(key: string, content: string): Promise<void>;
+    read(key: string): Promise<string | null>;
+    list(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/** In-memory artifact store for testing */
+declare class MemoryArtifactStore implements ArtifactStore {
+    private artifacts;
+    set(id: string, artifact: Artifact): Promise<void>;
+    get(id: string): Promise<Artifact | null>;
+    getAll(): Promise<Record<string, Artifact>>;
+}
+/** In-memory session store for testing */
+declare class MemorySessionStore implements SessionStore {
+    private snapshots;
+    private metas;
+    load(id: string): Promise<SessionSnapshot | null>;
+    save(id: string, snapshot: SessionSnapshot): Promise<void>;
+    getMeta(id: string): Promise<SessionMeta | null>;
+    saveMeta(id: string, meta: SessionMeta): Promise<void>;
+    list(): Promise<SessionMeta[]>;
+}
+
+/**
+ * File-based transcript store.
+ * Stores transcripts as individual JSON files in a directory.
+ */
+declare class FsTranscriptStore implements TranscriptStore {
+    private readonly dir;
+    private readonly indexPath;
+    private index;
+    private loaded;
+    constructor(dir: string);
+    append(transcript: Transcript): Promise<void>;
+    getAll(): Promise<Transcript[]>;
+    get(id: string): Promise<Transcript | null>;
+    private ensureLoaded;
+}
+/**
+ * File-based artifact store.
+ * Stores artifacts in a single JSON file.
+ */
+declare class FsArtifactStore implements ArtifactStore {
+    private readonly filePath;
+    private artifacts;
+    private loaded;
+    constructor(filePath: string);
+    set(id: string, artifact: Artifact): Promise<void>;
+    get(id: string): Promise<Artifact | null>;
+    getAll(): Promise<Record<string, Artifact>>;
+    private ensureLoaded;
+    private save;
+}
+
+export { AnyTool, type ArcConfig, type ArcEvent, ArcLoop, type ArcRunResult, type ArcTraceEvent, type Artifact, type ArtifactStore, type DispatchRecord, type DispatchTier, type ExpectedArtifact, type ExpectedOutputContract, FsArtifactStore, FsTranscriptStore, MemoryArtifactStore, MemoryMessageStore, MemoryScratchPad, MemorySessionStore, MemorySummaryDAG, MemoryTranscriptStore, MemoryVectorIndex, type MessageStore, ModelFactory, type OodaSnapshot, type OrchestratorContext, type ReadEpisodeArgs, type ReadEpisodeDetail, type RunWorkerConfig, type ScratchPad, type SessionMeta, type SessionSnapshot, type SessionStore, type StoredMessage, type SummaryDAG, type SummaryNode, type Tool, ToolProvider, ToolResult, ToolResultArtifact, type TraceToolCall, type Transcript, type TranscriptStore, type Tuple, type VectorIndex, type WorkerProgressEvent, type WorkerResult, cloneForTrace, formatDispatchForPrompt };