agent-afk 5.330.0 → 5.331.0

package/dist/agent/daemon/handoff-store.d.ts

@@ -3,6 +3,7 @@ export interface HandoffRoute {
     chatId: number;
     threadId?: number;
 }
+export declare const HANDOFF_STORE_NO_RECORD_PREFIX: "handoff-store: no record found";
 export interface UpdateHandoffResult {
     won: boolean;
 }

package/dist/agent/dag-subagent.d.ts

@@ -42,5 +42,7 @@ export interface SubagentDAGOptions {
     nodeTimeoutMs?: number;
     delegationBudget?: DelegationBudget;
     anchorCwd?: string;
+    defaultSubagentModel?: AgentModelInput;
+    defaultModel?: AgentModelInput;
 }
 export declare function runSubagentDAG(options: SubagentDAGOptions): Promise<DAGRunResult>;

package/dist/agent/file-checkpoint/file-checkpoint.d.ts

@@ -1,6 +1,7 @@
 export interface FileCheckpointRegistry {
     snapshotFile(absPath: string): Promise<void>;
     readonly turnId: string;
+    touchedPaths(): string[];
 }
 export interface FileSnapshot {
     absPath: string;

package/dist/agent/file-checkpoint/retention.d.ts

@@ -0,0 +1,29 @@
+import { type DirStats } from '../_lib/dir-newest-mtime.js';
+export declare const FILE_CHECKPOINT_MAX_AGE_DAYS_DEFAULT = 14;
+export declare const FILE_CHECKPOINT_MAX_BYTES_DEFAULT: number;
+export declare const FILE_CHECKPOINT_GRACE_MS: number;
+export declare const FILE_CHECKPOINT_SWEEP_MIN_INTERVAL_MS: number;
+export declare const FILE_CHECKPOINT_SWEEP_START_DELAY_MS = 5000;
+export declare function markCheckpointOwner(sessionId: string, stateDir?: string): void;
+export declare function acquireRewindLock(sessionId: string, stateDir?: string): () => void;
+export interface FileCheckpointSweepOptions {
+    root?: string;
+    activeSessionId?: string | undefined;
+    maxAgeDays?: number;
+    maxBytes?: number;
+    force?: boolean;
+    now?: number;
+}
+export interface FileCheckpointSweepResult {
+    skipped: boolean;
+    scanned: number;
+    evicted: string[];
+    freedBytes: number;
+}
+type Measured = {
+    name: string;
+    path: string;
+} & DirStats;
+export declare function chooseEvictions(dirs: readonly Measured[], now: number, maxAgeMs: number, maxBytes: number): Measured[];
+export declare function sweepFileCheckpoints(options?: FileCheckpointSweepOptions): Promise<FileCheckpointSweepResult>;
+export {};

package/dist/agent/file-checkpoint/rewind-files.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderRewindResult } from '../provider.js';
+import type { ProviderRewindResult, RewindFilesOptions } from '../provider.js';
 import type { ToolHandlerContext } from '../tools/types.js';
 export interface RewindFilesDeps {
     sessionId: string;
@@ -6,6 +6,4 @@ export interface RewindFilesDeps {
     writePolicy?: ToolHandlerContext;
     _stateDir?: string;
 }
-export declare function rewindFiles(deps: RewindFilesDeps, turnId: string, options?: {
-    dryRun?: boolean;
-}): Promise<ProviderRewindResult>;
+export declare function rewindFiles(deps: RewindFilesDeps, turnId: string, options?: RewindFilesOptions): Promise<ProviderRewindResult>;

package/dist/agent/file-checkpoint/rewind-plan.d.ts

@@ -0,0 +1,11 @@
+import { type FileSnapshot } from './file-checkpoint.js';
+export interface RewindPlan {
+    snapshots: FileSnapshot[];
+    expected: Map<string, string | null>;
+}
+export type RewindPlanResult = {
+    plan: RewindPlan;
+} | {
+    missing: true;
+};
+export declare function planRewind(sessionId: string, turnId: string, stateDir?: string): RewindPlanResult;

package/dist/agent/file-checkpoint/turn-lifecycle.d.ts

@@ -0,0 +1,7 @@
+import { type FileCheckpointRegistry } from './file-checkpoint.js';
+import type { RewindTarget } from '../provider.js';
+export declare function beginCheckpointTurn(sessionId: string, turnId: string, stateDir?: string): FileCheckpointRegistry;
+export declare function endCheckpointTurn(sessionId: string, registry: FileCheckpointRegistry | undefined, stateDir?: string): void;
+export declare function linkCheckpointTurn(message: object, turnId: string): void;
+export declare function checkpointTurnIdFor(message: object | undefined): string | undefined;
+export declare function withCheckpointTurnIds(targets: RewindTarget[], history: readonly object[]): RewindTarget[];

package/dist/agent/file-checkpoint/turn-log.d.ts

@@ -0,0 +1,22 @@
+export type PathHashes = Record<string, string | null>;
+export type TurnLogEntry = {
+    kind: 'turn';
+    turnId: string;
+    ts: number;
+} | {
+    kind: 'post';
+    turnId: string;
+    paths: PathHashes;
+    ts: number;
+} | {
+    kind: 'restore';
+    paths: PathHashes;
+    ts: number;
+};
+export declare function hashBytes(bytes: Buffer | null): string | null;
+export declare function currentHash(absPath: string): string | null;
+export declare function appendTurnLog(sessionId: string, entry: TurnLogEntry, stateDir?: string): boolean;
+export declare function readTurnLog(sessionId: string, stateDir?: string): TurnLogEntry[];
+export declare function turnsFrom(log: readonly TurnLogEntry[], turnId: string): string[] | undefined;
+export declare function expectedHashes(log: readonly TurnLogEntry[]): Map<string, string | null>;
+export declare function hashPaths(paths: Iterable<string>): PathHashes;

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

@@ -83,7 +83,7 @@ export interface JournalAdoption {
     readonly count: number;
 }
 export type JournalTruncateReason = 'resync' | 'compact' | 'rewind' | 'clear' | 'repair' | 'provider_switch';
-export type JournalMarkLabel = 'compact' | 'rewind' | 'clear' | 'resume' | 'fork' | 'model_switch' | 'suggestion';
+export type JournalMarkLabel = 'compact' | 'rewind' | 'clear' | 'resume' | 'fork' | 'model_switch' | 'suggestion' | 'checkpoint';
 export type JournalSuggestionDetail = {
     event: 'generated' | 'accepted' | 'word_accepted' | 'dismissed';
     source: 'completion' | 'prompt';

package/dist/agent/provider.d.ts

@@ -183,9 +183,7 @@ export interface ProviderQuery extends AsyncIterable<ProviderEvent> {
     getContextUsage(): Promise<ProviderContextUsage>;
     mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
     accountInfo(): Promise<ProviderAccountInfo>;
-    rewindFiles(userMessageId: string, options?: {
-        dryRun?: boolean;
-    }): Promise<ProviderRewindResult>;
+    rewindFiles(userMessageId: string, options?: RewindFilesOptions): Promise<ProviderRewindResult>;
     compact?(): Promise<ProviderCompactResult>;
     listRewindTargets?(): RewindTarget[];
     rewindConversation?(turnIndex: number): Promise<ProviderRewindConversationResult>;
@@ -281,6 +279,16 @@ export interface ProviderRewindResult {
     filesChanged?: string[];
     insertions?: number;
     deletions?: number;
+    failures?: RewindFileFailure[];
+    conflicts?: string[];
+}
+export interface RewindFileFailure {
+    path: string;
+    error: string;
+}
+export interface RewindFilesOptions {
+    dryRun?: boolean;
+    overwriteConflicts?: boolean;
 }
 export interface ProviderCompactResult {
     compacted: boolean;
@@ -297,6 +305,7 @@ export interface ProviderCompactResult {
 export interface RewindTarget {
     turnIndex: number;
     preview: string;
+    checkpointTurnId?: string;
 }
 export interface ProviderRewindConversationResult {
     rewound: boolean;

package/dist/agent/providers/openai-compatible/query/journal-wiring.d.ts

@@ -15,5 +15,6 @@ export declare class OpenAIJournalWiring {
     afterCompact(turns: readonly OpenAIMessage[], result: ProviderCompactResult): void;
     microcompactFallback(turns: OpenAIMessage[]): ProviderCompactResult | null;
     snapshot(turns: readonly OpenAIMessage[]): JournalMessage[] | undefined;
+    syncRewind(turns: readonly OpenAIMessage[], turnIndex: number): void;
     sync(turns: readonly OpenAIMessage[], compacted?: boolean): void;
 }

package/dist/agent/providers/openai-compatible/query/turn-iteration.d.ts

@@ -13,6 +13,9 @@ import type { OpenAIJournalWiring } from './journal-wiring.js';
 import type { TraceSink } from '../../../trace/index.js';
 import type { OpenAIAuthResolution } from '../auth.js';
 export interface IterationContext {
+    readonly checkpoint?: {
+        linkUserTurn(message: object, messageIndex: number): void;
+    };
     readonly currentModel: string;
     readonly currentPermissionMode: string;
     readonly closed: boolean;
@@ -37,5 +40,5 @@ export interface FinishTurnContext {
     lastUsage: ProviderUsage | null;
 }
 export declare function finishTurn(ctx: FinishTurnContext, accumulatedUsage: ProviderUsage, turnStartTime: number): Generator<ProviderEvent>;
-export declare function pushUserTurn(ctx: IterationContext, content: import('../../../provider.js').ProviderUserTurn['content']): void;
+export declare function pushUserTurn(ctx: IterationContext, content: import('../../../provider.js').ProviderUserTurn['content'], linkCheckpoint?: boolean): void;
 export declare function runIteration(ctx: IterationContext, controller: AbortController, vision: boolean, windDown: typeof TOOL_USE_LOOP_CAPPED | typeof SOFT_DEADLINE_WIND_DOWN | typeof CONTEXT_PRESSURE_WIND_DOWN | null): AsyncGenerator<ProviderEvent, IterationResult | null>;

package/dist/agent/providers/openai-compatible/query.d.ts

@@ -6,6 +6,7 @@ import type { OpenAIFunctionTool } from './loop.js';
 import { type WireMode } from './responses-config.js';
 import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
 import { AbortCoordinator } from '../shared/abort-coordinator.js';
+import { FileCheckpointState } from './query.file-checkpoint.js';
 import { OpenAIJournalWiring } from './query/journal-wiring.js';
 import { resolveReasoningEffort } from './query/model-params.js';
 import { FastTierSession } from './query/fast-tier-session.js';
@@ -57,7 +58,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery, TurnDriverC
     get closed(): boolean;
     lastUsage: ProviderUsage | null;
     private readonly autoCompactThreshold;
-    private readonly checkpoint;
+    readonly checkpoint: FileCheckpointState;
     constructor(opts: OpenAICompatibleQueryOptions);
     activeOpenAITools(): OpenAIFunctionTool[] | undefined;
     [Symbol.asyncIterator](): AsyncIterator<ProviderEvent>;
@@ -83,9 +84,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery, TurnDriverC
     getContextUsage(): Promise<ProviderContextUsage>;
     mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
     accountInfo(): Promise<ProviderAccountInfo>;
-    rewindFiles(userMessageId: string, options?: {
-        dryRun?: boolean;
-    }): Promise<ProviderRewindResult>;
+    rewindFiles(userMessageId: string, options?: import('../../provider.js').RewindFilesOptions): Promise<ProviderRewindResult>;
     journalSnapshot(): ReturnType<OpenAIJournalWiring['snapshot']>;
     close(): void;
 }

package/dist/agent/providers/openai-compatible/query.file-checkpoint.d.ts

@@ -1,14 +1,17 @@
 import type { ToolHandlerContext } from '../../tools/types.js';
-import type { ProviderEvent, ProviderRewindResult } from '../../provider.js';
+import type { ProviderEvent, ProviderRewindResult, RewindFilesOptions } from '../../provider.js';
+import type { MessageJournal } from '../../journal/types.js';
 export declare class FileCheckpointState {
     private readonly enabled;
     private readonly sessionId;
+    private readonly journal?;
     private currentTurnId;
-    constructor(enabled: boolean, sessionId: string);
+    private registry;
+    private markedTurnId;
+    constructor(enabled: boolean, sessionId: string, journal?: MessageJournal | undefined);
     begin(dispatcher: object | undefined, userMessageId?: string): string | undefined;
+    linkUserTurn(message: object, messageIndex: number): void;
     end(dispatcher: object | undefined): void;
     events(events: AsyncIterable<ProviderEvent>, dispatcher: object | undefined, checkpointId: string | undefined): AsyncGenerator<ProviderEvent>;
-    rewind(userMessageId: string, options?: {
-        dryRun?: boolean;
-    }, writePolicy?: ToolHandlerContext): Promise<ProviderRewindResult>;
+    rewind(userMessageId: string, options?: RewindFilesOptions, writePolicy?: ToolHandlerContext): Promise<ProviderRewindResult>;
 }

package/dist/agent/providers/router/provider-router.d.ts

@@ -1,4 +1,4 @@
-import type { ModelProvider, ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderCommandInfo, ProviderModelInfo, ProviderAgentInfo, ProviderContextUsage, ProviderMcpServerStatus, ProviderAccountInfo, ProviderRewindResult, ProviderRewindConversationResult, ProviderCompactResult, RewindTarget } from '../../provider.js';
+import type { ModelProvider, ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderCommandInfo, ProviderModelInfo, ProviderAgentInfo, ProviderContextUsage, ProviderMcpServerStatus, ProviderAccountInfo, ProviderRewindResult, RewindFilesOptions, ProviderRewindConversationResult, ProviderCompactResult, RewindTarget } from '../../provider.js';
 import type { AgentConfig } from '../../types/config-types.js';
 import type { JournalMessage } from '../../journal/index.js';
 export interface ProviderRouterDeps {
@@ -57,9 +57,7 @@ export declare class ProviderRouter implements ProviderQuery {
     getContextUsage(): Promise<ProviderContextUsage>;
     mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
     accountInfo(): Promise<ProviderAccountInfo>;
-    rewindFiles(userMessageId: string, options?: {
-        dryRun?: boolean;
-    }): Promise<ProviderRewindResult>;
+    rewindFiles(userMessageId: string, options?: RewindFilesOptions): Promise<ProviderRewindResult>;
     compact(): Promise<ProviderCompactResult>;
     journalSnapshot(): JournalMessage[] | undefined;
     listRewindTargets(): RewindTarget[];

package/dist/agent/session/agent-session.d.ts

@@ -80,10 +80,12 @@ export declare class AgentSession implements IAgentSession {
     accountInfo(): Promise<AccountInfo>;
     rewindFiles(userMessageId: string, options?: {
         dryRun?: boolean;
+        overwriteConflicts?: boolean;
     }): Promise<RewindFilesResult>;
     compact(): Promise<ProviderCompactResult>;
     listRewindTargets(): RewindTarget[];
     rewindConversation(turnIndex: number): Promise<ProviderRewindConversationResult>;
+    sealEventLedger(): Promise<void>;
     private makeCompactDeps;
     getLastResponseMetadata(): ResponseMetadata | null;
     getOutputStream(): AsyncIterable<OutputEvent>;

package/dist/agent/session/session-compact.d.ts

@@ -5,6 +5,7 @@ export interface CompactDeps {
     setState: (s: SessionState) => void;
     getProviderQuery: () => ProviderQuery;
 }
+export declare function makeCompactDeps(getState: CompactDeps['getState'], setState: CompactDeps['setState'], getProviderQuery: CompactDeps['getProviderQuery']): CompactDeps;
 export declare function compactSession(deps: CompactDeps): Promise<ProviderCompactResult>;
 export declare function listRewindTargets(deps: CompactDeps): RewindTarget[];
 export declare function rewindConversation(turnIndex: number, deps: CompactDeps): Promise<ProviderRewindConversationResult>;

package/dist/agent/session-control/clear.d.ts

@@ -0,0 +1,5 @@
+import type { AgentSession } from '../session.js';
+import type { SessionStats } from '../../cli/slash/types.js';
+export declare function clearConversation(session: Pick<AgentSession, 'reset'>, stats: SessionStats, ledger?: {
+    clear(): void;
+}): Promise<void>;

package/dist/agent/session-control/compact.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSession } from '../session.js';
+export type CompactProgress = (phase: 'start' | 'end') => void;
+export type CompactConversationResult = Awaited<ReturnType<AgentSession['compact']>> & {
+    promptsBefore: number;
+    promptsAfter: number;
+};
+type CompactSession = Pick<AgentSession, 'hookRegistry' | 'sessionId' | 'listRewindTargets' | 'compact'>;
+export declare function compactConversation(session: CompactSession, progress?: CompactProgress): Promise<CompactConversationResult>;
+export {};

package/dist/agent/session-control/index.d.ts

@@ -0,0 +1,5 @@
+export { clearConversation } from './clear.js';
+export { compactConversation, type CompactConversationResult, type CompactProgress } from './compact.js';
+export { setSessionModel, type SetSessionModelResult } from './model.js';
+export { setSessionName, type SetSessionNameResult, type SessionNameOptions, THINKING_MODES, getSessionThinking, setSessionThinking, readSessionFast, setSessionFast, } from './preferences.js';
+export { readSubscriptionUsage, readContextUsage, readLocalTokenUsage, readTokenUsage, readMcpStatus, readMcpOauthPending, type ContextUsage, type LocalTokenUsage, type TokenUsage, } from './reads.js';

package/dist/agent/session-control/model.d.ts

@@ -0,0 +1,11 @@
+import type { AgentSession } from '../session.js';
+import type { AgentModelInput } from '../types.js';
+import type { SessionStats } from '../../cli/slash/types.js';
+export type SetSessionModelResult = {
+    ok: true;
+    model: AgentModelInput;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function setSessionModel(session: Pick<AgentSession, 'setModel'>, stats: SessionStats, target: string): Promise<SetSessionModelResult>;

package/dist/agent/session-control/preferences.d.ts

@@ -0,0 +1,30 @@
+import type { SessionStats, ThinkingUiMode } from '../../cli/slash/types.js';
+import type { FastModeContext, FastModeController, FastModePreference, FastModeStatus } from '../fast-mode.js';
+export interface SessionNameOptions {
+    onName?: (name: string) => void;
+    persist?: (stats: SessionStats) => void;
+}
+export type SetSessionNameResult = {
+    ok: false;
+} | {
+    ok: true;
+    name: string;
+    saved: boolean;
+    saveError?: unknown;
+};
+export declare function setSessionName(stats: SessionStats, raw: string, options?: SessionNameOptions): SetSessionNameResult;
+export declare const THINKING_MODES: readonly ThinkingUiMode[];
+export declare function getSessionThinking(stats: Pick<SessionStats, 'thinkingUi'>): ThinkingUiMode;
+export declare function setSessionThinking(stats: Pick<SessionStats, 'thinkingUi'>, value: string): {
+    ok: true;
+    mode: ThinkingUiMode;
+} | {
+    ok: false;
+};
+export declare function readSessionFast(controller: FastModeController, context: FastModeContext): FastModeStatus;
+export declare function setSessionFast(controller: FastModeController, value: string): {
+    ok: true;
+    preference: FastModePreference;
+} | {
+    ok: false;
+};

package/dist/agent/session-control/reads.d.ts

@@ -0,0 +1,28 @@
+import type { AgentSession } from '../session.js';
+import type { SessionStats } from '../../cli/slash/types.js';
+import { fetchSubscriptionUsage } from '../subscription-usage.js';
+export type ContextUsage = Awaited<ReturnType<AgentSession['getContextUsage']>>;
+export interface LocalTokenUsage {
+    kind: 'local';
+    input: number;
+    output: number;
+    cache: number;
+    total: number;
+    contextUsed: number;
+    contextLimit: number;
+    percentage: number;
+    model: SessionStats['model'];
+}
+export type TokenUsage = {
+    kind: 'sdk';
+    usage: ContextUsage;
+} | LocalTokenUsage;
+export declare function readSubscriptionUsage(): ReturnType<typeof fetchSubscriptionUsage>;
+export declare function readContextUsage(session: Pick<AgentSession, 'getContextUsage'>): Promise<ContextUsage>;
+export declare function readLocalTokenUsage(stats: SessionStats): LocalTokenUsage;
+export declare function readTokenUsage(session: Pick<AgentSession, 'getContextUsage'>, stats: SessionStats): Promise<TokenUsage>;
+export declare function readMcpStatus(session: Pick<AgentSession, 'waitForInitialization'>): Promise<{
+    name: string;
+    status: string;
+}[]>;
+export declare function readMcpOauthPending(): Promise<Record<string, import("../mcp/oauth.js").OauthPendingEntry>>;

package/dist/agent/session-ledger-reader.d.ts

@@ -2,7 +2,14 @@ import type { LedgerRecord } from './session-ledger.js';
 export declare function parseRecord(line: string): LedgerRecord | null;
 export declare function ledgerExists(sessionId: string): Promise<boolean>;
 export declare function readLedger(sessionId: string): AsyncGenerator<LedgerRecord>;
+export declare function ledgerGeneration(stat: {
+    dev: number;
+    ino: number;
+    birthtimeMs: number;
+}): string;
 export declare function tailLedger(sessionId: string, opts?: {
     fromStart?: boolean;
     signal?: AbortSignal;
+    onGeneration?: (generation: string) => void;
+    onCaughtUp?: () => void;
 }): AsyncGenerator<LedgerRecord>;

package/dist/agent/subagent/fork-child-config.d.ts

@@ -25,6 +25,7 @@ export interface AssembleChildConfigArgs<T> {
     parentSurface: Surface | undefined;
     parentCanUseTool: CanUseTool | undefined;
     parentRootSessionId: string | undefined;
+    yieldEnabled?: boolean;
     nestedAgentAllowlist?: readonly string[];
 }
 export type ParentForkFields = Pick<AssembleChildConfigArgs<unknown>, 'parentCwd' | 'parentApiKey' | 'parentBaseUrl' | 'parentProvider' | 'parentTraceWriter' | 'parentSurface' | 'parentCanUseTool' | 'parentRootSessionId'>;

package/dist/agent/subagent/fork-types.d.ts

@@ -36,6 +36,7 @@ export interface ForkSubagentOptions<T = unknown> {
     progressEvents?: boolean;
     phaseRole?: PhaseRole;
     nestedAgentAllowlist?: readonly string[];
+    yieldEnabled?: boolean;
     modelFallback?: {
         model: string;
         buildProvider?: (model: string) => import('../provider.js').ModelProvider;

package/dist/agent/subagent/identity-preamble.d.ts

@@ -6,6 +6,7 @@ export interface SubagentIdentityFacts {
     maxDepth: number | undefined;
     nestedAgentAllowlist?: readonly string[];
     cwd?: string;
+    yieldEnabled?: boolean;
 }
 export declare function renderSubagentIdentityPreamble(facts: SubagentIdentityFacts): string;
-export declare function injectSubagentIdentityPreamble(config: AgentConfig, nestedAgentAllowlist?: readonly string[]): AgentConfig;
+export declare function injectSubagentIdentityPreamble(config: AgentConfig, nestedAgentAllowlist?: readonly string[], yieldEnabled?: boolean): AgentConfig;

package/dist/agent/subagent/result.d.ts

@@ -58,7 +58,14 @@ export interface SubagentResult<T = unknown> extends Partial<CappedHandoff> {
         continuable: boolean;
     };
     setupNotice?: string;
+    needsInput?: {
+        question: string;
+        summary?: string;
+        assumption?: string;
+        onceAnswered?: string;
+    };
 }
+export declare function detectNeedsInput(content: string): SubagentResult['needsInput'] | undefined;
 export declare function buildResultFromMessage<T>(id: string, status: SubagentStatus, message: Message, outputSchema: ZodType<T> | undefined, trace?: SubagentTrace, stopReason?: string): SubagentResult<T>;
 export declare function buildResultFromError<T>(id: string, status: SubagentStatus, err: unknown, trace?: SubagentTrace, stopReason?: string): SubagentResult<T>;
 export declare function describeFailure(result: Pick<SubagentResult, 'status' | 'error'>): string;

package/dist/agent/tools/handlers/lsp-symbols.d.ts

@@ -9,7 +9,7 @@ export interface LspSymbolResult {
     error?: string;
 }
 export type SymbolSubcommand = 'definition' | 'references';
-export declare const DEFAULT_LSP_CMD: readonly string[];
+export declare const DEFAULT_LSP_CMD: readonly ["typescript-language-server", "--stdio"];
 export declare function parseLocation(raw: unknown): LspLocation | null;
 export declare function isLspSymbolsEnabled(): boolean;
 export declare function queryLspSymbol(filePath: string, subcommand: SymbolSubcommand, line: number, col: number, rootDir?: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<LspSymbolResult>;

package/dist/agent/tools/subagent/foreground-handoff.d.ts

@@ -1,5 +1,7 @@
 import type { RunForegroundArgs, PromotedSubagentInfo } from './foreground-promotion.js';
 import type { ToolResult } from '../types.js';
+import type { SubagentResult } from '../../subagent/result.js';
+import type { ContinuationResultFields } from './continuation-dispatch.js';
 import type { QueuedNoteClaim } from './queued-note.js';
 import { type BackgroundDelivery } from './background-delivery.js';
 import { type teardownIsolatedWorktree } from '../handlers/worktree-managed.js';
@@ -19,4 +21,7 @@ export declare function prepareForegroundRun(args: RunForegroundArgs): {
 export declare function emitForegroundRejection(args: Pick<RunForegroundArgs, 'identity' | 'handle' | 'idPrefix' | 'parentSessionId' | 'depth'>, err: unknown, startedAt: number): void;
 export declare function foregroundCompletionResult(args: Pick<RunForegroundArgs, 'handle' | 'identity' | 'parentSessionId' | 'depth' | 'model' | 'parentModel' | 'idPrefix'>, result: Awaited<RunPromise>, startedAt: number): ToolResult;
 export declare function adoptForegroundRun(args: Pick<RunForegroundArgs, 'handle' | 'backgroundPrompt' | 'model' | 'parentSessionId' | 'budgetRelease'>, registry: NonNullable<RunForegroundArgs['registry']>, runPromise: RunPromise, isoTd: RunForegroundArgs['isolationTeardown']): import("../../background-registry.types.js").BackgroundJob;
+export declare function prependNeedsInputHeader(result: ToolResult & ContinuationResultFields & {
+    _needsInput?: SubagentResult['needsInput'];
+}): void;
 export {};

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

@@ -146,6 +146,11 @@ export interface RewindFilesResult {
     filesChanged?: string[];
     insertions?: number;
     deletions?: number;
+    failures?: Array<{
+        path: string;
+        error: string;
+    }>;
+    conflicts?: string[];
 }
 export interface IAgentSession {
     readonly state: SessionState;
@@ -184,6 +189,7 @@ export interface IAgentSession {
     accountInfo(): Promise<AccountInfo>;
     rewindFiles?(userMessageId: string, options?: {
         dryRun?: boolean;
+        overwriteConflicts?: boolean;
     }): Promise<RewindFilesResult>;
     compact(): Promise<ProviderCompactResult>;
     listRewindTargets(): RewindTarget[];

package/dist/cli/commands/interactive/bootstrap-session-builder.d.ts

@@ -32,6 +32,7 @@ export interface BuildAgentSessionDeps {
     maxTurns: number;
     autoResumeOnUsageLimit: boolean | undefined;
     permissionMode?: PermissionMode;
+    enableFileCheckpointing?: boolean;
     baseUrl?: string;
     temperature?: number;
     explicitProvider?: string;

package/dist/cli/config/types.d.ts

@@ -62,6 +62,7 @@ export interface CliConfig {
     theme?: 'dark' | 'light' | 'umber' | 'auto';
     autoResumeOnUsageLimit?: boolean;
     enforceDoneEvidence?: boolean;
+    fileCheckpoints?: boolean;
     bgSummaries?: boolean;
     maxSummaryCallsPerSession?: number;
     hooks?: RawHooksConfig;
@@ -137,6 +138,7 @@ export interface ConfigFileSchema {
     theme?: 'dark' | 'light' | 'umber' | 'auto';
     autoResumeOnUsageLimit?: boolean;
     enforceDoneEvidence?: boolean;
+    fileCheckpoints?: boolean;
     bgSummaries?: boolean;
     maxSummaryCallsPerSession?: number;
     hooks?: RawHooksConfig;

package/dist/cli/slash/capabilities.d.ts

@@ -0,0 +1,8 @@
+import type { SlashCommand } from './types.js';
+export type SurfaceCapability = 'tty' | 'choose' | 'progress' | 'sessionControl' | 'permissionMode' | 'conversationRetry' | 'hostCredentials' | 'shellJobs' | 'consoleOutput';
+export declare function commandRequirements(command: Pick<SlashCommand, 'name' | 'requires'>): readonly SurfaceCapability[];
+export declare function withCommandRequirements(command: SlashCommand): SlashCommand;
+export declare function missingCapabilities(command: Pick<SlashCommand, 'name' | 'requires'>, provided: ReadonlySet<SurfaceCapability>): SurfaceCapability[];
+export declare function webCapabilities(): ReadonlySet<SurfaceCapability>;
+export declare function capabilityReason(capability: SurfaceCapability): string;
+export declare function telegramCapabilities(): ReadonlySet<SurfaceCapability>;

package/dist/cli/slash/commands/core.rewind.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const rewindCmd: SlashCommand;

package/dist/cli/slash/commands/info.session.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const infoCmd: SlashCommand;

package/dist/cli/slash/commands/info.tokens.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const tokensCmd: SlashCommand;

package/dist/cli/slash/commands/info.usage.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../types.js';
+export declare const usageCmd: SlashCommand;

package/dist/cli/slash/interaction.d.ts

@@ -0,0 +1,18 @@
+export interface ChoiceRequest {
+    corrId: string;
+    title: string;
+    options: readonly {
+        value: string;
+        label: string;
+        description?: string;
+    }[];
+    default?: string;
+    cancellable?: boolean;
+}
+export type Choose = (request: ChoiceRequest) => Promise<string | null>;
+export interface ProgressEvent {
+    corrId: string;
+    phase: 'start' | 'update' | 'end';
+    label: string;
+    fraction?: number;
+}

package/dist/cli/slash/interaction.repl.d.ts

@@ -0,0 +1,6 @@
+import type { Choose, ProgressEvent } from './interaction.js';
+import type { SlashContext } from './types.js';
+export declare function createReplInteractions(ctx: Pick<SlashContext, 'out' | 'getCompositor'>): {
+    choose: Choose;
+    progress: (event: ProgressEvent) => void;
+};

package/dist/cli/slash/output-blocks.d.ts

@@ -0,0 +1,38 @@
+export { writeTable, writeKeyValue, writeDiff, writeList, writeLink } from './output-blocks.format.js';
+type Fallback = {
+    text: string;
+    ansi: string;
+};
+export type OutputBlock = Fallback & ({
+    kind: 'text';
+} | {
+    kind: 'table';
+    title?: string;
+    columns: string[];
+    rows: string[][];
+} | {
+    kind: 'keyValue';
+    title?: string;
+    entries: Array<{
+        key: string;
+        value: string;
+    }>;
+} | {
+    kind: 'diff';
+    diff: string;
+    fileName?: string;
+} | {
+    kind: 'list';
+    title?: string;
+    items: Array<{
+        text: string;
+        description?: string;
+    }>;
+} | {
+    kind: 'link';
+    url: string;
+    label: string;
+});
+export type BlockData<K extends OutputBlock['kind']> = Omit<Extract<OutputBlock, {
+    kind: K;
+}>, 'kind' | 'text' | 'ansi'>;

package/dist/cli/slash/output-blocks.format.d.ts

@@ -0,0 +1,15 @@
+import type { BlockData, OutputBlock } from './output-blocks.js';
+import type { Writer } from './types.js';
+export declare function writeTable(out: Writer, data: BlockData<'table'>, legacy: () => void): void;
+export declare function writeKeyValue(out: Writer, data: BlockData<'keyValue'>, legacy: () => void): void;
+export declare function writeDiff(out: Writer, data: BlockData<'diff'>, legacy: () => void): void;
+export declare function writeList(out: Writer, data: BlockData<'list'>, legacy: () => void): void;
+export declare function writeLink(out: Writer, data: BlockData<'link'>, legacy: () => void): void;
+type StructuredKind = Exclude<OutputBlock['kind'], 'text'>;
+type StructuredData = {
+    [K in StructuredKind]: {
+        kind: K;
+    } & BlockData<K>;
+}[StructuredKind];
+export declare function formatOutputBlock(data: StructuredData): OutputBlock;
+export {};