@mu-agent/mu 0.2.4 → 0.3.0

package/dist/types/profile-coding/index.d.ts

@@ -1,5 +1,4 @@
 import { ProcessManager, type Profile } from "../core/index.js";
-import { TodoStore } from "../sdk/index.js";
 import { InstructionLoader, type InstructionSettings } from "./context.js";
 import { FileState } from "./state.js";
 import { bashTool } from "./tools/bash.js";
@@ -11,25 +10,24 @@ export interface CodingProfileOptions {
     home?: string;
     instructions?: InstructionSettings;
     managedInstructionPaths?: string[];
+    checkpoints?: boolean;
 }
 export interface CodingProfile extends Profile {
     fileState: FileState;
-    todos: TodoStore;
     processes: ProcessManager;
     instructions: InstructionLoader;
 }
 export declare function codingProfile(options?: CodingProfileOptions): Promise<CodingProfile>;
-export type { TodoItem } from "../sdk/index.js";
-export { renderTodos, TodoStore, todoTool } from "../sdk/index.js";
 export type { GitRunner, ShadowCheckpointOptions } from "./checkpoint.js";
-export { gitConfigNullDevice, ShadowCheckpointProvider } from "./checkpoint.js";
+export { gitConfigNullDevice, partialCheckpointNotice, ShadowCheckpointProvider, } from "./checkpoint.js";
 export { codingEnvironment, contextMessages, DEFAULT_INSTRUCTION_FALLBACKS, DEFAULT_PROJECT_ROOT_MARKERS, discoverContextFiles, environmentMessage, type InstructionDiagnostic, InstructionLoader, type InstructionLoaderOptions, type InstructionSettings, type InstructionSnapshot, type InstructionSource, } from "./context.js";
-export { CODING_PERMISSION_DEFAULTS, CODING_PERMISSION_MODES, layerPermissions, loadProjectConfig, rememberAllow, } from "./permissions.js";
+export { CODING_PERMISSION_DEFAULTS, CODING_PERMISSION_MODES, codingPermissionModes, layerPermissions, loadProjectConfig, localConfigPath, rememberAllow, } from "./permissions.js";
 export { codingPrompt } from "./prompts.js";
 export { shellCommand, terminateProcessTree, windowsTaskkillCommand } from "./shell.js";
 export { classifyShellCommand, isInspectionShellCommand, parseInspectionCommands, type ShellCommandClassification, } from "./shell-inspection.js";
+export { shellPermissionTargets } from "./shell-permissions.js";
 export { FileState } from "./state.js";
 export { bashTool } from "./tools/bash.js";
-export { editTool, lsTool, readTool, resolveInRoot, writeTool } from "./tools/files.js";
+export { editPreviewProbe, editTool, lsTool, readTool, resolveInRoot, writeTool, } from "./tools/files.js";
 export { shellSpawner, taskTools } from "./tools/tasks.js";
 export { MAX_OUTPUT_CHARS, truncateOutput, withNotice } from "./truncate.js";

package/dist/types/profile-coding/permissions.d.ts

@@ -1,12 +1,18 @@
-import type { PermissionMode, PermissionRule } from "../core/index.js";
+import type { PermissionMode, PermissionRule, SavedPermissionRule } from "../core/index.js";
 import { z } from "zod";
 import type { InstructionSettings } from "./context.js";
 export declare const CODING_PERMISSION_DEFAULTS: PermissionRule[];
+export declare function codingPermissionModes(configured?: PermissionRule[]): PermissionMode[];
 export declare const CODING_PERMISSION_MODES: PermissionMode[];
 export interface ProjectConfig {
     permissions?: PermissionRule[];
     model?: string;
     instructions?: InstructionSettings;
+    checkpoints?: {
+        enabled?: boolean | undefined;
+        include?: string[] | undefined;
+        [key: string]: unknown;
+    };
     [key: string]: unknown;
 }
 export declare const instructionSettingsSchema: z.ZodObject<{
@@ -16,7 +22,16 @@ export declare const instructionSettingsSchema: z.ZodObject<{
     imports: z.ZodOptional<z.ZodBoolean>;
     claudeRules: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
+export declare const checkpointSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
 export declare function configPath(root: string): string;
 export declare function loadProjectConfig(root: string, onWarning?: (message: string) => void): Promise<ProjectConfig>;
 export declare function layerPermissions(...layers: (PermissionRule[] | undefined)[]): PermissionRule[];
+export declare function localConfigPath(root: string): string;
+export declare function loadPermissionsFile(path: string, onWarning?: (message: string) => void): Promise<PermissionRule[]>;
 export declare function rememberAllow(root: string, permission: string, pattern: string): Promise<void>;
+export declare function savedPermissions(paths: string[]): Promise<SavedPermissionRule[]>;
+export declare function forgetPermission(rule: SavedPermissionRule): Promise<void>;
+export declare function saveCheckpointIncludes(root: string, include: string[]): Promise<void>;

package/dist/types/profile-coding/prompts.d.ts

@@ -1,5 +1,4 @@
 import type { PromptSection } from "../ai/index.js";
 export declare const CODING_SIDE_BOUNDARY = "This is a coding side conversation. Do not modify files, source, git state, configuration, or workspace state unless the user deliberately changes the side conversation's permission mode. Do not request broader permissions or use subagents.";
-export declare const CODING_SEARCH_PROMPT = "Use rg and rg --files through bash for broad discovery, then use read offsets and limits to inspect only the relevant ranges. Do not read a whole file merely to inspect one symbol or range. Ground every finding in exact workspace-relative paths and 1-based line ranges. Distinguish observed code behavior from hypotheses.";
 export declare const CODING_COUNSEL_PROMPT = "Inspect the current implementation and tests before judging. Cite exact workspace-relative paths and 1-based line ranges for the evidence behind the recommendation.";
 export declare function codingPrompt(modelRef: string): PromptSection[];

package/dist/types/profile-coding/shell-permissions.d.ts

@@ -0,0 +1,5 @@
+import type { PermissionTarget } from "../core/index.js";
+export declare function shellPermissionTargets(command: string, options?: {
+    background?: boolean;
+    platform?: NodeJS.Platform;
+}): PermissionTarget[];

package/dist/types/profile-coding/terminal-text.d.ts

@@ -0,0 +1 @@
+export declare function plainTerminalText(text: string): string;

package/dist/types/profile-coding/tools/bash.d.ts

@@ -1,4 +1,4 @@
-import { type ProcessManager } from "../../core/index.js";
+import { type ManagedProcessHandle, type ProcessManager } from "../../core/index.js";
 type OutputStream = "stdout" | "stderr";
 type OutputChunk = (text: string, stream: OutputStream) => void;
 interface SpawnResult {
@@ -6,11 +6,16 @@ interface SpawnResult {
     stderr: string;
     exitCode: number | null;
     timedOut: boolean;
+    backgrounded?: boolean;
+}
+export interface BackgroundHandOff {
+    signal: AbortSignal;
+    adopt: (handle: ManagedProcessHandle) => (chunk: string) => void;
 }
 export interface BashDeps {
     root: string;
     processes?: ProcessManager;
-    spawn?: (command: string, cwd: string, signal: AbortSignal, timeoutMs: number, onOutput?: OutputChunk) => Promise<SpawnResult>;
+    spawn?: (command: string, cwd: string, signal: AbortSignal, timeoutMs: number, onOutput?: OutputChunk, background?: BackgroundHandOff) => Promise<SpawnResult>;
 }
 export declare function bashTool(deps: BashDeps): import("../../sdk/index.js").Tool<{
     command: string;

package/dist/types/profile-coding/tools/diff.d.ts

@@ -0,0 +1,8 @@
+import type { CheckpointDiffFile } from "../../core/index.js";
+export declare function fileDiff(path: string, before: string | undefined, after: string): CheckpointDiffFile;
+export interface Replacement {
+    start: number;
+    end: number;
+    newString: string;
+}
+export declare function replacementDiff(path: string, content: string, replacements: readonly Replacement[]): CheckpointDiffFile;

package/dist/types/profile-coding/tools/files.d.ts

@@ -13,6 +13,7 @@ export interface ToolDeps {
 export declare function resolveInRoot(root: string, path: string): string;
 export declare function resolveExistingInRoot(root: string, path: string): Promise<string>;
 export declare function resolveForWriteInRoot(root: string, path: string): Promise<string>;
+export declare function checkpointResource(root: string, path: string): string;
 export declare function filePermissionDiff(path: string, before: string | undefined, after: string): CheckpointDiffFile;
 export declare function readTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
     path: string;
@@ -23,6 +24,10 @@ export declare function writeTool(deps: ToolDeps): import("../../sdk/index.js").
     path: string;
     content: string;
 }>;
+export declare function editPreviewProbe(root: string): {
+    occurrences(path: string, text: string): number | undefined;
+    exists(path: string): boolean | undefined;
+};
 export declare function coerceEditInput(raw: unknown): unknown;
 export declare function editTool(deps: ToolDeps): import("../../sdk/index.js").Tool<{
     path: string;

package/dist/types/profile-coding/tools/tasks.d.ts

@@ -1,8 +1,9 @@
 import { type ProcessManager, type Spawner } from "../../core/index.js";
 export declare function shellSpawner(root: string): Spawner;
-export declare function taskTools(manager: ProcessManager): (import("../../sdk/index.js").Tool<{
+export declare function taskTools(manager: ProcessManager, waiting?: Map<string, number>): (import("../../sdk/index.js").Tool<{
     taskId: string;
     full?: boolean | undefined;
+    timeoutMs?: number | undefined;
 }> | import("../../sdk/index.js").Tool<{
     taskId: string;
     data: string;

package/dist/types/profile-coding/track-commands.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "../core/index.js";
+import type { ShadowCheckpointProvider } from "./checkpoint.js";
+export interface TrackCommandOptions {
+    root: string;
+    checkpoints?: ShadowCheckpointProvider;
+    unavailable?: string;
+    save?: (root: string, include: string[]) => Promise<void>;
+}
+export declare function trackCommands(options: TrackCommandOptions): Command[];

package/dist/types/sdk/agent.d.ts

@@ -1,5 +1,5 @@
 import { type Credential, type ModelInfo, type PromptSection, type Provider, type ThinkingLevel, type Usage } from "../ai/index.js";
-import { type AgentEvent, type AgentMessage, type AnyTool, type CheckpointDiffFile, CheckpointHistory, type CheckpointProvider, type CustomMessage, type EventSink, type ExtensionHost, type PermissionRequest, type PermissionRule, type ProfileRuntime, type SessionStore, SessionTree, type UserContent } from "../core/index.js";
+import { type AgentEvent, type AgentMessage, type AnyTool, type CheckpointDiffFile, CheckpointHistory, type CheckpointProvider, type CustomMessage, type EventSink, type ExtensionHost, type PermissionReply, type PermissionRequest, type PermissionRule, type ProfileRuntime, type SessionStore, SessionTree, type UserContent } from "../core/index.js";
 import type { z } from "zod";
 import { type Budget } from "./budget.js";
 export type HaltReason = "done" | "aborted" | "error" | "maxTurns" | "maxCostUsd" | "maxTokens";
@@ -9,7 +9,7 @@ export interface AgentOptions {
     systemPrompt?: string | PromptSection[];
     tools?: AnyTool[];
     permissions?: PermissionRule[];
-    onPermission?: (request: PermissionRequest) => Promise<"allow" | "deny">;
+    onPermission?: (request: PermissionRequest) => Promise<PermissionReply>;
     budget?: Budget;
     session?: SessionStore;
     sessionId?: string;
@@ -28,6 +28,8 @@ export interface AgentOptions {
     imageRetentionTurns?: number;
     imageBudgetTokens?: number;
     checkpointProvider?: CheckpointProvider;
+    checkpointUnavailable?: string;
+    checkpointNotice?: string;
     runtime?: ProfileRuntime;
     extensions?: ExtensionHost;
 }
@@ -37,6 +39,7 @@ export interface RunResult {
     usage: Usage;
     reason: HaltReason;
     sessionId: string;
+    error?: string;
 }
 export interface CheckpointActionData {
     kind: "checkpoint";
@@ -69,6 +72,7 @@ export interface AgentRunOptions<T = unknown> {
     output?: z.ZodType<T>;
     model?: string | ModelInfo;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }
 export interface ChildAgentOptions {
     model?: ModelInfo;
@@ -79,6 +83,12 @@ export interface ChildAgentOptions {
     budget?: Budget;
     inheritContext?: boolean;
     refreshContext?: AgentOptions["refreshContext"];
+    permissionLabel?: string | (() => string | undefined);
+}
+export interface BackgroundWork {
+    label: string;
+    done: Promise<unknown>;
+    stop: (reason: "user" | "session") => void;
 }
 export declare class Agent {
     private readonly options;
@@ -90,6 +100,9 @@ export declare class Agent {
     private controller;
     private steering;
     private followUps;
+    private notices;
+    private noticesHeld;
+    private heldPublished;
     private totals;
     private compactRequested;
     private compactRequestedFocus;
@@ -102,9 +115,14 @@ export declare class Agent {
     private lastContextUsage;
     private readonly checkpoints;
     private recoveryAttempted;
+    private turnRetries;
     private reactiveRecoveryPending;
     private pendingCheckpoint;
+    private readonly runningTasks;
+    private readonly backgroundCalls;
     private currentThinking;
+    private requestedThinking;
+    private readonly thinkingNotices;
     private running;
     private stopping;
     private activeEmit;
@@ -116,8 +134,14 @@ export declare class Agent {
     private shutdownPromise;
     private sessionStarted;
     private permissionRules;
+    private parentAgent;
+    private inheritsPermissions;
+    private readonly children;
+    private readonly background;
     constructor(options?: AgentOptions);
     get sessionId(): string;
+    get checkpointUnavailable(): string | undefined;
+    get checkpointNotice(): string | undefined;
     get usage(): Usage;
     get session(): SessionTree;
     get sessionStore(): SessionStore;
@@ -128,12 +152,23 @@ export declare class Agent {
     get thinkingLevels(): ThinkingLevel[];
     get isRunning(): boolean;
     get isCompacting(): boolean;
+    get isStopping(): boolean;
     get permissions(): PermissionRule[];
+    get waitingOnUser(): {
+        reason: string;
+        done: Promise<void>;
+    } | undefined;
+    get backgroundWork(): string[];
     get tools(): AnyTool[];
     availableModel(ref: string): ModelInfo | undefined;
     createChild(options: ChildAgentOptions): Agent;
     setPermissions(rules: PermissionRule[]): void;
     addPermissionRule(rule: PermissionRule): void;
+    chargeUsage(usage: Usage): void;
+    trackBackground(work: BackgroundWork): void;
+    stopBackgroundWork(label: string): boolean;
+    waitForSettled(): Promise<void>;
+    recordMessage(message: CustomMessage): Promise<void>;
     setModel(ref: string | ModelInfo): void;
     refreshModelInfo(): boolean;
     setThinking(level: ThinkingLevel): void;
@@ -141,6 +176,10 @@ export declare class Agent {
     newSession(sessionId?: string): void;
     send(message: string): void;
     followUp(message: string | CustomMessage): void;
+    notify(message: CustomMessage): void;
+    private publishHeld;
+    private releaseHeld;
+    withdrawFollowUp(message: AgentMessage): boolean;
     removeQueuedMessage(kind: "steer" | "follow-up", text: string): boolean;
     emitTaskEvent(event: AgentEvent): void;
     subscribe(listener: EventSink): () => void;
@@ -149,8 +188,11 @@ export declare class Agent {
     stop(): void;
     shutdown(): Promise<void>;
     abort(): void;
+    get backgroundableCalls(): string[];
+    backgroundToolCalls(ids?: readonly string[]): string[];
     requestCompaction(focus?: string): void;
     compactNow(focus?: string): Promise<ManualCompactionResult>;
+    private releaseNotices;
     private executeManualCompaction;
     get checkpointHistory(): CheckpointHistory;
     undoPoints(): UndoPoint[];
@@ -179,6 +221,7 @@ export declare class Agent {
     private beginCheckpoint;
     private finishCheckpoint;
     private appendCheckpointCursor;
+    private captureCurrent;
     private restoreCheckpointResources;
     private checkpointDetails;
     private rebuildCheckpointHistory;
@@ -186,6 +229,13 @@ export declare class Agent {
     private executeRun;
     private compactionContextTokens;
     private providerFor;
+    private backgroundBlocker;
+    private effectivePermissionRules;
+    private stopBackground;
+    private combinedUsage;
+    private claimChildUsage;
+    private budgetBreach;
+    private budgetBreachWithChild;
     private resolveChildPermission;
     private publishEvent;
     private refreshContextAccounting;

package/dist/types/sdk/commands.d.ts

@@ -27,6 +27,7 @@ export interface CoreCommandHooks {
     }>;
     forkPoints?: () => ForkPoint[];
     diff?: () => Promise<CheckpointDiffFile[]>;
+    checkpointUnavailable?: string;
 }
 export declare function formatUsageBreakdown(usage: Usage & {
     contextPercent: number;

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

@@ -1,8 +1,8 @@
 export type { Credential, ModelDiscoveryOptions, ModelInfo, Provider, ProviderModelDiscoveryOptions, ThinkingLevel, Usage, WebSearchAction, WebSearchCitation, WebSearchContent, } from "../ai/index.js";
-export { builtinProviderConfigs, defaultModelId, defaultModelRef, defaultThinkingLevel, discoverModels, findModel, listModels, providerConfig, providerHasCredentials, refreshModels, registerModels, registerProvider, supportedThinkingLevels, thinkingLevelForModel, } from "../ai/index.js";
-export type { AgentEvent, AgentMessage, AnyTool, Command, CommandContext, CommandResult, CustomMessage, Extension, ExtensionAPI, ExtensionEvent, ExtensionEventFor, ExtensionEventType, LifecycleEvent, LifecycleNotification, PermissionMode, PermissionModeTone, PermissionRequest, PermissionRule, ProfileRuntime, ProfileRuntimeHost, SessionStore, StreamDelta, Tool, ToolRenderer, UserContent, } from "../core/index.js";
+export { builtinProviderConfigs, defaultModelId, defaultModelRef, defaultThinkingLevel, discoverModels, findModel, listModels, providerConfig, providerEnvVars, providerHasCredentials, refreshModels, registerModels, registerProvider, supportedThinkingLevels, thinkingEffort, thinkingLevelForModel, } from "../ai/index.js";
+export type { AgentEvent, AgentMessage, AnyTool, Command, CommandContext, CommandResult, CustomMessage, Extension, ExtensionAPI, ExtensionEvent, ExtensionEventFor, ExtensionEventType, LifecycleEvent, LifecycleNotification, PermissionMode, PermissionModeTone, PermissionReply, PermissionRequest, PermissionRule, PermissionTarget, ProfileRuntime, ProfileRuntimeHost, SavedPermissionRule, SessionStore, StreamDelta, Tool, ToolRenderer, UserContent, } from "../core/index.js";
 export { CommandRegistry, customMessage, ExtensionHost, errorResult, MemorySessionStore, SessionTree, textResult, userMessage, } from "../core/index.js";
-export type { AgentOptions, AgentRunOptions, CheckpointActionData, CheckpointActionResult, ChildAgentOptions, HaltReason, ManualCompactionResult, RunResult, UndoPoint, } from "./agent.js";
+export type { AgentOptions, AgentRunOptions, BackgroundWork, CheckpointActionData, CheckpointActionResult, ChildAgentOptions, HaltReason, ManualCompactionResult, RunResult, UndoPoint, } from "./agent.js";
 export { Agent } from "./agent.js";
 export type { AuthFile, AuthStoreOptions, OpenAiCallbackServer, OpenAiLoginOptions, OpenAiLoginResult, PlanLoginCallbackServer, PlanLoginOptions, PlanLoginResult, StoredApiKey, StoredCredential, StoredOpenAiOAuth, StoredPlanOAuth, } from "./auth.js";
 export { createCredentialResolver, defaultAuthFile, loginGitHubCopilot, loginKimiCoding, loginOpenAI, loginOpenRouter, loginXai, preferredAuthProvider, readAuthFile, removeStoredCredential, saveApiKey, storedAuthProviders, } from "./auth.js";
@@ -18,21 +18,23 @@ export type { FileSessionStoreOptions } from "./file-store.js";
 export { FileSessionStore } from "./file-store.js";
 export type { MarkdownCommand, MarkdownCommandOptions, MarkdownCommandRun, } from "./markdown-commands.js";
 export { loadMarkdownCommands, parseFrontmatter, parseMarkdownCommand, substituteArguments, toCommand, } from "./markdown-commands.js";
-export type { LoadMcpConfigOptions, McpConfigReport, McpStdioServerConfig, } from "./mcp.js";
-export { loadMcpConfig, mcpExtension } from "./mcp.js";
+export type { McpExtensionOptions } from "./mcp.js";
+export { MCP_CONTEXT_TYPE, mcpExtension } from "./mcp.js";
+export type { CatalogTool, ServerCatalog } from "./mcp-catalog.js";
+export { describeText, openText, signature, validateArgs } from "./mcp-catalog.js";
+export type { LoadMcpConfigOptions, McpApprovals, McpConfigReport, McpExposure, McpScope, McpServerSpec, McpSource, McpTransport, } from "./mcp-config.js";
+export { loadMcpApprovals, loadMcpConfig, updateUserServerEntry } from "./mcp-config.js";
 export type { Profile, ProfileImporter } from "./profile.js";
 export { loadProfile, optionsFromProfile } from "./profile.js";
 export type { HookEvent, HookRunner, HookSpec } from "./shell-hooks.js";
 export { shellHooksExtension } from "./shell-hooks.js";
 export type { SideConversation, SideConversationInput } from "./side.js";
 export { startSideConversation } from "./side.js";
-export type { Skill } from "./skills.js";
-export { defaultSkillRoots, discoverSkills, loadSkill, skillListing, skillsExtension, } from "./skills.js";
-export { STRUCTURED_OUTPUT_TOOL, structuredOutputPrompt, structuredOutputTool, } from "./structured-output.js";
-export type { SubagentDetails, SubagentExtensionOptions, SubagentKind, SubagentProgressUpdate, } from "./subagents.js";
-export { subagentsExtension } from "./subagents.js";
-export type { TodoItem } from "./todo.js";
-export { renderTodos, TodoStore, todoTool } from "./todo.js";
+export type { Skill, SkillCatalog, SkillRoot, SkillRootOptions, SkillScope, SkillSource, SkillsExtensionOptions, } from "./skills.js";
+export { describeSkillCatalog, discoverSkills, loadSkill, projectDirectories, SKILLS_CONTEXT_TYPE, skillListing, skillRoots, skillsExtension, } from "./skills.js";
+export { STRUCTURED_OUTPUT_TOOL, StructuredOutputError, structuredOutputPrompt, structuredOutputTool, } from "./structured-output.js";
+export type { BackgroundSubagentDetails, SubagentDetails, SubagentExtensionOptions, SubagentKind, SubagentProgressUpdate, SubagentRoute, SubagentRouteOverride, SubagentRoutesStyle, SubagentsCommandData, } from "./subagents.js";
+export { formatSubagentRoutes, subagentsExtension, subagentThinking } from "./subagents.js";
 export type { ToolDefinition, ToolResult } from "./tool.js";
 export { tool } from "./tool.js";
 export type { MarkdownTranscript, TranscriptMarkdownOptions, } from "./transcript-markdown.js";

package/dist/types/sdk/markdown-commands.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../core/index.js";
+import { type Command, type CustomMessage } from "../core/index.js";
 export interface MarkdownCommand {
     name: string;
     description: string;
@@ -11,6 +11,7 @@ export interface MarkdownCommandRun {
     prompt: string;
     model?: string;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }
 export declare function parseFrontmatter(source: string): {
     meta: Record<string, string | string[]>;
@@ -26,4 +27,5 @@ export declare function loadMarkdownCommands(options?: MarkdownCommandOptions):
 export declare function toCommand(markdown: MarkdownCommand, submit?: (prompt: string, options: {
     model?: string;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }) => unknown | Promise<unknown>): Command;

package/dist/types/sdk/mcp-catalog.d.ts

@@ -0,0 +1,36 @@
+export interface CatalogTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        [key: string]: unknown;
+    };
+}
+export interface ServerCatalog {
+    serverInfo?: {
+        name?: string;
+        title?: string;
+        version?: string;
+    };
+    instructions?: string;
+    tools: CatalogTool[];
+    resources: boolean;
+    fetchedAt: number;
+}
+type Schema = Record<string, any>;
+export declare const LARGE_SERVER_TOKENS = 1000;
+export declare function estimateTokens(text: string): number;
+export declare function firstSentence(text: string | undefined, max: number): string;
+export declare function signature(tool: CatalogTool): string;
+export declare function isLargeServer(catalog: ServerCatalog): boolean;
+export declare function openText(server: string, catalog: ServerCatalog): string;
+export declare function describeText(server: string, catalog: ServerCatalog, names: string[]): string;
+export declare function validateArgs(value: unknown, schema: Schema | undefined, path?: string): string[];
+export declare function listingLine(server: string, options: {
+    description?: string;
+    catalog?: ServerCatalog;
+    note?: string;
+}): string;
+export {};

package/dist/types/sdk/mcp-config.d.ts

@@ -0,0 +1,61 @@
+export type McpTransport = {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+} | {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+};
+export type McpSource = "mu" | "claude" | "codex" | "cursor" | "opencode" | "gemini" | "vscode";
+export type McpScope = "user" | "project";
+export type McpExposure = "open" | "direct";
+export interface McpServerSpec {
+    name: string;
+    transport: McpTransport;
+    source: McpSource;
+    scope: McpScope;
+    file: string;
+    enabled: boolean;
+    exposure: McpExposure;
+    description?: string;
+    includeTools?: string[];
+    excludeTools?: string[];
+    startupTimeoutMs?: number;
+    toolTimeoutMs?: number;
+}
+export interface McpConfigReport {
+    servers: McpServerSpec[];
+    shadowed: McpServerSpec[];
+    errors: {
+        file: string;
+        message: string;
+    }[];
+}
+export interface LoadMcpConfigOptions {
+    projectDir?: string;
+    home?: string;
+    userFile?: string;
+    foreign?: boolean;
+}
+type Raw = Record<string, unknown>;
+export declare function parseJsonc(text: string): unknown;
+export declare function transportFingerprint(transport: McpTransport): string;
+export declare function loadMcpConfig(options?: LoadMcpConfigOptions): Promise<McpConfigReport>;
+export declare function expandVariables(value: string, env: Record<string, string | undefined>, extra?: Record<string, string>): {
+    value: string;
+    missing: string[];
+};
+export declare function expandTransport(transport: McpTransport, env: Record<string, string | undefined>, extra?: Record<string, string>): {
+    transport: McpTransport;
+    missing: string[];
+};
+export interface McpApprovals {
+    isApproved(projectDir: string, spec: McpServerSpec): boolean;
+    approve(projectDir: string, spec: McpServerSpec): Promise<void>;
+}
+export declare function loadMcpApprovals(file: string): Promise<McpApprovals>;
+export declare function updateUserServerEntry(file: string, name: string, patch: Raw): Promise<void>;
+export {};

package/dist/types/sdk/mcp.d.ts

@@ -1,22 +1,16 @@
 import { type Extension } from "../core/index.js";
-export interface McpStdioServerConfig {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    startupTimeoutMs?: number;
-    toolTimeoutMs?: number;
-}
-export interface McpConfigReport {
-    servers: Record<string, McpStdioServerConfig>;
-    errors: {
-        file: string;
-        message: string;
-    }[];
-}
-export interface LoadMcpConfigOptions {
+import { type McpApprovals, type McpConfigReport, type McpServerSpec } from "./mcp-config.js";
+export declare const MCP_CONTEXT_TYPE = "mcp_servers";
+export interface McpExtensionOptions {
+    servers: McpServerSpec[];
+    shadowed?: McpServerSpec[];
+    errors?: McpConfigReport["errors"];
     projectDir?: string;
+    approvals?: McpApprovals;
+    cacheDir?: string | false;
     userFile?: string;
+    env?: Record<string, string | undefined>;
+    home?: string;
+    warm?: boolean;
 }
-export declare function loadMcpConfig(options?: LoadMcpConfigOptions): Promise<McpConfigReport>;
-export declare function mcpExtension(servers: Record<string, McpStdioServerConfig>): Extension;
+export declare function mcpExtension(options: McpExtensionOptions): Extension;

package/dist/types/sdk/skills.d.ts

@@ -1,12 +1,46 @@
-import type { Extension } from "../core/index.js";
+import { type AgentMessage, type CustomMessage, type Extension } from "../core/index.js";
+export type SkillSource = "mu" | "agents" | "claude" | "codex" | "opencode";
+export type SkillScope = "project" | "user";
+export interface SkillRoot {
+    directory: string;
+    scope: SkillScope;
+    source: SkillSource;
+}
 export interface Skill {
     name: string;
     description: string;
     body: string;
     directory: string;
+    scope: SkillScope;
+    source: SkillSource;
+    disableModelInvocation: boolean;
+    userInvocable: boolean;
+    allowedTools?: string[];
+}
+export interface SkillCatalog {
+    skills: Skill[];
+    shadowed: Skill[];
+    warnings: string[];
 }
-export declare function loadSkill(directory: string): Promise<Skill | undefined>;
-export declare function discoverSkills(roots: string[]): Promise<Skill[]>;
-export declare function defaultSkillRoots(projectDir?: string): string[];
+export interface SkillRootOptions {
+    home?: string;
+    projectDirs?: string[];
+}
+export declare function skillRoots(options?: SkillRootOptions): SkillRoot[];
+export declare function loadSkill(directory: string, root?: Pick<SkillRoot, "scope" | "source">): Promise<Skill | string>;
+export declare function discoverSkills(roots: SkillRoot[]): Promise<SkillCatalog>;
+export declare const SKILLS_CONTEXT_TYPE = "skills";
 export declare function skillListing(skills: Skill[]): string;
-export declare function skillsExtension(skills: Skill[]): Extension;
+export declare function snapshotMessage(type: string, text: string): CustomMessage;
+export declare function refreshedSnapshot(messages: AgentMessage[], type: string, text: string): AgentMessage[];
+export declare function skillContent(skill: Skill, files: string[]): string;
+export declare function describeSkillCatalog(catalog: SkillCatalog): string;
+export interface SkillsExtensionOptions {
+    roots: SkillRoot[];
+    catalog?: SkillCatalog;
+}
+export declare function skillsExtension(options: SkillsExtensionOptions): Extension;
+export declare function projectDirectories(cwd: string, options?: {
+    home?: string;
+    markers?: string[];
+}): Promise<string[]>;

package/dist/types/sdk/structured-output.d.ts

@@ -1,5 +1,12 @@
-import type { AnyTool } from "../core/index.js";
+import { type AnyTool, type CustomMessage } from "../core/index.js";
 import { z } from "zod";
+import type { RunResult } from "./agent.js";
 export declare const STRUCTURED_OUTPUT_TOOL = "structured_output";
 export declare function structuredOutputTool<Schema extends z.ZodType>(schema: Schema, capture: (value: z.infer<Schema>) => void): AnyTool;
 export declare function structuredOutputPrompt(): string;
+export declare const STRUCTURED_OUTPUT_REMINDERS = 2;
+export declare function structuredOutputReminder(): CustomMessage;
+export declare class StructuredOutputError extends Error {
+    readonly result: RunResult;
+    constructor(message: string, result: RunResult);
+}