@gencode/agents 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -1,42 +1,1605 @@
+import { S as AgentsConfig, _ as saveAgentsConfig, a as listAgents, b as AgentConfig, c as normalizeAgentId, d as resolveAgentDir, f as resolveAgentIdByBinding, g as resolveModelString, h as resolveModelFallbacks, i as getAgentConfig, l as removeAgent, m as resolveDefaultAgentId, n as addBinding, o as listBindings, p as resolveAgentsConfigPath, s as loadAgentsConfig, t as addAgent, u as removeBindings, v as updateAgentIdentity, x as AgentModelConfig, y as AgentBinding } from "./index-BdfpRxFA.js";
+import { AssistantMessage, Message } from "@mariozechner/pi-ai";
+import { AgentTool } from "@mariozechner/pi-agent-core";
+import { AgentProgressEvent, AgentProgressEvent as AgentProgressEvent$1, CallbackEventPayload, CallbackEventPayload as CallbackEventPayload$1, Channel, Channel as Channel$1, RunResultPayload, RunResultPayload as RunResultPayload$1 } from "@gencode/shared";
+
+//#region src/loop-detection/tool-loop-detection.d.ts
+type ToolLoopDetectionConfig = {
+  enabled?: boolean;
+  historySize?: number;
+  warningThreshold?: number;
+  criticalThreshold?: number;
+  globalCircuitBreakerThreshold?: number;
+  detectors?: {
+    genericRepeat?: boolean;
+    knownPollNoProgress?: boolean;
+    pingPong?: boolean;
+  };
+};
+//#endregion
+//#region src/plugins/types.d.ts
+type PluginDiagnostic = {
+  level: "warn" | "error";
+  message: string;
+  pluginId?: string;
+  source?: string;
+};
+type PluginOrigin = "bundled" | "global" | "workspace" | "config";
+type PluginKind = "memory";
+type PluginConfigUiHint = {
+  label?: string;
+  help?: string;
+  tags?: string[];
+  advanced?: boolean;
+  sensitive?: boolean;
+  placeholder?: string;
+};
+type PluginManifest = {
+  id: string;
+  configSchema: Record<string, unknown>;
+  kind?: PluginKind;
+  skills?: string[];
+  name?: string;
+  description?: string;
+  version?: string;
+  uiHints?: Record<string, PluginConfigUiHint>;
+};
+type PluginManifestLoadResult = {
+  ok: true;
+  manifest: PluginManifest;
+  manifestPath: string;
+} | {
+  ok: false;
+  error: string;
+  manifestPath: string;
+};
+type PluginCandidate = {
+  idHint: string;
+  source: string;
+  rootDir: string;
+  origin: PluginOrigin;
+  workspaceDir?: string;
+  packageName?: string;
+  packageVersion?: string;
+  packageDescription?: string;
+  packageDir?: string;
+  packageManifest?: AIMaxPackageManifest;
+};
+type AIMaxPackageManifest = {
+  extensions?: string[];
+};
+type PluginDiscoveryResult = {
+  candidates: PluginCandidate[];
+  diagnostics: PluginDiagnostic[];
+};
+//#endregion
+//#region src/plugins/manifest-registry.d.ts
+type PluginManifestRecord = {
+  id: string;
+  rootDir: string;
+  source: string;
+  origin: PluginCandidate["origin"];
+  manifestPath: string;
+  manifest: PluginManifest;
+};
+type PluginManifestRegistry = {
+  manifests: Map<string, PluginManifestRecord>;
+  diagnostics: PluginDiagnostic[];
+};
+declare function loadPluginManifestRegistry(candidates: PluginCandidate[]): PluginManifestRegistry;
+//#endregion
+//#region src/plugins/config-state.d.ts
+type PluginEntryConfig = {
+  enabled?: boolean;
+  config?: Record<string, unknown>;
+};
+type PluginsConfig = {
+  enabled?: boolean;
+  allow?: string[];
+  deny?: string[];
+  llmAllowlist?: string[];
+  load?: {
+    paths?: string[];
+  };
+  entries?: Record<string, PluginEntryConfig>;
+  slots?: Partial<Record<PluginKind, string>>;
+};
+type NormalizedPluginsConfig = {
+  enabled: boolean;
+  allow: string[];
+  deny: string[];
+  loadPaths: string[];
+  entries: Record<string, PluginEntryConfig>;
+  slots: Partial<Record<PluginKind, string>>;
+};
+type PluginsConfigValidationResult = {
+  ok: boolean;
+  diagnostics: PluginDiagnostic[];
+};
+declare function normalizePluginsConfig(input?: PluginsConfig): NormalizedPluginsConfig;
+declare function validatePluginsConfig(params: {
+  config: NormalizedPluginsConfig;
+  registry: PluginManifestRegistry;
+}): PluginsConfigValidationResult;
+//#endregion
+//#region src/types.d.ts
+/** Context injected when this run is itself a subagent */
+type SubagentContext = {
+  /** Nesting depth of this run (root = 0, first child = 1, …) */depth: number; /** Session ID of the parent that spawned this subagent */
+  parentSessionId: string;
+};
+type AgentRunParamsBase = {
+  /** User data directory path (e.g. /data/user1) */dataDir: string; /** Session ID to resume; if omitted, a new session is created */
+  sessionId?: string; /** Message ID for correlating events */
+  messageId?: string; /** Channel type for this session */
+  channel: Channel$1; /** LLM provider configuration */
+  llm: {
+    /** vLLM/OpenAI-compatible API base URL */baseUrl: string;
+    apiKey: string;
+    model: string; /** Context window size; defaults to 200000 */
+    contextWindow?: number;
+  }; /** In-process progress callback */
+  onProgress?: (event: AgentProgressEvent$1) => Promise<void>; /** Execution timeout in milliseconds; defaults to 600000 (10 min) */
+  timeoutMs?: number; /** Present when this run is itself a subagent; controls depth limits */
+  subagentContext?: SubagentContext; /** AbortSignal to cancel this run from outside (used by parent kill) */
+  abortSignal?: AbortSignal; /** Tool-loop detection guardrails (disabled by default) */
+  loopDetection?: ToolLoopDetectionConfig; /** Plugin system options (optional) */
+  plugins?: {
+    /** Plugin config structure (allow/deny/entries/slots/load.paths) */config?: PluginsConfig; /** Data dir used to resolve .aimax extensions */
+    dataDir?: string; /** Workspace dir exposed to plugin runtime/hooks */
+    workspaceDir?: string; /** Bundled plugins directory (disabled unless explicitly enabled) */
+    bundledDir?: string; /** Optional ownership uid override for security checks */
+    ownershipUid?: number | null; /** Optional tool allowlist for plugin tools */
+    toolAllowlist?: string[]; /** Optional allowlist for plugin LLM access (plugin id or tool name) */
+    llmAllowlist?: string[];
+  }; /** Memory system options (optional) */
+  memory?: {
+    /** Explicit memory provider id (overrides plugins.slots.memory) */providerId?: string; /** Explicit plugin id for memory provider (used when providerId not set) */
+    pluginId?: string; /** Whether memory replies should include source path/line hints */
+    citationsMode?: "off" | "on";
+  }; /** Messaging prompt controls */
+  messaging?: {
+    enabled?: boolean; /** Human-readable configured channel list */
+    channels?: string[];
+  }; /** Documentation context for prompt guidance */
+  docs?: {
+    localPath?: string;
+    webUrl?: string;
+    sourceUrl?: string;
+  };
+  /**
+   * Maximum number of recent user turns to include in context.
+   * Older turns are dropped before the history is sent to the LLM.
+   * 0 or undefined means no limit.
+   */
+  historyLimit?: number;
+};
+/** Parameters for running an agent session */
+type AgentRunParams = AgentRunParamsBase & ({
+  /** The user message to process */message: string; /** Structured messages to process for file-based runs */
+  messages?: never;
+} | {
+  /** Structured messages to process for file-based runs */messages: Message[]; /** The user message to process */
+  message?: never;
+});
+/** Final result returned after agent execution completes */
+type AgentRunResult = RunResultPayload$1 & {
+  sessionId: string;
+};
+/** HTTP callback body formats */
+type CallbackPayload = CallbackEventPayload$1;
+/** A user message turn */
+type UserEntry = {
+  role: "user";
+  content: string;
+  timestamp: string;
+};
+/** An assistant message turn; may include tool calls when the LLM used tools */
+type AssistantEntry = {
+  role: "assistant"; /** Text response from the assistant (may be empty when the turn is tool-only) */
+  content: string; /** Tool calls issued by the assistant during this turn */
+  toolCalls?: Array<{
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+  }>;
+  timestamp: string;
+};
+/** The result returned by a single tool execution */
+type ToolResultEntry = {
+  role: "tool_result"; /** Matches AssistantEntry.toolCalls[].id */
+  toolCallId: string;
+  toolName: string; /** Text output of the tool */
+  content: string;
+  isError: boolean;
+  timestamp: string;
+};
 /**
- * @gencode/agents - Agent execution engine for AIMax CLI
+ * A compaction record written after LLM-based history summarisation.
+ * `content` holds the summary text so it is accessible via the common
+ * `.content` property without narrowing on `role`.
+ */
+type CompactionEntry = {
+  role: "compaction"; /** Summary of the dropped conversation history */
+  content: string;
+  keptCount: number;
+  droppedCount: number;
+  timestamp: string;
+};
+/** Union of all persisted transcript entry types */
+type TranscriptEntry = UserEntry | AssistantEntry | ToolResultEntry | CompactionEntry;
+//#endregion
+//#region src/subagent/types.d.ts
+/** Status of a spawned subagent run */
+type SubagentStatus = "running" | "done" | "error" | "killed";
+/** Record tracking a single subagent run */
+type SubagentRunRecord = {
+  runId: string;
+  childSessionId: string;
+  parentSessionId: string;
+  task: string;
+  label?: string; /** Nesting depth: parent is depth N, child is N+1 */
+  depth: number;
+  status: SubagentStatus;
+  result?: string;
+  error?: string;
+  startedAt: number;
+  endedAt?: number; /** Used to cancel the subagent run */
+  abortController: AbortController;
+};
+//#endregion
+//#region src/subagent/registry.d.ts
+declare const MAX_SUBAGENT_DEPTH = 3;
+declare const MAX_CHILDREN_PER_SESSION = 5;
+/**
+ * In-memory registry for subagent runs scoped to a single parent runAgent call.
+ * Child spawns create their own SubagentRegistry instances for their children.
+ */
+declare class SubagentRegistry {
+  private readonly entries;
+  /** RunIds that have already been returned by consumeCompleted */
+  private readonly announced;
+  register(record: SubagentRunRecord, promise: Promise<void>): void;
+  complete(runId: string, result: string): void;
+  fail(runId: string, error: string): void;
+  /** Aborts and marks a specific run as killed. Returns false if not found or already ended. */
+  kill(runId: string): boolean;
+  /** Aborts all running subagents for the given parent session. Returns count killed. */
+  killAll(parentSessionId: string): number;
+  /** Lists all runs registered for the given parent session. */
+  list(parentSessionId: string): SubagentRunRecord[];
+  /** Returns true if any subagents for this session are still running. */
+  hasPending(parentSessionId: string): boolean;
+  /** Count of currently running children for a session. */
+  countActive(parentSessionId: string): number;
+  /**
+   * Waits until all currently-running subagents for the given session settle.
+   * Returns immediately if nothing is pending.
+   */
+  waitForAll(parentSessionId: string): Promise<void>;
+  /**
+   * Returns all finished runs that have not yet been returned by this method,
+   * and marks them as announced so they are not returned again.
+   */
+  consumeCompleted(parentSessionId: string): SubagentRunRecord[];
+  /** Returns true if there are completed runs not yet returned by consumeCompleted. */
+  hasUnannounced(parentSessionId: string): boolean;
+  /**
+   * Returns true if the announce loop should run another iteration:
+   * either subagents are still running, or completed runs await announcement.
+   */
+  needsAnnounce(parentSessionId: string): boolean;
+  /** Checks whether a new child can be spawned given depth and active-children limits. */
+  checkSpawnAllowed(parentSessionId: string, depth: number): {
+    allowed: true;
+  } | {
+    allowed: false;
+    reason: string;
+  };
+  /** Returns the current status snapshot for a single run, or null if not found. */
+  getStatus(runId: string): SubagentStatus | null;
+}
+//#endregion
+//#region src/runner/title.d.ts
+/** Generates a session title by truncating the first user message */
+declare function generateSessionTitle(message: string, maxLength?: number): string;
+//#endregion
+//#region src/runner/runner.d.ts
+/**
+ * Runs an agent session end-to-end.
+ * Supports multi-agent: subagents spawned via sessions_spawn are automatically
+ * awaited and their results announced back to the parent agent.
+ *
+ * @param params - Run parameters.
+ * @param _registryForTesting - Internal: inject a pre-populated registry for unit tests.
+ */
+declare function runAgent(params: AgentRunParams, _registryForTesting?: SubagentRegistry): Promise<AgentRunResult>;
+//#endregion
+//#region src/memory/config.d.ts
+type MemorySearchConfig = {
+  chunkTokens: number;
+  chunkOverlap: number;
+  maxResults: number;
+  minScore: number;
+  embedding: {
+    providerId?: string;
+  };
+  experimental: {
+    sessionMemory: boolean;
+  };
+  sources: Array<"memory" | "sessions">;
+  store: {
+    vector: {
+      enabled: boolean;
+      extensionPath?: string;
+    };
+  };
+  hybrid: {
+    enabled: boolean;
+    vectorWeight: number;
+    textWeight: number;
+    candidateMultiplier: number;
+    mmr: {
+      enabled: boolean;
+      lambda: number;
+    };
+    temporalDecay: {
+      enabled: boolean;
+      halfLifeDays: number;
+    };
+  };
+  cache: {
+    enabled: boolean;
+    maxEntries?: number;
+  };
+  sync: {
+    onSessionStart: boolean;
+    onSearch: boolean;
+    watch: boolean;
+    watchDebounceMs: number;
+    sessions: {
+      deltaBytes: number;
+      deltaMessages: number;
+    };
+  };
+  citations: "off" | "auto" | "on";
+};
+//#endregion
+//#region src/memory/manager.d.ts
+type MemorySearchResult$1 = {
+  path: string;
+  startLine: number;
+  endLine: number;
+  score: number;
+  snippet: string;
+  source: "memory" | "sessions";
+  citation?: string;
+};
+type MemoryProviderStatus = {
+  backend: "builtin";
+  provider: string;
+  model?: string;
+  files?: number;
+  chunks?: number;
+  dirty?: boolean;
+  workspaceDir?: string;
+  dbPath?: string;
+  sources?: Array<"memory" | "sessions">;
+  sourceCounts?: Array<{
+    source: "memory" | "sessions";
+    files: number;
+    chunks: number;
+  }>;
+  cache?: {
+    enabled: boolean;
+    entries?: number;
+    maxEntries?: number;
+  };
+  fts?: {
+    enabled: boolean;
+    available: boolean;
+    error?: string;
+  };
+  vector?: {
+    enabled: boolean;
+    available?: boolean;
+    extensionPath?: string;
+    loadError?: string;
+    dims?: number;
+  };
+  custom?: Record<string, unknown>;
+};
+declare class MemoryIndexManager {
+  private readonly dataDir;
+  private readonly memoryRoot;
+  private readonly storePath;
+  private readonly config;
+  private provider;
+  private providerKey;
+  private embeddingProviderId?;
+  private db;
+  private dirty;
+  private ftsAvailable;
+  private ftsError?;
+  private vector;
+  private vectorReady;
+  private watchers;
+  private watchTimer;
+  private sessionWatchTimer;
+  private sessionsDirty;
+  private sessionsDirtyFiles;
+  private sessionPendingFiles;
+  private sessionDeltas;
+  static get(dataDir: string, config?: Partial<MemorySearchConfig>): MemoryIndexManager;
+  private constructor();
+  private applyConfig;
+  warmSession(): void;
+  noteSessionUpdate(sessionFile: string): void;
+  status(): MemoryProviderStatus;
+  probeEmbeddingAvailability(): Promise<{
+    ok: boolean;
+    error?: string;
+  }>;
+  probeVectorAvailability(): Promise<boolean>;
+  search(query: string): Promise<MemorySearchResult$1[]>;
+  readFile(params: {
+    relPath: string;
+    from?: number;
+    lines?: number;
+  }): Promise<{
+    text: string;
+    path: string;
+  }>;
+  replaceFile(params: {
+    relPath: string;
+    content: string;
+  }): Promise<void>;
+  deleteFile(relPath: string): Promise<void>;
+  appendToMemory(content: string): Promise<void>;
+  private openDatabase;
+  private ensureSchema;
+  private ensureVectorReady;
+  private loadVectorExtension;
+  private ensureVectorTable;
+  private dropVectorTable;
+  private withTimeout;
+  private ensureWatcher;
+  private scheduleWatchSync;
+  private ensureSessionListener;
+  private scheduleSessionDirty;
+  private processSessionDeltaBatch;
+  private updateSessionDelta;
+  private countNewlines;
+  private computeProviderKey;
+  private resolveMemoryFilePath;
+  private applyEmbeddingProvider;
+  private readMeta;
+  private writeMeta;
+  private loadEmbeddingCache;
+  private upsertEmbeddingCache;
+  private embedChunks;
+  private indexFile;
+  private buildSourceFilter;
+  private searchVector;
+  private searchKeyword;
+  private resetIndex;
+  sync(params?: {
+    reason?: string;
+  }): Promise<void>;
+  private syncSessionFiles;
+  private resetSessionDelta;
+  private decorateCitations;
+}
+//#endregion
+//#region src/memory/provider.d.ts
+type MemoryProviderContext = {
+  dataDir: string;
+  memoryDir: string;
+  sessionId?: string;
+  pluginId?: string;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+};
+type MemorySearchOptions = {
+  limit?: number;
+  sources?: Array<"memory" | "sessions">;
+};
+type MemoryChangeSource = "memory" | "sessions";
+type MemoryChangedEvent = {
+  reason: string;
+  files: string[];
+  source: MemoryChangeSource;
+  sessionId?: string;
+  providerId?: string;
+  timestamp: string;
+};
+type MemoryChangedHandler = (event: MemoryChangedEvent) => void | Promise<void>;
+type MemoryProvider = {
+  id: string;
+  name?: string;
+  status: () => MemoryProviderStatus;
+  search: (query: string, options?: MemorySearchOptions) => Promise<MemorySearchResult$1[]>;
+  getLines: (file: string, startLine: number, endLine: number) => Promise<string[] | null>;
+  listFiles: () => Promise<string[]>;
+  append: (content: string) => Promise<void>;
+  updateFile: (file: string, content: string) => Promise<void>;
+  deleteFile: (file: string) => Promise<void>;
+  sync?: (reason?: string) => Promise<void>;
+  noteSessionUpdate?: (sessionFile: string) => void;
+  onMemoryChanged?: MemoryChangedHandler;
+};
+type MemoryProviderFactory = (ctx: MemoryProviderContext) => MemoryProvider;
+//#endregion
+//#region src/session/session.d.ts
+type SessionMetadata = {
+  id: string;
+  title: string;
+  channel: Channel;
+  createdAt: string;
+  updatedAt: string;
+};
+type SessionSummary = {
+  id: string;
+  title: string;
+  channel: Channel;
+  createdAt: string;
+  updatedAt: string;
+};
+/** Resolves the sessions directory path within a data directory */
+declare function sessionsDir(dataDir: string): string;
+/** Resolves the directory for a specific session */
+declare function sessionDir(dataDir: string, sessionId: string): string;
+/** Resolves the transcript file path for a session */
+declare function transcriptPath(dataDir: string, sessionId: string): string;
+/** Resolves the metadata file path for a session */
+declare function metadataPath(dataDir: string, sessionId: string): string;
+/** Creates a new session with a generated ID */
+declare function createSession(dataDir: string, channel: Channel): Promise<string>;
+/** Ensures a session directory exists (for resuming an existing session) */
+declare function ensureSession(dataDir: string, sessionId: string): Promise<void>;
+/** Loads all transcript entries from a session */
+declare function loadTranscript(dataDir: string, sessionId: string): Promise<TranscriptEntry[]>;
+/** Appends a single entry to the transcript file */
+declare function appendTranscriptEntry(dataDir: string, sessionId: string, entry: TranscriptEntry, options?: {
+  providerId?: string;
+  pluginId?: string;
+  onMemoryChanged?: MemoryChangedHandler;
+}): Promise<void>;
+/** Lists all session IDs within a data directory */
+declare function listSessions(dataDir: string): Promise<string[]>;
+/** Saves session metadata to disk */
+declare function saveSessionMetadata(dataDir: string, metadata: SessionMetadata): Promise<void>;
+/** Loads session metadata from disk; returns null if not found */
+declare function loadSessionMetadata(dataDir: string, sessionId: string): Promise<SessionMetadata | null>;
+/** Lists all sessions with their metadata summaries, optionally filtered by channel */
+declare function listSessionSummaries(dataDir: string, channel?: Channel): Promise<SessionSummary[]>;
+//#endregion
+//#region src/bootstrap/bootstrap.d.ts
+/** Maximum characters per bootstrap file before truncation */
+declare const BOOTSTRAP_MAX_CHARS = 20000;
+/** Maximum total characters across all bootstrap files */
+declare const BOOTSTRAP_TOTAL_MAX_CHARS = 150000;
+/** Names of bootstrap identity files, in injection order */
+declare const BOOTSTRAP_FILE_NAMES: readonly ["AGENTS.md", "SOUL.md", "TOOLS.md", "IDENTITY.md", "USER.md", "HEARTBEAT.md", "MEMORY.md", "BOOTSTRAP.md"];
+/** A loaded (or missing) bootstrap file */
+type BootstrapFile = {
+  name: string;
+  path: string;
+  content: string | null;
+  missing: boolean;
+};
+/** A bootstrap file ready for system prompt injection */
+type BootstrapContextFile = {
+  path: string;
+  content: string;
+};
+/** Resolves the base .aimax directory within a data directory */
+declare function aimaxDir(dataDir: string): string;
+/**
+ * Loads all standard bootstrap identity files from the .aimax directory.
+ * Missing files are included as `missing: true` entries.
+ * BOOTSTRAP.md is deleted after loading (one-time use).
+ */
+declare function loadBootstrapFiles(dataDir: string): Promise<BootstrapFile[]>;
+/**
+ * Converts loaded bootstrap files into context file entries for system prompt injection.
+ * Applies per-file and total character budget limits.
+ */
+declare function buildBootstrapContextFiles(files: BootstrapFile[], opts?: {
+  maxChars?: number;
+  totalMaxChars?: number;
+  warn?: (message: string) => void;
+}): BootstrapContextFile[];
+//#endregion
+//#region src/bootstrap/bootstrap-layout.d.ts
+type BootstrapMountResult = {
+  dataDir: string;
+  createdDirs: string[];
+  skippedDirs: string[];
+  createdFiles: string[];
+  skippedFiles: string[];
+};
+type BootstrapMountStatus = {
+  dataDir: string;
+  ready: boolean;
+  missingDirs: string[];
+  missingFiles: string[];
+};
+type BootstrapEnsureResult = {
+  ready: boolean;
+  performedBootstrap: boolean;
+  result?: BootstrapMountResult;
+};
+declare function inspectBootstrapMountLayout(dataDir: string): Promise<BootstrapMountStatus>;
+declare function isBootstrapMountLayoutReady(dataDir: string): Promise<boolean>;
+declare function ensureBootstrapMountLayout(dataDir: string): Promise<BootstrapEnsureResult>;
+declare function bootstrapMountLayout(dataDir: string): Promise<BootstrapMountResult>;
+//#endregion
+//#region src/memory/memory.d.ts
+/** Resolves the memory root path within a data directory */
+declare function memoryDir(dataDir: string): string;
+/** Resolves the primary MEMORY.md path */
+declare function primaryMemoryPath(dataDir: string): string;
+/** A single search result from memory */
+type MemorySearchResult = MemorySearchResult$1;
+type MemoryCallOptions = {
+  providerId?: string;
+  pluginId?: string;
+  sessionId?: string;
+  onMemoryChanged?: MemoryChangedHandler;
+};
+/**
+ * Lists all memory file paths within the memory directory.
+ * Returns MEMORY.md first, then daily files (YYYY-MM-DD.md) sorted by date descending.
+ */
+declare function listMemoryFiles(dataDir: string): Promise<string[]>;
+/**
+ * Reads a memory file and returns its content.
+ * Returns null if the file does not exist.
+ */
+declare function readMemoryFile(filePath: string): Promise<string | null>;
+/**
+ * Reads the primary MEMORY.md file.
+ * Returns null if it does not exist.
+ */
+declare function readPrimaryMemory(dataDir: string): Promise<string | null>;
+/**
+ * Searches memory files for lines matching a query string (case-insensitive substring match).
+ * Returns matching lines with their file path and line number.
+ */
+declare function searchMemory(dataDir: string, query: string, options?: MemoryCallOptions): Promise<MemorySearchResult[]>;
+/**
+ * Reads specific line ranges from a memory file.
+ * Returns the requested lines (1-based line numbers), or null if file not found.
+ */
+declare function getMemoryLines(dataDir: string, filePath: string, startLine: number, endLine: number, options?: MemoryCallOptions): Promise<string[] | null>;
+/**
+ * Appends content to the primary MEMORY.md file, creating it if necessary.
+ */
+declare function appendToMemory(dataDir: string, content: string, options?: MemoryCallOptions): Promise<void>;
+declare function replaceMemoryFile(dataDir: string, filePath: string, content: string, options?: MemoryCallOptions): Promise<void>;
+declare function deleteMemoryFile(dataDir: string, filePath: string, options?: MemoryCallOptions): Promise<void>;
+//#endregion
+//#region src/memory/embeddings.d.ts
+type EmbeddingProvider = {
+  id: string;
+  model: string;
+  embedQuery: (text: string) => Promise<number[]>;
+  embedBatch: (texts: string[]) => Promise<number[][]>;
+};
+//#endregion
+//#region src/memory/embedding-registry.d.ts
+type EmbeddingProviderContext = {
+  dataDir: string;
+  memoryDir: string;
+  pluginId?: string;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+};
+type EmbeddingProviderFactory = (ctx: EmbeddingProviderContext) => EmbeddingProvider;
+type EmbeddingProviderRegistration = {
+  id: string;
+  pluginId?: string;
+  create: EmbeddingProviderFactory;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+};
+declare function registerEmbeddingProvider(params: {
+  pluginId: string;
+  create: EmbeddingProviderFactory;
+  id?: string;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+}): string;
+declare function resolveEmbeddingProvider(params: {
+  providerId?: string;
+  pluginId?: string;
+  dataDir: string;
+  memoryDir: string;
+}): {
+  provider: EmbeddingProvider;
+  registration: EmbeddingProviderRegistration;
+} | null;
+declare function resetEmbeddingProviderRegistryForTests(): void;
+//#endregion
+//#region src/memory/builtin-provider.d.ts
+declare function createBuiltinMemoryProvider(ctx: MemoryProviderContext, options?: {
+  includeSessions?: boolean;
+}): MemoryProvider;
+//#endregion
+//#region src/memory/provider-registry.d.ts
+type MemoryProviderRegistration = {
+  id: string;
+  pluginId?: string;
+  create: MemoryProviderFactory;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+};
+declare function registerMemoryProvider(params: {
+  pluginId: string;
+  create: MemoryProviderFactory;
+  id?: string;
+  config?: Record<string, unknown>;
+  rootDir?: string;
+  source?: string;
+}): string;
+declare function resolveMemoryProvider(params: {
+  providerId?: string;
+  pluginId?: string;
+  dataDir: string;
+  memoryDir: string;
+  sessionId?: string;
+}): {
+  provider: MemoryProvider;
+  registration: MemoryProviderRegistration;
+} | null;
+declare function resetMemoryProviderRegistryForTests(): void;
+//#endregion
+//#region src/skills/skills.d.ts
+/** Resolves the skills directory path within a data directory */
+declare function skillsDir(dataDir: string): string;
+/** Represents a loaded skill */
+type Skill = {
+  name: string;
+  description: string;
+  location: string;
+};
+/**
+ * Loads all installed skills from the skills directory.
+ * Each skill is a directory containing a SKILL.md file.
+ * Returns at most MAX_SKILLS_IN_PROMPT skills.
+ */
+declare function loadSkills(dataDir: string): Promise<Skill[]>;
+declare function loadSkillsWithPluginDirs(dataDir: string, pluginDirs: string[]): Promise<Skill[]>;
+declare function loadSkillsFromDirs(dirs: string[]): Promise<Skill[]>;
+/**
+ * Builds the skills section of the system prompt.
+ * Returns an empty string when no skills are available.
+ * Format matches openclaw's <available_skills> XML structure.
+ */
+declare function buildSkillsPrompt(skills: Skill[]): string;
+//#endregion
+//#region src/commands/types.d.ts
+type SlashCommandSpec = {
+  name: string;
+  description: string;
+};
+type SlashCommandList = {
+  builtin: SlashCommandSpec[];
+  skillCommands: SlashCommandSpec[];
+  all: SlashCommandSpec[];
+};
+//#endregion
+//#region src/commands/registry.d.ts
+declare function listAvailableSlashCommands(skills: Skill[]): SlashCommandList;
+//#endregion
+//#region src/system-prompt/builder.d.ts
+type PromptMode = "full" | "minimal" | "none";
+type MemoryCitationsMode = "off" | "on";
+/** Parameters for building the agent system prompt */
+type SystemPromptParams = {
+  dataDir: string;
+  skills?: Skill[];
+  contextFiles?: BootstrapContextFile[];
+  runtimeInfo?: {
+    os?: string;
+    node?: string;
+    model?: string;
+    hostname?: string;
+  };
+  toolNames?: string[];
+  toolSummaries?: Record<string, string>;
+  promptMode?: PromptMode;
+  heartbeatPrompt?: string;
+  bootstrapWarnings?: string[];
+  memoryCitationsMode?: MemoryCitationsMode;
+  sandboxInfo?: {
+    enabled?: boolean;
+    hostWorkspaceDir?: string;
+    containerWorkspaceDir?: string;
+  };
+  messaging?: {
+    enabled?: boolean;
+    channels?: string[];
+  };
+  docs?: {
+    localPath?: string;
+    webUrl?: string;
+    sourceUrl?: string;
+  };
+  currentDate?: string;
+  timezone?: string;
+  /**
+   * Summary of prior conversation history produced by compaction.
+   * When provided, it is appended to the system prompt so the agent
+   * understands what happened before the retained message window.
+   */
+  priorConversationSummary?: string;
+};
+/**
+ * Builds the complete system prompt for the agent.
+ * Assembles all sections in the correct order.
+ */
+declare function buildSystemPrompt(params: SystemPromptParams): string;
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/symbols/symbols.d.ts
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/readonly/readonly.d.ts
+type TReadonly<T extends TSchema> = T & {
+  [ReadonlyKind]: 'Readonly';
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/literal/literal.d.ts
+type TLiteralValue = boolean | number | string;
+interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
+  [Kind]: 'Literal';
+  static: T;
+  const: T;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/union/union-type.d.ts
+type UnionStatic<T extends TSchema[], P extends unknown[]> = { [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never }[number];
+interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+  [Kind]: 'Union';
+  static: UnionStatic<T, this['params']>;
+  anyOf: T;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/string/string.d.ts
+type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+interface StringOptions extends SchemaOptions {
+  /** The maximum string length */
+  maxLength?: number;
+  /** The minimum string length */
+  minLength?: number;
+  /** A regular expression pattern this string should match */
+  pattern?: string;
+  /** A format this string should match */
+  format?: StringFormatOption;
+  /** The content encoding for this string */
+  contentEncoding?: StringContentEncodingOption;
+  /** The content media type for this string */
+  contentMediaType?: string;
+}
+interface TString extends TSchema, StringOptions {
+  [Kind]: 'String';
+  static: string;
+  type: 'string';
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/boolean/boolean.d.ts
+interface TBoolean extends TSchema {
+  [Kind]: 'Boolean';
+  static: boolean;
+  type: 'boolean';
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/number/number.d.ts
+interface NumberOptions extends SchemaOptions {
+  exclusiveMaximum?: number;
+  exclusiveMinimum?: number;
+  maximum?: number;
+  minimum?: number;
+  multipleOf?: number;
+}
+interface TNumber extends TSchema, NumberOptions {
+  [Kind]: 'Number';
+  static: number;
+  type: 'number';
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/optional/optional.d.ts
+type TOptional<T extends TSchema> = T & {
+  [OptionalKind]: 'Optional';
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/record/record.d.ts
+type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{ [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P> }>);
+interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
+  [Kind]: 'Record';
+  static: RecordStatic<Key, Type, this['params']>;
+  type: 'object';
+  patternProperties: {
+    [pattern: string]: Type;
+  };
+  additionalProperties: TAdditionalProperties;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/static/static.d.ts
+/** Creates a static type from a TypeBox type */
+type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+  params: Params;
+})['static']> = Result;
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/object/object.d.ts
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never }[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never }[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = { [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never }[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, { [K in keyof T]: Static<T[K], P> }>;
+type TPropertyKey = string | number;
+type TProperties = Record<TPropertyKey, TSchema>;
+type TIsLiteralString<Type extends string> = ([Type] extends [string] ? [string] extends [Type] ? false : true : false);
+type IsRequiredArrayLiteralConstant<RequiredTuple extends string[]> = (RequiredTuple extends [infer Left extends string, ...infer _ extends string[]] ? TIsLiteralString<Left> : false);
+type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = { [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key] }, RequiredUnion extends string = Extract<keyof RequiredProperties, string>, RequiredTuple extends string[] = UnionToTuple<RequiredUnion>, Result extends string[] | undefined = (IsRequiredArrayLiteralConstant<RequiredTuple> extends true ? RequiredTuple : string[] | undefined)> = Result;
+type TAdditionalProperties = undefined | TSchema | boolean;
+interface ObjectOptions extends SchemaOptions {
+  /** Additional property constraints for this object */
+  additionalProperties?: TAdditionalProperties;
+  /** The minimum number of properties allowed on this object */
+  minProperties?: number;
+  /** The maximum number of properties allowed on this object */
+  maxProperties?: number;
+}
+interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+  [Kind]: 'Object';
+  static: ObjectStatic<T, this['params']>;
+  additionalProperties?: TAdditionalProperties;
+  type: 'object';
+  properties: T;
+  required: TRequiredArray<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/helpers/helpers.d.ts
+type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends ((arg: infer I) => 0) ? I : never;
+type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends ((x: infer L) => 0) ? L : never;
+type UnionToTuple<U, Acc extends unknown[] = [], R = UnionLast<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Acc]>;
+type Assert<T, E> = T extends E ? T : never;
+type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/cjs/type/schema/schema.d.ts
+interface SchemaOptions {
+  $schema?: string;
+  /** Id for this schema */
+  $id?: string;
+  /** Title of this schema */
+  title?: string;
+  /** Description of this schema */
+  description?: string;
+  /** Default value for this schema */
+  default?: any;
+  /** Example values matching this schema */
+  examples?: any;
+  /** Optional annotation for readOnly */
+  readOnly?: boolean;
+  /** Optional annotation for writeOnly */
+  writeOnly?: boolean;
+  [prop: string]: any;
+}
+interface TKind {
+  [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+  [ReadonlyKind]?: string;
+  [OptionalKind]?: string;
+  [Hint]?: string;
+  params: unknown[];
+  static: unknown;
+}
+//#endregion
+//#region src/tools/memory.d.ts
+type MemoryToolOptions = {
+  providerId?: string;
+  pluginId?: string;
+  sessionId?: string;
+  onMemoryChanged?: MemoryChangedHandler;
+};
+declare const memorySearchSchema: TObject<{
+  query: TString;
+}>;
+type SearchResult = {
+  matches: Array<{
+    file: string;
+    start_line: number;
+    end_line: number;
+    score: number;
+    text: string;
+    source: string;
+    citation?: string;
+  }>;
+};
+declare function createMemorySearchTool(dataDir: string, options?: MemoryToolOptions): AgentTool<typeof memorySearchSchema, SearchResult>;
+declare const memoryGetSchema: TObject<{
+  file: TString;
+  start_line: TNumber;
+  end_line: TNumber;
+}>;
+type GetResult = {
+  lines: string[] | null;
+};
+declare function createMemoryGetTool(dataDir: string, options?: MemoryToolOptions): AgentTool<typeof memoryGetSchema, GetResult>;
+declare const memoryAppendSchema: TObject<{
+  content: TString;
+}>;
+declare function createMemoryAppendTool(dataDir: string, options?: MemoryToolOptions): AgentTool<typeof memoryAppendSchema, {
+  appended: boolean;
+}>;
+//#endregion
+//#region src/tools/process-registry.d.ts
+type ProcessStatus = "running" | "completed" | "failed" | "killed" | "timeout";
+type ProcessSessionSnapshot = {
+  sessionId: string;
+  scopeKey?: string;
+  command: string;
+  cwd: string;
+  pid?: number;
+  startedAt: number;
+  endedAt?: number;
+  status: ProcessStatus;
+  exitCode?: number | null;
+  exitSignal?: NodeJS.Signals | null;
+  outputTail: string;
+  outputTruncated: boolean;
+};
+type ProcessLogSlice = {
+  sessionId: string;
+  status: ProcessStatus;
+  text: string;
+  totalLines: number;
+  totalChars: number;
+  truncated: boolean;
+  exitCode?: number | null;
+  exitSignal?: NodeJS.Signals | null;
+};
+type ProcessStartParams = {
+  command: string;
+  cwd: string;
+  env?: Record<string, string>;
+  timeoutSec: number;
+  scopeKey?: string;
+};
+type ProcessRegistry = {
+  start(params: ProcessStartParams): ProcessSessionSnapshot;
+  get(sessionId: string, scopeKey?: string): ProcessSessionSnapshot | null;
+  list(scopeKey?: string): ProcessSessionSnapshot[];
+  wait(sessionId: string, scopeKey: string | undefined, timeoutMs?: number): Promise<ProcessSessionSnapshot | null>;
+  readLog(params: {
+    sessionId: string;
+    scopeKey?: string;
+    offset?: number;
+    limit?: number;
+  }): ProcessLogSlice | null;
+  terminate(sessionId: string, scopeKey?: string): Promise<ProcessSessionSnapshot | null>;
+};
+//#endregion
+//#region src/tools/exec.d.ts
+declare const execSchema: TObject<{
+  command: TString;
+  workdir: TOptional<TString>;
+  env: TOptional<TRecord<TString, TString>>;
+  timeout: TOptional<TNumber>;
+  yieldMs: TOptional<TNumber>;
+  background: TOptional<TBoolean>;
+}>;
+type ExecToolOptions = {
+  workspaceDir: string;
+  registry: ProcessRegistry;
+  scopeKey?: string;
+};
+declare function createExecTool(options: ExecToolOptions): AgentTool<typeof execSchema, Record<string, unknown>>;
+//#endregion
+//#region src/tools/process.d.ts
+declare const processSchema: TObject<{
+  action: TString;
+  sessionId: TOptional<TString>;
+  offset: TOptional<TNumber>;
+  limit: TOptional<TNumber>;
+  timeout: TOptional<TNumber>;
+}>;
+type ProcessToolOptions = {
+  registry: ProcessRegistry;
+  scopeKey?: string;
+};
+declare function createProcessTool(options: ProcessToolOptions): AgentTool<typeof processSchema, Record<string, unknown>>;
+//#endregion
+//#region src/tools/bash.d.ts
+/**
+ * Backward-compatible alias kept for existing imports.
+ * New code should use createExecTool + createProcessTool directly.
+ */
+declare function createBashTool(workspaceDir: string): AgentTool;
+//#endregion
+//#region src/tools/files.d.ts
+declare const readFileSchema: TObject<{
+  path: TString;
+  offset: TOptional<TNumber>;
+  limit: TOptional<TNumber>;
+}>;
+type ReadFileResult = {
+  content: string;
+  lines: number;
+  truncated: boolean;
+};
+declare function createReadFileTool(workspaceDir: string): AgentTool<typeof readFileSchema, ReadFileResult>;
+declare const writeFileSchema: TObject<{
+  path: TString;
+  content: TString;
+}>;
+declare function createWriteFileTool(workspaceDir: string): AgentTool<typeof writeFileSchema, {
+  path: string;
+}>;
+declare const editFileSchema: TObject<{
+  path: TString;
+  old_string: TString;
+  new_string: TString;
+}>;
+declare function createEditFileTool(workspaceDir: string): AgentTool<typeof editFileSchema, {
+  path: string;
+  occurrences: number;
+}>;
+declare const listDirSchema: TObject<{
+  path: TOptional<TString>;
+}>;
+declare function createListDirTool(workspaceDir: string): AgentTool<typeof listDirSchema, {
+  entries: string[];
+}>;
+//#endregion
+//#region src/tools/apply-patch.d.ts
+type ApplyPatchSummary = {
+  added: string[];
+  modified: string[];
+  deleted: string[];
+};
+type ApplyPatchDetails = {
+  summary: ApplyPatchSummary;
+};
+declare const applyPatchSchema: TObject<{
+  input: TString;
+}>;
+declare function createApplyPatchTool(workspaceDir: string): AgentTool<typeof applyPatchSchema, ApplyPatchDetails>;
+//#endregion
+//#region src/tools/image.d.ts
+declare const imageSchema: TObject<{
+  image: TString;
+  prompt: TOptional<TString>;
+  model: TOptional<TString>;
+  maxBytesMb: TOptional<TNumber>;
+}>;
+type ImageResult = {
+  implemented: boolean;
+  error?: string;
+};
+declare function createImageTool(): AgentTool<typeof imageSchema, ImageResult>;
+//#endregion
+//#region src/tools/subagent-spawn.d.ts
+declare const spawnSchema: TObject<{
+  task: TString;
+  label: TOptional<TString>;
+}>;
+type SpawnResult = {
+  status: "accepted";
+  childSessionId: string;
+  runId: string;
+  note: string;
+} | {
+  status: "forbidden";
+  error: string;
+} | {
+  status: "error";
+  error: string;
+};
+/** Formats the announce message injected into the parent session when a subagent completes. */
+declare function buildSubagentAnnounceMessage(params: {
+  task: string;
+  label?: string;
+  status: "done" | "error" | "killed";
+  result?: string;
+  error?: string;
+}): string;
+/**
+ * Creates the sessions_spawn tool that allows an agent to delegate tasks to subagents.
  *
- * Core entry point for running agent sessions.
- */
-export { runAgent, generateSessionTitle } from "./runner/runner.js";
-export type { AgentRunParams, AgentRunResult, CallbackPayload, TranscriptEntry, SubagentContext, Channel, } from "./types.js";
-export type { AgentProgressEvent, CallbackEventPayload, RunResultPayload } from "@gencode/shared";
-export type { ToolLoopDetectionConfig } from "./loop-detection/tool-loop-detection.js";
-export { createSession, ensureSession, loadTranscript, appendTranscriptEntry, listSessions, listSessionSummaries, saveSessionMetadata, loadSessionMetadata, sessionsDir, sessionDir, transcriptPath, metadataPath, } from "./session/session.js";
-export type { SessionMetadata, SessionSummary } from "./session/session.js";
-export { loadBootstrapFiles, buildBootstrapContextFiles, aimaxDir, BOOTSTRAP_MAX_CHARS, BOOTSTRAP_TOTAL_MAX_CHARS, BOOTSTRAP_FILE_NAMES, } from "./bootstrap/bootstrap.js";
-export type { BootstrapFile, BootstrapContextFile } from "./bootstrap/bootstrap.js";
-export { bootstrapMountLayout, inspectBootstrapMountLayout, isBootstrapMountLayoutReady, ensureBootstrapMountLayout, } from "./bootstrap/bootstrap-layout.js";
-export type { BootstrapMountResult, BootstrapMountStatus, BootstrapEnsureResult, } from "./bootstrap/bootstrap-layout.js";
-export { memoryDir, primaryMemoryPath, listMemoryFiles, readMemoryFile, readPrimaryMemory, searchMemory, getMemoryLines, appendToMemory, replaceMemoryFile, deleteMemoryFile, } from "./memory/memory.js";
-export type { MemorySearchResult, MemoryCallOptions } from "./memory/memory.js";
-export { MemoryIndexManager } from "./memory/manager.js";
-export type { MemoryProviderStatus } from "./memory/manager.js";
-export { registerEmbeddingProvider, resolveEmbeddingProvider, resetEmbeddingProviderRegistryForTests, } from "./memory/embedding-registry.js";
-export type { EmbeddingProviderContext, EmbeddingProviderFactory, EmbeddingProviderRegistration, } from "./memory/embedding-registry.js";
-export type { EmbeddingProvider } from "./memory/embeddings.js";
-export type { MemoryProvider, MemoryProviderContext, MemoryProviderFactory, MemorySearchOptions, MemoryChangeSource, MemoryChangedEvent, MemoryChangedHandler, } from "./memory/provider.js";
-export { createBuiltinMemoryProvider } from "./memory/builtin-provider.js";
-export { registerMemoryProvider, resolveMemoryProvider, resetMemoryProviderRegistryForTests, } from "./memory/provider-registry.js";
-export type { MemoryProviderRegistration } from "./memory/provider-registry.js";
-export { loadSkills, loadSkillsFromDirs, loadSkillsWithPluginDirs, buildSkillsPrompt, skillsDir, } from "./skills/skills.js";
-export type { Skill } from "./skills/skills.js";
-export { listAvailableSlashCommands } from "./commands/index.js";
-export type { SlashCommandList } from "./commands/index.js";
-export { buildSystemPrompt } from "./system-prompt/builder.js";
-export type { SystemPromptParams } from "./system-prompt/builder.js";
-export { createAgentTools, createBashTool, createExecTool, createProcessTool, createReadFileTool, createWriteFileTool, createEditFileTool, createListDirTool, createApplyPatchTool, createMemorySearchTool, createMemoryGetTool, createMemoryAppendTool, createImageTool, createSessionsSpawnTool, createSubagentsTool, } from "./tools/index.js";
-export type { SubagentToolsContext } from "./tools/index.js";
-export { SubagentRegistry, MAX_SUBAGENT_DEPTH, MAX_CHILDREN_PER_SESSION } from "./subagent/registry.js";
-export type { SubagentRunRecord, SubagentStatus } from "./subagent/types.js";
-export { buildSubagentAnnounceMessage } from "./tools/subagent-spawn.js";
-export { loadSubagentRegistryFromDisk, saveSubagentRegistryToDisk, listSubagentRunsFromDisk, cleanupOldSubagentRecords, } from "./subagent/registry-persist.js";
-export type { PersistedSubagentRunRecord } from "./subagent/registry-persist.js";
-export * from "./config/index.js";
-export * from "./plugins/index.js";
-//# sourceMappingURL=index.d.ts.map
+ * @param registry  The parent session's subagent registry.
+ * @param parentSessionId  Session ID of the agent doing the spawning.
+ * @param depth  Current nesting depth of the spawning agent (child will be depth+1).
+ * @param dataDir  User data directory (shared between parent and child).
+ * @param channel  Channel inherited from the parent session.
+ * @param llm  LLM config inherited from the parent.
+ * @param loopDetection  Tool-loop detection config inherited from the parent.
+ * @param spawnFn  Function that actually runs a child agent (injected to avoid circular imports).
+ */
+declare function createSessionsSpawnTool(registry: SubagentRegistry, parentSessionId: string, depth: number, dataDir: string, channel: AgentRunParams["channel"], llm: AgentRunParams["llm"], loopDetection: ToolLoopDetectionConfig | undefined, inheritedRunParams: Pick<AgentRunParams, "plugins" | "memory" | "messaging" | "docs" | "historyLimit">, spawnFn: (params: AgentRunParams) => Promise<AgentRunResult>): AgentTool<typeof spawnSchema, SpawnResult>;
+//#endregion
+//#region src/tools/subagents.d.ts
+declare const ACTIONS: readonly ["list", "kill"];
+type SubagentsAction = (typeof ACTIONS)[number];
+declare const subagentsSchema: TObject<{
+  action: TUnion<[TLiteral<"list">, TLiteral<"kill">]>;
+  target: TOptional<TString>;
+}>;
+type SubagentsResult = {
+  action: SubagentsAction;
+  runs?: Array<{
+    index: number;
+    runId: string;
+    label: string;
+    task: string;
+    status: string;
+    depth: number;
+    runtimeMs: number;
+  }>;
+  killed?: number;
+  error?: string;
+  text: string;
+};
+/**
+ * Creates the subagents tool for listing and killing spawned subagents.
+ */
+declare function createSubagentsTool(registry: SubagentRegistry, parentSessionId: string): AgentTool<typeof subagentsSchema, SubagentsResult>;
+//#endregion
+//#region src/tools/index.d.ts
+/** Optional context for enabling subagent tools */
+type SubagentToolsContext = {
+  registry: SubagentRegistry;
+  parentSessionId: string; /** Depth of the current agent (root = 0) */
+  depth: number;
+  channel: AgentRunParams["channel"];
+  llm: AgentRunParams["llm"];
+  inheritedRunParams?: Pick<AgentRunParams, "plugins" | "memory" | "messaging" | "docs" | "historyLimit">;
+  loopDetection?: ToolLoopDetectionConfig;
+  memoryOptions?: MemoryToolOptions; /** Callback that runs a child agent; injected to avoid circular imports */
+  spawnFn: (params: AgentRunParams) => Promise<AgentRunResult>;
+};
+/**
+ * Creates the full set of agent tools for a given data directory.
+ * File and exec/process tools are scoped to the workspace directory.
+ * Memory tools are scoped to the data directory's .aimax root
+ * (MEMORY.md + memory/*.md).
+ * Subagent tools (sessions_spawn, subagents) are included when ctx is provided.
+ */
+declare function createAgentTools(dataDir: string, ctx?: SubagentToolsContext): AgentTool[];
+//#endregion
+//#region src/subagent/registry-persist.d.ts
+/** Persistable subagent run record (without AbortController) */
+type PersistedSubagentRunRecord = Omit<SubagentRunRecord, "abortController"> & {
+  version?: number;
+};
+/**
+ * Loads subagent run records from disk.
+ * Returns an empty map if the file doesn't exist or is invalid.
+ */
+declare function loadSubagentRegistryFromDisk(dataDir: string): Promise<Map<string, SubagentRunRecord>>;
+/**
+ * Saves subagent run records to disk.
+ * Only records with a valid endedAt timestamp are persisted
+ * (completed runs are kept for history, running runs are not persisted).
+ */
+declare function saveSubagentRegistryToDisk(dataDir: string, runs: Map<string, SubagentRunRecord>): Promise<void>;
+/**
+ * Lists subagent runs for a specific parent session from disk.
+ * Useful for querying historical subagent runs.
+ */
+declare function listSubagentRunsFromDisk(dataDir: string, parentSessionId: string): Promise<PersistedSubagentRunRecord[]>;
+/**
+ * Cleans up old subagent records from disk.
+ * Removes records older than the specified number of days.
+ */
+declare function cleanupOldSubagentRecords(dataDir: string, olderThanDays?: number): Promise<number>;
+//#endregion
+//#region src/plugins/discovery.d.ts
+type PluginDiscoveryOptions = {
+  dataDir?: string;
+  workspaceDir?: string;
+  extraPaths?: string[];
+  bundledDir?: string;
+  ownershipUid?: number | null;
+};
+declare function discoverAIMaxPlugins(options?: PluginDiscoveryOptions): PluginDiscoveryResult;
+//#endregion
+//#region src/plugins/manifest.d.ts
+declare const PLUGIN_MANIFEST_FILENAME = "aimax.plugin.json";
+declare const PLUGIN_MANIFEST_FILENAMES: readonly ["aimax.plugin.json"];
+declare function resolvePluginManifestPath(rootDir: string): string;
+declare function loadPluginManifest(rootDir: string, rejectHardlinks?: boolean): PluginManifestLoadResult;
+//#endregion
+//#region src/plugins/hooks.d.ts
+type PluginHookName = "before_model_resolve" | "before_prompt_build" | "after_prompt_build" | "llm_input" | "assistant_message_end" | "llm_output" | "before_tool_call" | "after_tool_call" | "agent_end" | "before_compaction" | "after_compaction" | "session_start" | "session_end" | "session_reset" | "memory_changed";
+type PluginHookAgentContext = {
+  agentId?: string;
+  sessionId?: string;
+  workspaceDir?: string;
+  channel?: AgentRunParams["channel"];
+};
+type PluginHookBeforeModelResolveEvent = {
+  prompt: string;
+};
+type PluginHookBeforeModelResolveResult = {
+  modelOverride?: string;
+};
+type PluginHookBeforePromptBuildEvent = {
+  prompt: string;
+};
+type PluginHookBeforePromptBuildResult = {
+  systemPrompt?: string;
+  prependContext?: string;
+};
+type PluginHookAfterPromptBuildEvent = {
+  prompt: string;
+  systemPrompt: string;
+};
+type PluginHookLlmInputEvent = {
+  sessionId: string;
+  model: string;
+  prompt: string;
+  historyMessages: unknown[];
+};
+type PluginHookAssistantMessageEndEvent = {
+  sessionId: string;
+  model: string;
+  assistantText: string;
+  assistantMessage: AssistantMessage;
+  hasToolCalls: boolean;
+  durationMs?: number;
+  usage?: {
+    input?: number;
+    output?: number;
+    total?: number;
+  };
+};
+type PluginHookLlmOutputEvent = {
+  sessionId: string;
+  model: string;
+  assistantTexts: string[];
+  lastAssistant?: AssistantMessage;
+  usage?: {
+    input?: number;
+    output?: number;
+    total?: number;
+  };
+};
+type PluginHookBeforeToolCallEvent = {
+  toolCallId: string;
+  toolName: string;
+  params: Record<string, unknown>;
+};
+type PluginHookBeforeToolCallResult = {
+  params?: Record<string, unknown>;
+  block?: boolean;
+  blockReason?: string;
+};
+type PluginHookAfterToolCallEvent = {
+  toolCallId: string;
+  toolName: string;
+  params: Record<string, unknown>;
+  result?: unknown;
+  error?: string;
+  durationMs?: number;
+};
+type PluginHookAgentEndEvent = {
+  success: boolean;
+  error?: string;
+  durationMs?: number;
+};
+type PluginHookBeforeCompactionEvent = {
+  messageCount: number;
+  compactingCount?: number;
+};
+type PluginHookAfterCompactionEvent = {
+  messageCount: number;
+  compactedCount: number;
+};
+type PluginHookSessionStartEvent = {
+  sessionId: string;
+};
+type PluginHookSessionEndEvent = {
+  sessionId: string;
+  messageCount: number;
+  durationMs?: number;
+};
+type PluginHookSessionResetEvent = {
+  action: "new" | "reset";
+  sessionId: string;
+  previousSessionId?: string;
+  message: string;
+};
+type PluginHookMemoryChangedEvent = MemoryChangedEvent;
+type PluginHookHandlerMap = {
+  before_model_resolve: (event: PluginHookBeforeModelResolveEvent, ctx: PluginHookAgentContext) => PluginHookBeforeModelResolveResult | void | Promise<PluginHookBeforeModelResolveResult | void>;
+  before_prompt_build: (event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext) => PluginHookBeforePromptBuildResult | void | Promise<PluginHookBeforePromptBuildResult | void>;
+  after_prompt_build: (event: PluginHookAfterPromptBuildEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  llm_input: (event: PluginHookLlmInputEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  assistant_message_end: (event: PluginHookAssistantMessageEndEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  llm_output: (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  before_tool_call: (event: PluginHookBeforeToolCallEvent, ctx: PluginHookAgentContext) => PluginHookBeforeToolCallResult | void | Promise<PluginHookBeforeToolCallResult | void>;
+  after_tool_call: (event: PluginHookAfterToolCallEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  agent_end: (event: PluginHookAgentEndEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  before_compaction: (event: PluginHookBeforeCompactionEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  after_compaction: (event: PluginHookAfterCompactionEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  session_start: (event: PluginHookSessionStartEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  session_end: (event: PluginHookSessionEndEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  session_reset: (event: PluginHookSessionResetEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+  memory_changed: (event: PluginHookMemoryChangedEvent, ctx: PluginHookAgentContext) => void | Promise<void>;
+};
+type PluginHookRegistration<K extends PluginHookName = PluginHookName> = {
+  pluginId: string;
+  hookName: K;
+  handler: PluginHookHandlerMap[K];
+  priority?: number;
+  source: string;
+};
+declare class PluginHookRegistry {
+  private readonly hooks;
+  register<K extends PluginHookName>(registration: PluginHookRegistration<K>): void;
+  dispatch<K extends PluginHookName>(hookName: K, event: Parameters<PluginHookHandlerMap[K]>[0], ctx: Parameters<PluginHookHandlerMap[K]>[1]): Promise<Array<Awaited<ReturnType<PluginHookHandlerMap[K]>>>>;
+}
+//#endregion
+//#region src/plugins/tools.d.ts
+type PluginToolOptions = {
+  optional?: boolean;
+  name?: string;
+  names?: string[];
+};
+type RegisteredPluginTool = {
+  pluginId: string;
+  tool: AgentTool;
+  optional: boolean;
+  names: string[];
+};
+declare class PluginToolRegistry {
+  private readonly tools;
+  register(pluginId: string, tool: AgentTool, opts?: PluginToolOptions): void;
+  list(): RegisteredPluginTool[];
+  namesForPlugin(pluginId: string): string[];
+  resolveEnabled(allowlist?: string[]): AgentTool[];
+}
+//#endregion
+//#region src/plugins/runtime.d.ts
+type PluginRuntime = {
+  version: string;
+  logging: {
+    getLogger: (name: string) => {
+      info: (message: string) => void;
+      warn: (message: string) => void;
+      error: (message: string) => void;
+    };
+  };
+};
+type CreatePluginRuntimeOptions = {
+  pluginId: string;
+};
+declare function createPluginRuntime(options: CreatePluginRuntimeOptions): PluginRuntime;
+//#endregion
+//#region src/llm/client.d.ts
+type LlmChatMessage = {
+  role: "system" | "user" | "assistant";
+  content: string;
+};
+type LlmChatParams = {
+  system?: string;
+  user?: string;
+  messages?: LlmChatMessage[];
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+};
+type LlmChatResult = {
+  text: string;
+  usage: {
+    input: number;
+    output: number;
+    total: number;
+  };
+  raw?: unknown;
+};
+//#endregion
+//#region src/plugins/runtime-context.d.ts
+type PluginRuntimeContext = {
+  llm?: {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    contextWindow?: number;
+  };
+  hookCtx?: PluginHookAgentContext;
+  llmAllowlist?: string[];
+};
+//#endregion
+//#region src/plugins/loader.d.ts
+type PluginRecord = {
+  id: string;
+  source: string;
+  origin: PluginOrigin;
+  enabled: boolean;
+  status: "loaded" | "disabled" | "error";
+  error?: string;
+  toolCount: number;
+  hookCount: number;
+  skills: string[];
+  configSchema: boolean;
+};
+type PluginRegistry = {
+  plugins: PluginRecord[];
+  diagnostics: PluginDiagnostic[];
+  tools: PluginToolRegistry;
+  hooks: PluginHookRegistry;
+  skills: string[];
+};
+type PluginLoadOptions = {
+  registry: PluginManifestRegistry;
+  plugins: NormalizedPluginsConfig;
+  workspaceDir?: string;
+  runtime?: PluginRuntimeContext;
+};
+type PluginApi = {
+  id: string;
+  source: string;
+  rootDir: string;
+  config: Record<string, unknown> | undefined;
+  runtime: ReturnType<typeof createPluginRuntime>;
+  llm: {
+    chat: (params: LlmChatParams) => Promise<LlmChatResult>;
+  };
+  registerTool: (tool: Parameters<PluginToolRegistry["register"]>[1], opts?: Parameters<PluginToolRegistry["register"]>[2]) => void;
+  registerEmbeddingProvider: (params: {
+    id?: string;
+    create: EmbeddingProviderFactory;
+  }) => void;
+  registerMemoryProvider: (params: {
+    id?: string;
+    create: MemoryProviderFactory;
+  }) => void;
+  registerHook: <K extends PluginHookName>(hookName: K, handler: PluginHookHandlerMap[K], opts?: {
+    priority?: number;
+  }) => void;
+  registerSkillDir: (dir: string) => void;
+};
+declare function loadPlugins(options: PluginLoadOptions): PluginRegistry;
+//#endregion
+//#region src/plugins/manager.d.ts
+type PluginSystemOptions = {
+  config?: PluginsConfig;
+  dataDir?: string;
+  workspaceDir?: string;
+  bundledDir?: string;
+  ownershipUid?: number | null;
+  toolAllowlist?: string[];
+  runtime?: PluginRuntimeContext;
+};
+type PluginSystem = {
+  registry: PluginRegistry;
+  diagnostics: PluginDiagnostic[];
+  normalizedConfig: NormalizedPluginsConfig;
+};
+declare function initializePluginSystem(options?: PluginSystemOptions): PluginSystem;
+//#endregion
+//#region src/plugins/tool-hooks.d.ts
+declare function wrapToolsWithHooks(tools: AgentTool[], hooks: PluginHookRegistry, ctx: PluginHookAgentContext): AgentTool[];
+//#endregion
+export { AgentBinding, AgentConfig, AgentModelConfig, type AgentProgressEvent, type AgentRunParams, type AgentRunResult, AgentsConfig, BOOTSTRAP_FILE_NAMES, BOOTSTRAP_MAX_CHARS, BOOTSTRAP_TOTAL_MAX_CHARS, type BootstrapContextFile, type BootstrapEnsureResult, type BootstrapFile, type BootstrapMountResult, type BootstrapMountStatus, type CallbackEventPayload, type CallbackPayload, type Channel, type EmbeddingProvider, type EmbeddingProviderContext, type EmbeddingProviderFactory, type EmbeddingProviderRegistration, MAX_CHILDREN_PER_SESSION, MAX_SUBAGENT_DEPTH, type MemoryCallOptions, type MemoryChangeSource, type MemoryChangedEvent, type MemoryChangedHandler, MemoryIndexManager, type MemoryProvider, type MemoryProviderContext, type MemoryProviderFactory, type MemoryProviderRegistration, type MemoryProviderStatus, type MemorySearchOptions, type MemorySearchResult, type NormalizedPluginsConfig, PLUGIN_MANIFEST_FILENAME, PLUGIN_MANIFEST_FILENAMES, type PersistedSubagentRunRecord, type PluginApi, type PluginCandidate, type PluginConfigUiHint, type PluginDiagnostic, type PluginDiscoveryOptions, type PluginDiscoveryResult, type PluginEntryConfig, type PluginHookAfterCompactionEvent, type PluginHookAfterPromptBuildEvent, type PluginHookAfterToolCallEvent, type PluginHookAgentContext, type PluginHookAgentEndEvent, type PluginHookAssistantMessageEndEvent, type PluginHookBeforeCompactionEvent, type PluginHookBeforeModelResolveEvent, type PluginHookBeforeModelResolveResult, type PluginHookBeforePromptBuildEvent, type PluginHookBeforePromptBuildResult, type PluginHookBeforeToolCallEvent, type PluginHookBeforeToolCallResult, type PluginHookHandlerMap, type PluginHookLlmInputEvent, type PluginHookLlmOutputEvent, type PluginHookMemoryChangedEvent, type PluginHookName, PluginHookRegistry, type PluginHookSessionEndEvent, type PluginHookSessionResetEvent, type PluginHookSessionStartEvent, type PluginKind, type PluginManifest, type PluginManifestLoadResult, type PluginManifestRegistry, type PluginOrigin, type PluginRecord, type PluginRegistry, type PluginRuntime, type PluginRuntimeContext, type PluginSystem, type PluginSystemOptions, type PluginToolOptions, PluginToolRegistry, type PluginsConfig, type PluginsConfigValidationResult, type RegisteredPluginTool, type RunResultPayload, type SessionMetadata, type SessionSummary, type Skill, type SlashCommandList, type SubagentContext, SubagentRegistry, type SubagentRunRecord, type SubagentStatus, type SubagentToolsContext, type SystemPromptParams, type ToolLoopDetectionConfig, type TranscriptEntry, addAgent, addBinding, aimaxDir, appendToMemory, appendTranscriptEntry, bootstrapMountLayout, buildBootstrapContextFiles, buildSkillsPrompt, buildSubagentAnnounceMessage, buildSystemPrompt, cleanupOldSubagentRecords, createAgentTools, createApplyPatchTool, createBashTool, createBuiltinMemoryProvider, createEditFileTool, createExecTool, createImageTool, createListDirTool, createMemoryAppendTool, createMemoryGetTool, createMemorySearchTool, createPluginRuntime, createProcessTool, createReadFileTool, createSession, createSessionsSpawnTool, createSubagentsTool, createWriteFileTool, deleteMemoryFile, discoverAIMaxPlugins, ensureBootstrapMountLayout, ensureSession, generateSessionTitle, getAgentConfig, getMemoryLines, initializePluginSystem, inspectBootstrapMountLayout, isBootstrapMountLayoutReady, listAgents, listAvailableSlashCommands, listBindings, listMemoryFiles, listSessionSummaries, listSessions, listSubagentRunsFromDisk, loadAgentsConfig, loadBootstrapFiles, loadPluginManifest, loadPluginManifestRegistry, loadPlugins, loadSessionMetadata, loadSkills, loadSkillsFromDirs, loadSkillsWithPluginDirs, loadSubagentRegistryFromDisk, loadTranscript, memoryDir, metadataPath, normalizeAgentId, normalizePluginsConfig, primaryMemoryPath, readMemoryFile, readPrimaryMemory, registerEmbeddingProvider, registerMemoryProvider, removeAgent, removeBindings, replaceMemoryFile, resetEmbeddingProviderRegistryForTests, resetMemoryProviderRegistryForTests, resolveAgentDir, resolveAgentIdByBinding, resolveAgentsConfigPath, resolveDefaultAgentId, resolveEmbeddingProvider, resolveMemoryProvider, resolveModelFallbacks, resolveModelString, resolvePluginManifestPath, runAgent, saveAgentsConfig, saveSessionMetadata, saveSubagentRegistryToDisk, searchMemory, sessionDir, sessionsDir, skillsDir, transcriptPath, updateAgentIdentity, validatePluginsConfig, wrapToolsWithHooks };