hammer-ai 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2231 @@
+import * as xstate from 'xstate';
+
+/**
+ * Core type definitions shared across mjolno apps.
+ *
+ * These types are intentionally decoupled from any CLI or desktop-specific
+ * concerns so they can be consumed by both apps/hammer and apps/tauri.
+ */
+interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+interface FetchResponseLike {
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    body?: unknown;
+}
+type FetchLike = (url: string, init?: any) => Promise<FetchResponseLike>;
+/** Configuration for an LLM provider endpoint. */
+interface LLMProviderConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    /** Extra headers merged into every request (e.g. HTTP-Referer for OpenRouter). */
+    extraHeaders?: Record<string, string>;
+    /** Custom fetch implementation (e.g. expo/fetch for RN streaming support). */
+    fetchImpl?: FetchLike;
+}
+/** Options for a single chat completion request. */
+interface LLMRequestOptions {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    signal?: AbortSignal;
+}
+/** Callbacks invoked during streaming. All optional – pass only what you need. */
+interface StreamCallbacks {
+    /**
+     * Fired for every content token received.
+     *
+     * Return `true` to signal early termination — the stream will be
+     * aborted cleanly and `onComplete` will still fire with the content
+     * accumulated so far.
+     */
+    onToken?: (token: string) => void | boolean;
+    /**
+     * Fired once when the first SSE data chunk arrives from the model.
+     * Useful for closing premature-cancellation windows: Qwen 3+ models
+     * send reasoning tokens (delta.reasoning_content) for several seconds
+     * before any delta.content arrives, so onToken alone is insufficient
+     * to detect that the model is actively processing.
+     */
+    onStreamStart?: () => void;
+    /** Fired once when the stream finishes (includes full concatenated content). */
+    onComplete?: (fullContent: string, finishReason: string) => void;
+    /** Fired on recoverable stream errors (e.g. frozen stream detected). */
+    onError?: (error: Error) => void;
+    /** Informational log messages (replaces console.log / chalk in shared code). */
+    onLog?: (message: string, level: "info" | "warn" | "error") => void;
+}
+/** Result returned by LLMClient.chat(). */
+interface LLMClientResponse {
+    content: string;
+    finishReason: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}
+type ToolDataPrimitive = string | number | boolean | null;
+type ToolDataValue = ToolDataPrimitive | ToolDataValue[] | {
+    [key: string]: ToolDataValue;
+};
+interface ToolDataSchema {
+    type?: string | string[];
+    description?: string;
+    enum?: readonly ToolDataPrimitive[];
+    items?: ToolDataSchema;
+    properties?: Record<string, ToolDataSchema>;
+    required?: string[];
+    additionalProperties?: boolean | ToolDataSchema;
+    default?: ToolDataValue;
+}
+interface ToolParameterDefinition {
+    type: string | string[];
+    description: string;
+    required?: boolean;
+    positional?: boolean;
+    enum?: readonly ToolDataPrimitive[];
+    items?: ToolDataSchema;
+    properties?: Record<string, ToolDataSchema>;
+    additionalProperties?: boolean | ToolDataSchema;
+    default?: ToolDataValue;
+}
+type ToolMemoryNoteScope = "none" | "tool";
+type ToolMemoryNoteKind = "workflow" | "operation" | "change";
+type ToolMemoryEvidenceKind = "codebase" | "research";
+type ToolMemoryCitationKind = "path" | "query" | "url" | "command";
+interface ToolMemoryNotePolicy {
+    scope: ToolMemoryNoteScope;
+    kind?: ToolMemoryNoteKind;
+}
+interface ToolMemoryEvidencePolicy {
+    kind: ToolMemoryEvidenceKind;
+    citation?: ToolMemoryCitationKind;
+}
+interface ToolMemoryMetadata {
+    note?: ToolMemoryNotePolicy;
+    evidence?: ToolMemoryEvidencePolicy[];
+}
+interface ToolDefinitionMetadata {
+    category: string;
+    capabilities: string[];
+    requirements?: string[];
+    memory?: ToolMemoryMetadata;
+    source?: "builtin" | "mcp";
+    mcpServerName?: string;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    usageExample?: string;
+    parameters: Record<string, ToolParameterDefinition>;
+    metadata?: ToolDefinitionMetadata;
+}
+interface ToolCall {
+    name: string;
+    parameters: Record<string, any>;
+    kind?: "tool" | "bash" | "background_bash";
+    rawInvocation?: string;
+    truncated?: boolean;
+}
+interface ToolResult {
+    success: boolean;
+    error?: string;
+    [key: string]: any;
+}
+type LoopOutcome = "continue" | "success" | "failure";
+interface LLMRequest {
+    role: "agent";
+    task: string;
+    tools?: ToolDefinition[];
+    action_count: number;
+}
+interface LLMResponse {
+    content: string;
+    reasoning: string;
+    scratchpad?: string;
+    selectedToolCall?: ToolCall;
+    outcome: LoopOutcome;
+    finishReason?: string;
+}
+type ProviderName = "qwen-max" | "qwen-plus" | "openrouter-claude" | "openrouter-gemini" | "minimax" | "minimax-her" | "chatglm" | "kimi" | "doubao";
+
+/**
+ * configure.ts — global configuration store for hammer-agent.
+ *
+ * Call `configure(options)` once at app startup to register provider configs
+ * and optional overrides (timeouts, memory limits, etc.).
+ *
+ * Provider configs are looked up by name via `getProviderConfig(name)`.
+ * Any name not explicitly configured falls back to a runtime error explaining
+ * what to register — no hardcoded API keys ship in this library.
+ */
+
+interface HammerAgentProviderPreset {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    /** Extra headers merged into every request (e.g. HTTP-Referer for OpenRouter). */
+    extraHeaders?: Record<string, string>;
+}
+/**
+ * Options accepted by `configure()`.
+ *
+ * `providers` is a map from provider name to provider config. You only need
+ * to register the providers your agent actually uses.
+ *
+ * All other fields have sensible defaults and are optional.
+ */
+interface HammerAgentConfig {
+    /**
+     * Named provider presets.  Keys are `ProviderName` strings, values are
+     * provider configs.  Pass at minimum the provider(s) your agent uses.
+     *
+     * @example
+     * configure({
+     *   providers: {
+     *     openrouter: { apiKey: process.env.OPENROUTER_KEY!, baseUrl: '...', model: '...' },
+     *     minimax:    { apiKey: process.env.MINIMAX_KEY!,    baseUrl: '...', model: '...' },
+     *   },
+     *   compactionProvider: 'minimax',
+     * })
+     */
+    providers?: Partial<Record<ProviderName, HammerAgentProviderPreset>>;
+    /**
+     * Which provider to use for memory compaction LLM calls.
+     * Must be a key in `providers`.
+     * @default first key in `providers`, or throws if not configured
+     */
+    compactionProvider?: ProviderName;
+    /**
+     * Milliseconds without any SSE data before treating the stream as frozen.
+     * @default 60_000
+     */
+    streamInactivityTimeout?: number;
+    /**
+     * Maximum milliseconds to wait for the very first SSE chunk.
+     * @default 120_000
+     */
+    firstChunkTimeout?: number;
+    /** @default 100 */
+    maxRetainedNotes?: number;
+    /** @default 50 */
+    maxFailedAttempts?: number;
+    /** @default 100 */
+    maxCodebaseEvidence?: number;
+    /** @default 50 */
+    maxResearchEvidence?: number;
+    /** @default 50 */
+    maxConstraints?: number;
+    /** @default 50 */
+    maxOpenTasks?: number;
+    /** @default 50 */
+    maxResolvedTasks?: number;
+    /** @default 0.1 */
+    compactionLlmTemperature?: number;
+    /** @default 4096 */
+    compactionLlmMaxTokens?: number;
+}
+/**
+ * Configure hammer-agent at startup.
+ *
+ * This function is safe to call multiple times — later calls merge over
+ * earlier ones, so you can split configuration across modules.
+ *
+ * @example
+ * import { configure } from 'hammer-agent'
+ *
+ * configure({
+ *   providers: {
+ *     minimax: {
+ *       apiKey: process.env.MINIMAX_KEY!,
+ *       baseUrl: 'https://api.minimaxi.com/v1',
+ *       model: 'MiniMax-M2.7-highspeed',
+ *     },
+ *   },
+ *   compactionProvider: 'minimax',
+ * })
+ */
+declare function configure(options: HammerAgentConfig): void;
+/**
+ * Return the `LLMProviderConfig` registered for `name`.
+ * Throws a descriptive error if the provider has not been configured.
+ */
+declare function getProviderConfig(name: ProviderName): LLMProviderConfig;
+
+/**
+ * LLMClient – generic, browser-compatible streaming client for
+ * OpenAI-compatible chat completion endpoints.
+ *
+ * This is the heart of the shared library.  It handles:
+ *   • Building the request payload
+ *   • SSE streaming with inactivity / first-chunk timeouts
+ *   • Retry with exponential back-off on network and transient HTTP errors
+ *   • Pluggable callbacks so the consumer decides how to render output
+ *
+ * No Node.js-only APIs (chalk, process, fs) are used here – it works in
+ * both Node 22+ and modern browsers.
+ */
+
+declare class LLMClient {
+    private config;
+    constructor(config: LLMProviderConfig);
+    /** Swap the underlying provider at runtime. */
+    setConfig(config: LLMProviderConfig): void;
+    /** Read-only access to the current provider config. */
+    getConfig(): LLMProviderConfig;
+    /**
+     * Send a chat completion request.
+     *
+     * When `options.stream` is true (the default) the response is streamed
+     * token-by-token through the supplied `callbacks`.
+     */
+    chat(options: LLMRequestOptions, callbacks?: StreamCallbacks): Promise<LLMClientResponse>;
+    private handleStream;
+}
+/** Custom error class for HTTP-level API errors (preserves status code). */
+declare class ApiError extends Error {
+    readonly status: number;
+    constructor(status: number, body: string);
+}
+
+/** All possible states the agent can be in. */
+type AgentMachineState = "idle" | "prompting" | "analyzing" | "executing" | "updating" | "done" | "failed";
+declare const AGENT_MACHINE_STATES: readonly AgentMachineState[];
+/** Truncated-tool metadata carried across iterations (Hammer-specific). */
+interface TruncatedToolInfo {
+    name: string;
+    filePath?: string;
+    executionSucceeded: boolean;
+}
+/** Machine context — all mutable state for the agent loop. */
+interface AgentMachineContext {
+    /** The user's task. */
+    task: string;
+    /** Current action counter (resumes from persisted state). */
+    actionCount: number;
+    /** Truncated-tool metadata for continuation guidance. */
+    truncatedToolInfo: TruncatedToolInfo | undefined;
+    /** Last tool result JSON string (for resume persistence). */
+    lastToolResult: string | undefined;
+    /** Error message when in failed state. */
+    error: string | undefined;
+    /** Final outcome that caused loop exit. */
+    finalOutcome: string;
+    /** Whether ListSkills has been called this session. */
+    hasCalledListSkills: boolean;
+}
+/** Events the machine accepts. */
+type AgentMachineEvent = {
+    type: "START";
+    task: string;
+    actionCount?: number;
+} | {
+    type: "PROMPT_COMPLETE";
+} | {
+    type: "LLM_SUCCESS";
+} | {
+    type: "LLM_VALIDATION_ERROR";
+    error: string;
+} | {
+    type: "LLM_API_ERROR";
+    error: string;
+} | {
+    type: "OUTCOME_SUCCESS";
+} | {
+    type: "OUTCOME_FAILURE";
+    error?: string;
+} | {
+    type: "TOOLS_EXECUTED";
+    lastToolResult?: string;
+} | {
+    type: "ENFORCEMENT_BREAK";
+    lastToolResult: string;
+} | {
+    type: "NO_TOOLS";
+} | {
+    type: "UPDATE_COMPLETE";
+} | {
+    type: "SET_TRUNCATION";
+    info: TruncatedToolInfo | undefined;
+} | {
+    type: "RESTORE_CONTEXT";
+    context: Partial<AgentMachineContext>;
+};
+declare const agentMachine: xstate.StateMachine<AgentMachineContext, {
+    type: "START";
+    task: string;
+    actionCount?: number;
+} | {
+    type: "PROMPT_COMPLETE";
+} | {
+    type: "LLM_SUCCESS";
+} | {
+    type: "LLM_VALIDATION_ERROR";
+    error: string;
+} | {
+    type: "LLM_API_ERROR";
+    error: string;
+} | {
+    type: "OUTCOME_SUCCESS";
+} | {
+    type: "OUTCOME_FAILURE";
+    error?: string;
+} | {
+    type: "TOOLS_EXECUTED";
+    lastToolResult?: string;
+} | {
+    type: "ENFORCEMENT_BREAK";
+    lastToolResult: string;
+} | {
+    type: "NO_TOOLS";
+} | {
+    type: "UPDATE_COMPLETE";
+} | {
+    type: "SET_TRUNCATION";
+    info: TruncatedToolInfo | undefined;
+} | {
+    type: "RESTORE_CONTEXT";
+    context: Partial<AgentMachineContext>;
+}, {}, never, {
+    type: "assignTask";
+    params: {
+        task: string;
+        actionCount?: number;
+    };
+} | {
+    type: "assignLlmError";
+    params: {
+        error: string;
+    };
+} | {
+    type: "assignOutcomeFailure";
+    params: {
+        error?: string;
+    };
+} | {
+    type: "assignOutcomeSuccess";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "assignToolsExecuted";
+    params: {
+        lastToolResult?: string;
+    };
+} | {
+    type: "assignEnforcementBreak";
+    params: {
+        lastToolResult: string;
+    };
+} | {
+    type: "incrementAction";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "setTruncation";
+    params: {
+        info: TruncatedToolInfo | undefined;
+    };
+} | {
+    type: "restoreContext";
+    params: {
+        context: Partial<AgentMachineContext>;
+    };
+}, never, never, "done" | "idle" | "prompting" | "analyzing" | "executing" | "updating" | "failed", string, xstate.NonReducibleUnknown, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "agent";
+    states: {
+        readonly idle: {};
+        readonly prompting: {};
+        readonly analyzing: {};
+        readonly executing: {};
+        readonly updating: {};
+        readonly done: {};
+        readonly failed: {};
+    };
+}>;
+
+/**
+ * BaseValidationEnforcer — shared error-handling infrastructure for
+ * any LLM agent loop (Hammer CLI, Tauri voice agent, etc.).
+ *
+ * Provides:
+ *  • `surfaceError` / `surfaceWarning` → conversation injection
+ *  • `handleValidationError` (run-line/Zod parse failures)
+ *  • `handleApiError` (rate-limit, 5xx, etc.)
+ *
+ * Subclasses add domain-specific enforcement (skills-first policy,
+ * TTS error announcements, etc.).
+ */
+interface ConversationSink {
+    addMessage(role: "user" | "assistant" | "system" | "tool", content: string): Promise<void>;
+}
+declare function createConversationSink(appendMessage: (role: "user" | "assistant" | "system" | "tool", content: string) => void | Promise<void>): ConversationSink;
+interface EnforcerResult {
+    /** Error message surfaced to the agent as a user-visible message. */
+    errorMessage: string;
+    /** JSON-serialised `{ success, error, data }` suitable for `lastToolResult`. */
+    lastToolResult: string;
+}
+declare abstract class BaseValidationEnforcer {
+    protected sink: ConversationSink;
+    constructor(sink: ConversationSink);
+    /**
+     * Warn the agent that it sent a non-terminal response without any
+     * executable control block — this wastes an action turn.
+     */
+    handleMissingToolCall(actionCount: number): Promise<void>;
+    /**
+    * Handle an LLM response validation error (shell-line parse, Zod, etc.).
+     *
+     *  - surfaces a structured corrective error as a user message
+     */
+    handleValidationError(error: Error): Promise<EnforcerResult>;
+    /**
+     * Handle a non-validation LLM API error (rate-limit, 5xx, etc.).
+     * Surfaces the message to the agent so it can retry on the next turn.
+     */
+    handleApiError(error: Error): Promise<EnforcerResult>;
+    /**
+     * Handle an unrecoverable runtime error that terminates the current run.
+     * Surfaces the message through the same user-visible error channel as
+     * validation and API failures.
+     */
+    handleFatalError(error: Error | string): Promise<EnforcerResult>;
+    /**
+     * Override to route warnings to a domain-specific logger.
+     * Default: `console.warn`.
+     */
+    protected logWarning(message: string): void;
+    /**
+     * Override to route errors to a domain-specific logger.
+     * Default: `console.error`.
+     */
+    protected logError(message: string): void;
+    protected surfaceValidationContext(error: Error): Promise<void>;
+    protected readValidationRawContent(error: Error): string | null;
+    protected surfaceError(errorMessage: string): Promise<EnforcerResult>;
+    protected surfaceWarning(warningMessage: string): Promise<void>;
+}
+
+/** Abstraction over conversation storage (memory layer / conversation manager). */
+interface ConversationAdapter {
+    appendMessage(role: "user" | "assistant" | "tool", content: string): Promise<void>;
+    /** Append a tool result with tool name for compaction tracking. Falls back to appendMessage("tool",...) if not provided. */
+    appendToolMessage?(content: string, toolCallId: string): Promise<void>;
+    getLastMessageRole(): string | undefined;
+    getLastMessageContent(): string | undefined;
+    triggerCompactionIfNeeded(): Promise<void>;
+}
+/** Callbacks for platform-specific UI / logging. */
+interface AgentLoopCallbacks {
+    onToolStart?(name: string, parameters: Record<string, unknown>, index: number, total: number): void;
+    onToolComplete?(name: string, result: ToolResult, truncatedResultStr: string): void;
+    onPhaseChange?(state: AgentMachineState): void;
+    /** Called when the agent reports success. */
+    onComplete?(): void;
+    /** Called when the agent reports failure. */
+    onFail?(): void;
+}
+/** Everything the AgentLoop needs from its host environment. */
+interface AgentLoopDeps {
+    /** Execute a single tool call. */
+    executeTool: (call: ToolCall) => Promise<ToolResult>;
+    /** Validation / error enforcer. */
+    enforcer: BaseValidationEnforcer;
+    /** Conversation storage adapter. */
+    conversation: ConversationAdapter;
+    /** Optional: transform raw ToolResult before truncation (e.g. spinner cleanup). */
+    formatToolResult?: (result: ToolResult, toolName: string) => ToolResult;
+    /**
+     * Optional: pre-tool hook. Return non-null to **block** execution and
+     * break out of the tool loop (e.g. Hammer's ListSkills-first enforcement).
+     * The returned `lastToolResult` is stored and the machine transitions
+     * to ENFORCEMENT_BREAK.
+     */
+    onBeforeToolExecution?: (name: string, params: Record<string, unknown>) => Promise<{
+        lastToolResult: string;
+    } | null>;
+    /** Platform-specific callbacks for UI/logging. */
+    callbacks?: AgentLoopCallbacks;
+}
+/** Parsed LLM step response — the caller parses, AgentLoop processes. */
+interface ParsedStepInput {
+    outcome: LoopOutcome;
+    reasoning?: string;
+    selectedToolCall?: ToolCall;
+    wasTruncated: boolean;
+    /**
+     * Raw LLM content string. When provided, `processStep` records it
+     * as an assistant message in the conversation adapter before
+     * processing, so callers don't need to do it themselves.
+     */
+    rawContent?: string;
+}
+/** Result of a single tool execution (for the caller to build UI). */
+interface ToolExecutionResult {
+    name: string;
+    result: ToolResult;
+    truncatedResultStr: string;
+}
+/** What processStep returns — outcome is the loop-control signal. */
+interface StepResult {
+    outcome: LoopOutcome;
+    toolResults: ToolExecutionResult[];
+}
+declare class AgentLoop {
+    private deps;
+    private actor;
+    private _truncatedToolInfo?;
+    private _lastToolResult?;
+    constructor(deps: AgentLoopDeps);
+    /**
+     * Send an event to the actor, silently swallowing errors if the actor
+     * was stopped concurrently (e.g. abort/destroy during an async gap).
+     */
+    private safeSend;
+    /** Current XState machine state. */
+    get machineState(): AgentMachineState;
+    /** Current action count from the machine context. */
+    get actionCount(): number;
+    /** Last truncation info (for the caller to store / display). */
+    get truncatedToolInfo(): TruncatedToolInfo | undefined;
+    /** Last tool result string (independent of machine state). */
+    get lastToolResult(): string | undefined;
+    /** Transition: idle → prompting. */
+    start(task: string): void;
+    /**
+     * Inject the step user-message and transition to analyzing.
+     *
+     * @param actionCountOverride If provided, use this count instead of the
+     *   machine's internal count (useful when the caller tracks total count
+     *   across sessions).
+     * @returns `true` if a user message was injected, `false` if skipped.
+     */
+    prepareStep(actionCountOverride?: number): Promise<boolean>;
+    /**
+     * Process a fully-parsed LLM step response end-to-end.
+     *
+     * The caller is responsible for:
+     *   1. The LLM call (streaming or not)
+     *   2. Parsing the response into {@link ParsedStepInput}
+     *   3. UI updates based on the returned {@link StepResult}
+     *
+    * This method handles:
+    *   1. Recording the assistant message (when `rawContent` is provided)
+    *   2. Terminal outcomes (success / failure)
+    *   3. State machine transitions
+    *   4. Tool execution (via deps.executeTool)
+    *   5. Result formatting, truncation, and conversation storage
+    *   6. Truncation tracking across iterations
+     */
+    processStep(input: ParsedStepInput, signal?: AbortSignal): Promise<StepResult>;
+    /** Handle an LLM validation error (JSON parse, Zod, etc.). */
+    handleLLMValidationError(error: Error): Promise<EnforcerResult>;
+    /** Handle an LLM API error (network, rate limit, 5xx). */
+    handleLLMApiError(error: Error): Promise<EnforcerResult>;
+    /**
+     * Classify a step LLM error as validation or API error and
+     * delegate to the appropriate handler.
+     */
+    classifyStepError(error: Error): Promise<void>;
+    /**
+     * Handle an unrecoverable error and transition the machine to a
+     * terminal state.
+     */
+    handleFatalError(errorMsg: string): Promise<void>;
+    /** Send an arbitrary event to the machine (for platform-specific transitions). */
+    sendEvent(event: Parameters<typeof this$1.actor.send>[0]): void;
+    /** Get the raw machine context snapshot. */
+    getContext(): AgentMachineContext;
+    /** Restore truncated tool info from a previous session. */
+    restoreTruncatedToolInfo(info: TruncatedToolInfo | undefined): void;
+    /** Stop the XState actor. Call during cleanup / unmount. */
+    destroy(): void;
+    /**
+     * Reset the AgentLoop by stopping the current actor and creating
+     * a new one. Returns to idle state.
+     */
+    reset(): void;
+}
+
+/**
+ * Base Memory Layer — shared infrastructure for memory compaction.
+ *
+ * Both workspace agents and the Voice Agent use episodic compaction with
+ * structured state extraction. This module provides the shared skeleton:
+ *
+ * - Generic base class (`BaseMemoryLayer<TState, TMessage>`)
+ * - Shared types: `MemoryMessage`, `CompactionCursor`, `MemoryStorage`, etc.
+ * - Token estimation strategy (pluggable: tiktoken vs char-based)
+ * - Shared algorithms: sliding-window, buildMessages, triggerCompaction
+ *
+ * Core Invariants (enforced by this base):
+ * 1. Raw history is NEVER modified in-place; entries are pruned after compaction
+ * 2. Compaction is a state transition, not a view transform
+ * 3. Compressed state is NEVER recursively summarized
+ * 4. State compaction removes obsolete structure but preserves meaning
+ * 5. buildMessages is a PURE function (cache writes are benign memoization)
+ */
+
+/**
+ * Minimal interface for an LLM client used during compaction.
+ * Kept abstract so memory-layer has no hard dependency on LLMClient.
+ * The shared `LLMClient` class satisfies this interface.
+ */
+interface CompactionLLMClient {
+    chat(options: {
+        messages: ChatMessage[];
+        temperature?: number;
+        maxTokens?: number;
+        stream?: boolean;
+    }): Promise<{
+        content: string;
+    }>;
+}
+/** Base message stored in raw history. */
+interface MemoryMessage {
+    id: string;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    timestamp: number;
+    /** Monotonic message counter. */
+    turn: number;
+    /** Cached token count for this message (computed once at creation). */
+    tokenCount: number;
+}
+interface MemoryProvenance {
+    source: "rule" | "llm" | "tool" | "assistant" | "user";
+    detail?: string;
+}
+/** Tracks how far compaction has progressed. */
+interface CompactionCursor {
+    lastCompactedTurn: number;
+}
+/**
+ * Strategy for estimating token counts.
+ *
+ * - Workspace agents share the same estimator strategy by default
+ * - CharTokenEstimator is the cross-platform baseline implementation
+ */
+interface TokenEstimator {
+    /** Estimate token count for a string. */
+    estimateTokens(text: string): number;
+    /** Dispose any resources (e.g. tiktoken WASM). No-op by default. */
+    dispose?(): void;
+}
+/**
+ * Character-based token estimator.
+ * GPT/Claude average ~4 chars/token for English; 3.5 is conservative.
+ */
+declare class CharTokenEstimator implements TokenEstimator {
+    private charsPerToken;
+    constructor(charsPerToken?: number);
+    estimateTokens(text: string): number;
+}
+/**
+ * Platform-agnostic persistence adapter (generic over data shape).
+ *
+ * Implementations: LocalStorageAdapter, HttpAdapter, ExpoFileAdapter,
+ * and the Bun-server FileMemoryAdapter.
+ */
+interface MemoryStorage<T = unknown> {
+    load(): Promise<T | null>;
+    save(data: T): Promise<void>;
+    clear(): Promise<void>;
+}
+/** Base shape of persisted memory data. Apps may extend with extra fields. */
+interface PersistedMemoryData<TState = unknown, TMessage extends MemoryMessage = MemoryMessage> {
+    rawHistory: TMessage[];
+    compressedState: TState;
+    compactionCursor: CompactionCursor;
+    currentTurn: number;
+    compactionCount: number;
+}
+interface MemoryLayerConfig {
+    /** Trigger compaction when estimated context exceeds this many tokens. */
+    compactionTokenThreshold: number;
+    /** Keep at least this many tokens of recent messages uncompressed. */
+    protectedContextTokens: number;
+    /** Maximum tokens for the rendered compressed state. */
+    stateBudgetTokens: number;
+    /** Hard cap on raw history entries (safety net). */
+    maxRawHistory: number;
+    /** Minimum turns between compaction attempts. */
+    compactionDebounceTurns: number;
+    /** Baseline token overhead for system prompt (conservative estimate). */
+    systemPromptOverhead: number;
+    /** Strategy for estimating token counts. */
+    tokenEstimator: TokenEstimator;
+    /** Optional LLM client for enhanced compaction (e.g. MiniMax). */
+    compactionClient?: CompactionLLMClient;
+    /** Temperature for compaction LLM calls (default 0.1). */
+    compactionTemperature?: number;
+    /** Max tokens for compaction LLM output (default 4096). */
+    compactionMaxTokens?: number;
+}
+/**
+ * Abstract base class for memory layers with episodic compaction.
+ *
+ * Subclasses provide:
+ * - Message creation (TMessage construction with app-specific fields)
+ * - Compaction logic (extraction plus pruning obsolete state entries)
+ * - State rendering (converting TState to human-readable text)
+ *
+ * The base class provides:
+ * - Append-only raw history with hard cap enforcement
+ * - Token-budgeted sliding window for recent messages
+ * - buildMessages assembly (system → state → recent)
+ * - Compaction triggering (debounce, threshold check, prune)
+ * - Rendered state caching with invalidation
+ * - Persistence lifecycle (save/load/clear)
+ * - Accessors for metrics
+ */
+declare abstract class BaseMemoryLayer<TState, TMessage extends MemoryMessage> {
+    protected readonly config: MemoryLayerConfig;
+    protected rawHistory: TMessage[];
+    protected compressedState: TState;
+    protected compactionCursor: CompactionCursor;
+    protected currentTurn: number;
+    protected compactionCount: number;
+    /** Rendered state cache (invalidated on mutation). */
+    protected renderedStateCache: string | null;
+    protected stateTokenCountCache: number | null;
+    /** Debounce: turns since last compaction attempt. */
+    protected lastCompactionAttempt: number;
+    /**
+     * Static context: rules/instructions injected once, always included in
+     * buildMessages, never compressed or pruned.
+     */
+    protected staticContext: string | null;
+    constructor(config: MemoryLayerConfig, initialState: TState);
+    /**
+     * Create a TMessage from the given parts.
+     * Subclass should compute and cache the tokenCount (or use tokenEstimator).
+     */
+    protected abstract createMessage(id: string, role: "system" | "user" | "assistant" | "tool", content: string, turn: number, timestamp: number): TMessage;
+    /**
+    * Extract structured facts from raw messages into compressedState and
+    * enforce any dedupe, aging, and hard-cap rules for the durable state.
+    * This is deterministic pattern matching, NOT LLM summarization.
+     * Should mutate `this.compressedState` in place.
+     */
+    protected abstract performCompaction(messages: TMessage[]): void;
+    /**
+     * Render compressedState as human-readable structured text for LLM context.
+     * Result is cached — only called when cache is invalidated.
+     */
+    protected abstract renderState(): string;
+    /**
+     * Create a fresh initial state (used by clear()).
+     */
+    protected abstract createInitialState(): TState;
+    /** Label for the compressed state section in buildMessages. */
+    protected getStateLabel(): string;
+    /** Placeholder user message when no user message precedes the first assistant. */
+    protected getResumePlaceholder(): string;
+    /** Called after a message is appended (e.g. for failure tracking). */
+    protected onMessageAppended(_msg: TMessage): void;
+    /** Called after compaction + prune (e.g. for extra persistence). */
+    protected onCompactionComplete(): void;
+    /**
+     * LLM-enhanced compaction. Override in subclass to provide LLM-based
+     * summarization using `this.config.compactionClient`.
+     *
+     * When this returns `true`, the pattern-matching `performCompaction()`
+     * is skipped. When it returns `false` (or throws), pattern matching
+     * runs as a deterministic fallback.
+     */
+    protected performLLMCompaction(_messages: TMessage[]): Promise<boolean>;
+    /** Append a message to raw history. Returns the message ID. */
+    appendMessage(role: "system" | "user" | "assistant" | "tool", content: string): string;
+    /**
+     * Build the message array for LLM context.
+     *
+     * Assembly order:
+     * 1. System prompt
+     * 2. Static context (if any)
+     * 3. Compressed state
+     * 4. Recent raw messages (token-budgeted sliding window)
+     *
+     * Post-processing:
+     * - Tool messages converted to user role ("Tool result: …")
+     * - Consecutive same-role messages merged
+     * - Guard: user message inserted before first assistant if missing
+     * - Leading system messages merged into one
+     */
+    buildMessages(systemPrompt: string): ChatMessage[];
+    /** Trigger compaction if conversation context exceeds token threshold. */
+    triggerCompactionIfNeeded(): Promise<void>;
+    /** Get recent messages that fit within the protected token budget. */
+    protected getRecentMessages(): TMessage[];
+    /** Estimate total context tokens (recent + state + system overhead). */
+    estimateContextTokens(): number;
+    /** Estimate compressed state tokens. Cached alongside rendered state. */
+    estimateStateTokens(): number;
+    /** Get rendered state, using cache when valid. */
+    protected getCachedRenderedState(): string;
+    /** Invalidate rendered state cache (call after any state mutation). */
+    invalidateStateCache(): void;
+    /**
+     * Set static context (rules/instructions injected once into every
+     * buildMessages call). Never compressed or pruned.
+     */
+    setStaticContext(content: string): void;
+    /** Check if static context has been set. */
+    hasStaticContext(): boolean;
+    /** Serialize base memory state. Subclasses can extend. */
+    serializeBase(): PersistedMemoryData<TState, TMessage>;
+    /** Restore base memory state from persisted data. */
+    loadBase(data: PersistedMemoryData<TState, TMessage>): void;
+    /**
+     * Sanitize raw history messages loaded from persistence.
+     *
+    * Guards against corrupted or older persisted data by providing safe defaults
+     * for all base MemoryMessage fields. Subclasses can extend to handle
+     * app-specific fields (e.g. charCount, toolCallId).
+     */
+    protected sanitizeHistory(rawHistory: Array<Partial<TMessage> & Record<string, any>>): TMessage[];
+    /** Reset all state. */
+    reset(): void;
+    getCurrentTurn(): number;
+    getCompactionCount(): number;
+    getRawHistoryLength(): number;
+    getRawHistory(): TMessage[];
+    getCompressedState(): TState;
+    getCompactionCursor(): CompactionCursor;
+    getLastMessageRole(): string | null;
+    getLastMessageContent(): string | null;
+    getLastCompactionAttempt(): number;
+    /**
+     * Remove and return the last message from raw history.
+     * Useful for cancelling a premature assistant response.
+     */
+    popLastMessage(): TMessage | undefined;
+    /**
+     * Find the last message with the given role, scanning backward.
+     */
+    getLastMessageByRole(role: string): TMessage | undefined;
+    /**
+     * Update the content of the last message matching `role`.
+     * Re-estimates token count automatically. Returns `true` if
+     * a matching message was found and updated.
+     */
+    updateLastMessageByRole(role: string, content: string): boolean;
+}
+
+/**
+ * Shared Agent Memory Layer with Episodic Compaction
+ *
+ * Extends BaseMemoryLayer with agent-specific compressed state:
+ * - Retained notes, constraints, structured evidence, failed attempts
+ * - Compaction patterns (shell-line command parsing, tool/result extraction)
+ * - Compaction rules (retained-note canonicalization, failure subsuming)
+ * - LLM-based compaction with structured prompts
+ *
+ * Used by both Hammer CLI and Magic browser agents. Consumers configure
+ * agent-specific behaviour via AgentMemoryLayerConfig (logger, tool names,
+ * token budgets, etc.).
+ */
+
+interface RawMessage extends MemoryMessage {
+    toolCallId?: string;
+}
+interface AgentMemoryCitation {
+    kind: ToolMemoryCitationKind;
+    value: string;
+}
+interface AgentMemoryMetadata {
+    provenance: MemoryProvenance;
+}
+interface AgentMemoryNote extends AgentMemoryMetadata {
+    summary: string;
+    category?: string;
+    rationale?: string;
+    kind?: ToolMemoryNoteKind;
+    citations?: AgentMemoryCitation[];
+    turn: number;
+}
+interface AgentMemoryEvidence extends AgentMemoryMetadata {
+    summary: string;
+    kind: ToolMemoryEvidenceKind;
+    citations?: AgentMemoryCitation[];
+    turn: number;
+}
+interface AgentMemoryConstraint extends AgentMemoryMetadata {
+    text: string;
+    canonical: string;
+    turn: number;
+}
+interface AgentMemoryTask extends AgentMemoryMetadata {
+    task: string;
+    canonical: string;
+    turn: number;
+}
+interface AgentMemoryResolvedTask extends AgentMemoryMetadata {
+    task: string;
+    canonical: string;
+    resolvedTurn: number;
+}
+interface AgentMemoryFailedAttempt extends AgentMemoryMetadata {
+    approach: string;
+    reason: string;
+    canonicalApproach: string;
+    turn: number;
+}
+type CompressedAgentState = {
+    scratchpad?: string;
+    retainedNotes: AgentMemoryNote[];
+    constraints: AgentMemoryConstraint[];
+    evidence: AgentMemoryEvidence[];
+    failedAttempts: AgentMemoryFailedAttempt[];
+    openTasks: AgentMemoryTask[];
+    resolvedTasks: AgentMemoryResolvedTask[];
+    lastUpdatedTurn: number;
+};
+type MemoryMetrics = {
+    totalTurns: number;
+    totalMessages: number;
+    compactedTurns: number;
+    compactionCount: number;
+    recentWindowSize: number;
+    protectedContextTokens: number;
+    compressedStateTokens: number;
+    estimatedContextTokens: number;
+};
+/** Optional structured logger — avoids coupling to Hammer's `log` import. */
+interface AgentMemoryLogger {
+    warn(label: string, message: string): void;
+}
+interface ToolMemoryExtractionContext {
+    toolName: string;
+    parsed: Record<string, any>;
+    toolDefinition?: ToolDefinition;
+    turn: number;
+}
+/**
+ * Defines how successful tool results should be converted into structured
+ * durable memory entries.
+ */
+interface ToolMemoryExtractor {
+    /** Add retained notes derived from successful tool results. */
+    extractNotes?(context: ToolMemoryExtractionContext): AgentMemoryNote[];
+    /** Add durable evidence entries derived from successful tool results. */
+    extractEvidence?(context: ToolMemoryExtractionContext): AgentMemoryEvidence[];
+}
+/**
+ * Default tool-memory extractor for Hammer-style tools. Tool definitions carry
+ * the policy; this default implementation turns those policies into structured
+ * evidence entries.
+ */
+declare const DEFAULT_TOOL_MEMORY_EXTRACTOR: ToolMemoryExtractor;
+interface AgentMemoryLayerConfig {
+    /** Token threshold that triggers compaction. */
+    compactionTokenThreshold: number;
+    /** Tokens reserved for recent uncompressed messages. */
+    protectedContextTokens: number;
+    /** Token budget for the rendered compressed state block. */
+    stateBudgetTokens: number;
+    /** Hard cap on raw history entries. */
+    maxRawHistory: number;
+    /** Minimum turns between compaction attempts. */
+    compactionDebounceTurns: number;
+    /** Token estimate for the system prompt. */
+    systemPromptOverhead: number;
+    /** Token estimator implementation. */
+    tokenEstimator: TokenEstimator;
+    /** Optional LLM client for LLM-based compaction. */
+    compactionClient?: CompactionLLMClient;
+    /** Temperature for compaction LLM calls (default: 0.1). */
+    compactionTemperature?: number;
+    /** Max tokens for compaction LLM output (default: 4096). */
+    compactionMaxTokens?: number;
+    /** Registry-backed tool definitions used to classify tool calls during compaction. */
+    getToolDefinitions?: () => ToolDefinition[];
+    /** Optional tool-memory extractor for converting tool results to state entries. */
+    toolMemoryExtractor?: ToolMemoryExtractor;
+    /** Optional structured logger. */
+    logger?: AgentMemoryLogger;
+}
+declare class AgentMemoryLayer extends BaseMemoryLayer<CompressedAgentState, RawMessage> {
+    /** Temporary storage for toolCallId during appendMessage. */
+    private pendingToolCallId?;
+    /** The agent-level config (superset of base MemoryLayerConfig). */
+    private readonly agentConfig;
+    constructor(config: AgentMemoryLayerConfig);
+    /**
+     * Append a message to raw history.
+     * Extends the base signature with an optional toolCallId.
+     */
+    appendMessage(role: "system" | "user" | "assistant" | "tool", content: string): string;
+    appendMessage(role: "system" | "user" | "assistant" | "tool", content: string, toolCallId: string | undefined): string;
+    appendMessage(message: {
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        toolCallId?: string;
+    }): string;
+    protected createMessage(id: string, role: "system" | "user" | "assistant" | "tool", content: string, turn: number, timestamp: number): RawMessage;
+    protected performCompaction(messages: RawMessage[]): void;
+    protected performLLMCompaction(messages: RawMessage[]): Promise<boolean>;
+    private parseLLMCompactionObject;
+    private finalizeCompactedState;
+    protected renderState(): string;
+    protected createInitialState(): CompressedAgentState;
+    protected getStateLabel(): string;
+    protected getResumePlaceholder(): string;
+    reset(): void;
+    /**
+     * Get comprehensive metrics for monitoring and observability
+     */
+    getMetrics(): MemoryMetrics;
+    /**
+     * Create a ConversationAdapter backed by this memory layer.
+     *
+     * Eliminates boilerplate glue code that both Magic and Hammer
+     * previously duplicated when wiring AgentLoop.
+     */
+    toConversationAdapter(): ConversationAdapter;
+    /**
+     * Free token estimator resources.
+     * Call when the memory layer is no longer needed to prevent memory leaks.
+     */
+    dispose(): void;
+    /**
+     * Serialize full agent memory state for persistence.
+     * Combines base fields with agent-specific state.
+     */
+    serialize(): PersistedMemoryData<CompressedAgentState, RawMessage> & {
+        lastCompactionAttempt: number;
+    };
+    /**
+     * Load from persisted data with comprehensive validation.
+     * Ensures all fields have valid structure and reasonable defaults.
+     */
+    loadFromPersisted(data: {
+        rawHistory: RawMessage[];
+        compressedState: any;
+        compactionCursor: {
+            lastCompactedTurn: number;
+        };
+        currentTurn: number;
+        lastCompactionAttempt?: number;
+        compactionCount?: number;
+    }): void;
+    /**
+    * Extract structured assistant response data from prose plus
+    * standalone control segments.
+     */
+    private extractStructuredResponse;
+    /**
+     * Safe parsing of tool response with fallback.
+     * Returns structured data instead of string matching.
+     */
+    private parseToolResponse;
+}
+
+/**
+ * Shared non-voice tool-loop runtime for Hammer, Magic, Monoslides, and Monospace.
+ *
+ * This base owns the common runtime seam across non-voice agents: memory
+ * bootstrap, static context injection, AgentLoop setup, per-step LLM calls,
+ * and parsed step execution.
+ */
+
+interface ToolLoopRuntimeStepContext<TStepInput = undefined> {
+    task: string;
+    actionCount: number;
+    tools: ToolDefinition[];
+    stepInput?: TStepInput;
+}
+interface ToolLoopRuntimeRunStepOptions<TStepInput = undefined> {
+    task: string;
+    actionCount: number;
+    signal?: AbortSignal;
+    stepInput?: TStepInput;
+}
+interface ToolLoopRuntimeLLMRequest {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    onToken?: (token: string) => void | boolean;
+    normalizeResponseContent?: (content: string) => string;
+}
+interface ToolLoopRuntimeLLMResponse {
+    content: string;
+    finishReason: string;
+    usage?: LLMClientResponse["usage"];
+}
+interface ToolLoopRuntimeHooks<TStepInput = undefined> {
+    onBeforeStep?(context: ToolLoopRuntimeStepContext<TStepInput>): Promise<void> | void;
+    onAfterStep?(context: ToolLoopRuntimeStepContext<TStepInput>, result: StepResult): Promise<void> | void;
+    onToken?(token: string): void | boolean;
+}
+interface ToolLoopAgentRuntimeDeps<TStepInput = undefined> {
+    llmClient?: LLMClient;
+    loopCallbacks?: AgentLoopCallbacks;
+    hooks?: ToolLoopRuntimeHooks<TStepInput>;
+    requireTodoListOnFirstResponse?: boolean;
+}
+interface ToolLoopRuntimeSetup<TMemory extends AgentMemoryLayer, TEnforcer extends BaseValidationEnforcer> {
+    memory: TMemory;
+    enforcer: TEnforcer;
+    conversation: ConversationAdapter;
+    loopDeps: Omit<AgentLoopDeps, "enforcer" | "conversation" | "callbacks">;
+}
+interface ToolLoopRuntimeInfrastructure<TMemory extends AgentMemoryLayer, TEnforcer extends BaseValidationEnforcer> extends ToolLoopRuntimeSetup<TMemory, TEnforcer> {
+    loop: AgentLoop;
+}
+interface ToolLoopRuntimeRunStepResult<TStepInput = undefined> {
+    context: ToolLoopRuntimeStepContext<TStepInput>;
+    response: ToolLoopRuntimeLLMResponse;
+    parsed: ParsedStepInput;
+    result: StepResult;
+}
+interface ToolLoopRuntimeExecuteStepResult {
+    response: ToolLoopRuntimeLLMResponse;
+    parsed: ParsedStepInput;
+}
+declare abstract class ToolLoopAgentRuntime<TMemory extends AgentMemoryLayer = AgentMemoryLayer, TEnforcer extends BaseValidationEnforcer = BaseValidationEnforcer, TStepInput = undefined> {
+    protected readonly llmClient: LLMClient | null;
+    protected readonly loopCallbacks: AgentLoopCallbacks;
+    protected readonly hooks: ToolLoopRuntimeHooks<TStepInput>;
+    private readonly requireTodoListOnFirstResponse;
+    private infrastructure;
+    private infrastructurePromise;
+    protected constructor(deps: ToolLoopAgentRuntimeDeps<TStepInput>);
+    protected abstract createRuntimeSetup(): Promise<ToolLoopRuntimeSetup<TMemory, TEnforcer>>;
+    protected abstract getToolDefinitions(): ToolDefinition[];
+    protected buildSystemPrompt(_context: ToolLoopRuntimeStepContext<TStepInput>): string;
+    protected buildLLMRequest(_context: ToolLoopRuntimeStepContext<TStepInput>, _messages: ChatMessage[]): ToolLoopRuntimeLLMRequest;
+    protected parseStepResponse(_response: ToolLoopRuntimeLLMResponse, _tools: ToolDefinition[]): ParsedStepInput;
+    protected get runtimeLoop(): AgentLoop | null;
+    protected get runtimeMemory(): TMemory | null;
+    protected get runtimeEnforcer(): TEnforcer | null;
+    protected createStepContext(options: ToolLoopRuntimeRunStepOptions<TStepInput>, tools: ToolDefinition[]): ToolLoopRuntimeStepContext<TStepInput>;
+    protected ensureStaticContext(_memory: TMemory): Promise<void>;
+    protected prepareMemoryForRun(memory: TMemory, task: string): Promise<void>;
+    protected prepareMemoryForStep(memory: TMemory): Promise<void>;
+    protected buildStepMessages(memory: TMemory, context: ToolLoopRuntimeStepContext<TStepInput>): Promise<ChatMessage[]>;
+    protected invokeLLM(request: ToolLoopRuntimeLLMRequest): Promise<ToolLoopRuntimeLLMResponse>;
+    protected executeLLMStep(context: ToolLoopRuntimeStepContext<TStepInput>, messages: ChatMessage[]): Promise<ToolLoopRuntimeExecuteStepResult>;
+    protected validateParsedStep(context: ToolLoopRuntimeStepContext<TStepInput>, parsed: ParsedStepInput): Promise<void>;
+    /**
+     * Called after the LLM response is parsed but before the tool
+     * executes.  Web runtimes override this to flush streaming content
+     * to the store and transition the UI to a "tool running" state.
+     */
+    protected onBeforeToolDispatch(_context: ToolLoopRuntimeStepContext<TStepInput>, _parsed: ParsedStepInput): Promise<void>;
+    protected ensureInfrastructure(): Promise<ToolLoopRuntimeInfrastructure<TMemory, TEnforcer>>;
+    beginRun(task: string): Promise<ToolLoopRuntimeInfrastructure<TMemory, TEnforcer>>;
+    runStep(options: ToolLoopRuntimeRunStepOptions<TStepInput>): Promise<ToolLoopRuntimeRunStepResult<TStepInput>>;
+    protected onDestroy(_infrastructure: ToolLoopRuntimeInfrastructure<TMemory, TEnforcer>): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+interface CommandRuntime {
+    getToolDefinitions(): ToolDefinition[];
+    executeTool(name: string, parameters: Record<string, any>): Promise<ToolResult>;
+    executeBash?(command: string): Promise<ToolResult>;
+    executeBackgroundBash?(command: string): Promise<ToolResult>;
+}
+interface CommandTargetInfo {
+    name: string;
+    path?: string;
+    command?: string;
+}
+declare function isBashToolCall(toolCall: Pick<ToolCall, "name" | "kind">): boolean;
+declare function isBackgroundBashToolCall(toolCall: Pick<ToolCall, "name" | "kind">): boolean;
+declare function resolveToolDefinitionForInvocation(tools: ToolDefinition[], invocationName: string): ToolDefinition | undefined;
+declare function formatUnixToolSurface(tools: ToolDefinition[]): string;
+declare function formatToolCallAsUnixCommand(toolCall: Pick<ToolCall, "name" | "kind" | "parameters" | "rawInvocation">, toolDefinitions?: ToolDefinition[]): string | undefined;
+declare function enrichToolResultWithUnixMetadata(toolCall: Pick<ToolCall, "name" | "kind" | "parameters" | "rawInvocation">, result: ToolResult, toolDefinitions?: ToolDefinition[]): ToolResult;
+declare function extractPrimaryCommandMetadata(command: string): {
+    name?: string;
+    path?: string;
+    command?: string;
+};
+declare function tokenizeUnixCommand(command: string, options?: {
+    allowTruncated?: boolean;
+}): string[] | null;
+declare function parseUnixToolCommand(tool: ToolDefinition, command: string, options?: {
+    allowTruncated?: boolean;
+}): {
+    ok: true;
+    parameters: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+declare function executeUnixCommandString(command: string, runtime: CommandRuntime): Promise<ToolResult>;
+declare function executeBackgroundUnixCommandString(command: string, runtime: CommandRuntime): Promise<ToolResult>;
+
+type RunInvocationTarget = "tool" | "bash" | "background_bash";
+interface ExtractedRunInvocationLike {
+    target: RunInvocationTarget;
+    command: string;
+    truncated: boolean;
+}
+interface RunCommandParseResult {
+    outcome?: LoopOutcome;
+    selectedToolCall?: ToolCall;
+    selectedToolCallCount?: number;
+}
+interface RunCommandPromptAvailability {
+    bashAvailable: boolean;
+    backgroundBashAvailable: boolean;
+}
+type BackgroundBashAction = "start" | "status" | "logs" | "stop";
+interface ParsedBackgroundBashCommand {
+    action: BackgroundBashAction;
+    name: string;
+    rawCommand: string;
+    startCommand?: string;
+    port?: number;
+    tailBytes?: number;
+}
+declare const DEFAULT_ALLOWED_RUN_TARGETS: readonly RunInvocationTarget[];
+declare const SUPPORTED_RUN_TARGETS: readonly RunInvocationTarget[];
+declare function createBackgroundBashDefinition({ description, portDescription, }: {
+    description: string;
+    portDescription: string;
+}): ToolDefinition;
+declare abstract class RunCommand {
+    readonly target: RunInvocationTarget;
+    protected constructor(target: RunInvocationTarget);
+    abstract isAvailable(runtime: CommandRuntime): boolean;
+    abstract parseInvocation(invocation: ExtractedRunInvocationLike, options?: {
+        allowTruncated?: boolean;
+    }): RunCommandParseResult | null;
+    abstract execute(toolCall: ToolCall, runtime: CommandRuntime): Promise<ToolResult>;
+    matchesToolCall(toolCall: ToolCall): boolean;
+}
+declare class ToolRunCommand extends RunCommand {
+    constructor();
+    isAvailable(runtime: CommandRuntime): boolean;
+    parseInvocation(invocation: ExtractedRunInvocationLike, options?: {
+        allowTruncated?: boolean;
+    }): RunCommandParseResult | null;
+    execute(toolCall: ToolCall, runtime: CommandRuntime): Promise<ToolResult>;
+}
+declare class BashRunCommand extends RunCommand {
+    constructor();
+    protected getCommand(toolCall: ToolCall): string;
+    isAvailable(runtime: CommandRuntime): boolean;
+    parseInvocation(invocation: ExtractedRunInvocationLike): RunCommandParseResult | null;
+    protected executeCommand(command: string, runtime?: CommandRuntime): Promise<ToolResult>;
+    executeRaw(command: string, runtime?: CommandRuntime): Promise<ToolResult>;
+    execute(toolCall: ToolCall, runtime: CommandRuntime): Promise<ToolResult>;
+}
+declare class BackgroundBashRunCommand extends RunCommand {
+    constructor();
+    protected getCommand(toolCall: ToolCall): string;
+    isAvailable(runtime: CommandRuntime): boolean;
+    parseInvocation(invocation: ExtractedRunInvocationLike): RunCommandParseResult | null;
+    protected executeCommand(command: string, runtime?: CommandRuntime): Promise<ToolResult>;
+    executeRaw(command: string, runtime?: CommandRuntime): Promise<ToolResult>;
+    protected buildBackgroundBashErrorResult(command: string, error: string): ToolResult;
+    protected parseBackgroundBashCommand(definition: ToolDefinition, command: string): {
+        ok: true;
+        value: ParsedBackgroundBashCommand;
+    } | {
+        ok: false;
+        result: ToolResult;
+    };
+    execute(toolCall: ToolCall, runtime: CommandRuntime): Promise<ToolResult>;
+}
+declare class RunCommandRegistry {
+    private readonly commands;
+    constructor(commands: readonly RunCommand[]);
+    getCommand(target: RunInvocationTarget): RunCommand | undefined;
+    getSupportedTargets(): readonly RunInvocationTarget[];
+    getAllowedTargets(runtime: CommandRuntime): readonly RunInvocationTarget[];
+    getPromptAvailability(allowedTargets: readonly RunInvocationTarget[]): RunCommandPromptAvailability;
+    parseInvocation(invocation: ExtractedRunInvocationLike, options?: {
+        allowTruncated?: boolean;
+    }): RunCommandParseResult | null;
+    executeToolCall(runtime: CommandRuntime, toolCall: ToolCall): Promise<ToolResult>;
+    private resolveCommandForToolCall;
+}
+declare const DEFAULT_RUN_COMMAND_REGISTRY: RunCommandRegistry;
+declare function createCustomRunCommandRegistry(bashCommand: BashRunCommand, backgroundBashCommand: BackgroundBashRunCommand): RunCommandRegistry;
+declare function createRunCommandRuntimeBindings(bashCommand: BashRunCommand, backgroundBashCommand: BackgroundBashRunCommand): {
+    executeBash: (command: string) => Promise<ToolResult>;
+    executeBackgroundBash: (command: string) => Promise<ToolResult>;
+    runCommandRegistry: RunCommandRegistry;
+};
+declare function getRunCommandPromptAvailability(allowedTargets: readonly RunInvocationTarget[]): RunCommandPromptAvailability;
+declare function executeToolCallWithRunCommands(runtime: CommandRuntime, toolCall: ToolCall, commandRegistry?: RunCommandRegistry): Promise<ToolResult>;
+
+declare function formatToolDefinitions(tools: ToolDefinition[], style?: "compact" | "verbose" | "unix"): string;
+declare function coerceToolCallToDefinition(call: ToolCall | undefined, tools?: ToolDefinition[]): ToolCall | undefined;
+interface ParsedStructuredAgentText {
+    prose: string;
+    outcome?: LoopOutcome;
+    selectedToolCall?: ToolCall;
+    selectedToolCallCount: number;
+}
+declare function containsStandaloneStructuredInvocationStart(content: string, allowedTargets?: readonly RunInvocationTarget[]): boolean;
+declare function parseStructuredAgentText(content: string, options?: {
+    allowTruncated?: boolean;
+    allowedTargets?: readonly RunInvocationTarget[];
+    commandRegistry?: RunCommandRegistry;
+}): ParsedStructuredAgentText | null;
+
+type RuntimeSubscriber = () => void;
+type RuntimeSnapshotUpdater<TSnapshot> = TSnapshot | ((current: TSnapshot) => TSnapshot);
+interface RuntimeStore<TSnapshot> {
+    subscribe: (subscriber: RuntimeSubscriber) => () => void;
+    getSnapshot: () => TSnapshot;
+    getServerSnapshot: () => TSnapshot;
+    setSnapshot: (updater: RuntimeSnapshotUpdater<TSnapshot>) => TSnapshot;
+    resetSnapshot: () => TSnapshot;
+}
+interface RuntimeController<TSnapshot, TActions extends Record<string, unknown>, TRefs extends Record<string, unknown> = {}> {
+    store: RuntimeStore<TSnapshot>;
+    actions: TActions;
+    refs: TRefs;
+}
+declare function createRuntimeStore<TSnapshot>(createInitialSnapshot: () => TSnapshot): RuntimeStore<TSnapshot>;
+declare function defineRuntimeController<TSnapshot, TActions extends Record<string, unknown>, TRefs extends Record<string, unknown> = {}>(controller: RuntimeController<TSnapshot, TActions, TRefs>): RuntimeController<TSnapshot, TActions, TRefs>;
+
+type TodoStatus = "not-started" | "in-progress" | "completed";
+interface TodoItem {
+    id: number;
+    title: string;
+    status: TodoStatus;
+}
+
+type AgentPhase = "idle" | "thinking" | "tool-calling" | "complete" | "error";
+interface AgentMessage {
+    id: string;
+    role: "user" | "assistant" | "tool";
+    content: string;
+    diagnosticLevel?: "error" | "warning";
+    diagnosticSource?: "agent-feedback";
+    toolName?: string;
+    toolSuccess?: boolean;
+    reasoning?: string;
+    rawContent?: string;
+    timestamp: number;
+}
+interface AgentState {
+    phase: AgentPhase;
+    messages: AgentMessage[];
+    streamingContent: string;
+    actionCount: number;
+    error: string | null;
+    activeToolName: string | null;
+    todoItems: TodoItem[];
+}
+declare function createInitialWebAgentState(): AgentState;
+declare function machineStateToWebAgentPhase(state: AgentMachineState): AgentPhase;
+declare function createWebAgentMessageIdGenerator(prefix?: string): () => string;
+
+declare class PendingAgentMessageBuffer<TMessage> {
+    private messages;
+    push(message: TMessage): void;
+    clear(): void;
+    takeForRun(runId: number, isRunActive: (runId: number) => boolean): TMessage[];
+}
+declare function createToolAgentMessage(options: {
+    id: string;
+    name: string;
+    content: string;
+    success: boolean;
+    timestamp?: number;
+}): AgentMessage;
+interface CreateWebToolLoopCallbacksOptions {
+    getToolDefinitions: () => ToolDefinition[];
+    updateActiveToolName: (activeToolName: string | null) => void;
+    onToolCompleteMessage: (name: string, result: ToolResult, truncatedResult: string) => void;
+    onPhaseChange: (state: AgentMachineState) => void;
+}
+declare function applyInitialWebAgentRunState<TState extends WebToolLoopRuntimeStateLike<TMessage>, TMessage extends AgentMessage>(state: TState, userMessage: TMessage): TState;
+declare function applyIdleWebAgentState<TState extends WebToolLoopRuntimeStateLike>(state: TState): TState;
+declare function createWebToolLoopCallbacks(options: CreateWebToolLoopCallbacksOptions): AgentLoopCallbacks;
+
+/**
+ * WebValidationEnforcer — shared subclass of BaseValidationEnforcer
+ * for browser-based agents (Magic webapp, future web agents).
+ *
+ * Provides:
+ *  • Missing tool-call warning (non-terminal response without an executable control segment)
+ *  • API error surfacing
+ *  • Browser-compatible logging (no chalk, no file I/O)
+ *
+ * Unlike Hammer's ValidationEnforcer, this does NOT include:
+ *  • ListSkills/ReadSkill-first enforcement (no skills concept in web)
+ *  • Init error handlers (web agents use simpler init flow)
+ *  • File system session persistence
+ */
+
+/**
+ * WebValidationEnforcer — lightweight validation enforcement for
+ * browser-based agents.
+ *
+ * Wire up with `createConversationSink(...)` against the underlying
+ * message store:
+ * ```ts
+ * const sink = createConversationSink((role, content) =>
+ *     memory.appendMessage(role, content)
+ * )
+ * const enforcer = new WebValidationEnforcer(sink)
+ * ```
+ */
+declare class WebValidationEnforcer extends BaseValidationEnforcer {
+    /** Optional callback for logging (default: console). */
+    private onLog?;
+    constructor(sink: ConversationSink, opts?: {
+        onLog?: (level: "warn" | "error", message: string) => void;
+    });
+    protected logWarning(message: string): void;
+    protected logError(message: string): void;
+    protected surfaceValidationContext(error: Error): Promise<void>;
+}
+
+interface WebToolLoopRuntimeStateLike<TMessage extends AgentMessage = AgentMessage> {
+    phase: AgentPhase;
+    messages: TMessage[];
+    streamingContent: string;
+    actionCount: number;
+    error: string | null;
+    activeToolName: string | null;
+    todoItems: TodoItem[];
+}
+declare const suppressWebValidationLog: (_level: "warn" | "error", _message: string) => void;
+declare function readDiagnosticLevel(content: string): AgentMessage["diagnosticLevel"] | undefined;
+declare function readDiagnosticSource(content: string): AgentMessage["diagnosticSource"] | undefined;
+declare function mapConversationRoleToAgentRole(role: "user" | "assistant" | "system" | "tool"): AgentMessage["role"];
+interface CreateWebRuntimeSetupOptions {
+    memoryPreset: string;
+    getToolDefinitions: () => ToolDefinition[];
+    executeTool: AgentLoopDeps["executeTool"];
+    toolMemoryExtractor?: ToolMemoryExtractor;
+    validationLog?: (level: "warn" | "error", message: string) => void;
+}
+interface ExecuteWebLoopRunOptions<TState extends WebToolLoopRuntimeStateLike<TMessage>, TMessage extends AgentMessage, TStepInput extends {
+    runId: number;
+}> {
+    runId: number;
+    userTask: string;
+    stepInput: TStepInput;
+    createUserMessage: () => TMessage;
+    applyInitialState: (state: TState, userMessage: TMessage) => TState;
+    onStepCompleted: (step: ToolLoopRuntimeRunStepResult<TStepInput>) => Promise<void> | void;
+    createParseFailureMessage?: () => TMessage;
+    applyParseFailureState?: (state: TState, message: TMessage) => TState;
+    onBeforeRun?: () => void;
+    onAfterRun?: () => void;
+}
+interface WebToolLoopAgentRuntimeConstructorOptions<TState, TStepInput> extends ToolLoopAgentRuntimeDeps<TStepInput> {
+    store: RuntimeStore<TState>;
+    messageIdPrefix: string;
+    getToolDefinitions: () => ToolDefinition[];
+    memoryPreset: string;
+    executeTool: AgentLoopDeps["executeTool"];
+    systemIdentity?: string;
+    extraRules: string;
+    temperature: number;
+    maxTokens: number;
+    toolMemoryExtractor?: ToolMemoryExtractor;
+    validationLog?: (level: "warn" | "error", message: string) => void;
+    allowedRunTargets?: readonly RunInvocationTarget[];
+    logLabel?: string;
+    logFullSystemPromptOnChange?: boolean;
+    logFullLlmMessages?: boolean;
+}
+declare abstract class WebToolLoopAgentRuntime<TState extends WebToolLoopRuntimeStateLike<TMessage>, TMessage extends AgentMessage = AgentMessage, TStepInput extends {
+    runId: number;
+} = {
+    runId: number;
+}> extends ToolLoopAgentRuntime<AgentMemoryLayer, WebValidationEnforcer, TStepInput> {
+    protected readonly store: RuntimeStore<TState>;
+    protected readonly pendingToolMessages: PendingAgentMessageBuffer<TMessage>;
+    private readonly createMessageId;
+    private readonly runtimeToolDefinitions;
+    private readonly memoryPreset;
+    private readonly executeTool;
+    private readonly systemIdentity?;
+    private readonly extraRules;
+    private readonly temperature;
+    private readonly maxTokens;
+    private readonly toolMemoryExtractor?;
+    private readonly validationLog?;
+    private readonly allowedRunTargets;
+    private readonly logLabel;
+    private readonly logFullSystemPromptOnChange;
+    private readonly logFullLlmMessages;
+    private lastLoggedSystemPrompt;
+    protected abortController: AbortController | null;
+    protected memory: AgentMemoryLayer | null;
+    protected enforcer: WebValidationEnforcer | null;
+    protected running: boolean;
+    protected activeRunId: number | null;
+    protected nextRunId: number;
+    protected inFlightRunPromise: Promise<void> | null;
+    private pendingDestroyPromise;
+    private pendingSurfacedMessages;
+    private pendingStreamingContent;
+    private pendingStreamingTokenCounts;
+    protected constructor(options: WebToolLoopAgentRuntimeConstructorOptions<TState, TStepInput>);
+    protected createRuntimeSetup(): Promise<ToolLoopRuntimeSetup<AgentMemoryLayer, WebValidationEnforcer>>;
+    protected getToolDefinitions(): ToolDefinition[];
+    protected ensureStaticContext(memory: AgentMemoryLayer): Promise<void>;
+    protected getAllowedRunTargets(): readonly RunInvocationTarget[];
+    /**
+     * Run targets for the parser layer. Always includes "bash" so the
+     * universal finish signals (`---bash--- exit 0` / `exit 1`) are
+     * recognized even when the agent has no bash execution capability.
+     */
+    private getParserRunTargets;
+    protected buildSystemPrompt(context: ToolLoopRuntimeStepContext<TStepInput>): string;
+    protected buildLLMRequest(context: {
+        stepInput?: TStepInput;
+    }, messages: ChatMessage[]): ToolLoopRuntimeLLMRequest;
+    protected invokeLLM(request: ToolLoopRuntimeLLMRequest): Promise<ToolLoopRuntimeLLMResponse>;
+    protected parseStepResponse(response: {
+        content: string;
+        finishReason: string;
+    }, tools: ToolDefinition[]): {
+        outcome: LoopOutcome;
+        reasoning: string;
+        selectedToolCall: ToolCall | undefined;
+        wasTruncated: boolean;
+        rawContent: string;
+    };
+    protected onBeforeToolDispatch(context: ToolLoopRuntimeStepContext<TStepInput>, parsed: ParsedStepInput): Promise<void>;
+    protected nextMessageId(): string;
+    protected updateSnapshot(updater: RuntimeSnapshotUpdater<TState>): void;
+    protected isRunActive(runId: number): boolean;
+    protected updateSnapshotForActiveRun(updater: RuntimeSnapshotUpdater<TState>): boolean;
+    protected updateSnapshotForRun(runId: number, updater: RuntimeSnapshotUpdater<TState>): boolean;
+    protected surfaceFatalError(error: unknown, runId: number): Promise<Error>;
+    protected appendSurfacedConversationMessage(role: "user" | "assistant" | "system" | "tool", content: string): void;
+    protected takePendingSurfacedMessagesForRun(runId: number): TMessage[];
+    protected flushPendingSurfacedMessagesForRun(runId: number): void;
+    protected clearPendingSurfacedMessages(): void;
+    protected appendStreamingToken(runId: number, token: string): void;
+    protected flushPendingStreamingContentForRun(runId: number): void;
+    protected clearPendingStreamingContent(runId?: number): void;
+    protected syncPhase(machineState?: AgentMachineState): void;
+    protected createWebRuntimeSetup(options: CreateWebRuntimeSetupOptions): Promise<ToolLoopRuntimeSetup<AgentMemoryLayer, WebValidationEnforcer>>;
+    protected buildStreamingLLMRequest(context: {
+        stepInput?: TStepInput;
+    }, messages: ChatMessage[], options: {
+        temperature: number;
+        maxTokens: number;
+    }): ToolLoopRuntimeLLMRequest;
+    protected parseRecoveringStepResponse(response: {
+        content: string;
+        finishReason: string;
+    }, tools: ToolDefinition[]): {
+        outcome: LoopOutcome;
+        reasoning: string;
+        selectedToolCall: ToolCall | undefined;
+        wasTruncated: boolean;
+        rawContent: string;
+    };
+    protected startSerializedRun(execute: (runId: number) => Promise<void>): Promise<void>;
+    protected executeWebLoopRun(options: ExecuteWebLoopRunOptions<TState, TMessage, TStepInput>): Promise<void>;
+    protected abortWebRuntime(applyAbortState: (state: TState) => TState, cleanup?: () => void): void;
+    private scheduleRuntimeDestroy;
+    protected resetWebRuntime(cleanup?: () => void): void;
+    protected clearWebRuntimeState(cleanup?: () => void): Promise<void>;
+    protected defaultWebAbort(): void;
+    protected defaultWebReset(): void;
+    protected onDestroy(): Promise<void>;
+    protected executeDefaultWebRun(userTask: string, options?: {
+        shouldSurfaceAssistantContent?: (reasoning?: string, rawContent?: string) => boolean;
+        onNonContinueStep?: () => Promise<void>;
+        onBeforeRun?: () => void;
+        onAfterRun?: () => void;
+    }): Promise<void>;
+}
+
+/**
+ * Agent Memory Layer Factory — Shared factory for creating pre-configured
+ * AgentMemoryLayer instances.
+ *
+ * Centralizes the shared Hammer/Magic/Monoslides/Monospace memory-layer presets so each
+ * agent only provides the small set of overrides it actually owns.
+ *
+ * Usage:
+ *   import { createAgentMemoryLayer } from "./agent-memory-factory"
+ *   const memory = createAgentMemoryLayer("hammer", { logger: myLogger })
+ *   const memory = createAgentMemoryLayer("magic", { toolMemoryExtractor: canvasExtractor })
+ */
+
+interface AgentMemoryFactoryOverrides {
+    /** Override the compaction LLM client. */
+    compactionClient?: CompactionLLMClient;
+    /** Override the token estimator (default: CharTokenEstimator for browser safety). */
+    tokenEstimator?: AgentMemoryLayerConfig["tokenEstimator"];
+    /** Provide registry-backed tool definitions for compaction-time classification. */
+    getToolDefinitions?: () => ToolDefinition[];
+    /** Override tool memory extractor. */
+    toolMemoryExtractor?: ToolMemoryExtractor;
+    /** Optional structured logger. */
+    logger?: AgentMemoryLogger;
+}
+/**
+ * Create an AgentMemoryLayer pre-configured for a specific agent preset.
+ *
+ * @param preset - Agent preset name ("hammer" | "magic" | "monoslides" | "monospace").
+ * @param overrides - Optional overrides for any preset value.
+ * @returns Configured AgentMemoryLayer instance.
+ *
+ * @example
+ * ```ts
+ * // Hammer (Node.js — use TiktokenEstimator for precision)
+ * const memory = createAgentMemoryLayer("hammer", {
+ *     compactionClient,
+ *     tokenEstimator: new TiktokenEstimator(),
+ *     logger: hammerLogger,
+ * })
+ *
+ * // Magic/Monoslides/Monospace (browser — CharTokenEstimator is default)
+ * const memory = createAgentMemoryLayer("magic", {
+ *     compactionClient,
+ *     getToolDefinitions: () => registry.getToolDefinitions(),
+ *     toolMemoryExtractor: MAGIC_TOOL_MEMORY_EXTRACTOR,
+ * })
+ * ```
+ */
+declare function createAgentMemoryLayer(preset: string, overrides?: AgentMemoryFactoryOverrides): AgentMemoryLayer;
+
+interface BashCommandsSectionOptions {
+    shellNativeWorkflowCommandExamples?: string;
+    additionalGuidanceLines?: string[];
+}
+
+/**
+ * Shared prompt building utilities for agentic loops.
+ *
+ * Used by Hammer CLI agent, Magic webapp agent, Monoslides, and Monospace to format
+ * tool surfaces and construct core prompt templates.
+ */
+
+declare const DEFAULT_AGENT_FALLBACK_SYSTEM_PROMPT = "You are an AI agent.";
+interface FormatToolsSectionOptions {
+    bashAvailable?: boolean;
+    backgroundBashAvailable?: boolean;
+    allowedRunTargets?: readonly RunInvocationTarget[];
+    bashCommandsSectionOptions?: BashCommandsSectionOptions;
+}
+interface SystemPromptSections {
+    basePrompt: string;
+    toolsHeading?: string;
+    toolsSection: string;
+    supplementalRules?: string;
+}
+interface SystemPromptBuildContext {
+    tools: ToolDefinition[];
+    toolsSectionOptions: FormatToolsSectionOptions;
+}
+type SystemPromptCustomizer = (sections: Readonly<SystemPromptSections>, context: Readonly<SystemPromptBuildContext>) => Partial<SystemPromptSections> | void;
+declare function createAppendToolsSectionCustomizer(block: string): SystemPromptCustomizer;
+declare function createToolsSectionOverrideCustomizer(buildToolsSection: (context: Readonly<SystemPromptBuildContext>) => string): SystemPromptCustomizer;
+/**
+ * Format tool definitions for injection into a system prompt.
+ * Thin wrapper over `formatToolDefinitions` with configurable bash guidance.
+ */
+declare function formatToolsSection(tools: ToolDefinition[], options?: FormatToolsSectionOptions): string;
+declare function buildAgentSystemPrompt(options: {
+    identityLine?: string;
+    tools: ToolDefinition[];
+    supplementalRules?: string;
+    bashAvailable?: boolean;
+    backgroundBashAvailable?: boolean;
+    allowedRunTargets?: readonly RunInvocationTarget[];
+    toolsSectionOptions?: Omit<FormatToolsSectionOptions, "bashAvailable" | "backgroundBashAvailable" | "allowedRunTargets">;
+    systemPromptCustomizers?: readonly SystemPromptCustomizer[];
+}): string;
+/**
+ * Core static rules shared by all agent loops (Hammer, Magic, Monoslides, Monospace).
+ *
+ * Covers:
+ *  - Shell-style output format specification
+ *  - Terminal exit requirements
+ *  - Tool call formatting
+ *  - Scratchpad usage
+ *
+ * Hammer extends this with file-path rules, skills-first policy,
+ * incremental testing, etc. Magic uses this as-is or with lighter extensions.
+ *
+ * Designed to be injected once via `memoryLayer.setStaticContext()`,
+ * saving ~1500 tokens per action vs repeating in every system prompt.
+ */
+declare function buildCoreStaticRules(): string;
+interface StepUserMessageOptions {
+    /** Current action number. */
+    actionCount: number;
+    /** Truncated tool info from the previous iteration (if any). */
+    truncatedToolInfo?: TruncatedToolInfo;
+}
+/**
+ * Build the user message injected at the start of each agentic loop step.
+ *
+ * Handles truncation-specific continuation guidance (Write → "Use Append",
+ * generic tool → "continue from where you left off") and the default
+ * "Continue working" prompt.
+ *
+ * Shared by Hammer's UnifiedAgent, Magic's useAgent hook, and Monoslides/Monospace runtimes.
+ */
+declare function buildStepUserMessage(opts: StepUserMessageOptions): string;
+/**
+ * Check whether the last message in the conversation is a user error
+ * message (prefixed with ⚠️), which means we should skip injecting
+ * another user message to avoid double user messages.
+ *
+ * Shared by Hammer's UnifiedAgent, Magic's useAgent hook, and Monoslides/Monospace runtimes.
+ */
+declare function shouldSkipStepUserMessage(lastRole: string | null, lastContent: string | null): boolean;
+interface ToolCallLike {
+    name: string;
+    parameters?: Record<string, unknown>;
+}
+/**
+ * Extract `TruncatedToolInfo` from the first tool call in a response
+ * when the LLM response was truncated (finishReason === "length").
+ *
+ * Returns `undefined` if no tool calls are provided.
+ */
+declare function extractTruncatedToolInfo(calls: ToolCallLike[]): TruncatedToolInfo | undefined;
+
+/**
+ * Shared agent response parsing pipeline.
+ *
+ * Unifies the response parsing logic used by both Hammer CLI agent
+ * (`BaseLLMProvider.parseAgentResponse`) and Magic webapp agent
+ * (`useAgent.parseResponse`).
+ *
+ * Pipeline: raw content → structured control-segment
+ * extraction → Zod validation
+ */
+
+interface ParsedAgentResponse {
+    /** Zod-validated (or raw fallback) parsed response object. */
+    parsed: Record<string, unknown>;
+    /** The single executable tool call selected for this turn, if any. */
+    selectedToolCall?: ToolCall;
+    /** The outcome field ("continue", "success", "failure"). */
+    outcome: LoopOutcome;
+    /** The reasoning string from the LLM. */
+    reasoning: string;
+    /** Validation error message, if validation failed but raw data was usable. */
+    validationError?: string;
+    /** Original raw content string. */
+    raw: string;
+}
+interface ParseAgentResponseOptions {
+    /**
+     * If `true`, throw on Zod validation failure (Hammer behavior).
+     * If `false`, fall back to raw parsed data on Zod failure (Magic behavior).
+     * Default: `false`.
+     */
+    throwOnValidationError?: boolean;
+    /** Allow truncated structured control segments during recovery paths. */
+    allowTruncatedRuns?: boolean;
+    /**
+     * Custom error formatter called when `throwOnValidationError` is `true`.
+     * Receives the Zod error and raw content, should return an Error to throw.
+     */
+    formatValidationError?: (zodError: unknown, rawContent: string) => Error;
+    /** Allowed structured control targets for this agent. Defaults to tool/bash. */
+    allowedRunTargets?: readonly RunInvocationTarget[];
+}
+/**
+ * Parse an LLM response string into a structured agent response.
+ *
+ * Shared pipeline:
+ * 1. Extract prose + structured control segments
+ * 2. Validate via `LLMResponseSchema` (Zod)
+ * 3. Return structured result or null if extraction fails
+ *
+ * @returns Parsed response, or `null` if no structured control segments could be extracted.
+ */
+declare function parseAgentResponse(content: string, options?: ParseAgentResponseOptions): ParsedAgentResponse | null;
+
+/**
+ * Shared tool-call recovery utilities for the structured control-segment protocol.
+ *
+ * Extracts truncation recovery, validation error formatting, and error
+ * message templates so Hammer, Magic, Monoslides, Monospace, and the voice agent share one
+ * response contract.
+ */
+
+/** Error message sent to the LLM when its response was truncated mid-generation. */
+declare const ERROR_TRUNCATED_RESPONSE = "VALIDATION_ERROR: Your response was truncated before the final executable control block could be extracted.\n\nRetry with normal prose and one final executable control block only. Put the standalone slug header on its own line and put the payload on the following line(s). Do not discuss the control syntax.";
+/**
+ * Format a Zod validation error (or generic Error) into a human-readable string.
+ *
+ * Returns per-field details showing which parts are missing or have wrong types,
+ * suitable for feeding back to the LLM so it can self-correct.
+ */
+declare function formatZodValidationError(zodError: unknown): string;
+/**
+ * Build a complete VALIDATION_ERROR string with Zod details + fix reference.
+ *
+ * Suitable for throwing as an `Error.message` that gets sent back to the LLM.
+ */
+declare function buildValidationErrorMessage(zodError: unknown): string;
+/**
+ * Build a "no structured control segment found" error message.
+ *
+ * Keep this message focused on the repair instruction instead of duplicating
+ * the failed output inline.
+ */
+declare function buildNoStructuredResponseFoundError(): string;
+
+/**
+ * Build a user-feedback message to send to the LLM when its response failed
+ * to parse. Gives more actionable guidance than a generic "parse failed" message.
+ *
+ * @param content     The raw LLM content that failed to parse
+ * @param zodError    Optional Zod validation error for field-specific feedback
+ * @returns           A feedback string to send as a user message
+ */
+declare function buildParseFeedback(_content: string, zodError?: unknown): string;
+interface ParseResponseWithRecoveryOptions extends ParseAgentResponseOptions {
+    /**
+     * The LLM's `finishReason` string. When `"length"`, Tier 2 truncation
+     * recovery is attempted.
+     */
+    finishReason?: string;
+}
+/**
+ * Three-tier parsing cascade for LLM step responses.
+ *
+ * Shared by Magic (`use-agent.ts`) and Hammer (`BaseLLMProvider`).
+ *
+ *   Tier 1: `parseAgentResponse` — control-segment extraction + Zod validation
+ *   Tier 2: `recoverTruncatedResponse` — if `finishReason === "length"`
+ *
+ * Tier 1 respects `throwOnValidationError`: if structured lines are found but
+ * validation fails in strict mode, the error propagates immediately.
+ *
+ * @returns Parsed response, or `null` if nothing could be extracted.
+ */
+declare function parseResponseWithRecovery(content: string, options?: ParseResponseWithRecoveryOptions): ParsedAgentResponse | null;
+
+/**
+ * Shared tool execution utilities for agentic loops.
+ *
+ * Used by both Hammer CLI agent and Magic webapp agent for
+ * consistent tool result truncation and safe execution wrapping.
+ */
+
+/** Default maximum characters for tool result strings. */
+declare const MAX_TOOL_RESULT_CHARS = 30000;
+interface TruncateOptions {
+    /** Maximum character length (default: 30,000). */
+    maxChars?: number;
+    /**
+     * Truncation strategy:
+     * - `"head-tail"`: Keep first half + last half (preserves end of large outputs).
+     * - `"head-only"`: Keep the first N characters.
+     */
+    strategy?: "head-tail" | "head-only";
+}
+/**
+ * Truncate an oversized tool result string to stay within LLM context limits.
+ *
+ * @returns The original string if within limit, otherwise a truncated version.
+ */
+declare function truncateToolResult(resultStr: string, options?: TruncateOptions): string;
+declare function formatToolResultMessage(toolCall: ToolCall, result: ToolResult): string;
+declare function parseToolResultMessage(content: string): {
+    success: boolean;
+    toolName?: string;
+    error?: string;
+    parsed?: Record<string, any>;
+};
+/**
+ * Execute a tool call with standard error handling.
+ * Catches any thrown error and returns `{ success: false, error: message }`.
+ */
+declare function executeToolSafe(fn: () => Promise<ToolResult>): Promise<ToolResult>;
+
+/**
+ * StreamingToolParser — separates speech from structured control segments
+ * during streaming. It normally parses tool calls at stream end, but if a
+ * second control header appears it immediately seals the stream and keeps only
+ * the first segment.
+ */
+
+interface StreamingToolParserCallbacks {
+    /** Fired for every token that is regular speech (not part of a control segment). */
+    onSpeechToken?: (token: string) => void;
+    /** Fired when structured control segments have been parsed into tool calls. */
+    onToolCall?: (selectedToolCall: ToolCall) => void;
+    /** Fired if structured command text was detected but could not be parsed. */
+    onToolCallError?: (error: Error, rawCommandText: string) => void;
+    /** Informational log messages. */
+    onLog?: (msg: string) => void;
+    /** Allowed control-segment targets for this parser. Defaults to tool/bash. */
+    allowedRunTargets?: readonly RunInvocationTarget[];
+}
+declare class StreamingToolParser {
+    private speechBuffer;
+    private segmentBuffer;
+    private inSegment;
+    private _sealed;
+    private callbacks;
+    /** The full raw content accumulated so far (speech + structured lines). */
+    private fullContent;
+    private static buildControlHeaderPattern;
+    private static getControlHeaders;
+    private static findControlHeader;
+    private static findSecondControlHeader;
+    private getRunPrefixLookback;
+    constructor(callbacks?: StreamingToolParserCallbacks);
+    /** Replace callbacks (e.g. after construction). */
+    on(cb: StreamingToolParserCallbacks): void;
+    /**
+     * Whether the parser has sealed after stream completion.
+     */
+    get sealed(): boolean;
+    /** Feed a new token from the SSE stream. */
+    push(token: string): void;
+    /**
+     * Signal that the stream has ended.
+     *
+     * If we're mid-command (truncated response), buffer it and attempt
+     * recovery only after the full streamed response is available.
+     */
+    finish(): void;
+    /** Reset internal state for reuse across turns. */
+    reset(): void;
+    /** Get all content accumulated so far. */
+    getFullContent(): string;
+    private captureSegmentHeaderIfPresent;
+    private flushSafeSpeechTail;
+    private sealAtFirstSegmentIfSecondHeaderDetected;
+    private tryParseFullContent;
+    private tryParseContent;
+    private containsStandaloneRunStart;
+}
+
+declare const DEFAULT_THREAD_AUTO_SCROLL_BOTTOM_THRESHOLD = 24;
+type ScrollMetrics = {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+};
+declare function shouldAutoScrollThread(scrollMetrics: ScrollMetrics, threshold?: number): boolean;
+declare function getToolLogSummaryLine(content: string): string;
+declare function stripDiagnosticMessagePrefix(content: string): string;
+declare function getDiagnosticSummaryLine(content: string): string;
+declare function buildToolLogRevealFrames(content: string, targetFrameCount?: number): string[];
+
+type WebSearchToolActionInput = {
+    tool: "BraveWebSearch" | "BochaWebSearch";
+    input: Record<string, unknown>;
+};
+type WebSearchToolActionDeps = {
+    executeWebSearch: (tool: "BraveWebSearch" | "BochaWebSearch", input: Record<string, unknown>) => Promise<ToolResult>;
+};
+declare function createWebSearchToolActions(deps: WebSearchToolActionDeps): {
+    executeWebTool: (input: WebSearchToolActionInput) => Promise<ToolResult>;
+};
+
+/**
+ * Base Tool class — all shared tools extend this.
+ *
+ * Mirrors the Hammer agent tool format so code is shared between
+ * apps/hammer and apps/tauri via the DRY principle.
+ *
+ * Filesystem-aware tools should extend SystemTool directly, which adds
+ * `validatePath()` on top of this base class.
+ */
+
+/** Tool parameter schema — same shape as ToolDefinition["parameters"]. */
+type ToolSchema = ToolDefinition["parameters"];
+/** Tool metadata — generic version (Hammer extends this with constrained categories). */
+interface ToolMetadata extends ToolDefinitionMetadata {
+    requirements: string[];
+}
+declare abstract class Tool {
+    protected workspaceRoot: string;
+    constructor(workspaceRoot?: string);
+    /**
+     * Get tool metadata — capabilities, categories, requirements.
+     * Override in subclasses.
+     */
+    getMetadata(): ToolMetadata;
+    /** Execute the tool — must be implemented by subclasses. */
+    abstract execute(params: Record<string, any>): Promise<ToolResult>;
+    /** Get tool name. */
+    abstract getName(): string;
+    /** Get tool description. */
+    abstract getDescription(): string;
+    /** Get parameter schema. */
+    abstract getSchema(): ToolSchema;
+    /** Get an explicit usage example shown in tool prompts. */
+    getUsageExample(): string | undefined;
+    /** Convert this tool instance to a ToolDefinition for LLM consumption. */
+    toDefinition(): ToolDefinition;
+}
+
+/**
+ * Shared ToolRegistry infrastructure.
+ *
+ * This mirrors the Hammer and Magic registry shape: a real
+ * Map<string, Tool> registry with registration, lookup, execution,
+ * definition generation, and executor creation.
+ */
+
+type ToolExecutor = (toolCall: ToolCall) => Promise<ToolResult>;
+type BashExecutor = (command: string) => Promise<ToolResult>;
+type BackgroundBashExecutor = (command: string) => Promise<ToolResult>;
+interface ToolRegistryMissingToolContext {
+    name: string;
+    availableToolNames: string[];
+}
+interface ToolRegistryBeforeExecuteContext {
+    name: string;
+    parameters: Record<string, any>;
+    registry: ToolRegistry;
+}
+interface ToolRegistryOptions {
+    tools?: Iterable<Tool>;
+    canExecute?: boolean | (() => boolean);
+    executeBash?: BashExecutor;
+    executeBackgroundBash?: BackgroundBashExecutor;
+    runCommandRegistry?: RunCommandRegistry;
+    onMissingTool?: (context: ToolRegistryMissingToolContext) => Error | string;
+    beforeExecute?: (context: ToolRegistryBeforeExecuteContext) => Promise<ToolResult | void> | ToolResult | void;
+}
+declare function createToolRegistry(tools?: Iterable<Tool>, options?: Omit<ToolRegistryOptions, "tools">): ToolRegistry;
+declare class ToolRegistry {
+    protected tools: Map<string, Tool>;
+    private canExecuteOverride?;
+    private bashExecutor?;
+    private backgroundBashExecutor?;
+    private runCommandRegistry;
+    private onMissingTool?;
+    private beforeExecute?;
+    constructor(toolsOrOptions?: Iterable<Tool> | ToolRegistryOptions);
+    registerTool(tool: Tool): void;
+    registerTools(tools: Iterable<Tool>): void;
+    replaceTools(tools: Iterable<Tool>): void;
+    hasTool(name: string): boolean;
+    getTool(name: string): Tool;
+    protected buildMissingToolError(name: string): Error;
+    getTools(): Tool[];
+    executeTool(name: string, parameters: Record<string, any>): Promise<ToolResult>;
+    executeToolCall(toolCall: ToolCall): Promise<ToolResult>;
+    private createConcreteRuntime;
+    private executeConcreteTool;
+    getToolDefinitions(): ToolDefinition[];
+    getToolNames(): string[];
+    hasTools(): boolean;
+    canExecuteBash(): boolean;
+    canExecuteBackgroundBash(): boolean;
+    getAvailableRunTargets(): readonly RunInvocationTarget[];
+    getRunCommandRegistry(): RunCommandRegistry;
+    canExecute(): boolean;
+    createExecutor(): ToolExecutor;
+}
+
+type ProxyToolExecutor = (parameters: Record<string, any>, definition: ToolDefinition) => Promise<ToolResult>;
+/**
+ * Shared adapter for exposing a ToolDefinition as a concrete Tool while
+ * delegating execution across a runtime boundary.
+ */
+declare class ProxyTool extends Tool {
+    private definition;
+    private executor;
+    constructor(definition: ToolDefinition, executor: ProxyToolExecutor);
+    getName(): string;
+    getDescription(): string;
+    getSchema(): ToolDefinition["parameters"];
+    getMetadata(): ToolMetadata;
+    execute(parameters: Record<string, any>): Promise<ToolResult>;
+}
+
+interface ToolLoopStepExecutorResponse {
+    content: string;
+    finishReason: string;
+    usage?: LLMClientResponse["usage"];
+}
+interface ToolLoopStepExecutorCallbacks {
+    onMessagesBuilt?(messages: ChatMessage[]): void;
+    onToken?(token: string): void;
+    onComplete?(response: ToolLoopStepExecutorResponse): void;
+    onStreamError?(error: Error): void;
+    onLog?(message: string, level: "info" | "warn" | "error"): void;
+}
+interface ToolLoopStepExecutorOptions<TResult> {
+    llmClient: LLMClient;
+    memoryLayer: Pick<AgentMemoryLayer, "buildMessages">;
+    systemPrompt: string;
+    temperature: number;
+    maxTokens: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    callbacks?: ToolLoopStepExecutorCallbacks;
+    parseResponse(response: {
+        content: string;
+        finishReason: string;
+        usage?: LLMClientResponse["usage"];
+        messages: ChatMessage[];
+    }): TResult;
+}
+interface ToolLoopStepExecutionResult<TResult> {
+    messages: ChatMessage[];
+    response: ToolLoopStepExecutorResponse;
+    parsed: TResult;
+}
+declare function executeToolLoopStep<TResult>(options: ToolLoopStepExecutorOptions<TResult>): Promise<ToolLoopStepExecutionResult<TResult>>;
+
+declare function decodeEscapedShellText(value: string): string;
+
+declare function buildToolUsageExample(tool: Pick<ToolDefinition, "name" | "parameters" | "metadata">): string;
+
+interface BuildMemoryCompactionPromptOptions {
+    persona: string;
+    currentState: string;
+    messageBlock: string;
+    schema: string;
+    rules: string[];
+}
+
+interface MemoryMetadataLike {
+    provenance: MemoryProvenance;
+}
+declare function buildCompactionEntry<T>(options: {
+    text: string;
+    provenance: MemoryProvenance;
+    summarize: (text: string) => string;
+    canonicalize: (text: string) => string;
+    preprocess?: (text: string) => string;
+    canonicalizeSource?: (preprocessed: string, normalized: string) => string;
+    build: (normalized: string, canonical: string, metadata: MemoryMetadataLike) => T;
+}): T | null;
+declare function canonicalizeCompactionText(text: string, options?: {
+    stopWords?: Iterable<string>;
+    stripQuotes?: boolean;
+}): string;
+declare function selectLatestByKey<T>(entries: T[], keyOf: (entry: T) => string, recencyOf: (entry: T) => number): T[];
+declare function limitEntriesByRecency<T>(entries: T[], limit: number, recencyOf: (entry: T) => number): T[];
+declare function runStructuredLLMCompaction<TMessage extends MemoryMessage, TState>(options: {
+    client?: CompactionLLMClient;
+    currentState: string;
+    messages: TMessage[];
+    formatMessage: (message: TMessage) => string;
+    persona: string;
+    schema: string;
+    rules: string[];
+    temperature?: number;
+    maxTokens?: number;
+    parseState: (obj: Record<string, unknown>) => TState | null;
+}): Promise<TState | null>;
+
+export { AGENT_MACHINE_STATES, AgentLoop, type AgentLoopCallbacks, type AgentLoopDeps, type AgentMachineContext, type AgentMachineEvent, type AgentMachineState, type AgentMemoryCitation, type AgentMemoryConstraint, type AgentMemoryEvidence, type AgentMemoryFactoryOverrides, AgentMemoryLayer, type AgentMemoryLayerConfig, type AgentMemoryLogger, type AgentMemoryNote, type AgentMemoryTask, type AgentMessage, type AgentPhase, type AgentState, ApiError, type BackgroundBashAction, BackgroundBashRunCommand, BaseMemoryLayer, BaseValidationEnforcer, BashRunCommand, type BuildMemoryCompactionPromptOptions, CharTokenEstimator, type ChatMessage, type CommandRuntime, type CommandTargetInfo, type CompactionCursor, type CompactionLLMClient, type ConversationAdapter, type ConversationSink, type CreateWebRuntimeSetupOptions, DEFAULT_AGENT_FALLBACK_SYSTEM_PROMPT, DEFAULT_ALLOWED_RUN_TARGETS, DEFAULT_RUN_COMMAND_REGISTRY, DEFAULT_THREAD_AUTO_SCROLL_BOTTOM_THRESHOLD, DEFAULT_TOOL_MEMORY_EXTRACTOR, ERROR_TRUNCATED_RESPONSE, type EnforcerResult, type ExecuteWebLoopRunOptions, type FetchLike, type FetchResponseLike, type HammerAgentConfig, type HammerAgentProviderPreset, LLMClient, type LLMClientResponse, type LLMProviderConfig, type LLMRequest, type LLMRequestOptions, type LLMResponse, type LoopOutcome, MAX_TOOL_RESULT_CHARS, type MemoryMessage, type MemoryProvenance, type MemoryStorage, type ParseAgentResponseOptions, type ParsedAgentResponse, type ParsedBackgroundBashCommand, type ParsedStepInput, PendingAgentMessageBuffer, type PersistedMemoryData, type ProviderName, ProxyTool, type ProxyToolExecutor, type RawMessage, RunCommand, type RunCommandParseResult, type RunCommandPromptAvailability, RunCommandRegistry, type RunInvocationTarget, type RuntimeController, type RuntimeSnapshotUpdater, type RuntimeStore, type RuntimeSubscriber, SUPPORTED_RUN_TARGETS, type StepResult, type StreamCallbacks, StreamingToolParser, type StreamingToolParserCallbacks, type SystemPromptCustomizer, type TodoItem, type TodoStatus, type TokenEstimator, Tool, type ToolCall, type ToolDataPrimitive, type ToolDataSchema, type ToolDataValue, type ToolDefinition, type ToolDefinitionMetadata, type ToolExecutionResult, ToolLoopAgentRuntime, type ToolLoopAgentRuntimeDeps, type ToolLoopRuntimeExecuteStepResult, type ToolLoopRuntimeHooks, type ToolLoopRuntimeInfrastructure, type ToolLoopRuntimeLLMRequest, type ToolLoopRuntimeLLMResponse, type ToolLoopRuntimeRunStepOptions, type ToolLoopRuntimeRunStepResult, type ToolLoopRuntimeSetup, type ToolLoopRuntimeStepContext, type ToolLoopStepExecutionResult, type ToolLoopStepExecutorCallbacks, type ToolLoopStepExecutorOptions, type ToolLoopStepExecutorResponse, type ToolMemoryCitationKind, type ToolMemoryEvidenceKind, type ToolMemoryEvidencePolicy, type ToolMemoryExtractor, type ToolMemoryMetadata, type ToolMemoryNoteKind, type ToolMemoryNotePolicy, type ToolMemoryNoteScope, type ToolMetadata, type ToolParameterDefinition, ToolRegistry, type ToolRegistryBeforeExecuteContext, type ToolRegistryMissingToolContext, type ToolRegistryOptions, type ToolResult, ToolRunCommand, type ToolSchema, type TruncatedToolInfo, type WebSearchToolActionInput, WebToolLoopAgentRuntime, type WebToolLoopAgentRuntimeConstructorOptions, type WebToolLoopRuntimeStateLike, WebValidationEnforcer, agentMachine, applyIdleWebAgentState, applyInitialWebAgentRunState, buildAgentSystemPrompt, buildCompactionEntry, buildCoreStaticRules, buildNoStructuredResponseFoundError, buildParseFeedback, buildStepUserMessage, buildToolLogRevealFrames, buildToolUsageExample, buildValidationErrorMessage, canonicalizeCompactionText, coerceToolCallToDefinition, configure, containsStandaloneStructuredInvocationStart, createAgentMemoryLayer, createAppendToolsSectionCustomizer, createBackgroundBashDefinition, createConversationSink, createCustomRunCommandRegistry, createInitialWebAgentState, createRunCommandRuntimeBindings, createRuntimeStore, createToolAgentMessage, createToolRegistry, createToolsSectionOverrideCustomizer, createWebAgentMessageIdGenerator, createWebSearchToolActions, createWebToolLoopCallbacks, decodeEscapedShellText, defineRuntimeController, enrichToolResultWithUnixMetadata, executeBackgroundUnixCommandString, executeToolCallWithRunCommands, executeToolLoopStep, executeToolSafe, executeUnixCommandString, extractPrimaryCommandMetadata, extractTruncatedToolInfo, formatToolCallAsUnixCommand, formatToolDefinitions, formatToolResultMessage, formatToolsSection, formatUnixToolSurface, formatZodValidationError, getDiagnosticSummaryLine, getProviderConfig, getRunCommandPromptAvailability, getToolLogSummaryLine, isBackgroundBashToolCall, isBashToolCall, limitEntriesByRecency, machineStateToWebAgentPhase, mapConversationRoleToAgentRole, parseAgentResponse, parseResponseWithRecovery, parseStructuredAgentText, parseToolResultMessage, parseUnixToolCommand, readDiagnosticLevel, readDiagnosticSource, resolveToolDefinitionForInvocation, runStructuredLLMCompaction, selectLatestByKey, shouldAutoScrollThread, shouldSkipStepUserMessage, stripDiagnosticMessagePrefix, suppressWebValidationLog, tokenizeUnixCommand, truncateToolResult };