@prometheus-ai/agent 0.5.0

package/dist/types/modes/ultrathink.d.ts

@@ -0,0 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
+/** Hidden system notice appended after a user message that mentions "ultrathink". */
+export declare const ULTRATHINK_NOTICE: string;
+/**
+ * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export declare function containsUltrathink(text: string): boolean;
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
+ */
+export declare const highlightUltrathink: KeywordHighlighter;

package/dist/types/modes/utils/context-usage.d.ts

@@ -0,0 +1,47 @@
+import type { Model } from "@prometheus-ai/ai";
+import type { Skill } from "../../extensibility/skills";
+import type { AgentSession } from "../../session/agent-session";
+import type { Tool } from "../../tools";
+import type { theme as Theme } from "../theme/theme";
+type CategoryId = "systemPrompt" | "systemContext" | "systemTools" | "skills" | "messages";
+interface CategoryInfo {
+    id: CategoryId;
+    label: string;
+    tokens: number;
+    color: "accent" | "warning" | "success" | "userMessageText" | "customMessageLabel";
+    glyph: string;
+}
+export interface ContextBreakdown {
+    model: Model | undefined;
+    contextWindow: number;
+    categories: CategoryInfo[];
+    usedTokens: number;
+    autoCompactBufferTokens: number;
+    freeTokens: number;
+}
+export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
+export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
+/**
+ * Compute just the NON-MESSAGE token total: system prompt (with its skills
+ * section subtracted, since skills are tokenized separately) + system context
+ * (the rest of the system-prompt array) + tools + skills.
+ *
+ * Exposed so callers like `StatusLineComponent` can cache the non-message
+ * total separately from the message total. Non-message inputs (skills,
+ * tools, system prompt) change rarely; the message list grows on every
+ * streaming turn. Splitting the two lets the caller refresh each on its own
+ * cadence — non-message recomputed only when the inputs identity changes,
+ * messages walked incrementally as new entries append.
+ */
+export declare function computeNonMessageTokens(session: AgentSession): number;
+/**
+ * Compute a breakdown of estimated context usage by category for the active
+ * session and model.
+ */
+export declare function computeContextBreakdown(session: AgentSession): ContextBreakdown;
+/**
+ * Render a colorful context-usage panel as ANSI text. Output is a series of
+ * lines pairing the grid (left) with the legend (right).
+ */
+export declare function renderContextUsage(breakdown: ContextBreakdown, theme: typeof Theme): string;
+export {};

package/dist/types/modes/utils/copy-targets.d.ts

@@ -0,0 +1,53 @@
+import type { AgentMessage } from "@prometheus-ai/agent-core";
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+    /** Info string after the opening fence (language id), trimmed. */
+    lang: string;
+    /** Block body with the trailing newline stripped. */
+    code: string;
+}
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+    kind: "bash" | "eval";
+    code: string;
+    /** Highlight language: "bash" for bash, "python"/"javascript" for eval. */
+    language: string;
+}
+/**
+ * A node in the `/copy` picker tree. Leaves carry `content` (placed on the
+ * clipboard) plus `copyMessage` (the status shown afterwards); groups carry
+ * `children` to drill into.
+ */
+export interface CopyTarget {
+    /** Stable identifier (e.g. "msg:1", "msg:1:code:0", "msg:1:all", "cmd:1"). */
+    id: string;
+    label: string;
+    /** Dim annotation: line/block counts, language, or tool name. */
+    hint?: string;
+    /** Full text rendered in the preview pane. */
+    preview: string;
+    /** Highlight language for code/command previews (undefined = plain/markdown). */
+    language?: string;
+    /** Leaf: text copied to the clipboard. */
+    content?: string;
+    /** Leaf: status message shown after copying. */
+    copyMessage?: string;
+    /** Group: nested targets to drill into. */
+    children?: CopyTarget[];
+}
+/** Minimal session surface needed to assemble copy targets (eases testing). */
+export interface CopySource {
+    readonly messages: readonly AgentMessage[];
+    getLastVisibleHandoffText(): string | undefined;
+}
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export declare function extractCodeBlocks(text: string): CodeBlock[];
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export declare function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined;
+/**
+ * Assemble the unified `/copy` target tree: recent assistant messages
+ * (most recent first, each drillable into its code blocks), runnable command
+ * targets interleaved after the assistant message that issued them, and a
+ * fresh-handoff fallback when no assistant message exists yet.
+ */
+export declare function buildCopyTargets(source: CopySource): CopyTarget[];

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { KeybindingsManager } from "../../config/keybindings";
+export interface HotkeysMarkdownBindings {
+    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+}
+export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Match the coding-agent interrupt key.
+ *
+ * Interactive mode installs a keybinding manager that exposes `app.interrupt`
+ * globally, but some isolated component tests still run with only TUI
+ * keybindings registered. In that case, fall back to raw Escape matching.
+ */
+export declare function matchesAppInterrupt(data: string): boolean;
+/** Match the generic selector cancel keybinding. */
+export declare function matchesSelectCancel(data: string): boolean;
+/** Match the generic selector up-navigation keybinding. */
+export declare function matchesSelectUp(data: string): boolean;
+/** Match the generic selector down-navigation keybinding. */
+export declare function matchesSelectDown(data: string): boolean;
+/** Match the generic selector page-up keybinding. */
+export declare function matchesSelectPageUp(data: string): boolean;
+/** Match the generic selector page-down keybinding. */
+export declare function matchesSelectPageDown(data: string): boolean;
+export declare function matchesAppExternalEditor(data: string): boolean;

package/dist/types/modes/utils/tools-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "../../tools";
+export interface ToolsMarkdownBindings {
+    tools: ReadonlyArray<Pick<Tool, "description" | "name">>;
+}
+export declare function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -0,0 +1,55 @@
+import type { AgentMessage } from "@prometheus-ai/agent-core";
+import type { AssistantMessage, Message } from "@prometheus-ai/ai";
+import { type Component } from "@prometheus-ai/tui";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { SessionContext } from "../../session/session-manager";
+interface RenderInitialMessagesOptions {
+    preserveExistingChat?: boolean;
+    clearTerminalHistory?: boolean;
+}
+export declare class UiHelpers {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /** Extract text content from a user message */
+    getUserMessageText(message: Message): string;
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    addMessageToChat(message: AgentMessage, options?: {
+        populateHistory?: boolean;
+        imageLinks?: readonly (string | undefined)[];
+    }): Component[];
+    /**
+     * Render session context to chat. Used for initial load and rebuild after compaction.
+     * @param sessionContext Session context to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionContext(sessionContext: SessionContext, options?: {
+        updateFooter?: boolean;
+        populateHistory?: boolean;
+    }): void;
+    renderInitialMessages(prebuiltContext?: SessionContext, options?: RenderInitialMessagesOptions): void;
+    clearEditor(): void;
+    showError(errorMessage: string): void;
+    showWarning(warningMessage: string): void;
+    showNewVersionNotification(newVersion: string): void;
+    updatePendingMessagesDisplay(): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp"): void;
+    isKnownSlashCommand(text: string): boolean;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    /** Move pending bash components from pending area to chat */
+    flushPendingBashComponents(): void;
+    findLastAssistantMessage(): AssistantMessage | undefined;
+    extractAssistantText(message: AssistantMessage): string;
+}
+export {};

package/dist/types/modes/workflow.d.ts

@@ -0,0 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
+/** Hidden system notice appended after a user message that mentions "workflow". */
+export declare const WORKFLOW_NOTICE: string;
+/**
+ * Whether `text` contains the standalone keyword "workflow"/"workflows"
+ * (lowercase, whitespace-delimited) in prose — never inside a code block, inline
+ * code span, or XML/HTML section.
+ */
+export declare function containsWorkflow(text: string): boolean;
+/**
+ * Highlight every standalone "workflow"/"workflows" in `text` for editor display
+ * with a warm amber→green gradient (hue 30..150), visually distinct from
+ * ultrathink's rainbow and orchestrate's teal→violet.
+ */
+export declare const highlightWorkflow: KeywordHighlighter;

package/dist/types/plan-mode/approved-plan.d.ts

@@ -0,0 +1,49 @@
+/** Shape forwarded from the plan-mode resolve handler to InteractiveMode's
+ *  approval popup. Populated by the standing handler that the resolve tool
+ *  dispatches to when the agent submits `resolve { action: "apply" }`. */
+export interface PlanApprovalDetails {
+    planFilePath: string;
+    finalPlanFilePath: string;
+    title: string;
+    planExists: boolean;
+}
+/** Validate and normalize the agent-supplied plan title into a safe filename stem.
+ *  Spaces and other URL-safe punctuation are replaced with hyphens so models that
+ *  produce natural-language titles (e.g. "My feature plan") still succeed.
+ *  Characters that cannot be safely represented after replacement are dropped.
+ *  The result is restricted to letters, numbers, underscores, and hyphens so it
+ *  is safe to splice into a `local://` URL without escaping. */
+export declare function normalizePlanTitle(title: string): {
+    title: string;
+    fileName: string;
+};
+/** Best-effort derivation of a plan title from inputs the agent already produced.
+ *  Returns the first non-empty candidate that survives `normalizePlanTitle`:
+ *    1. an explicit `suppliedTitle` (e.g. `extra.title` from the resolve call),
+ *    2. the first level-1 markdown heading inside `planContent`,
+ *    3. the filename stem of `planFilePath` (e.g. `PLAN` from `local://PLAN.md`),
+ *    4. the literal `"plan"` so callers never have to handle `null`.
+ *  The fallback exists because some grammar-constrained models cannot emit a
+ *  string into the open `extra` schema and instead drop in `{}` (issue #1179);
+ *  plan-mode would otherwise loop forever on an unreachable validation. */
+export declare function resolvePlanTitle(input: {
+    suppliedTitle?: unknown;
+    planContent: string;
+    planFilePath: string;
+}): {
+    title: string;
+    fileName: string;
+    source: "supplied" | "heading" | "filename" | "default";
+};
+/** Humanize a normalized plan title for use as a session display name.
+ *  Replaces `-`/`_` separators with spaces and capitalizes the first letter.
+ *  Returns an empty string when the input collapses to whitespace. */
+export declare function humanizePlanTitle(title: string): string;
+interface RenameApprovedPlanFileOptions {
+    planFilePath: string;
+    finalPlanFilePath: string;
+    getArtifactsDir: () => string | null;
+    getSessionId: () => string | null;
+}
+export declare function renameApprovedPlanFile(options: RenameApprovedPlanFileOptions): Promise<void>;
+export {};

package/dist/types/plan-mode/plan-handoff.d.ts

@@ -0,0 +1,20 @@
+import { type LocalProtocolOptions } from "../internal-urls";
+/** The session's active plan, resolved for handoff into a subagent's context. */
+export interface OverallPlanReference {
+    /** The `local://` reference path (e.g. `local://my-feature.md`), kept for display. */
+    path: string;
+    /** The full plan markdown, as written to disk. */
+    content: string;
+}
+/**
+ * Load the session's active overall plan for subagent handoff.
+ *
+ * Returns the plan referenced by `planReferencePath` when it exists on disk with
+ * non-empty content, or `undefined` when there is no plan (the file is absent or
+ * empty). This mirrors `AgentSession.#buildPlanReferenceMessage`'s gating so a
+ * subagent sees exactly the plan the main agent treats as its active reference.
+ *
+ * Callers MUST skip this during plan mode itself — read-only plan exploration
+ * uses a different prompt and a draft plan should not be handed off as approved.
+ */
+export declare function loadOverallPlanReference(planReferencePath: string, localProtocolOptions: LocalProtocolOptions): Promise<OverallPlanReference | undefined>;

package/dist/types/plan-mode/plan-protection.d.ts

@@ -0,0 +1,12 @@
+import { type ProtectedToolContext } from "@prometheus-ai/agent-core/compaction/tool-protection";
+/**
+ * Build a compaction protection matcher that keeps `read` results for the active
+ * plan file intact through prune/shake — the plan analog of skill-read
+ * protection. Matches both the canonical `local://PLAN.md` alias and the
+ * session's current plan reference path (e.g. a titled `local://<title>.md`), so
+ * the plan survives compaction whether the agent reads it by alias or by title.
+ *
+ * `getPlanReferencePath` is evaluated at match time so a mid-session retitle
+ * (plan approval renames `PLAN.md` → `<title>.md`) is honored immediately.
+ */
+export declare function createPlanReadMatcher(getPlanReferencePath: () => string): (context: ProtectedToolContext) => boolean;

package/dist/types/plan-mode/state.d.ts

@@ -0,0 +1,6 @@
+export interface PlanModeState {
+    enabled: boolean;
+    planFilePath: string;
+    workflow?: "parallel" | "iterative";
+    reentry?: boolean;
+}

package/dist/types/registry/agent-registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * AgentRegistry - Process-global registry of live AgentSession instances.
+ *
+ * Tracks every alive agent (the main session plus every subagent) so the
+ * `irc` tool can address peers by id. Sessions are registered explicitly at
+ * creation and removed when the owner releases them.
+ */
+import type { AgentSession } from "../session/agent-session";
+export declare const MAIN_AGENT_ID = "Main";
+export type AgentStatus = "running" | "idle" | "completed" | "aborted";
+export type AgentKind = "main" | "sub";
+export interface AgentRef {
+    id: string;
+    displayName: string;
+    kind: AgentKind;
+    parentId?: string;
+    status: AgentStatus;
+    session: AgentSession | null;
+    sessionFile: string | null;
+    createdAt: number;
+    lastActivity: number;
+}
+export type RegistryEvent = {
+    type: "registered";
+    ref: AgentRef;
+} | {
+    type: "status_changed";
+    ref: AgentRef;
+} | {
+    type: "removed";
+    ref: AgentRef;
+};
+type RegistryListener = (event: RegistryEvent) => void;
+export interface RegisterInput {
+    id: string;
+    displayName: string;
+    kind: AgentKind;
+    parentId?: string;
+    session: AgentSession | null;
+    sessionFile?: string | null;
+    status?: AgentStatus;
+}
+export declare class AgentRegistry {
+    #private;
+    static global(): AgentRegistry;
+    /** Reset the global registry. Test-only. */
+    static resetGlobalForTests(): void;
+    register(input: RegisterInput): AgentRef;
+    setStatus(id: string, status: AgentStatus): void;
+    attachSession(id: string, session: AgentSession, sessionFile?: string | null): void;
+    detachSession(id: string): void;
+    unregister(id: string): void;
+    get(id: string): AgentRef | undefined;
+    list(): AgentRef[];
+    /**
+     * Returns every alive agent (running | idle) except the caller.
+     * Flat namespace: every agent can see every other agent.
+     */
+    listVisibleTo(id: string): AgentRef[];
+    onChange(listener: RegistryListener): () => void;
+}
+export {};

package/dist/types/sdk.d.ts

@@ -0,0 +1,271 @@
+import { type AgentTelemetryConfig, type ThinkingLevel } from "@prometheus-ai/agent-core";
+import { type Model } from "@prometheus-ai/ai";
+import { type Rule } from "./capability/rule";
+import { ModelRegistry } from "./config/model-registry";
+import { type PromptTemplate } from "./config/prompt-templates";
+import { Settings, type SkillsSettings } from "./config/settings";
+import "./discovery";
+import { type CustomCommandsLoadResult } from "./extensibility/custom-commands";
+import type { CustomTool } from "./extensibility/custom-tools/types";
+import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "./extensibility/extensions";
+import { type Skill, type SkillWarning } from "./extensibility/skills";
+import { type FileSlashCommand } from "./extensibility/slash-commands";
+import type { HindsightSessionState } from "./hindsight/state";
+import { type LocalProtocolOptions } from "./internal-urls";
+import { MCPManager, type MCPToolsLoadResult } from "./mcp";
+import { type MnemopiSessionState } from "./mnemopi/state";
+import { AgentRegistry } from "./registry/agent-registry";
+import { AgentSession } from "./session/agent-session";
+import { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
+import { type BuildSystemPromptResult } from "./system-prompt";
+import { type ConfiguredThinkingLevel } from "./thinking";
+import { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, type LspStartupServerInfo, loadSshTool, ReadTool, ResolveTool, SearchTool, type Tool, type ToolSession, WebSearchTool, WriteTool } from "./tools";
+import { EventBus } from "./utils/event-bus";
+import { type WorkspaceTree } from "./workspace-tree";
+export interface CreateAgentSessionOptions {
+    /** Working directory for project-local discovery. Default: getProjectDir() */
+    cwd?: string;
+    /** Global config directory. Default: ~/.prometheus/agent */
+    agentDir?: string;
+    /** Spawns to allow. Default: "*" */
+    spawns?: string;
+    /** Auth storage for credentials. Default: discoverAuthStorage(agentDir) */
+    authStorage?: AuthStorage;
+    /** Model registry. Default: discoverModels(authStorage, agentDir) */
+    modelRegistry?: ModelRegistry;
+    /** Model to use. Default: from settings, else first available */
+    model?: Model;
+    /** Raw model pattern string (e.g. from --model CLI flag) to resolve after extensions load.
+     * Used when model lookup is deferred because extension-provided models aren't registered yet. */
+    modelPattern?: string;
+    /** Thinking selector. Default: from settings, else unset */
+    thinkingLevel?: ConfiguredThinkingLevel;
+    /** Models available for cycling (Ctrl+P in interactive mode) */
+    scopedModels?: Array<{
+        model: Model;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
+    systemPrompt?: string[] | ((defaultPrompt: string[]) => string[]);
+    /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
+     * Keeps persisted session files isolated while reusing provider-side caches. */
+    providerSessionId?: string;
+    /** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
+    customTools?: (CustomTool | ToolDefinition)[];
+    /** Inline extensions (merged with discovery). */
+    extensions?: ExtensionFactory[];
+    /** Additional extension paths to load (merged with discovery). */
+    additionalExtensionPaths?: string[];
+    /** Disable extension discovery (explicit paths still load). */
+    disableExtensionDiscovery?: boolean;
+    /**
+     * Pre-loaded extensions (skips file discovery).
+     * @internal Used by CLI when extensions are loaded early to parse custom flags.
+     */
+    preloadedExtensions?: LoadExtensionsResult;
+    /** Shared event bus for tool/extension communication. Default: creates new bus. */
+    eventBus?: EventBus;
+    /** Skills. Default: discovered from multiple locations */
+    skills?: Skill[];
+    /** Rules. Default: discovered from multiple locations */
+    rules?: Rule[];
+    /** Context files (AGENTS.md content). Default: discovered walking up from cwd */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+    /** Pre-built workspace tree (skips re-scanning; passed by parents to subagents). */
+    workspaceTree?: WorkspaceTree;
+    /** Prompt templates. Default: discovered from cwd/.prometheus/prompts/ + agentDir/prompts/ */
+    promptTemplates?: PromptTemplate[];
+    /** File-based slash commands. Default: discovered from commands/ directories */
+    slashCommands?: FileSlashCommand[];
+    /** Enable MCP server discovery from .mcp.json files. Default: true */
+    enableMCP?: boolean;
+    /** Existing MCP manager to reuse (skips discovery, propagates to toolSession). */
+    mcpManager?: MCPManager;
+    /** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
+    enableLsp?: boolean;
+    /** Skip Python kernel availability check and prelude warmup */
+    skipPythonPreflight?: boolean;
+    /** Tool names explicitly requested (enables disabled-by-default tools) */
+    toolNames?: string[];
+    /** Output schema for structured completion (subagents) */
+    outputSchema?: unknown;
+    /** Whether to include the yield tool by default */
+    requireYieldTool?: boolean;
+    /** Task recursion depth (for subagent sessions). Default: 0 */
+    taskDepth?: number;
+    /** Parent Hindsight state to alias for subagent memory tools. */
+    parentHindsightSessionState?: HindsightSessionState;
+    /** Parent Mnemopi state to alias for subagent memory tools. */
+    parentMnemopiSessionState?: MnemopiSessionState;
+    /** Pre-allocated agent identity for IRC routing. Default: "Main" for top-level, parentTaskPrefix-derived for sub. */
+    agentId?: string;
+    /** Display name for the agent in IRC. Default: "main" or "sub". */
+    agentDisplayName?: string;
+    /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
+    agentRegistry?: AgentRegistry;
+    /** Parent task ID prefix for nested artifact naming (e.g., "Extensions") */
+    parentTaskPrefix?: string;
+    /** Inherited eval executor session id for subagents sharing parent eval state. */
+    parentEvalSessionId?: string;
+    /** Session manager. Default: session stored under the configured agentDir sessions root */
+    sessionManager?: SessionManager;
+    /** Override local:// protocol options for subagent local:// sharing. Default: uses the session's own artifacts dir and session ID. */
+    localProtocolOptions?: LocalProtocolOptions;
+    /** Settings instance. Default: Settings.init({ cwd, agentDir }) */
+    settings?: Settings;
+    /** Whether UI is available (enables interactive tools like ask). Default: false */
+    hasUI?: boolean;
+    /**
+     * Opt-in OpenTelemetry instrumentation forwarded to the underlying Agent.
+     * Passing `{}` enables the loop's GenAI-semantic-convention spans. See
+     * {@link AgentTelemetryConfig} for the full surface (hooks, content capture,
+     * cost estimator, agent identity).
+     *
+     * Safe to enable without an OTEL SDK registered in the host: the
+     * `@opentelemetry/api` package returns a no-op tracer in that case.
+     */
+    telemetry?: AgentTelemetryConfig;
+    /** Whether to auto-approve all tool calls (--auto-approve CLI flag). Default: false */
+    autoApprove?: boolean;
+}
+/** Result from createAgentSession */
+export interface CreateAgentSessionResult {
+    /** The created session */
+    session: AgentSession;
+    /** Extensions result (loaded extensions + runtime) */
+    extensionsResult: LoadExtensionsResult;
+    /** Update tool UI context (interactive mode) */
+    setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
+    /** MCP manager for server lifecycle management (undefined if MCP disabled) */
+    mcpManager?: MCPManager;
+    /** Warning if session was restored with a different model than saved */
+    modelFallbackMessage?: string;
+    /** LSP servers detected for startup; warmup may continue in the background */
+    lspServers?: LspStartupServerInfo[];
+    /** Shared event bus for tool/extension communication */
+    eventBus: EventBus;
+}
+export type { PromptTemplate } from "./config/prompt-templates";
+export { Settings, type SkillsSettings } from "./config/settings";
+export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";
+export type { CustomTool, CustomToolFactory } from "./extensibility/custom-tools/types";
+export type * from "./extensibility/extensions";
+export type { Skill } from "./extensibility/skills";
+export type { FileSlashCommand } from "./extensibility/slash-commands";
+export type { MCPManager, MCPServerConfig, MCPServerConnection, MCPToolsLoadResult } from "./mcp";
+export type { Tool } from "./tools";
+export { buildDirectoryTree, buildWorkspaceTree, type DirectoryTree, type WorkspaceTree } from "./workspace-tree";
+export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HIDDEN_TOOLS, loadSshTool, ReadTool, ResolveTool, SearchTool, type ToolSession, WebSearchTool, WriteTool, };
+/**
+ * Create an AuthStorage instance.
+ *
+ * Default: local SQLite store at `<agentDir>/agent.db`.
+ *
+ * Broker mode: when `PROMETHEUS_AUTH_BROKER_URL` is set, credentials are pulled from
+ * a remote auth-broker over the wire. Refresh tokens never leave the broker;
+ * the client receives access tokens with `refresh = "__remote__"` and calls
+ * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
+ * override to re-mint access tokens when needed.
+ */
+export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
+/**
+ * Discover extensions from cwd.
+ */
+export declare function discoverExtensions(cwd?: string): Promise<LoadExtensionsResult>;
+/**
+ * Load the discovered/configured extensions for a session — everything {@link
+ * createAgentSession} would load except the inline factory extensions it appends
+ * itself. Extracted so the CLI can resolve extension-registered flags (and thus
+ * classify `@file` arguments extension-aware) *before* a session — and its
+ * terminal breadcrumb — is created, then hand the result back through
+ * {@link CreateAgentSessionOptions.preloadedExtensions} so the work is not
+ * repeated. Keep this the single source of the discovery branch logic.
+ */
+export declare function loadSessionExtensions(options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">, cwd: string, settings: Settings, eventBus: EventBus): Promise<LoadExtensionsResult>;
+/**
+ * Discover skills from cwd and agentDir.
+ */
+export declare function discoverSkills(cwd?: string, _agentDir?: string, settings?: SkillsSettings): Promise<{
+    skills: Skill[];
+    warnings: SkillWarning[];
+}>;
+/**
+ * Discover context files (AGENTS.md) walking up from cwd.
+ * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
+ */
+export declare function discoverContextFiles(cwd?: string, _agentDir?: string): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Discover prompt templates from cwd and agentDir.
+ */
+export declare function discoverPromptTemplates(cwd?: string, agentDir?: string): Promise<PromptTemplate[]>;
+/**
+ * Discover file-based slash commands from commands/ directories.
+ */
+export declare function discoverSlashCommands(cwd?: string): Promise<FileSlashCommand[]>;
+/**
+ * Discover custom commands (TypeScript slash commands) from cwd and agentDir.
+ */
+export declare function discoverCustomTSCommands(cwd?: string, agentDir?: string): Promise<CustomCommandsLoadResult>;
+/**
+ * Discover MCP servers from .mcp.json files.
+ * Returns the manager and loaded tools.
+ */
+export declare function discoverMCPServers(cwd?: string): Promise<MCPToolsLoadResult>;
+export interface BuildSystemPromptOptions {
+    tools?: Tool[];
+    skills?: Skill[];
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+    }>;
+    cwd?: string;
+    appendPrompt?: string;
+    repeatToolDescriptions?: boolean;
+}
+/**
+ * Build the default provider-facing system prompt blocks.
+ *
+ * The returned `systemPrompt` preserves the stable harness prompt and dynamic project context
+ * as separate entries so providers can cache prompt prefixes without concatenating blocks.
+ */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+/**
+ * Create an AgentSession with the specified options.
+ *
+ * @example
+ * ```typescript
+ * // Minimal - uses defaults
+ * const { session } = await createAgentSession();
+ *
+ * // With explicit model
+ * import { getModel } from '@prometheus-ai/ai';
+ * const { session } = await createAgentSession({
+ *   model: getModel('anthropic', 'claude-opus-4-5'),
+ *   thinkingLevel: 'high',
+ * });
+ *
+ * // Continue previous session
+ * const { session, modelFallbackMessage } = await createAgentSession({
+ *   continueSession: true,
+ * });
+ *
+ * // Full control
+ * const { session } = await createAgentSession({
+ *   model: myModel,
+ *   getApiKey: async () => Bun.env.MY_KEY,
+ *   systemPrompt: ['You are helpful.'],
+ *   tools: codingTools({ cwd: getProjectDir() }),
+ *   skills: [],
+ *   sessionManager: SessionManager.inMemory(),
+ * });
+ * ```
+ */
+export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

package/dist/types/secrets/index.d.ts

@@ -0,0 +1,9 @@
+import type { SecretEntry } from "./obfuscator";
+export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+/**
+ * Load secrets from project-local and global secrets.yml files.
+ * Project-local entries override global entries with matching content.
+ */
+export declare function loadSecrets(cwd: string, agentDir: string): Promise<SecretEntry[]>;
+/** Collect environment variable values that look like secrets. */
+export declare function collectEnvSecrets(): SecretEntry[];