agent-worker 0.17.0 → 0.19.0

package/dist/index.d.mts

@@ -1,889 +1,289 @@
-import { LanguageModel } from "ai";
-import { BashToolkit, CreateBashToolOptions, createBashTool } from "bash-tool";
-import { z } from "zod/v4";
+import { Hono } from "hono";
+import { AgentDefinition, AgentResponse, AgentWorker, AgentWorkerConfig, BackendType, CreateSkillToolOptions, Logger, ProviderConfig, ScheduleConfig, SendOptions, SendOptions as SendOptions$1, SessionState, SkillImporter, SkillToolkit, StepInfo, createSkillTool } from "@moniro/agent-loop";
+import { ConversationLog, PersonalContextProvider, ThinThread } from "@moniro/agent-worker";
+import { AgentInstruction, AgentLoop, EventKind, EventSink, Message, ParsedWorkflow, Workspace } from "@moniro/workspace";
 
-//#region src/backends/model-maps.d.ts
-/**
- * Model Translation Maps — Single Source of Truth
- *
- * All backend-specific model naming and translation logic lives here.
- * Both `backends/types.ts` and `workflow/loop/types.ts` re-export from this module.
- */
-/** Backend type (union of all supported backends) */
-type BackendType = "default" | "claude" | "cursor" | "codex" | "opencode" | "mock";
-//#endregion
-//#region src/backends/types.d.ts
-interface BackendConfig {
-  type: BackendType;
-  /** Model identifier (interpretation depends on backend) */
-  model?: string;
-  /** Additional CLI flags or SDK options */
-  options?: Record<string, unknown>;
-}
-interface BackendResponse {
-  content: string;
-  /** Tool calls made during execution (if supported) */
-  toolCalls?: Array<{
-    name: string;
-    arguments: unknown;
-    result: unknown;
-  }>;
-  /** Usage statistics (if available) */
-  usage?: {
-    input: number;
-    output: number;
-    total: number;
-  };
-}
-interface Backend {
-  readonly type: BackendType;
-  /** Send a message and get a response */
-  send(message: string, options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-  /** Check if the backend is available (CLI installed, API key set, etc.) */
-  isAvailable?(): Promise<boolean>;
-  /** Get backend info for display */
-  getInfo?(): {
-    name: string;
-    version?: string;
-    model?: string;
-  };
-  /** Abort any running operations and cleanup resources */
-  abort?(): void;
-}
-//#endregion
-//#region src/workflow/types.d.ts
-/**
- * Custom provider configuration for API endpoint overrides.
- * Allows pointing any compatible SDK at a different base URL.
- *
- * Examples:
- *   provider: anthropic                    # string → built-in provider
- *   provider:                              # object → custom endpoint
- *     name: anthropic
- *     base_url: https://api.minimax.io/anthropic/v1
- *     api_key: $MINIMAX_API_KEY
- */
-interface ProviderConfig {
-  /** Provider SDK name (e.g., 'anthropic', 'openai') */
-  name: string;
-  /** Override base URL for the provider */
-  base_url?: string;
-  /** API key — env var reference with '$' prefix (e.g., '$MINIMAX_API_KEY') or literal value */
-  api_key?: string;
-}
-//#endregion
-//#region src/agent/types.d.ts
-/**
- * Message status for streaming/response tracking
- */
-type MessageStatus = "responding" | "complete";
-/**
- * Extended message with status for tracking streaming state
- */
-interface AgentMessage {
-  role: "user" | "assistant" | "system" | "tool";
-  content: string;
-  /** Message status - 'responding' while streaming, 'complete' when done */
-  status?: MessageStatus;
-  /** Timestamp when message started */
-  timestamp?: string;
-}
-/**
- * Approval check — static boolean or dynamic function
- */
-type ApprovalCheck = boolean | ((args: Record<string, unknown>) => boolean);
-/**
- * Tool info returned by getTools() — read-only view
- */
-interface ToolInfo {
-  name: string;
-  description?: string;
-  needsApproval: boolean;
-}
-/**
- * A pending tool call awaiting user approval
- */
-interface PendingApproval {
-  /** Unique approval ID */
-  id: string;
-  /** Tool name */
-  toolName: string;
-  /** Tool call ID from the model */
-  toolCallId: string;
-  /** Arguments passed to the tool */
-  arguments: Record<string, unknown>;
-  /** When the approval was requested */
-  requestedAt: string;
-  /** Current status */
-  status: "pending" | "approved" | "denied";
-  /** Denial reason if denied */
-  denyReason?: string;
-}
-/**
- * A single tool call with its result
- */
-interface ToolCall {
-  name: string;
-  arguments: Record<string, unknown>;
-  result: unknown;
-  timing: number;
-}
-/**
- * Token usage statistics
- */
-interface TokenUsage {
-  input: number;
-  output: number;
-  total: number;
-}
-/**
- * Response from a single message exchange
- */
-interface AgentResponse {
-  /** Final text content */
-  content: string;
-  /** All tool calls made during this turn */
-  toolCalls: ToolCall[];
-  /** Tool calls awaiting approval (response is incomplete until approved) */
-  pendingApprovals: PendingApproval[];
-  /** Token usage */
-  usage: TokenUsage;
-  /** Response latency in ms */
-  latency: number;
-}
-/**
- * Session configuration
- */
-interface SessionConfig {
-  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5') */
-  model: string;
-  /** System prompt */
-  system: string;
-  /** AI SDK tools — Record<name, tool()> */
-  tools?: Record<string, unknown>;
-  /** Per-tool approval config — Record<name, boolean | (args) => boolean> */
-  approval?: Record<string, ApprovalCheck>;
-  /** Maximum tokens for response (default: 4096) */
-  maxTokens?: number;
-  /** Maximum tool call steps per turn (default: 200) */
-  maxSteps?: number;
-}
-/**
- * Persisted session state for restoration
- */
-interface SessionState {
-  /** Session ID to restore */
-  id: string;
-  /** Creation timestamp */
-  createdAt: string;
-  /** Conversation messages with status */
-  messages: AgentMessage[];
-  /** Accumulated token usage */
-  totalUsage: TokenUsage;
-  /** Pending tool approvals */
-  pendingApprovals: PendingApproval[];
-}
-/**
- * Exported transcript for analysis
- */
-interface Transcript {
-  sessionId: string;
-  model: string;
-  system: string;
-  messages: AgentMessage[];
-  totalUsage: TokenUsage;
-  createdAt: string;
-}
-//#endregion
-//#region src/agent/worker.d.ts
-/**
- * Extended worker config that supports both SDK and CLI backends.
- * When a backend is provided, send() delegates to it instead of ToolLoopAgent.
- * This enables unified worker management regardless of backend type.
- */
-interface AgentWorkerConfig extends SessionConfig {
-  /** CLI backend - when provided, send() delegates to this backend */
-  backend?: Backend;
-  /** Provider configuration — when set, model is resolved via createModelWithProvider */
-  provider?: string | ProviderConfig;
-}
-/**
- * Step finish callback info
- */
-interface StepInfo {
-  stepNumber: number;
-  toolCalls: ToolCall[];
-  usage: TokenUsage;
-}
-/**
- * Options for send() method
- */
-interface SendOptions {
-  /** Auto-approve all tool calls that require approval (default: true) */
-  autoApprove?: boolean;
-  /** Callback after each agent step */
-  onStepFinish?: (info: StepInfo) => void | Promise<void>;
-}
-/**
- * AgentWorker - Stateful worker for controlled agent execution
- *
- * Uses ToolLoopAgent internally for multi-step reasoning loops.
- * Maintains conversation state across multiple send() calls,
- * enabling improvisational testing where you observe responses
- * and decide next actions.
- *
- * Tools are AI SDK tool() objects passed as Record<name, tool()>.
- * Approval is configured separately via Record<name, check>.
- */
-declare class AgentWorker {
-  readonly id: string;
-  readonly model: string;
-  readonly system: string;
-  readonly createdAt: string;
-  private tools;
-  private approval;
-  private maxTokens;
-  private maxSteps;
-  private messages;
-  private totalUsage;
-  private pendingApprovals;
-  private backend;
-  private provider;
-  private cachedAgent;
-  private toolsChanged;
-  /**
-   * Whether this session supports tool management (SDK backend only)
-   */
-  get supportsTools(): boolean;
-  /**
-   * Convert AgentMessage[] to ModelMessage[] for AI SDK
-   */
-  private toModelMessages;
-  constructor(config: AgentWorkerConfig, restore?: SessionState);
-  /**
-   * Check if a tool needs approval for given arguments
-   */
-  private checkApproval;
-  /**
-   * Build tools with approval wrapping for ToolLoopAgent
-   */
-  private buildTools;
-  /**
-   * Get or create cached agent, rebuild if tools changed
-   */
-  private getAgent;
-  /**
-   * Send a message via CLI backend (non-SDK path)
-   */
-  private sendViaBackend;
+//#region src/agent/agent-handle.d.ts
+type AgentHandleState = "idle" | "running" | "stopped" | "error";
+declare class AgentHandle implements PersonalContextProvider {
+  /** Agent definition (from YAML or API) */
+  readonly definition: AgentDefinition;
+  /** Absolute path to agent's persistent context directory */
+  readonly contextDir: string;
+  /**
+   * Whether this agent is ephemeral (in-memory only).
+   * Ephemeral agents are created via the daemon API (POST /agents) and
+   * lost on daemon restart. Config agents are defined in config.yml.
+   */
+  readonly ephemeral: boolean;
+  /** Current agent state */
+  state: AgentHandleState;
+  /** The agent's execution loop (lazy — created on first run/serve) */
+  loop: AgentLoop | null;
+  /** Conversation log (lazy — created on first access) */
+  private _conversationLog?;
+  /** Thin thread (lazy — created on first access) */
+  private _thinThread?;
+  /** Optional logger (injected by registry; absent in standalone CLI) */
+  private log?;
+  constructor(definition: AgentDefinition, contextDir: string, logger?: Logger, ephemeral?: boolean);
+  /** Agent name (convenience accessor) */
+  get name(): string;
+  /**
+   * Get the conversation log (JSONL persistence).
+   * Returns null for ephemeral agents (no disk).
+   * Lazy — created on first access.
+   */
+  get conversationLog(): ConversationLog | null;
+  /**
+   * Get the thin thread (bounded in-memory conversation buffer).
+   * Restores from ConversationLog on first access if history exists.
+   * Lazy — created on first access.
+   */
+  get thinThread(): ThinThread;
+  /**
+   * Send a typed instruction to this agent's loop.
+   *
+   * Convenience method that creates an AgentInstruction and enqueues it.
+   * The loop must exist (call ensureAgentLoop first for standalone agents).
+   *
+   * @throws if no loop is attached
+   */
+  send(instruction: AgentInstruction): void;
+  /**
+   * Send a simple message with auto-classified priority.
+   *
+   * Shorthand for creating an AgentInstruction from a raw message string.
+   */
+  sendMessage(message: string, options?: {
+    priority?: AgentInstruction["priority"];
+    source?: AgentInstruction["source"];
+  }): void;
   /**
-   * Send a message and get the agent's response
+   * Ensure the context directory and all subdirectories exist.
+   * Called on agent load/creation. Idempotent.
    */
-  send(content: string, options?: SendOptions): Promise<AgentResponse>;
+  ensureContextDir(): void;
   /**
-   * Send a message and stream the response
+   * Read all memory entries as key-value records.
+   * Memory files are YAML in memory/<key>.yaml.
    */
-  sendStream(content: string, options?: SendOptions): AsyncGenerator<string, AgentResponse, unknown>;
+  readMemory(): Promise<Record<string, unknown>>;
   /**
-   * Add an AI SDK tool
-   * Only supported for SDK backends (ToolLoopAgent)
+   * Write a memory entry. Creates/overwrites memory/<key>.yaml.
    */
-  addTool(name: string, t: unknown): void;
+  writeMemory(key: string, value: unknown): Promise<void>;
   /**
-   * Set approval requirement for a tool
+   * Read agent's notes, most recent first.
+   * Notes are markdown files in notes/.
    */
-  setApproval(name: string, check: ApprovalCheck): void;
+  readNotes(limit?: number): Promise<string[]>;
   /**
-   * Replace a tool's execute function (for testing)
+   * Append a note. Creates notes/<date>-<slug>.md.
    */
-  mockTool(name: string, mockFn: (args: Record<string, unknown>) => unknown): void;
+  appendNote(content: string, slug?: string): Promise<string>;
   /**
-   * Set a static mock response for an existing tool
+   * Read active todos from todo/index.md.
+   * Returns lines that look like incomplete tasks: "- [ ] ..."
    */
-  setMockResponse(name: string, response: unknown): void;
+  readTodos(): Promise<string[]>;
   /**
-   * Get tool info (names, descriptions, approval status)
+   * Write the full todo list. Replaces todo/index.md.
    */
-  getTools(): ToolInfo[];
-  history(): AgentMessage[];
-  stats(): {
-    messageCount: number;
-    usage: TokenUsage;
-  };
-  export(): Transcript;
-  getState(): SessionState;
-  getPendingApprovals(): PendingApproval[];
-  approve(approvalId: string): Promise<unknown>;
-  deny(approvalId: string, reason?: string): void;
-  clear(): void;
+  writeTodos(todos: string[]): Promise<void>;
 }
 //#endregion
-//#region src/agent/models.d.ts
-/**
- * Parse model identifier and return the appropriate provider model
- *
- * Supports three formats:
- *
- * 1. Provider-only format: provider
- *    Uses first model from FRONTIER_MODELS via gateway
- *    Examples: anthropic → anthropic/claude-sonnet-4-5, openai → openai/gpt-5.2
- *
- * 2. Gateway format: provider/model-name
- *    Uses Vercel AI Gateway (requires AI_GATEWAY_API_KEY)
- *    Examples: anthropic/claude-sonnet-4-5, openai/gpt-5.2, deepseek/deepseek-chat
- *
- * 3. Direct provider format: provider:model-name
- *    Requires installing the specific @ai-sdk/provider package
- *    Examples: anthropic:claude-sonnet-4-5, openai:gpt-5.2, deepseek:deepseek-chat
- */
-declare function createModel(modelId: string): LanguageModel;
-/**
- * Async version of createModel - supports lazy loading of direct providers
- * Use this when you need direct provider access (provider:model format)
- */
-declare function createModelAsync(modelId: string): Promise<LanguageModel>;
-/**
- * List of supported providers for direct access
- */
-declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "deepseek", "google", "groq", "mistral", "xai"];
-type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
-/**
- * Frontier models for each provider (as of 2026-02)
- * Only includes the latest/best models, no legacy versions
- *
- * Note: Some models may be placeholders for testing or future releases.
- * Always verify model availability with the provider before production use.
- */
-declare const FRONTIER_MODELS: {
-  readonly anthropic: readonly ["claude-sonnet-4-5", "claude-haiku-4-5", "claude-opus-4-5"];
-  readonly openai: readonly ["gpt-5.2", "gpt-5.2-codex"];
-  readonly google: readonly ["gemini-3-pro-preview", "gemini-2.5-flash", "gemini-2.5-pro"];
-  readonly deepseek: readonly ["deepseek-chat", "deepseek-reasoner"];
-  readonly groq: readonly ["meta-llama/llama-4-scout-17b-16e-instruct", "deepseek-r1-distill-llama-70b"];
-  readonly mistral: readonly ["mistral-large-latest", "pixtral-large-latest", "magistral-medium-2506"];
-  readonly xai: readonly ["grok-4", "grok-4-fast-reasoning"];
-};
-//#endregion
-//#region src/agent/tools/bash.d.ts
-/**
- * Options for creating bash tools compatible with AgentWorker
- */
-interface BashToolsOptions extends CreateBashToolOptions {
-  /**
-   * Include readFile tool (default: true)
-   */
-  includeReadFile?: boolean;
-  /**
-   * Include writeFile tool (default: true)
-   */
-  includeWriteFile?: boolean;
+//#region src/agent/agent-registry.d.ts
+declare class AgentRegistry {
+  /** Loaded agent handles, keyed by name */
+  private agents;
+  /** Workspace root directory (e.g. ~/.agent-worker/ for global) */
+  readonly projectDir: string;
+  /** Optional logger (injected by daemon) */
+  private log?;
+  constructor(projectDir: string, logger?: Logger);
+  /**
+   * Register a config agent (from config.yml). Creates context dir on disk.
+   * Overwrites existing agent with same name (reload semantics).
+   */
+  registerDefinition(def: AgentDefinition): AgentHandle;
+  /**
+   * Register an ephemeral agent (from daemon API).
+   * Exists only in memory, lost on restart.
+   */
+  registerEphemeral(def: AgentDefinition): AgentHandle;
+  /**
+   * Unregister an agent from memory.
+   * @returns true if agent existed and was removed.
+   */
+  delete(name: string): boolean;
+  /** Get agent handle by name */
+  get(name: string): AgentHandle | undefined;
+  /** Check if agent exists */
+  has(name: string): boolean;
+  /** List all registered agent handles */
+  list(): AgentHandle[];
+  /** Number of registered agents */
+  get size(): number;
+  /** Resolve agent's context directory (absolute path) */
+  private resolveContextDir;
 }
-/**
- * Create bash tools as AI SDK tool() objects for use with AgentWorker
- *
- * @example
- * ```typescript
- * const { tools } = await createBashTools({
- *   files: { 'src/index.ts': 'console.log("hello")' }
- * })
- *
- * const session = new AgentWorker({
- *   model: 'anthropic/claude-sonnet-4-5',
- *   system: 'You are a coding assistant.',
- *   tools
- * })
- * ```
- */
-declare function createBashTools(options?: BashToolsOptions): Promise<{
-  tools: Record<string, unknown>;
-  toolkit: BashToolkit;
-}>;
-/**
- * Quick helper to create bash tools with a directory
- */
-declare function createBashToolsFromDirectory(source: string, options?: Omit<BashToolsOptions, "uploadDirectory">): Promise<{
-  tools: Record<string, unknown>;
-  toolkit: BashToolkit;
-}>;
-/**
- * Quick helper to create bash tools with inline files
- */
-declare function createBashToolsFromFiles(files: Record<string, string>, options?: Omit<BashToolsOptions, "files">): Promise<{
-  tools: Record<string, unknown>;
-  toolkit: BashToolkit;
-}>;
 //#endregion
-//#region src/agent/tools/feedback.d.ts
-/**
- * Feedback tool — lets agents surface workflow improvement needs
- *
- * When enabled, agents can report what's missing or inconvenient during work:
- * a tool they wished they had, a step that felt unnecessarily slow, or a
- * capability gap. The purpose is workflow improvement, not bug reporting.
- *
- * @example
- * ```typescript
- * const { tool, getFeedback } = createFeedbackTool();
- *
- * const session = new AgentWorker({
- *   model: 'anthropic/claude-sonnet-4-5',
- *   system: FEEDBACK_PROMPT + '\nYou are a coding assistant.',
- *   tools: { feedback: tool, bash: bashTool },
- * });
- *
- * await session.send('...');
- * console.log(getFeedback()); // review what the agent reported
- * ```
- */
-interface FeedbackEntry {
-  /** ISO timestamp */
-  timestamp: string;
-  /** What area this is about — a tool name, workflow step, etc. */
-  target: string;
-  /** Category */
-  type: "missing" | "friction" | "suggestion";
-  /** What the agent needed or what could be improved */
-  description: string;
-  /** Optional: what the agent was trying to do */
-  context?: string;
-}
-interface FeedbackToolOptions {
-  /** Called each time the agent submits feedback */
-  onFeedback?: (entry: FeedbackEntry) => void;
-  /** Maximum entries to keep (default: 50) */
-  maxEntries?: number;
-}
-interface FeedbackToolResult {
-  /** AI SDK tool() object — pass to AgentWorker as a tool */
-  tool: unknown;
-  /** Retrieve all collected feedback entries */
-  getFeedback(): FeedbackEntry[];
-  /** Clear collected feedback */
-  clearFeedback(): void;
+//#region src/agent/store.d.ts
+interface StateStore {
+  /** Load conversation state for an agent. Returns null if no state exists. */
+  load(agentId: string): Promise<SessionState | null>;
+  /** Save conversation state for an agent. */
+  save(agentId: string, state: SessionState): Promise<void>;
+  /** Delete conversation state for an agent. */
+  delete(agentId: string): Promise<void>;
 }
 /**
- * Append this to the system prompt when the feedback tool is enabled.
- * Tells the agent the tool exists and when to use it.
+ * In-memory state store. State is lost when the daemon stops.
+ * Suitable for development and single-machine deployments.
  */
-declare const FEEDBACK_PROMPT: string;
-declare function createFeedbackTool(options?: FeedbackToolOptions): FeedbackToolResult;
-//#endregion
-//#region src/backends/stream-json.d.ts
-/** Structured callbacks for stream parser output */
-interface StreamParserCallbacks {
-  /** Debug-level messages (kind="debug") */
-  debugLog: (message: string) => void;
-  /** Text output from backend (kind="output") — assistant/user messages */
-  outputLog?: (message: string) => void;
-  /** Backend native tool call (kind="tool_call", source="backend") */
-  toolCallLog?: (name: string, args: string) => void;
-  /** MCP tool names to skip (already logged by MCP server) */
-  mcpToolNames?: Set<string>;
+declare class MemoryStateStore implements StateStore {
+  private states;
+  load(agentId: string): Promise<SessionState | null>;
+  save(agentId: string, state: SessionState): Promise<void>;
+  delete(agentId: string): Promise<void>;
 }
 //#endregion
-//#region src/backends/claude-code.d.ts
-interface ClaudeCodeOptions {
-  /** Model to use (e.g., 'opus', 'sonnet') */
-  model?: string;
-  /** Additional system prompt to append */
-  appendSystemPrompt?: string;
-  /** Allowed tools (permission rule syntax) */
-  allowedTools?: string[];
-  /** Output format: 'text' | 'json' | 'stream-json' */
-  outputFormat?: "text" | "json" | "stream-json";
-  /** Continue most recent conversation */
-  continue?: boolean;
-  /** Resume specific session by ID */
-  resume?: string;
-  /** Working directory (defaults to workspace if set) */
-  cwd?: string;
-  /** Workspace directory for agent isolation */
-  workspace?: string;
-  /** Idle timeout in milliseconds — kills process if no output for this duration */
-  timeout?: number;
-  /** MCP config file path (for workflow context) */
-  mcpConfigPath?: string;
-  /** Stream parser callbacks (structured event output) */
-  streamCallbacks?: StreamParserCallbacks;
-}
-declare class ClaudeCodeBackend implements Backend {
-  readonly type: "claude";
-  private options;
-  private currentAbort?;
-  constructor(options?: ClaudeCodeOptions);
-  send(message: string, options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-  isAvailable(): Promise<boolean>;
-  getInfo(): {
-    name: string;
-    version?: string;
-    model?: string;
-  };
-  private buildArgs;
-  /**
-   * Abort any running claude process
-   */
-  abort(): void;
+//#region src/daemon/serve.d.ts
+interface ServerHandle {
+  /** Actual port the server is listening on */
+  port: number;
+  /** Gracefully close the server */
+  close(): Promise<void>;
 }
 //#endregion
-//#region src/backends/codex.d.ts
-interface CodexOptions {
-  /** Model to use (e.g., 'gpt-5.2-codex') */
-  model?: string;
-  /** Working directory (defaults to workspace if set) */
-  cwd?: string;
-  /** Workspace directory for agent isolation */
-  workspace?: string;
-  /** Resume a previous session */
-  resume?: string;
-  /** Idle timeout in milliseconds — kills process if no output for this duration */
-  timeout?: number;
-  /** Stream parser callbacks (structured event output) */
-  streamCallbacks?: StreamParserCallbacks;
-}
-declare class CodexBackend implements Backend {
-  readonly type: "codex";
-  private options;
-  constructor(options?: CodexOptions);
-  send(message: string, _options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-  isAvailable(): Promise<boolean>;
-  getInfo(): {
-    name: string;
-    version?: string;
-    model?: string;
-  };
-  private buildArgs;
-}
-//#endregion
-//#region src/backends/cursor.d.ts
-interface CursorOptions {
-  /** Model to use */
-  model?: string;
-  /** Working directory (defaults to workspace if set, otherwise cwd) */
-  cwd?: string;
-  /** Workspace directory for agent isolation (contains .cursor/mcp.json) */
-  workspace?: string;
-  /** Idle timeout in milliseconds — kills process if no output for this duration */
-  timeout?: number;
-  /** Stream parser callbacks (structured event output) */
-  streamCallbacks?: StreamParserCallbacks;
-}
-declare class CursorBackend implements Backend {
-  readonly type: "cursor";
-  private options;
-  /**
-   * Resolved command style:
-   * - "subcommand": `cursor agent -p ...` (IDE-bundled CLI)
-   * - "direct": `agent -p ...` (standalone install via cursor.com/install)
-   * - null: not yet resolved
-   */
-  private resolvedStyle;
-  constructor(options?: CursorOptions);
-  send(message: string, _options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-  isAvailable(): Promise<boolean>;
-  getInfo(): {
-    name: string;
-    version?: string;
-    model?: string;
-  };
-  /**
-   * Resolve which cursor command style is available.
-   * Tries in order:
-   *   1. `cursor agent --version` — IDE-bundled CLI (subcommand style)
-   *   2. `agent --version` — standalone install via cursor.com/install (direct style)
-   * Result is cached after first resolution.
-   */
-  private resolveStyle;
-  protected buildCommand(message: string): Promise<{
-    command: string;
-    args: string[];
-  }>;
-}
-//#endregion
-//#region src/backends/opencode.d.ts
-interface OpenCodeOptions {
-  /** Model to use in provider/model format (e.g., 'deepseek/deepseek-chat') */
-  model?: string;
-  /** Working directory (defaults to workspace if set) */
-  cwd?: string;
-  /** Workspace directory for agent isolation */
-  workspace?: string;
-  /** Idle timeout in milliseconds — kills process if no output for this duration */
-  timeout?: number;
-  /** Stream parser callbacks (structured event output) */
-  streamCallbacks?: StreamParserCallbacks;
-}
+//#region src/daemon/daemon.d.ts
+/** Handle for a running workflow managed by the daemon */
+interface WorkflowHandle {
+  /** Workflow name (from YAML name field or filename) */
+  name: string;
+  /** Workspace instance tag (optional) */
+  tag?: string;
+  /** Key for lookup: "name:tag" */
+  key: string;
+  /** Agent names in this workflow */
+  agents: string[];
+  /** Agent loops for lifecycle management */
+  loops: Map<string, AgentLoop>;
+  /** Workspace providing shared infrastructure */
+  workspace: Workspace;
+  /** Shutdown function (stops loops + cleans context) */
+  shutdown: () => Promise<void>;
+  /** Original workflow file path (for display) */
+  workflowPath?: string;
+  /** When this workflow was started */
+  startedAt: string;
+}
+interface DaemonState {
+  /** Agent registry — manages agent handles (definition + loop + state) */
+  agents: AgentRegistry;
+  /** Default workspace — shared by all standalone agents */
+  defaultWorkspace: Workspace | null;
+  /** Parsed config from config.yml (workflow format) */
+  config: ParsedWorkflow | null;
+  /** Running workflows — keyed by "name:tag" */
+  workflows: Map<string, WorkflowHandle>;
+  /** State store — conversation persistence (pluggable) */
+  store: StateStore;
+  /** HTTP server handle (optional — missing when app is used without server) */
+  server?: ServerHandle;
+  port: number;
+  host: string;
+  startedAt: string;
+}
+declare function startDaemon(config?: {
+  port?: number;
+  host?: string;
+  store?: StateStore;
+}): Promise<void>;
 //#endregion
-//#region src/backends/sdk.d.ts
-interface SdkBackendOptions {
-  /** Model identifier (e.g., 'openai/gpt-5.2' or 'anthropic:claude-sonnet-4-5' or just 'MiniMax-M2.5' with provider) */
-  model: string;
-  /** Maximum tokens to generate */
-  maxTokens?: number;
-  /** Provider configuration — when set, model is a plain name resolved via the provider */
-  provider?: string | ProviderConfig;
-}
-declare class SdkBackend implements Backend {
-  readonly type: "default";
-  private modelId;
-  private model;
-  private maxTokens;
-  private provider;
-  constructor(options: SdkBackendOptions);
-  send(message: string, options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-  isAvailable(): Promise<boolean>;
-  getInfo(): {
-    name: string;
-    version?: string;
-    model?: string;
-  };
-}
+//#region src/daemon/registry.d.ts
+declare const DEFAULT_PORT = 5099;
+interface DaemonInfo {
+  pid: number;
+  host: string;
+  port: number;
+  startedAt: string;
+  /** Auth token for API access (random per daemon instance) */
+  token?: string;
+}
+/** Write daemon.json for client discovery */
+declare function writeDaemonInfo(info: DaemonInfo): void;
+/** Read daemon.json. Returns null if missing or malformed. */
+declare function readDaemonInfo(): DaemonInfo | null;
+/** Remove daemon.json (on shutdown) */
+declare function removeDaemonInfo(): void;
+/** Check if a daemon is already running (daemon.json exists + PID alive) */
+declare function isDaemonRunning(): DaemonInfo | null;
 //#endregion
-//#region src/backends/mock.d.ts
+//#region src/daemon/event-log.d.ts
 /**
- * Mock AI Backend for testing
- *
- * In single-agent mode, provides a simple echo send().
- * In workflow mode, the loop handles MCP tool orchestration
- * via the mock runner strategy (loop/mock-runner.ts).
+ * Append-only JSONL event log for daemon-level events.
+ * Uses synchronous writes — daemon events are infrequent and must not be lost.
  */
-declare class MockAIBackend implements Backend {
-  private debugLog?;
-  readonly type: "mock";
-  constructor(debugLog?: ((message: string) => void) | undefined);
-  send(message: string, _options?: {
-    system?: string;
-  }): Promise<BackendResponse>;
-}
-/**
- * Create a mock AI backend
- */
-declare function createMockBackend(debugLog?: (msg: string) => void): Backend;
-//#endregion
-//#region src/backends/index.d.ts
-type BackendOptions = {
-  type: "default";
-  model?: string;
-  maxTokens?: number;
-  provider?: string | ProviderConfig;
-} | {
-  type: "claude";
-  model?: string;
-  options?: Omit<ClaudeCodeOptions, "model">;
-} | {
-  type: "codex";
-  model?: string;
-  options?: Omit<CodexOptions, "model">;
-} | {
-  type: "cursor";
-  model?: string;
-  options?: Omit<CursorOptions, "model">;
-} | {
-  type: "opencode";
-  model?: string;
-  options?: Omit<OpenCodeOptions, "model">;
-};
-/**
- * Create a backend instance
- * Model names are automatically translated to backend-specific format
- * Accepts "sdk" as deprecated alias for "default"
- *
- * Examples:
- * - "sonnet" → cursor: "sonnet-4.5", claude: "sonnet", default: "claude-sonnet-4-5-20250514"
- * - "anthropic/claude-sonnet-4-5" → cursor: "sonnet-4.5", claude: "sonnet"
- */
-declare function createBackend(config: BackendOptions | {
-  type: "sdk";
-  model?: string;
-  maxTokens?: number;
-}): Backend;
-/**
- * Check which backends are available
- */
-declare function checkBackends(): Promise<Record<BackendType, boolean>>;
-/**
- * List available backends with info
- */
-declare function listBackends(): Promise<Array<{
-  type: BackendType;
-  available: boolean;
-  name: string;
-}>>;
-//#endregion
-//#region src/agent/skills/provider.d.ts
-interface SkillMetadata {
-  name: string;
-  description: string;
-  path: string;
-}
-declare class SkillsProvider {
-  private skills;
-  /**
-   * Add a single skill directory
-   */
-  addSkill(skillPath: string): Promise<void>;
-  /**
-   * Scan a directory and add all valid skills found
-   */
-  scanDirectory(dir: string): Promise<void>;
-  /**
-   * List all available skills (metadata only)
-   */
-  list(): Array<{
-    name: string;
-    description: string;
-  }>;
-  /**
-   * View the full SKILL.md content
-   */
-  view(skillName: string): Promise<string>;
-  /**
-   * Read a file within a skill directory (relative path)
-   */
-  readFile(skillName: string, relativePath: string): Promise<string>;
-  /**
-   * Parse YAML frontmatter from SKILL.md
-   */
-  private parseFrontmatter;
-  /**
-   * Resolve tilde and relative paths
-   */
-  private resolvePath;
-  /**
-   * Synchronous version: Add a single skill directory
-   */
-  addSkillSync(skillPath: string): void;
-  /**
-   * Synchronous version: Scan a directory and add all valid skills found
-   */
-  scanDirectorySync(dir: string): void;
-  /**
-   * Synchronous version: Parse YAML frontmatter from SKILL.md
-   */
-  private parseFrontmatterSync;
-  /**
-   * Add skills from a SkillImporter (async)
-   * Used for temporary imported skills during session lifecycle
-   */
-  addImportedSkills(importer: {
-    getAllImportedSkillPaths(): string[];
-  }): Promise<void>;
-  /**
-   * Add skills from a SkillImporter (sync)
-   */
-  addImportedSkillsSync(importer: {
-    getAllImportedSkillPaths(): string[];
+declare class DaemonEventLog implements EventSink {
+  private filePath;
+  constructor(daemonDir: string);
+  append(from: string, content: string, options?: {
+    kind?: EventKind;
   }): void;
+  /** Read all events (full file read). */
+  readAll(): Promise<Message[]>;
+  /** Read events from byte offset (incremental sync). */
+  readFrom(offset: number): Promise<{
+    events: Message[];
+    offset: number;
+  }>;
 }
 //#endregion
-//#region src/agent/tools/skills.d.ts
-/**
- * Create a Skills tool as an AI SDK tool() object
- */
-declare function createSkillsTool(provider: SkillsProvider): unknown;
-//#endregion
-//#region src/agent/skills/importer.d.ts
-interface ImportedSkill {
+//#region src/agent/config.d.ts
+interface AgentConfig {
+  /** Agent name (unique within daemon) */
   name: string;
-  source: string;
-  tempPath: string;
-}
-/**
- * Temporary skill importer for session lifecycle
- * Clones Git repos to temp directory and manages imported skills
- */
-declare class SkillImporter {
-  private tempDir;
-  private imported;
-  constructor(sessionId: string);
-  /**
-   * Import skills from a Git repository
-   */
-  import(spec: string): Promise<string[]>;
-  /**
-   * Import skills from multiple specs
-   */
-  importMultiple(specs: string[]): Promise<string[]>;
-  /**
-   * Get path for an imported skill
-   */
-  getImportedSkillPath(skillName: string): string | null;
-  /**
-   * Get all imported skill paths
-   */
-  getAllImportedSkillPaths(): string[];
-  /**
-   * Get all imported skills metadata
-   */
-  getImportedSkills(): ImportedSkill[];
-  /**
-   * Get temporary directory path
-   */
-  getTempDir(): string;
-  /**
-   * Cleanup temporary directory
-   */
-  cleanup(): Promise<void>;
-  /**
-   * Clone Git repository (shallow clone)
-   */
-  private cloneRepo;
-  /**
-   * Extract skills from cloned repository
-   */
-  private extractSkills;
-  /**
-   * Find skills directory in repository
-   * Tries: skills/, agent-skills/, . (root)
-   */
-  private findSkillsDirectory;
-  /**
-   * Find all skills in a directory
-   */
-  private findAllSkills;
-  /**
-   * Execute git command
-   */
-  private execGit;
+  /** Model identifier (e.g., 'anthropic/claude-sonnet-4-5' or just 'MiniMax-M2.5' when provider is set) */
+  model: string;
+  /** System prompt */
+  system: string;
+  /** Backend type */
+  backend: BackendType;
+  /** Provider configuration — string (built-in) or object (custom endpoint) */
+  provider?: string | ProviderConfig;
+  /** Workflow this agent belongs to (optional — standalone agents have no workflow) */
+  workflow?: string;
+  /** Workflow instance tag (optional — standalone agents have no tag) */
+  tag?: string;
+  /** When this agent was created */
+  createdAt: string;
+  /** Periodic wakeup schedule */
+  schedule?: ScheduleConfig;
 }
 //#endregion
-//#region src/agent/skills/import-spec.d.ts
-type GitProvider = "github" | "gitlab" | "gitee";
-interface ImportSpec {
-  provider: GitProvider;
-  owner: string;
-  repo: string;
-  ref: string;
-  skills: string[] | "all";
-  rawSpec: string;
+//#region src/agent/handle.d.ts
+interface WorkerHandle {
+  /** Send a message synchronously */
+  send(input: string, options?: SendOptions$1): Promise<AgentResponse>;
+  /** Send a message with streaming response */
+  sendStream(input: string, options?: SendOptions$1): AsyncGenerator<string, AgentResponse>;
+  /** Snapshot current conversation state (for persistence) */
+  getState(): SessionState;
 }
 /**
- * Parse import spec: [provider:]owner/repo[@ref]:{skill1,skill2,...}
+ * LocalWorker — In-process execution via AgentWorker.
  *
- * Examples:
- *   vercel-labs/agent-skills:react-best-practices
- *   vercel-labs/agent-skills:{react,web}
- *   vercel-labs/agent-skills@v1.0.0:react
- *   github:vercel-labs/agent-skills@main:react
- *   vercel-labs/agent-skills  (imports all)
- */
-declare function parseImportSpec(spec: string): ImportSpec;
-/**
- * Build Git URL from import spec
- */
-declare function buildGitUrl(spec: ImportSpec): string;
-/**
- * Get display name for import spec
- */
-declare function getSpecDisplayName(spec: ImportSpec): string;
+ * Wraps an AgentWorker instance. State lives in the AgentWorker's memory.
+ * This is the default for single-machine deployments.
+ */
+declare class LocalWorker implements WorkerHandle {
+  private engine;
+  constructor(config: AgentConfig, restore?: SessionState);
+  send(input: string, options?: SendOptions$1): Promise<AgentResponse>;
+  sendStream(input: string, options?: SendOptions$1): AsyncGenerator<string, AgentResponse>;
+  getState(): SessionState;
+}
 //#endregion
-export { type AgentMessage, type AgentResponse, AgentWorker, type AgentWorkerConfig, type ApprovalCheck, type Backend, type BackendConfig, type BackendOptions, type BackendResponse, type BackendType, type BashToolkit, type BashToolsOptions, ClaudeCodeBackend, type ClaudeCodeOptions, CodexBackend, type CodexOptions, type CreateBashToolOptions, CursorBackend, type CursorOptions, FEEDBACK_PROMPT, FRONTIER_MODELS, type FeedbackEntry, type FeedbackToolOptions, type FeedbackToolResult, type GitProvider, type ImportSpec, type ImportedSkill, type MessageStatus, MockAIBackend, type PendingApproval, SUPPORTED_PROVIDERS, SdkBackend, type SdkBackendOptions, type SendOptions, type SessionConfig, type SessionState, SkillImporter, type SkillMetadata, SkillsProvider, type StepInfo, type SupportedProvider, type TokenUsage, type ToolCall, type ToolInfo, type Transcript, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };
+export { type AgentConfig, AgentHandle, type AgentHandleState, AgentRegistry, AgentWorker, type AgentWorkerConfig, type CreateSkillToolOptions, DEFAULT_PORT, DaemonEventLog, type DaemonInfo, type DaemonState, LocalWorker, MemoryStateStore, type SendOptions, SkillImporter, type SkillToolkit, type StateStore, type StepInfo, type WorkerHandle, type WorkflowHandle, createSkillTool, isDaemonRunning, readDaemonInfo, removeDaemonInfo, startDaemon, writeDaemonInfo };