@cerebriline/core 4.100.240

package/dist/session/services/message-builder.d.ts

@@ -0,0 +1,208 @@
+/**
+ * API-safe message builder for provider payloads.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/context/message-builder.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `MessageBuilder`.
+ *
+ * Walks the conversation to produce provider-ready messages, handling
+ * tool-result truncation and outdated-file-content rewrite for compaction.
+ * Per-instance caches make this host state.
+ */
+import { type MediaBudgetOptions, type Message } from "@cerebriline/shared";
+export declare const DEFAULT_MAX_TOOL_RESULT_CHARS = 32000;
+export declare const DEFAULT_MAX_FILE_CONTENT_CHARS = 50000;
+export declare const DEFAULT_MAX_TOTAL_TEXT_BYTES = 6000000;
+export declare const DEFAULT_MAX_ASSISTANT_TEXT_CHARS = 200000;
+export declare const DEFAULT_MAX_ASSISTANT_TOOL_MARKUP_CHARS = 12000;
+export declare const DEFAULT_MIN_OUTDATED_REWRITE_BYTES = 65536;
+/**
+ * Share of the context window the transcript must fill, as it would be sent,
+ * before stale reads are rewritten at all.
+ *
+ * A rewrite breaks the prefix cache from the first rewritten read onward, and
+ * every server this talks to caches prefixes. Rewriting whenever a small share
+ * was reclaimable made it routine: on pandorum 2026-09-26, 834 of 7,465
+ * builds rewrote a read a few turns back -- swarm agents re-reading the file
+ * they were editing, at a 5,243-byte threshold on a 65,536-token window --
+ * and opencoti measured 499k tokens re-prefilled behind those rewrites. Now a
+ * turn is a pure append until the transcript is large enough for the stale
+ * copies to matter, and then every pending one goes at once. Well under the
+ * compaction trigger, since tool schemas and the system prompt, which are not
+ * in the transcript, share the window.
+ */
+export declare const OUTDATED_REWRITE_PRESSURE_SHARE = 0.4;
+/**
+ * Transcript bytes, as sent, past which stale reads are rewritten -- or
+ * `undefined` when the window is unknown and the byte threshold decides.
+ */
+export declare function resolveOutdatedRewritePressureBytes(contextWindowTokens: number | undefined): number | undefined;
+/**
+ * Scale the stale-read rewrite threshold to the model's context window.
+ *
+ * Falls back to the fixed default when the window is unknown, so a caller that
+ * cannot say keeps the previous behaviour rather than guessing.
+ */
+export declare function resolveMinOutdatedRewriteBytes(contextWindowTokens: number | undefined): number;
+export declare const MESSAGE_BUILDER_LIMIT_ENV: {
+    readonly maxToolResultChars: "CLINE_MESSAGE_BUILDER_MAX_TOOL_RESULT_CHARS";
+    readonly maxTotalTextBytes: "CLINE_MESSAGE_BUILDER_MAX_TOTAL_TEXT_BYTES";
+    readonly minOutdatedRewriteBytes: "CLINE_MESSAGE_BUILDER_MIN_OUTDATED_REWRITE_BYTES";
+};
+export interface MessageBuilderOptions {
+    maxToolResultChars?: number;
+    maxFileContentChars?: number;
+    maxTotalTextBytes?: number;
+    mediaBudget?: MediaBudgetOptions;
+    maxAssistantTextChars?: number;
+    maxAssistantToolMarkupChars?: number;
+    minOutdatedRewriteBytes?: number;
+    /**
+     * The model's context window, in tokens. Scales the stale-read rewrite
+     * threshold; ignored when `minOutdatedRewriteBytes` is given explicitly.
+     */
+    contextWindowTokens?: number;
+}
+export declare function getMessageBuilderOptionsFromEnv(env?: Record<string, string | undefined>): MessageBuilderOptions;
+/**
+ * Builds an API-safe message copy without mutating original conversation history.
+ */
+export declare class MessageBuilder {
+    private indexedMessageCount;
+    private indexedTailRef;
+    private readonly toolNameByIdCache;
+    private readonly readLocatorsByToolUseIdCache;
+    private readonly readsByPathCache;
+    private readOrderCounter;
+    private readResultLocatorCache;
+    private readonly maxToolResultChars;
+    private readonly maxFileContentChars;
+    private readonly maxTotalTextBytes;
+    private readonly mediaBudget;
+    private readonly maxAssistantTextChars;
+    private readonly maxAssistantToolMarkupChars;
+    private readonly minOutdatedRewriteBytes;
+    /** Set when the window is known and no byte threshold was named. */
+    private readonly outdatedRewritePressureBytes;
+    private readonly committedOutdatedRewrites;
+    private readonly duplicateReadKeys;
+    constructor(options?: MessageBuilderOptions);
+    resetConversationState(): void;
+    buildForApi(messages: Message[]): Message[];
+    private transformBlock;
+    private reindex;
+    /** Commits pending stale-read rewrites once reclaimable bytes cross the threshold. */
+    private commitOutdatedRewrites;
+    /** Estimates reclaimable bytes for stale locators inside one tool-result block. */
+    private estimateOutdatedReclaimBytes;
+    private providerBoundEntryBytes;
+    private addMissingToolResults;
+    private appendMissingToolResults;
+    private shouldMergeUserAfterToolResults;
+    private contentBlocksForUserMerge;
+    private collectToolResultIds;
+    private isToolResultOnlyMessage;
+    private trackMissingToolCalls;
+    private createMissingToolResultMessage;
+    private createMissingToolResultBlocks;
+    private formatMissingToolResultText;
+    private resetIndexes;
+    private getReadLocators;
+    private extractLocatorsFromReadToolInput;
+    private extractReadLocatorsFromToolResultContent;
+    private tryParseReadLocators;
+    private extractLocatorsFromParsedReadResult;
+    private extractLocatorFromReadRequest;
+    private extractLocatorFromResultEntry;
+    private extractPath;
+    private extractLineNumber;
+    private parseReadQuery;
+    private dedupeReadLocators;
+    private toReadLocatorKey;
+    private isFullFileRead;
+    /**
+     * Whether a later read makes an earlier one redundant.
+     *
+     * A whole-file read covers every range of that file. A range covers another
+     * range only when it contains it, and never covers a whole-file read: the
+     * file has lines the range does not, and dropping the only copy of them to
+     * save bytes trades a correct transcript for a smaller one.
+     */
+    private readCovers;
+    /**
+     * A read is outdated when a *later* read covers it.
+     *
+     * The recency half is what the previous "latest full read owns the path"
+     * check got wrong: it compared owners by identity, so a whole-file read at
+     * turn 5 marked a ranged read at turn 20 as outdated — the newest content
+     * in the transcript was replaced by a placeholder pointing at an older
+     * copy, and the model was left reading the file it had already superseded.
+     */
+    private isOutdatedReadLocator;
+    /** Records one read of one path at the next transcript position. */
+    private noteIndexedRead;
+    /**
+     * Whether a read only repeats a range an earlier read already covers.
+     *
+     * The mirror of `isOutdatedReadLocator`: that one asks whether something
+     * newer replaced this read, this one asks whether something older already
+     * contains it. Both describe redundancy, but they are not interchangeable —
+     * the newest copy of a range is never stale, so a duplicate must be labelled
+     * as such rather than sent to look for a newer version that does not exist.
+     *
+     * Requires the equality witness to pass. Without proof that the overlapping
+     * lines are unchanged, an edit may have landed between the two reads, and
+     * then the contained read is the only fresh copy in the transcript —
+     * collapsing it would hand the model source that no longer exists. A read
+     * whose text could not be recovered is therefore never treated as a
+     * duplicate.
+     */
+    /**
+     * Which placeholder a rewritten read should carry.
+     *
+     * Duplicates are recorded during the same pass that decides staleness, so by
+     * rewrite time the classification is already made; anything not recorded as
+     * a duplicate is superseded.
+     */
+    private placeholderForKey;
+    /**
+     * Recover each read's rendered text, keyed by locator.
+     *
+     * Best-effort: a result that is not the JSON-entry shape yields nothing, and
+     * a read with no recoverable text is simply never eligible to be called a
+     * duplicate. Failing to find the text has to mean "cannot prove", never
+     * "assume equal".
+     */
+    private extractReadTextByLocator;
+    private isDuplicateReadLocator;
+    private replaceOutdatedReadContent;
+    private countOutdatedImageEntries;
+    private replaceOutdatedInString;
+    private replaceOutdatedReadEntry;
+    private isReadTool;
+    /**
+     * Tool results can outlive their paired tool_use block (compacted or
+     * imported histories), so fall back to the name carried on the result
+     * itself when the id lookup misses.
+     */
+    private resolveToolName;
+    private truncateToolResultContent;
+    /**
+     * Deep-truncates string values inside structured tool outputs (e.g.
+     * `ToolOperationResult[]` from run_commands/read_files), which carry the
+     * payload in untyped `{query, result, ...}` fields rather than text
+     * blocks. Image blocks are left intact so base64 payloads survive.
+     */
+    private truncateNestedStrings;
+    private truncateMiddle;
+    private truncateAssistantText;
+    private hasRepeatedToolCallMarkup;
+    private truncateToTotalTextBudget;
+    private countMessageTextBytes;
+    private collectTruncationCandidates;
+    private applyMediaBudget;
+    private resolveMediaBudget;
+    private applyMediaBudgetToBlock;
+    private applyMediaBudgetToToolResultEntry;
+    private limitNestedMedia;
+    private limitImageContent;
+}

package/dist/session/services/persistence-service.d.ts

@@ -0,0 +1,92 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentResult, BasicLogger } from "@cerebriline/shared";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { type SessionStatus, type TerminalSessionStatus } from "../../types/common";
+import type { PersistedSessionUpdateInput, SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import type { SessionCompactionState } from "../models/session-compaction";
+import type { SessionRow } from "../models/session-row";
+export type { PersistedSessionUpdateInput, SessionPersistenceAdapter };
+export declare class UnifiedSessionPersistenceService {
+    private readonly adapter;
+    private readonly manifestStore;
+    private readonly teamChildren;
+    private static readonly STALE_REASON;
+    private static readonly STALE_SOURCE;
+    private static readonly TEAM_HEARTBEAT_LOG_INTERVAL_MS;
+    constructor(adapter: SessionPersistenceAdapter, options?: {
+        messagesArtifactUploader?: SessionMessagesArtifactUploader;
+        logger?: BasicLogger;
+    });
+    private toPersistedMessages;
+    ensureSessionsDir(): string;
+    writeSessionManifest(manifestPath: string, manifest: import("../models/session-manifest").SessionManifest): void;
+    readSessionManifest(sessionId: string): import("../models/session-manifest").SessionManifest | undefined;
+    createRootSessionWithArtifacts(input: import("../models/session-row").CreateRootSessionWithArtifactsInput): Promise<import("../models/session-row").RootSessionArtifacts>;
+    /**
+     * Move a session to `status`, and — when that status means the session is
+     * live — record the process it is live in.
+     *
+     * Only the process actually running a session moves it to a non-terminal
+     * status, so that write is the moment its ownership is known. Recording it
+     * matters because the row keeps whichever pid created it, and a resumed
+     * session runs in a different process than the one that opened it: after a
+     * host restart, the reconciler tested a pid belonging to the dead host,
+     * concluded the live session had failed, and re-marked it on every
+     * `listSessions` scan. The task then offered "Resume" forever — for a
+     * session that had in fact completed a dozen turns since — because the
+     * resume affordance is chosen from exactly this status.
+     *
+     * The same write clears the reconciler's death certificate from the
+     * metadata, so a session that turned out to be alive does not keep carrying
+     * the record of having been declared dead.
+     */
+    updateSessionStatus(sessionId: string, status: SessionStatus, exitCode?: number | null, pid?: number): Promise<{
+        updated: boolean;
+        endedAt?: string;
+    }>;
+    updateSession(input: {
+        sessionId: string;
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    queueSpawnRequest(event: HookEventPayload): Promise<void>;
+    upsertSubagentSession(input: import("../models/session-row").UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
+    appendSubagentHookAudit(_subSessionId: string, event: HookEventPayload): Promise<void>;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.MessageWithMetadata[], systemPrompt?: string): Promise<void>;
+    readSessionCompactionState(sessionId: string): Promise<SessionCompactionState | undefined>;
+    persistSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<void>;
+    deleteSessionCompactionState(sessionId: string): Promise<void>;
+    applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
+    applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
+    applyStatusToRunningChildSessions(parentSessionId: string, status: TerminalSessionStatus): Promise<void>;
+    onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
+    onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, summary?: string, result?: AgentResult, messages?: LlmsProviders.MessageWithMetadata[]): Promise<void>;
+    onTeamTaskProgress(rootSessionId: string, agentId: string, progress: string, options?: {
+        kind?: "heartbeat" | "progress" | "text";
+    }): Promise<void>;
+    handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
+    handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
+    private isPidAlive;
+    private reconcileDeadRunningSession;
+    listSessions(limit?: number): Promise<SessionRow[]>;
+    /**
+     * Lightweight, effectively unbounded listing of session ids + metadata
+     * (no manifest reads, no dead-session reconciliation). listSessions caps
+     * its scan at 2000 rows; callers that must see every row — e.g. import
+     * dedup markers — use this instead.
+     */
+    listSessionMetadata(limit?: number): Promise<Array<{
+        sessionId: string;
+        metadata?: Record<string, unknown>;
+    }>>;
+    reconcileDeadSessions(limit?: number): Promise<number>;
+    deleteSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+    private deleteSessionCompactionStateIfExists;
+}

package/dist/session/services/read-overlap.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Deciding whether two reads of the same file saw the same text.
+ *
+ * Read results are rendered with line numbers — `"  80 | const x = 1"` — and
+ * the number is padded to the width of the widest line number *in that read*
+ * (see `file-read.ts`). So a read of lines 80-120 renders `" 80 | "` while a
+ * whole-file read of a 1000-line file renders `"  80 | "` for the same source
+ * line. Hashing the rendered text directly would therefore report "changed"
+ * for two reads that saw identical content, which is exactly backwards: the
+ * comparison would fail closed and nothing would ever be collapsed.
+ *
+ * Everything here works on the text *after* the delimiter, keyed by line
+ * number, so padding cannot influence the answer.
+ */
+/**
+ * Parse a rendered read result into line number → source text.
+ *
+ * Lines that do not carry a number are skipped rather than guessed at: a read
+ * result also contains headers and truncation markers, and treating those as
+ * source would make two reads of the same range compare unequal purely because
+ * one of them was truncated somewhere else.
+ */
+export declare function parseNumberedLines(content: string): Map<number, string>;
+/**
+ * Whether two reads saw identical text everywhere their ranges overlap.
+ *
+ * This is the equality witness for collapsing a redundant read. The dangerous
+ * case is an edit landing between the two reads: then the later read is the
+ * fresh one and the earlier is stale, and collapsing in the wrong direction
+ * feeds the model source that no longer exists. Comparing the overlap turns
+ * "did the file change?" from an inference into a check — and it catches edits
+ * made outside the agent, which scanning the transcript for editor calls
+ * cannot.
+ *
+ * Returns false when the overlap is empty or when either side is missing a
+ * line the other has. Both are "cannot prove equal", and the caller must treat
+ * an unproven overlap as changed — the whole point is to never collapse on a
+ * guess.
+ */
+export declare function readOverlapUnchanged(earlier: string, later: string, overlapStart: number, overlapEnd: number): boolean;

package/dist/session/services/session-service.d.ts

@@ -0,0 +1,15 @@
+import type { BasicLogger } from "@cerebriline/shared";
+import type { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import { type CreateRootSessionInput } from "../models/session-row";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+export declare class CoreSessionService extends UnifiedSessionPersistenceService {
+    private readonly store;
+    constructor(store: SqliteSessionStore, options?: {
+        sessionArtifactsDir?: string;
+        messagesArtifactUploader?: SessionMessagesArtifactUploader;
+        logger?: BasicLogger;
+    });
+    createRootSession(input: CreateRootSessionInput): void;
+}
+export type { CreateRootSessionInput, CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRow, UpsertSubagentInput, } from "../models/session-row";

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

@@ -0,0 +1,59 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+export interface CoreSessionCheckpointSnapshot {
+    enabled?: boolean;
+    latest?: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+export interface CoreSessionSnapshot {
+    version: 1;
+    sessionId: string;
+    source: SessionRecord["source"];
+    status: SessionRecord["status"];
+    createdAt: string;
+    updatedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    interactive: boolean;
+    workspace: {
+        cwd: string;
+        root: string;
+    };
+    model: {
+        providerId: string;
+        modelId: string;
+    };
+    capabilities: {
+        enableTools: boolean;
+        enableSpawn: boolean;
+        enableTeams: boolean;
+    };
+    lineage: {
+        parentSessionId?: string;
+        parentAgentId?: string;
+        agentId?: string;
+        conversationId?: string;
+        isSubagent: boolean;
+    };
+    team?: {
+        name: string;
+    };
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    artifacts?: {
+        messagesPath?: string;
+    };
+    messages?: LlmsProviders.MessageWithMetadata[];
+    usage?: SessionAccumulatedUsage;
+    aggregateUsage?: SessionAccumulatedUsage;
+    checkpoint?: CoreSessionCheckpointSnapshot;
+}
+export declare function createCoreSessionSnapshot(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.MessageWithMetadata[];
+    usage?: SessionAccumulatedUsage;
+    aggregateUsage?: SessionAccumulatedUsage;
+}): CoreSessionSnapshot;
+export declare function coreSessionSnapshotToRecord(snapshot: CoreSessionSnapshot): SessionRecord;

package/dist/session/session-versioning-service.d.ts

@@ -0,0 +1,50 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { CheckpointEntry, CheckpointMetadata } from "../hooks/checkpoint-hooks";
+import type { RestoreSessionInput } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+import { type CheckpointRestorePlan, type WorktreeRestoreTransaction } from "./checkpoint-restore";
+import { type CoreSessionSnapshot } from "./session-snapshot";
+export type SessionVersioningErrorCode = "invalid_restore" | "session_not_found" | "session_messages_not_found";
+export declare class SessionVersioningError extends Error {
+    readonly code: SessionVersioningErrorCode;
+    constructor(code: SessionVersioningErrorCode, message: string);
+}
+export interface SessionCheckpointRestoreContext {
+    sourceSession: SessionRecord;
+    sourceMessages?: LlmsProviders.MessageWithMetadata[];
+    sourceSnapshot: CoreSessionSnapshot;
+    plan: CheckpointRestorePlan;
+    restoredCheckpointMetadata?: CheckpointMetadata;
+    initialMessages: LlmsProviders.MessageWithMetadata[];
+    restoreMessages: boolean;
+    restoreWorkspace: boolean;
+    checkpointRunCount: number;
+}
+export interface SessionCheckpointRestoreResult<TStartResult = unknown> {
+    sessionId?: string;
+    startResult?: TStartResult;
+    messages?: LlmsProviders.MessageWithMetadata[];
+    checkpoint: CheckpointEntry;
+    sourceSnapshot: CoreSessionSnapshot;
+    restoredSnapshot?: CoreSessionSnapshot;
+}
+export interface SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult> {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: RestoreSessionInput["restore"];
+    start?: TRestoreStartInput;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    readMessages(sessionId: string): Promise<LlmsProviders.MessageWithMetadata[]>;
+    buildStartInput?: (context: SessionCheckpointRestoreContext, start: TRestoreStartInput) => TStartInput | Promise<TStartInput>;
+    startSession?: (input: TStartInput) => Promise<TStartResult>;
+    getStartedSessionId?: (result: TStartResult) => string | undefined;
+    cleanupStartedSession?: (result: Awaited<TStartResult>) => Promise<void>;
+    readRestoredSession?: (sessionId: string) => Promise<SessionRecord | undefined>;
+    applyWorkspaceCheckpoint?: (cwd: string, checkpoint: CheckpointEntry) => Promise<void>;
+    beginWorkspaceRestoreTransaction?: (cwd: string) => Promise<WorktreeRestoreTransaction>;
+    retainCheckpointRefs?: (cwd: string, sessionId: string, history: CheckpointEntry[]) => Promise<void>;
+}
+export declare class SessionVersioningService {
+    restoreCheckpoint<TRestoreStartInput, TStartInput, TStartResult>(input: SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult>): Promise<SessionCheckpointRestoreResult<TStartResult>>;
+}

package/dist/session/stores/atomic-file.d.ts

@@ -0,0 +1 @@
+export declare function writeFileAtomic(path: string, contents: string): Promise<void>;

package/dist/session/stores/conversation-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-session conversation transcript store.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/runtime/conversation-store.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `ConversationStore`.
+ *
+ * Pure port of the old agents implementation. Owns the message list,
+ * conversation id, and "session started" gate that today's `Agent`
+ * class uses to decide when to fire `session_start` hooks.
+ */
+import type { MessageWithMetadata } from "@cerebriline/shared";
+/** Generate a fresh conversation id. Exported for reuse by `SessionRuntime`. */
+export declare function createConversationId(): string;
+export declare class ConversationStore {
+    private messages;
+    private conversationId;
+    private sessionStarted;
+    constructor(initialMessages?: readonly MessageWithMetadata[]);
+    getConversationId(): string;
+    getMessages(): MessageWithMetadata[];
+    appendMessage(message: MessageWithMetadata): void;
+    appendMessages(messages: readonly MessageWithMetadata[]): void;
+    replaceMessages(messages: readonly MessageWithMetadata[]): void;
+    resetForRun(): void;
+    clearHistory(): void;
+    restore(messages: readonly MessageWithMetadata[]): void;
+    isSessionStarted(): boolean;
+    markSessionStarted(): void;
+}

package/dist/session/stores/session-manifest-store.d.ts

@@ -0,0 +1,49 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { BasicLogger } from "@cerebriline/shared";
+import { SessionArtifacts } from "../../services/session-artifacts";
+import type { SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import { type SessionCompactionState } from "../models/session-compaction";
+import { type SessionManifest } from "../models/session-manifest";
+import type { SessionRow } from "../models/session-row";
+export declare class SessionManifestStore {
+    private readonly adapter;
+    private readonly messagesArtifactUploader?;
+    private readonly logger?;
+    readonly artifacts: SessionArtifacts;
+    constructor(adapter: SessionPersistenceAdapter, messagesArtifactUploader?: SessionMessagesArtifactUploader | undefined, logger?: BasicLogger | undefined);
+    ensureSessionsDir(): string;
+    initializeMessagesFile(row: SessionRow, path: string, startedAt: string): void;
+    writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
+    readSessionManifest(sessionId: string): SessionManifest | undefined;
+    /**
+     * Asynchronously read only the manifest `metadata.title`.
+     *
+     * The session-listing hot path needs nothing from the manifest except the
+     * title, but the manifest JSON can be large (it embeds metadata and prompt
+     * text). This reads the file off the event-loop thread and pulls the title
+     * out of the parsed JSON directly, skipping the full `SessionManifestSchema`
+     * (Zod) validation that `readSessionManifest` performs. On any error (missing
+     * file, malformed JSON, non-string title) it resolves to `undefined` so
+     * callers fall back to the row metadata/prompt title.
+     */
+    readSessionManifestTitle(sessionId: string): Promise<string | undefined>;
+    readManifestFile(sessionId: string): {
+        path: string;
+        manifest?: SessionManifest;
+    };
+    /**
+     * Resolve the session row backing a message write, re-adopting it from the
+     * on-disk manifest when the DB row is missing (session artifacts restored
+     * or copied while the session DB was rebuilt). Sessions with neither a row
+     * nor a manifest throw so message writes cannot silently recreate
+     * orphaned session files.
+     */
+    private resolveSessionRow;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.MessageWithMetadata[], systemPrompt?: string): Promise<void>;
+    private resolveCompactionPath;
+    private updateCompactionPath;
+    readSessionCompactionState(sessionId: string): Promise<SessionCompactionState | undefined>;
+    persistSessionCompactionState(sessionId: string, state: SessionCompactionState): Promise<void>;
+    deleteSessionCompactionState(sessionId: string): Promise<void>;
+    appendStaleSessionHookLog(detectedAt: string, sessionId: string, pid: number, reason: string, source: string): void;
+}

package/dist/session/stores/team-persistence-store.d.ts

@@ -0,0 +1,23 @@
+import type { TeamTeammateSpec } from "@cerebriline/shared";
+import type { AgentTeamsRuntime, TeamEvent } from "../../extensions/tools/team";
+import { type TeamRuntimeState } from "../models/session-row";
+export interface FileTeamPersistenceStoreOptions {
+    teamName: string;
+    baseDir?: string;
+}
+export declare class FileTeamPersistenceStore {
+    private readonly dirPath;
+    private readonly statePath;
+    private readonly taskHistoryPath;
+    private readonly teammateSpecs;
+    constructor(options: FileTeamPersistenceStoreOptions);
+    loadState(): TeamRuntimeState | undefined;
+    getTeammateSpecs(): TeamTeammateSpec[];
+    upsertTeammateSpec(spec: TeamTeammateSpec): void;
+    removeTeammateSpec(agentId: string): void;
+    persist(runtime: AgentTeamsRuntime): void;
+    appendTaskHistory(event: TeamEvent): void;
+    private ensureDir;
+    private hasPersistableState;
+    private clearPersistedState;
+}

package/dist/session/team/index.d.ts

@@ -0,0 +1,2 @@
+export { TeamChildSessionManager } from "./team-child-session-manager";
+export { buildTeamRunContinuationPrompt, dispatchTeamEventToBackend, emitTeamProgress, formatModePrompt, hasPendingTeamRunWork, notifyTeamRunWaiters, shouldAutoContinueTeamRuns, trackTeamRunState, waitForTeamRunUpdates, } from "./team-session-coordinator";

package/dist/session/team/team-child-session-manager.d.ts

@@ -0,0 +1,35 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentResult } from "@cerebriline/shared";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { type SessionStatus, type TerminalSessionStatus } from "../../types/common";
+import type { SessionPersistenceAdapter, StoredMessageWithMetadata } from "../../types/session";
+import type { UpsertSubagentInput } from "../models/session-row";
+import type { SessionManifestStore } from "../stores/session-manifest-store";
+export declare class TeamChildSessionManager {
+    private readonly adapter;
+    private readonly manifestStore;
+    private readonly toPersistedMessages;
+    private readonly heartbeatLogIntervalMs;
+    private readonly teamTaskSessionsByAgent;
+    private readonly teamTaskLastHeartbeatBySession;
+    private readonly teamTaskLastProgressLineBySession;
+    constructor(adapter: SessionPersistenceAdapter, manifestStore: SessionManifestStore, toPersistedMessages: (messages: LlmsProviders.MessageWithMetadata[] | undefined, result?: AgentResult, previousMessages?: LlmsProviders.MessageWithMetadata[]) => StoredMessageWithMetadata[] | undefined, heartbeatLogIntervalMs: number);
+    private teamTaskQueueKey;
+    private activeTeamTaskSessionId;
+    private buildSubsessionRow;
+    queueSpawnRequest(event: HookEventPayload): Promise<void>;
+    upsertSubagentSession(input: UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
+    applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
+    applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
+    applyStatusToRunningChildSessions(parentSessionId: string, status: TerminalSessionStatus): Promise<void>;
+    onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
+    onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, _summary?: string, result?: AgentResult, messages?: LlmsProviders.MessageWithMetadata[]): Promise<void>;
+    onTeamTaskProgress(rootSessionId: string, agentId: string, progress: string, options?: {
+        kind?: "heartbeat" | "progress" | "text";
+    }): Promise<void>;
+    handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
+    handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
+    appendSubagentHookAudit(event: HookEventPayload): void;
+}

package/dist/session/team/team-session-coordinator.d.ts

@@ -0,0 +1,13 @@
+import { type AgentMode, type AgentResult } from "@cerebriline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession, TeamRunUpdate } from "../../types/session";
+export declare function trackTeamRunState(session: ActiveSession, event: TeamEvent): void;
+export declare function dispatchTeamEventToBackend(rootSessionId: string, event: TeamEvent, invokeOptional: (method: string, ...args: unknown[]) => Promise<void>): Promise<void>;
+export declare function emitTeamProgress(session: ActiveSession, rootSessionId: string, event: TeamEvent, emit: (event: CoreSessionEvent) => void): void;
+export declare function hasPendingTeamRunWork(session: ActiveSession): boolean;
+export declare function shouldAutoContinueTeamRuns(session: ActiveSession, finishReason: AgentResult["finishReason"]): boolean;
+export declare function notifyTeamRunWaiters(session: ActiveSession): void;
+export declare function waitForTeamRunUpdates(session: ActiveSession): Promise<TeamRunUpdate[]>;
+export declare function buildTeamRunContinuationPrompt(session: ActiveSession, updates: TeamRunUpdate[]): string;
+export declare function formatModePrompt(prompt: string, mode: AgentMode | undefined): string;

package/dist/session/user-run-messages.d.ts

@@ -0,0 +1,20 @@
+export type MessageDisplayRole = "user" | "assistant" | "tool" | "system" | "status" | "error";
+type MessageLike = {
+    role?: unknown;
+    content?: unknown;
+    metadata?: unknown;
+};
+/** Resolves the role a persisted message should use when presented to a user. */
+export declare function resolveMessageDisplayRole(message: MessageLike): MessageDisplayRole;
+/**
+ * Returns how many absolute root runs a persisted message represents.
+ *
+ * Compaction can fold several earlier user turns into one synthetic message.
+ * Its persisted span keeps later visible prompts aligned with checkpoint
+ * history. Tool results and system-injected user-role messages contribute no
+ * runs.
+ */
+export declare function getUserRunSpan(message: MessageLike): number;
+export declare function isUserRunMessage(message: MessageLike): boolean;
+export declare function countUserRunMessages(messages: readonly MessageLike[] | undefined): number;
+export {};

package/dist/settings/index.d.ts

@@ -0,0 +1,2 @@
+export { CoreSettingsService, createCoreSettingsService, } from "./settings-service";
+export type { ClineCoreSettingsApi, CorePluginContributions, CorePluginSettingsSnapshot, CorePluginSettingsSource, CoreSettingsItem, CoreSettingsItemKind, CoreSettingsItemSource, CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsServiceOptions, CoreSettingsSnapshot, CoreSettingsToggleInput, CoreSettingsType, } from "./types";