agent-afk 5.265.2 → 5.266.0

package/dist/agent/_lib/dir-newest-mtime.d.ts

@@ -0,0 +1,5 @@
+export interface DirStats {
+    newestMtimeMs: number;
+    bytes: number;
+}
+export declare function newestMtimeAndBytes(dir: string): Promise<DirStats>;

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

@@ -3,6 +3,7 @@ import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import type { AgentModelInput, CanUseTool, IAgentSession } from './types.js';
 import type { ModelProvider } from './provider.js';
 import type { SubagentManager } from './subagent.js';
+import type { JournalParent } from './subagent/fork-types.js';
 import { type DAGEdge, type DAGRunResult } from './dag.js';
 import type { DelegationBudget } from './tools/delegation-budget.js';
 import type { ImageBlockAttachment } from './content/image-blocks.js';
@@ -32,7 +33,7 @@ export interface SubagentDAGNode {
 }
 export interface SubagentDAGOptions {
     manager: SubagentManager;
-    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'>;
+    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'> & JournalParent;
     nodes: SubagentDAGNode[];
     edges: DAGEdge[];
     failFast?: boolean;

package/dist/agent/journal/append-queue.d.ts

@@ -0,0 +1,17 @@
+export type OnceReporter = (what: string, err?: unknown) => void;
+export declare function createOnceReporter(label: string): OnceReporter;
+export declare class SerialQueue {
+    private readonly onError;
+    private tail;
+    constructor(onError: (err: unknown) => void);
+    push(task: () => Promise<void>): void;
+    idle(): Promise<void>;
+}
+export declare class JsonlFileAppender {
+    readonly path: string;
+    private dirReady;
+    constructor(path: string);
+    write(data: string): Promise<void>;
+    private ensureDir;
+    private append;
+}

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

@@ -0,0 +1,14 @@
+import type { BlobRef } from './types.js';
+export interface PendingBlob {
+    ref: BlobRef;
+    data: Buffer;
+    absPath: string;
+}
+export declare function extForMediaType(mediaType: string): string;
+export declare function makePendingBlob(sessionId: string, sha256: string, data: Buffer, mediaType: string): PendingBlob;
+export declare function resolveBlobPath(ref: BlobRef): string | null;
+export declare function readBlob(ref: BlobRef): Buffer | null;
+export declare class BlobStore {
+    private readonly inFlight;
+    write(blob: PendingBlob): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export declare function forkJournal(sourceSessionId: string, newSessionId: string): boolean;

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

@@ -0,0 +1,4 @@
+import type { JournalBlock, JournalMessage, JournalResultPart } from './types.js';
+export declare function hydratePart(p: JournalResultPart): JournalResultPart;
+export declare function hydrateBlock(b: JournalBlock): JournalBlock;
+export declare function hydrateMessage(m: JournalMessage): JournalMessage;

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

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { JournalSync, type SyncOptions } from './sync.js';
+export { createMessageJournal, isMessageJournalDisabled, type CreateMessageJournalOptions } from './writer.js';
+export { findToolResult, foldJournal, hydrateMessages, journalExists, listSubagentJournals, loadJournalFold, loadJournalMessages, readJournalRecords, type FoldResult, type JournalLocator, } from './reader.js';
+export { forkJournal } from './fork.js';

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

@@ -0,0 +1,37 @@
+import { type OnceReporter } from './append-queue.js';
+import type { BlobStore } from './blobs.js';
+import { type JournalRecordInput } from './types.js';
+export declare const MAX_BUFFERED_RECORDS = 10000;
+export interface JournalSessionShared {
+    getSessionId: () => string | undefined;
+    meta: {
+        provider?: string;
+        model?: string;
+        cwd?: string;
+    };
+    blobs: BlobStore;
+    report: OnceReporter;
+}
+export declare class JournalFileWriter {
+    private readonly shared;
+    readonly subagentId?: string | undefined;
+    private readonly writerId;
+    private readonly queue;
+    private resolved;
+    private failed;
+    private closed;
+    private metaWritten;
+    private buffered;
+    private bufferedDropped;
+    private len;
+    constructor(shared: JournalSessionShared, subagentId?: string | undefined);
+    get length(): number;
+    get isClosed(): boolean;
+    record(input: JournalRecordInput): void;
+    private recordUnsafe;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private tryResolve;
+    private enqueue;
+    private metaLine;
+}

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

@@ -0,0 +1,3 @@
+import type { MessageJournal } from './types.js';
+export declare function isMessageJournalDisabled(): boolean;
+export declare const NOOP_JOURNAL: MessageJournal;

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

@@ -0,0 +1,24 @@
+import type { JournalBlock, JournalMessage, JournalRecord } from './types.js';
+export interface JournalLocator {
+    subagentId?: string;
+}
+export interface FoldResult {
+    messages: JournalMessage[];
+    meta: Extract<JournalRecord, {
+        kind: 'meta';
+    }> | undefined;
+    anomalies: string[];
+}
+export declare function journalExists(sessionId: string, loc?: JournalLocator): boolean;
+export declare function readJournalRecords(sessionId: string, loc?: JournalLocator): JournalRecord[];
+export declare function foldJournal(records: readonly JournalRecord[]): FoldResult;
+export declare function loadJournalFold(sessionId: string, loc?: JournalLocator): FoldResult | null;
+export declare function hydrateMessages(messages: readonly JournalMessage[]): JournalMessage[];
+export declare function loadJournalMessages(sessionId: string, loc?: JournalLocator): JournalMessage[] | null;
+export declare function findToolResult(sessionId: string, toolUseId: string): {
+    block: Extract<JournalBlock, {
+        type: 'tool_result';
+    }>;
+    subagentId?: string;
+} | null;
+export declare function listSubagentJournals(sessionId: string): string[];

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

@@ -0,0 +1,13 @@
+import { type JournalRecord, type JournalRecordInput } from './types.js';
+export declare function parseJournalLine(line: string): JournalRecord | null;
+export interface JournalFileRead {
+    exists: boolean;
+    records: JournalRecord[];
+    malformedLines: number;
+    endsWithNewline: boolean;
+}
+export declare function readJournalFile(path: string): JournalFileRead;
+type LengthInput = JournalRecord | JournalRecordInput;
+export declare function nextLength(len: number, rec: LengthInput): number;
+export declare function foldLength(records: readonly LengthInput[]): number;
+export {};

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

@@ -0,0 +1,9 @@
+import { type PendingBlob } from './blobs.js';
+import type { JournalMessage } from './types.js';
+export declare const SPILL_TEXT_BYTES: number;
+export declare const PREVIEW_CHARS: number;
+export interface SpillResult {
+    message: JournalMessage;
+    blobs: PendingBlob[];
+}
+export declare function spillMessage(sessionId: string, message: JournalMessage): SpillResult;

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

@@ -0,0 +1,18 @@
+import type { JournalAdapter, JournalMessage, JournalTruncateReason, MessageJournal } from './types.js';
+export interface SyncOptions {
+    reason?: JournalTruncateReason;
+}
+export declare class JournalSync<T> {
+    private readonly journal;
+    private readonly adapter;
+    private committed;
+    private lenAfter;
+    private seeded;
+    constructor(journal: MessageJournal | undefined, adapter: JournalAdapter<T>);
+    get enabled(): boolean;
+    seed(messages: readonly T[]): void;
+    sync(messages: readonly T[], opts?: SyncOptions): void;
+    invalidateFrom(index: number): void;
+    snapshot(): JournalMessage[];
+    private mapAll;
+}

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

@@ -0,0 +1,121 @@
+export declare const JOURNAL_VERSION: 1;
+export interface BlobRef {
+    path: string;
+    bytes: number;
+    sha256: string;
+    mediaType: string;
+}
+export type JournalBinary = {
+    kind: 'base64';
+    mediaType: string;
+    data: string;
+} | {
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'ref';
+    ref: BlobRef;
+};
+export type JournalResultPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'text_ref';
+    ref: BlobRef;
+    preview: string;
+} | {
+    type: 'image';
+    source: JournalBinary;
+} | {
+    type: 'document';
+    source: JournalBinary;
+    title?: string;
+};
+export type JournalBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'text_ref';
+    ref: BlobRef;
+    preview: string;
+} | {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+} | {
+    type: 'redacted_thinking';
+    data: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    isError?: boolean;
+    content: JournalResultPart[];
+} | {
+    type: 'image';
+    source: JournalBinary;
+} | {
+    type: 'document';
+    source: JournalBinary;
+    title?: string;
+};
+export interface JournalMessage {
+    role: 'user' | 'assistant';
+    content: JournalBlock[];
+}
+export type JournalTruncateReason = 'resync' | 'compact' | 'rewind' | 'clear' | 'repair' | 'provider_switch';
+export type JournalMarkLabel = 'compact' | 'rewind' | 'clear' | 'resume' | 'fork' | 'model_switch';
+interface RecordBase {
+    v: typeof JOURNAL_VERSION;
+    ts: number;
+}
+export type JournalRecord = (RecordBase & {
+    kind: 'meta';
+    sessionId: string;
+    subagentId?: string;
+    writerId: string;
+    provider?: string;
+    model?: string;
+    cwd?: string;
+    forkedFrom?: {
+        sessionId: string;
+        length: number;
+    };
+}) | (RecordBase & {
+    kind: 'append';
+    index: number;
+    message: JournalMessage;
+}) | (RecordBase & {
+    kind: 'truncate';
+    length: number;
+    reason?: JournalTruncateReason;
+}) | (RecordBase & {
+    kind: 'mark';
+    label: JournalMarkLabel;
+    detail?: Record<string, unknown>;
+});
+export type JournalRecordInput = Omit<Extract<JournalRecord, {
+    kind: 'append';
+}>, 'v' | 'ts'> | Omit<Extract<JournalRecord, {
+    kind: 'truncate';
+}>, 'v' | 'ts'> | Omit<Extract<JournalRecord, {
+    kind: 'mark';
+}>, 'v' | 'ts'>;
+export interface MessageJournal {
+    readonly length: number;
+    append(index: number, message: JournalMessage): void;
+    truncate(length: number, reason?: JournalTruncateReason): void;
+    mark(label: JournalMarkLabel, detail?: Record<string, unknown>): void;
+    forSubagent(subagentId: string): MessageJournal;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface JournalAdapter<T> {
+    toJournal(message: T): JournalMessage | null;
+    fromJournalMessages(messages: readonly JournalMessage[]): T[];
+}
+export {};

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

@@ -0,0 +1,11 @@
+import type { MessageJournal } from './types.js';
+export { isMessageJournalDisabled } from './noop.js';
+export interface CreateMessageJournalOptions {
+    getSessionId: () => string | undefined;
+    meta?: {
+        provider?: string;
+        model?: string;
+        cwd?: string;
+    };
+}
+export declare function createMessageJournal(opts: CreateMessageJournalOptions): MessageJournal;

package/dist/agent/provider.d.ts

@@ -172,6 +172,7 @@ export interface ProviderQuery extends AsyncIterable<ProviderEvent> {
     compact?(): Promise<ProviderCompactResult>;
     listRewindTargets?(): RewindTarget[];
     rewindConversation?(turnIndex: number): Promise<ProviderRewindConversationResult>;
+    journalSnapshot?(): import('./journal/types.js').JournalMessage[] | undefined;
     setCwd?(cwd: string): void;
     setSystemPrompt?(basePrompt: string | undefined): boolean;
     setBeforeNextRound?(cb: (() => string | undefined) | undefined): void;
@@ -266,6 +267,7 @@ export interface ProviderCompactResult {
     microcompaction?: {
         blocksCleared: number;
         bytesReclaimed: number;
+        firstClearedIndex?: number;
     };
 }
 export interface RewindTarget {

package/dist/agent/providers/anthropic-direct/journal-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { MessageParam } from '@anthropic-ai/sdk/resources';
+import type { JournalAdapter } from '../../journal/index.js';
+export declare const anthropicJournalAdapter: JournalAdapter<MessageParam>;

package/dist/agent/providers/anthropic-direct/query/session-state.d.ts

@@ -1,6 +1,7 @@
 import type { MessageParam } from '@anthropic-ai/sdk/resources';
 import type { ProviderUsage } from '../../../provider.js';
 import type { ToolDispatcher } from '../tool-dispatcher.js';
+import { JournalSync, type MessageJournal } from '../../../journal/index.js';
 export interface SessionState {
     readonly messages: MessageParam[];
     currentModel: string;
@@ -11,6 +12,8 @@ export interface SessionState {
     lastUsage: ProviderUsage | null;
     closed: boolean;
     autoCompactThreshold: number | undefined;
+    readonly journalSync: JournalSync<MessageParam>;
+    readonly messageJournal: MessageJournal | undefined;
 }
 export declare function createSessionState(opts: {
     model: string;
@@ -21,4 +24,5 @@ export declare function createSessionState(opts: {
     initialMessages?: MessageParam[];
     autoCompactThreshold?: number;
     initialUsageInputTokens?: number;
+    messageJournal?: MessageJournal;
 }): SessionState;

package/dist/agent/providers/anthropic-direct/query/turn-request.d.ts

@@ -25,6 +25,7 @@ export interface TurnRequestInput {
     throttleQueue?: RunTurnInput['throttleQueue'];
     onUsageProgress?: RunTurnInput['onUsageProgress'];
     beforeNextRound?: RunTurnInput['beforeNextRound'];
+    journalSync?: RunTurnInput['journalSync'];
 }
 export declare function prepareTurnRequest(input: TurnRequestInput): {
     decision: FastTurnDecision | undefined;

package/dist/agent/providers/anthropic-direct/query-options.d.ts

@@ -11,6 +11,7 @@ export interface AnthropicDirectQueryOptions {
     toolDispatcher: ToolDispatcher;
     sessionId?: string;
     initialMessages?: MessageParam[];
+    messageJournal?: import('../../journal/index.js').MessageJournal;
     initialUsageInputTokens?: number;
     model: string;
     requestedModel?: string;

package/dist/agent/providers/anthropic-direct/query-runtime.d.ts

@@ -1,5 +1,6 @@
 import type { ProviderAccountInfo, ProviderAgentInfo, ProviderCommandInfo, ProviderCompactResult, ProviderContextUsage, ProviderEvent, ProviderMcpServerStatus, ProviderModelInfo, ProviderQuery, ProviderRewindConversationResult, ProviderRewindResult, RewindTarget } from '../../provider.js';
 import type { AnthropicDirectQueryOptions } from './query-options.js';
+import type { JournalMessage } from '../../journal/index.js';
 export type { AnthropicDirectQueryOptions } from './query-options.js';
 export declare class AnthropicDirectQuery implements ProviderQuery {
     private readonly initSessionId;
@@ -52,6 +53,7 @@ export declare class AnthropicDirectQuery implements ProviderQuery {
     }): Promise<ProviderRewindResult>;
     compact(): Promise<ProviderCompactResult>;
     listRewindTargets(): RewindTarget[];
+    journalSnapshot(): JournalMessage[] | undefined;
     rewindConversation(turnIndex: number): Promise<ProviderRewindConversationResult>;
     close(): void;
 }

package/dist/agent/providers/anthropic-direct/request-types.d.ts

@@ -24,6 +24,7 @@ export interface RunTurnInput {
     onUsageProgress?: (usage: ProviderUsage) => void;
     throttleQueue?: import('./throttle-queue.js').ThrottleQueue;
     beforeNextRound?: () => string | undefined;
+    journalSync?: import('../../journal/index.js').JournalSync<MessageParam>;
 }
 export interface AnthropicClientLike {
     messages: {

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

@@ -0,0 +1,4 @@
+import type { JournalAdapter } from '../../journal/index.js';
+import type { OpenAIMessage } from './messages.js';
+export declare const INTERRUPTED_TOOL_RESULT: string;
+export declare const openAIJournalAdapter: JournalAdapter<OpenAIMessage>;

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

@@ -0,0 +1,18 @@
+import type { AgentConfig, ResumeHistoryTurn } from '../../../types/config-types.js';
+import type { ProviderCompactResult, ProviderUsage } from '../../../provider.js';
+import type { OpenAIMessage } from '../messages.js';
+import type { JournalMessage } from '../../../journal/index.js';
+export declare class OpenAIJournalWiring {
+    private readonly config;
+    private readonly journalSync;
+    constructor(config: AgentConfig);
+    initialTurns(): OpenAIMessage[];
+    resumedUsage(): ProviderUsage | null;
+    legacyResumeHistory(): {
+        resumeHistory?: ResumeHistoryTurn[];
+    };
+    afterCompact(turns: readonly OpenAIMessage[], result: ProviderCompactResult): void;
+    microcompactFallback(turns: OpenAIMessage[]): ProviderCompactResult | null;
+    snapshot(turns: readonly OpenAIMessage[]): JournalMessage[] | undefined;
+    sync(turns: readonly OpenAIMessage[], compacted?: boolean): void;
+}

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

@@ -3,6 +3,7 @@ import type { TraceSink } from '../../trace/index.js';
 import type { ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderContextUsage, ProviderRewindResult, ProviderModelInfo, ProviderCommandInfo, ProviderAgentInfo, ProviderMcpServerStatus, ProviderAccountInfo, ProviderCompactResult } from '../../provider.js';
 import { type OpenAIAuthResolution, type AuthResolverDeps } from './auth.js';
 import type { ToolDispatcher } from '../anthropic-direct/tool-dispatcher.js';
+import { OpenAIJournalWiring } from './query/journal-wiring.js';
 import { resolveReasoningEffort } from './query/model-params.js';
 import { type FastTierOptions } from './query/fast-tier-session.js';
 export { __setRetryBaseDelay } from './query/retry.js';
@@ -39,6 +40,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery {
     private readonly traceWriter;
     private readonly fastTier;
     private priorTurns;
+    private readonly journal;
     private currentModel;
     private currentPermissionMode;
     private responsesCompactionUnavailable;
@@ -70,6 +72,7 @@ export declare class OpenAICompatibleQuery implements ProviderQuery {
     rewindFiles(_userMessageId: string, _options?: {
         dryRun?: boolean;
     }): Promise<ProviderRewindResult>;
+    journalSnapshot(): ReturnType<OpenAIJournalWiring['snapshot']>;
     close(): void;
 }
 export declare function buildQueryFromConfig(config: AgentConfig, promptStream: AsyncIterable<ProviderUserTurn>, options?: {

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

@@ -1,5 +1,6 @@
 import type { ModelProvider, ProviderQuery, ProviderEvent, ProviderUserTurn, ProviderCommandInfo, ProviderModelInfo, ProviderAgentInfo, ProviderContextUsage, ProviderMcpServerStatus, ProviderAccountInfo, ProviderRewindResult, ProviderRewindConversationResult, ProviderCompactResult, RewindTarget } from '../../provider.js';
 import type { AgentConfig } from '../../types/config-types.js';
+import type { JournalMessage } from '../../journal/index.js';
 export interface ProviderRouterDeps {
     resolveProvider: (model: string | undefined) => ModelProvider;
     providerNameForModel: (model: string | undefined) => string;
@@ -53,6 +54,7 @@ export declare class ProviderRouter implements ProviderQuery {
         dryRun?: boolean;
     }): Promise<ProviderRewindResult>;
     compact(): Promise<ProviderCompactResult>;
+    journalSnapshot(): JournalMessage[] | undefined;
     listRewindTargets(): RewindTarget[];
     rewindConversation(turnIndex: number): Promise<ProviderRewindConversationResult>;
     reloadPlugins(...args: unknown[]): Promise<unknown>;

package/dist/agent/providers/shared/compaction.d.ts

@@ -20,6 +20,7 @@ export interface ToolResultRef {
     isPlaceholder: boolean;
     clear(placeholder: string): void;
     toolName?: string;
+    messageIndex?: number;
 }
 export interface MicrocompactOps<M> {
     listToolResults(messages: ReadonlyArray<M>): ToolResultRef[];
@@ -33,6 +34,7 @@ export interface MicrocompactResult {
     blocksCleared: number;
     bytesReclaimed: number;
     blocksScanned: number;
+    firstClearedIndex?: number;
 }
 export declare function microcompactToolResults<M>(messages: ReadonlyArray<M>, ops: MicrocompactOps<M>, opts?: MicrocompactOptions): MicrocompactResult;
 export declare function byteLengthOf(text: string): number;

package/dist/agent/providers/shared/resume-usage-seed.d.ts

@@ -0,0 +1,8 @@
+import type { JournalMessage } from '../../journal/types.js';
+import type { ResumeHistoryTurn } from '../../types/config-types.js';
+export declare const BINARY_TOKEN_ESTIMATE = 1600;
+export declare function estimateJournalInputTokens(messages: readonly JournalMessage[]): number;
+export declare function resumeSeedInputTokens(config: {
+    resumeHistory?: ResumeHistoryTurn[];
+    resumeMessages?: JournalMessage[];
+}): number | undefined;

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

@@ -5,6 +5,7 @@ import type { ProviderCommandInfo, ProviderCompactResult, ProviderQuery, Provide
 import type { AccountInfo, AgentConfig, AgentInfo, AgentModelInput, IAgentSession, InputStreamRef, McpServerStatus, Message, ModelInfo, OutputEvent, PermissionMode, ResponseMetadata, RewindFilesResult, SDKControlGetContextUsageResponse, SendMessageOptions, SessionIdentity, SessionMetadata, SessionState, StructuredMessageOptions } from '../types.js';
 import type { ZodType } from 'zod';
 import type { ElicitationRequest } from '../types/sdk-types.js';
+import type { MessageJournal } from '../journal/index.js';
 export declare class AgentSession implements IAgentSession {
     private readonly ownedTraceWriter;
     private config;
@@ -26,6 +27,7 @@ export declare class AgentSession implements IAgentSession {
     private stateManager;
     private readonly accounting;
     private readonly ledger;
+    private readonly journal;
     private readonly outputBroadcast;
     private readonly shutdown;
     private runner;
@@ -36,6 +38,7 @@ export declare class AgentSession implements IAgentSession {
     get cwd(): string | undefined;
     get abortSignal(): AbortSignal;
     get hookRegistry(): HookRegistry | undefined;
+    get messageJournal(): MessageJournal | undefined;
     abort(reason: string): void;
     private makeSendDeps;
     sendMessage(content: string, options?: SendMessageOptions): Promise<Message>;

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

@@ -0,0 +1,22 @@
+import { type MessageJournal } from '../journal/index.js';
+import type { AgentConfig } from '../types.js';
+export declare function isForkConfig(config: AgentConfig): boolean;
+export declare class JournalLifecycle {
+    private readonly getLiveSessionId;
+    private journal;
+    private owned;
+    private gate;
+    constructor(getLiveSessionId: () => string | undefined);
+    get current(): MessageJournal | undefined;
+    open(config: AgentConfig): AgentConfig;
+    arm(config: AgentConfig): void;
+    closeForReset(): Promise<void>;
+    stripForReset(config: AgentConfig): AgentConfig;
+    markCleared(): void;
+    markModelSwitch(model: string): void;
+    flush(): void;
+    close(): Promise<void>;
+    private freezeGate;
+    private resolveGateId;
+    private safeLiveId;
+}

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

@@ -3,6 +3,7 @@ import type { AgentConfig } from '../types.js';
 import type { ProviderQuery } from '../provider.js';
 import type { SessionStateManager } from './session-state.js';
 import type { PlanExitBridge } from './plan-exit-bridge.js';
+import type { JournalLifecycle } from './journal-lifecycle.js';
 export interface ConfigDeps {
     getConfig: () => AgentConfig;
     setConfig: (patch: (prev: AgentConfig) => AgentConfig) => void;
@@ -10,6 +11,7 @@ export interface ConfigDeps {
     getStateManager: () => SessionStateManager;
     getPlanExit: () => PlanExitBridge;
     pushSidebandEvent: (event: OutputEvent) => void;
+    getJournal?: () => JournalLifecycle;
 }
 export declare function setModel(model: AgentModelInput | undefined, deps: ConfigDeps): Promise<void>;
 export declare function setPermissionMode(mode: PermissionMode, deps: ConfigDeps): Promise<void>;

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

@@ -3,6 +3,7 @@ import type { ProviderQuery, ProviderEvent } from '../provider.js';
 import type { SessionStateManager } from './session-state.js';
 import type { SessionShutdown } from './session-shutdown.js';
 import type { LedgerLifecycle } from './ledger-lifecycle.js';
+import type { JournalLifecycle } from './journal-lifecycle.js';
 export interface ResetDeps {
     getState: () => SessionState;
     setState: (s: SessionState) => void;
@@ -12,6 +13,7 @@ export interface ResetDeps {
     getInitPromise: () => Promise<void> | null;
     getShutdown: () => SessionShutdown;
     getLedger: () => LedgerLifecycle;
+    getJournal: () => JournalLifecycle;
     getStateManager: () => SessionStateManager;
     reinitialize: (patchConfig: (prev: AgentConfig) => AgentConfig) => void;
 }

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

@@ -4,3 +4,4 @@ export declare function buildInitialState(config: AgentConfig, resolvedModel: st
     sessionIdentity: SessionIdentity;
     metadata: SessionMetadata;
 };
+export declare function scheduleTopLevelHousekeeping(getActiveLabel: () => string | undefined, getActiveSessionId: () => string | undefined): void;

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

@@ -5,11 +5,13 @@ export interface SessionSweepResult {
     evictedAge: number;
     evictedCount: number;
     remaining: number;
+    evictedDirs: number;
 }
 export interface SessionSweepOptions {
     root?: string;
     force?: boolean;
     activeSessionId?: string;
     _unlink?: (path: string) => Promise<void>;
+    _rmDir?: (path: string) => Promise<void>;
 }
 export declare function sweepSessionSidecars(opts?: SessionSweepOptions): Promise<SessionSweepResult>;

package/dist/agent/session-sidecar-sweep.dirs.d.ts

@@ -0,0 +1,9 @@
+export interface SessionDirSweepOptions {
+    root: string;
+    now: number;
+    maxAgeMs: number;
+    graceMs: number;
+    activeSessionId?: string;
+    _rm?: (path: string) => Promise<void>;
+}
+export declare function sweepSessionDirs(opts: SessionDirSweepOptions): Promise<number>;

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

@@ -7,12 +7,17 @@ import type { SubagentProgressSink, OutputEvent } from '../types/session-types.j
 import type { TraceSink } from '../trace/index.js';
 import type { Surface } from '../awareness/types.js';
 import type { PhaseRole } from '../tools/nesting.js';
+import type { MessageJournal } from '../journal/index.js';
 export interface ForkParent {
     sessionId?: string;
     id?: string;
+    readonly messageJournal?: MessageJournal;
+}
+export interface JournalParent {
+    readonly messageJournal?: MessageJournal;
 }
 export interface ForkSubagentOptions<T = unknown> {
-    parent: Pick<IAgentSession, 'sessionId'> & Partial<Pick<IAgentSession, 'getInputStreamRef' | 'abortSignal' | 'hookRegistry'>>;
+    parent: Pick<IAgentSession, 'sessionId'> & Partial<Pick<IAgentSession, 'getInputStreamRef' | 'abortSignal' | 'hookRegistry'>> & JournalParent;
     config: AgentConfig;
     idPrefix?: string;
     outputSchema?: ZodType<T>;

package/dist/agent/tools/compose-executor.d.ts

@@ -7,7 +7,7 @@ import type { ToolCall, ToolResult } from './types.js';
 import type { InboundAttachmentReader } from '../content/attachment-registry.js';
 import type { AgentRegistry } from '../agents/index.js';
 export interface ComposeExecutorContext {
-    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'>;
+    parentSession: Pick<IAgentSession, 'sessionId' | 'abortSignal'> & import('../subagent/fork-types.js').JournalParent;
     defaultModel?: AgentModelInput;
     defaultSubagentModel: AgentModelInput;
     apiKey?: string;