@mu-agent/mu 0.2.4 → 0.3.1

package/dist/types/profile-browser/agent/permissions.d.ts

@@ -22,3 +22,4 @@ export declare function browserPermissionModes(hosts?: PermissionRule[]): Permis
 export declare function rememberedPermissionsPath(home: string): string;
 export declare function loadRememberedPermissions(home: string, onWarning?: (message: string) => void): PermissionRule[];
 export declare function rememberAllow(home: string, permission: string, pattern: string): PermissionRule[];
+export declare function forgetRemembered(home: string, permission: string, pattern: string): 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;
 }

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/context.d.ts

@@ -2,6 +2,7 @@ import { type AgentMessage } from "../core/index.js";
 export declare const DEFAULT_PROJECT_ROOT_MARKERS: string[];
 export declare const DEFAULT_INSTRUCTION_FALLBACKS: string[];
 export declare const INSTRUCTION_PRIMARY_NAMES: string[];
+export declare const SNAPSHOT_TYPE_PREFIX = "project-instructions-";
 export interface InstructionSettings {
     enabled?: boolean;
     fallbackFilenames?: string[];

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, codingSideAccess, 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,19 @@
-import type { PermissionMode, PermissionRule } from "../core/index.js";
+import type { PermissionMode, PermissionRule, ProfileSideAccess, 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 function codingSideAccess(configured?: PermissionRule[]): ProfileSideAccess;
 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 +23,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_SIDE_BOUNDARY = "This is a read-only coding side conversation for answering questions about the session, the project and what the main agent is doing. You can read files, list directories, run read-only shell commands and read background task output; anything else is denied. When an answer needs a command that changes state or runs a build or tests, say so instead of attempting it.";
 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,7 +1,8 @@
 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";
+import { type CostReport, type ExternalUsageData, type UsageLine } from "./cost-report.js";
 export type HaltReason = "done" | "aborted" | "error" | "maxTurns" | "maxCostUsd" | "maxTokens";
 export interface AgentOptions {
     model?: string | ModelInfo;
@@ -9,7 +10,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,8 +29,13 @@ export interface AgentOptions {
     imageRetentionTurns?: number;
     imageBudgetTokens?: number;
     checkpointProvider?: CheckpointProvider;
+    checkpointUnavailable?: string;
+    checkpointNotice?: string;
     runtime?: ProfileRuntime;
     extensions?: ExtensionHost;
+    toolNames?: string[];
+    extensionContext?: boolean;
+    contextLabel?: (customType: string) => string | undefined;
 }
 export interface RunResult {
     text: string;
@@ -37,6 +43,7 @@ export interface RunResult {
     usage: Usage;
     reason: HaltReason;
     sessionId: string;
+    error?: string;
 }
 export interface CheckpointActionData {
     kind: "checkpoint";
@@ -51,6 +58,17 @@ export interface CheckpointActionResult {
     message: string;
     data?: CheckpointActionData;
 }
+export interface ForkPoint {
+    id: string;
+    prompt: string;
+}
+export interface ForkResult {
+    ok: boolean;
+    message: string;
+    sessionId?: string;
+    sourceSessionId?: string;
+    prompt?: string;
+}
 export interface UndoPoint {
     steps: number;
     prompt: string;
@@ -69,6 +87,7 @@ export interface AgentRunOptions<T = unknown> {
     output?: z.ZodType<T>;
     model?: string | ModelInfo;
     allowedTools?: string[];
+    context?: CustomMessage[];
 }
 export interface ChildAgentOptions {
     model?: ModelInfo;
@@ -79,6 +98,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,7 +115,11 @@ export declare class Agent {
     private controller;
     private steering;
     private followUps;
+    private notices;
+    private noticesHeld;
+    private heldPublished;
     private totals;
+    private ledger;
     private compactRequested;
     private compactRequestedFocus;
     private queuedManualCompactionFocus;
@@ -102,9 +131,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 +150,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 +168,25 @@ 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, lines?: UsageLine[]): void;
+    trackBackground(work: BackgroundWork): void;
+    stopBackgroundWork(label: string): boolean;
+    waitForSettled(): Promise<void>;
+    recordMessage(message: CustomMessage): Promise<void>;
+    recordExternalUsage(data: ExternalUsageData): Promise<void>;
+    costReport(): CostReport;
     setModel(ref: string | ModelInfo): void;
     refreshModelInfo(): boolean;
     setThinking(level: ThinkingLevel): void;
@@ -141,6 +194,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,22 +206,20 @@ 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[];
     undo(turnCount?: number): Promise<CheckpointActionResult>;
     redo(): Promise<CheckpointActionResult>;
     sessionDiff(): Promise<Awaited<ReturnType<CheckpointProvider["diff"]>>>;
-    forkPoints(): {
-        id: string;
-        description: string;
-    }[];
-    fork(entryId: string): Promise<{
-        ok: boolean;
-        message: string;
-    }>;
+    forkPoints(): ForkPoint[];
+    createFork(beforeEntryId?: string): Promise<ForkResult>;
+    fork(beforeEntryId?: string): Promise<ForkResult>;
     get contextPercent(): number;
     get contextTokens(): number;
     run<T>(prompt: string | UserContent[], opts: AgentRunOptions<T> & {
@@ -179,13 +234,28 @@ export declare class Agent {
     private beginCheckpoint;
     private finishCheckpoint;
     private appendCheckpointCursor;
+    private captureCurrent;
     private restoreCheckpointResources;
     private checkpointDetails;
     private rebuildCheckpointHistory;
     private execute;
     private executeRun;
+    private runContextState;
+    private recordRunUsage;
+    private prepareRunContext;
+    private recoverRunError;
+    private finishRunTurn;
+    private summarize;
+    private appendCompactionAttempt;
     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

@@ -1,9 +1,16 @@
-import type { Usage } from "../ai/index.js";
 import { type CheckpointDiffFile, type Command, CommandRegistry } from "../core/index.js";
-import type { CheckpointActionResult, ManualCompactionResult, UndoPoint } from "./agent.js";
-export interface ForkPoint {
-    id: string;
-    description: string;
+import type { CheckpointActionResult, ForkPoint, ForkResult, ManualCompactionResult, UndoPoint } from "./agent.js";
+import type { CostReport } from "./cost-report.js";
+export type { ForkPoint } from "./agent.js";
+export interface ForkPointsCommandData {
+    kind: "fork-points";
+    points: ForkPoint[];
+}
+export interface ForkedCommandData {
+    kind: "forked";
+    sessionId: string;
+    sourceSessionId: string;
+    prompt?: string;
 }
 export interface DiffCommandData {
     kind: "diff";
@@ -15,21 +22,14 @@ export interface UndoPointsCommandData {
 }
 export interface CoreCommandHooks {
     requestCompaction?: (focus?: string) => ManualCompactionResult | undefined | Promise<ManualCompactionResult | undefined>;
-    usage?: () => Usage & {
-        contextPercent: number;
-    };
+    costReport?: () => CostReport;
     undo?: (turnCount?: number) => Promise<CheckpointActionResult>;
     undoPoints?: () => UndoPoint[];
     redo?: () => Promise<CheckpointActionResult>;
-    fork?: (entryId: string) => Promise<{
-        ok: boolean;
-        message: string;
-    }>;
+    fork?: (beforeEntryId?: string) => Promise<ForkResult>;
     forkPoints?: () => ForkPoint[];
     diff?: () => Promise<CheckpointDiffFile[]>;
+    checkpointUnavailable?: string;
 }
-export declare function formatUsageBreakdown(usage: Usage & {
-    contextPercent: number;
-}): string;
 export declare function coreCommands(hooks?: CoreCommandHooks): Command[];
 export declare function registryWithCoreCommands(hooks?: CoreCommandHooks): CommandRegistry;

package/dist/types/sdk/cost-report.d.ts

@@ -0,0 +1,64 @@
+import { type PromptSection, type Usage } from "../ai/index.js";
+import { type AgentMessage } from "../core/index.js";
+export type UsageSource = "main" | "subagents" | "tools" | "compaction" | "other" | (string & {});
+export interface UsageLine {
+    source: UsageSource;
+    model: string;
+    usage: Usage;
+    turns: number;
+}
+export interface ContextPart {
+    id: "system" | "tools" | "context" | "summary" | "messages" | "toolResults";
+    label: string;
+    tokens: number;
+    count?: number;
+    children?: {
+        id: string;
+        tokens: number;
+    }[];
+}
+export interface ContextBreakdown {
+    tokens: number;
+    window: number;
+    reported: boolean;
+    autoCompactAt: number;
+    parts: ContextPart[];
+}
+export interface CostReport {
+    kind: "cost";
+    totals: Usage;
+    lines: UsageLine[];
+    context: ContextBreakdown;
+}
+export declare class UsageLedger {
+    private lines;
+    add(line: UsageLine): void;
+    list(): UsageLine[];
+    clear(): void;
+}
+export declare function usageDelta(after: Usage, before: Usage): Usage;
+export declare function attachedUsageLines(usage: Usage, details: unknown, fallbackModel: string): UsageLine[];
+export interface ExternalUsageData {
+    source: UsageSource;
+    model: string;
+    usage: Usage;
+    turns: number;
+}
+export declare const EXTERNAL_USAGE_TYPE = "usage";
+export declare function isExternalUsageData(value: unknown): value is ExternalUsageData;
+export interface ContextBreakdownInput {
+    systemPrompt: PromptSection[];
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: unknown;
+    }[];
+    messages: AgentMessage[];
+    compactions: number;
+    tokens: number;
+    window: number;
+    reported: boolean;
+    autoCompactAt: number;
+    label?: (customType: string) => string | undefined;
+}
+export declare function contextBreakdown(input: ContextBreakdownInput): ContextBreakdown;

package/dist/types/sdk/file-store.d.ts

@@ -5,11 +5,14 @@ export interface FileSessionStoreOptions {
 }
 export declare class FileSessionStore implements SessionStore {
     private readonly dir;
+    private readonly written;
+    private readonly queue;
     constructor(options?: FileSessionStoreOptions);
     private path;
     private fallbackId;
     load(sessionId: string): Promise<SessionTree | undefined>;
     save(sessionId: string, tree: SessionTree): Promise<void>;
+    private write;
     list(): Promise<string[]>;
     delete(sessionId: string): Promise<boolean>;
 }