@mu-agent/mu 0.2.3 → 0.3.0

package/dist/types/profile-browser/browser/lease.d.ts

@@ -0,0 +1,22 @@
+export interface LeaseHolder {
+    pid: number;
+    host: string;
+    token: string;
+    since: string;
+}
+export declare function profileInUseMessage(holder: LeaseHolder, profileName: string): string;
+export declare class ProfileInUseError extends Error {
+    readonly holder: LeaseHolder;
+    constructor(holder: LeaseHolder, profileName: string);
+}
+export declare function liveHolder(userDataDir: string): LeaseHolder | undefined;
+export declare class ProfileLease {
+    readonly userDataDir: string;
+    readonly profileName: string;
+    private readonly token;
+    private timer;
+    constructor(userDataDir: string, profileName: string);
+    acquire(): void;
+    release(): void;
+    private hold;
+}

package/dist/types/profile-browser/browser/manager.d.ts

@@ -4,6 +4,7 @@ import { SecretRegistry } from "../page/secrets.js";
 import { type BrowserLauncher, type ConnectedBrowser } from "./connect.js";
 import { DownloadTracker } from "./downloads.js";
 import type { Size } from "./launch.js";
+import { ProfileLease } from "./lease.js";
 import { Tab, type TabInfo } from "./tabs.js";
 export interface BrowserManagerOptions {
     connect: "managed" | "cdp";
@@ -18,6 +19,7 @@ export interface BrowserManagerOptions {
     keepOpen: boolean;
     launcher?: BrowserLauncher | undefined;
     downloadsDir?: string | undefined;
+    hostAllowed?: ((url: string) => boolean) | undefined;
 }
 export interface BrowserStatus {
     mode: "managed" | "cdp";
@@ -57,6 +59,7 @@ declare class SharedBrowser {
     nextTab: number;
     nextLane: number;
     closingIntentionally: boolean;
+    lease: ProfileLease | undefined;
     product: {
         product: string;
         version: string;
@@ -68,6 +71,7 @@ declare class SharedBrowser {
     readonly downloads: DownloadTracker;
     readonly secrets: SecretRegistry;
     readonly dataflow: DataFlowGuard;
+    readonly blockedLoads: Map<string, string>;
     constructor(downloadsDir: string | undefined);
 }
 export declare class BrowserManager {
@@ -101,6 +105,9 @@ export declare class BrowserManager {
     drainNotices(): string[];
     ensureConnected(signal?: AbortSignal): Promise<CdpConnection>;
     private connect;
+    private guardNewPages;
+    private guardPage;
+    private agentOwned;
     private requireCdpUrl;
     private onDisconnect;
     private tabIdFor;
@@ -112,6 +119,8 @@ export declare class BrowserManager {
     private own;
     private info;
     tabs(): TabInfo[];
+    tabPattern(tabId?: string): string | undefined;
+    userTab(tab: Tab): boolean;
     openedSince(since: number, openerTargetIds: string[]): TabInfo[];
     private attach;
     activeTab(signal?: AbortSignal): Promise<Tab>;

package/dist/types/profile-browser/browser/tabs.d.ts

@@ -16,6 +16,8 @@ export interface JsDialog {
     message: string;
     defaultPrompt?: string;
 }
+export declare function blockOffHostLoads(session: CdpSession, mainFrameId: () => string, hostAllowed: (url: string) => boolean, onBlocked: (url: string) => void): () => void;
+export declare function enableLoadBlocking(session: CdpSession, signal?: AbortSignal): Promise<unknown>;
 export declare class Tab {
     readonly tabId: string;
     readonly targetId: string;
@@ -36,6 +38,9 @@ export declare class Tab {
     } | undefined;
     lastFingerprint: string | undefined;
     unchangedStreak: number;
+    blockedNavigation: string | undefined;
+    errorPage: boolean;
+    private repeats;
     private readonly offs;
     private constructor();
     static attach(connection: CdpConnection, target: {
@@ -45,7 +50,8 @@ export declare class Tab {
     }, tabId: string, openedByAgent: boolean, signal?: AbortSignal, emulateViewport?: {
         width: number;
         height: number;
-    }): Promise<Tab>;
+    }, hostAllowed?: (url: string) => boolean): Promise<Tab>;
+    countRepeat(documentId: string, key: string): number;
     get detached(): boolean;
     info(active: boolean): TabInfo;
     dispose(): void;

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

@@ -1,12 +1,10 @@
 import { type AgentMessage, type Profile } from "../core/index.js";
-import { TodoStore } from "../sdk/index.js";
 import { type CommitLedger, type NotesStore } from "./agent/state.js";
 import { BrowserManager } from "./browser/manager.js";
 import { type BrowserProfileOptions, type ResolvedBrowserOptions } from "./config.js";
 export interface BrowserProfile extends Profile {
     browser: BrowserManager;
     config: ResolvedBrowserOptions;
-    todos: TodoStore;
     notes: NotesStore;
     ledger: CommitLedger;
 }
@@ -18,4 +16,5 @@ export { BrowserManager };
 export { closeManaged, managedState } from "./browser/connect.js";
 export { discoverBrowser } from "./browser/discover.js";
 export { launchForSignIn } from "./browser/launch.js";
+export { type LeaseHolder, liveHolder, ProfileInUseError, profileInUseMessage, } from "./browser/lease.js";
 export default browserProfile;

package/dist/types/profile-browser/page/model.d.ts

@@ -35,6 +35,7 @@ export interface PageNode {
     options?: string[];
     optionCount?: number;
     cursorOnly?: boolean;
+    focusable?: boolean;
     form?: {
         post: boolean;
         submit?: boolean;

package/dist/types/profile-browser/page/text.d.ts

@@ -1,9 +1,11 @@
 import type { PageModel, PageNode } from "./model.js";
 export declare const READ_PAGE_CHARS = 12000;
-export declare function pageMarkdown(model: PageModel): {
+export interface PageText {
     markdown: string;
+    full: string;
     scope: string;
-};
+}
+export declare function pageMarkdown(model: PageModel): PageText;
 export declare function filterSections(markdown: string, query: string): string;
 export declare function paginate(text: string, offset: number, size?: number): {
     chunk: string;

package/dist/types/profile-browser/testing/fixture-site.d.ts

@@ -3,6 +3,7 @@ export interface FixtureSite {
     origin: string;
     crossOrigin: string;
     url: (page: string) => string;
+    requests: string[];
     submissions: Record<string, unknown>[];
     signups: {
         email: string;

package/dist/types/profile-browser/tools/shared.d.ts

@@ -11,7 +11,14 @@ export interface BrowserToolDeps {
     notes?: () => string;
 }
 export declare const observationKey: (slot: number) => string;
+export declare function repeatNudge(tab: Tab, documentId: string, tool: string, key: string): string | undefined;
 export type ActResult = ActionResult;
+export interface HostBlock {
+    result: ActResult;
+    withhold: boolean;
+}
+export declare function enforceHosts(deps: BrowserToolDeps, tab: Tab, signal: AbortSignal): Promise<HostBlock | undefined>;
+export declare function withheldResult(block: HostBlock, tab: Tab, stopwatch: Stopwatch): ToolResult;
 export interface PageActionOptions {
     blockedByDialog?: boolean;
     screenshot?: boolean;
@@ -19,5 +26,7 @@ export interface PageActionOptions {
     subtreeRef?: string;
     detectChange?: boolean;
     tabSwitch?: boolean;
+    leavesPage?: boolean;
+    repeatTool?: string;
 }
 export declare function pageAction(deps: BrowserToolDeps, toolSignal: AbortSignal, act: (tab: Tab, stopwatch: Stopwatch, signal: AbortSignal) => Promise<ActResult>, options?: PageActionOptions): Promise<ToolResult>;

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

@@ -2,33 +2,67 @@ import type { CheckpointDiffFile, CheckpointProvider } from "../core/index.js";
 export interface ShadowCheckpointOptions {
     root: string;
     shadowDir?: string;
+    home?: string;
     scope?: string;
     run?: GitRunner;
+    include?: string[];
+    coverage?: "full" | "declared";
 }
-export type GitRunner = (args: string[], env: Record<string, string>, cwd: string) => Promise<{
+export interface GitRunOptions {
+    signal?: AbortSignal;
+    stdin?: string;
+    background?: boolean;
+}
+export type GitRunner = (args: string[], env: Record<string, string>, cwd: string, options?: GitRunOptions) => Promise<{
     stdout: string;
     stderr: string;
     exitCode: number;
 }>;
 export declare function gitConfigNullDevice(platform?: NodeJS.Platform): string;
+export declare function partialCheckpointNotice(root: string, home?: string, run?: GitRunner): Promise<string | undefined>;
 export declare class ShadowCheckpointProvider implements CheckpointProvider {
+    readonly coverage: "full" | "declared";
     private readonly root;
     private readonly shadowDir;
     private readonly run;
     private readonly lockDir;
-    private readonly excludedPathspecs;
+    private readonly excludedPrefixes;
+    private included;
     private initialized;
+    private lastMaintenance;
+    private maintenance;
     constructor(options: ShadowCheckpointOptions);
     get directory(): string;
+    get includedPaths(): string[];
+    setIncludedPaths(paths: string[]): void;
+    workspacePath(path: string): string;
+    private isIncluded;
     private env;
     private git;
+    private cancellableGit;
+    private workspaceGit;
+    private isExcluded;
     private acquireLock;
     private locked;
     private ensure;
-    private ignoredDisposableDirectories;
-    private checkpointPathspecs;
-    snapshot(label?: string): Promise<string | undefined>;
+    private workspacePaths;
+    private updateIndex;
+    private stage;
+    snapshot(label?: string, signal?: AbortSignal): Promise<string | undefined>;
+    settled(): Promise<void>;
+    private startMaintenance;
+    private maintain;
+    private capture;
+    private commit;
+    snapshotResources(baseRef: string | undefined, resources: string[], label?: string): Promise<string | undefined>;
+    private captureResources;
+    private buildTree;
+    private recordedPaths;
+    private head;
+    private resourceScope;
+    private requireCheckpoints;
     restore(ref: string): Promise<void>;
+    private removeEmptyParents;
     restoreResources(ref: string, resources: string[]): Promise<void>;
     diff(fromRef: string, toRef?: string): Promise<CheckpointDiffFile[]>;
 }

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,18 +152,34 @@ 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;
     resume(tree: SessionTree): void;
     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;
@@ -148,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[];
@@ -178,6 +221,7 @@ export declare class Agent {
     private beginCheckpoint;
     private finishCheckpoint;
     private appendCheckpointCursor;
+    private captureCurrent;
     private restoreCheckpointResources;
     private checkpointDetails;
     private rebuildCheckpointHistory;
@@ -185,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";