qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/session/session-resume.js

@@ -0,0 +1,60 @@
+import * as fs from "node:fs";
+import { getTranscriptPath } from "./session-paths.js";
+import { readSessionMetadata } from "./session-metadata-store.js";
+import { loadTranscript } from "./session-transcript-store.js";
+export async function loadSessionForResume(sessionId, projectRoot, options = {}) {
+    try {
+        await fs.promises.access(projectRoot, fs.constants.R_OK);
+    }
+    catch {
+        console.error(`[session-persistence] loadSessionForResume: projectRoot not accessible: ${projectRoot}`);
+        return null;
+    }
+    const transcript = await loadTranscript(sessionId, projectRoot, options);
+    if (!transcript)
+        return null;
+    if (transcript.corruptLines > 0) {
+        console.warn(`[session-persistence] ${transcript.corruptLines} corrupt line(s) skipped in ${getTranscriptPath(sessionId, projectRoot)}`);
+    }
+    if (transcript.messages.length === 0 && transcript.corruptLines > 0) {
+        console.error(`[session-persistence] Transcript fully corrupt for session ${sessionId}`);
+        return null;
+    }
+    const metadata = await readSessionMetadata(sessionId, projectRoot, {
+        messageCount: transcript.messages.length,
+    });
+    return {
+        metadata,
+        messages: toResumeMessages(transcript.messages, options.includeDisplayMetadata === true),
+    };
+}
+function toResumeMessages(messages, includeDisplayMetadata) {
+    return messages
+        .filter((message) => message.role !== "system")
+        .map((message) => includeDisplayMetadata ? message : stripDisplayOnlyFields(message));
+}
+function stripDisplayOnlyFields(message) {
+    const stripped = {
+        role: message.role,
+        content: message.content,
+    };
+    if (message.tool_calls)
+        stripped.tool_calls = message.tool_calls;
+    if (message.tool_call_id)
+        stripped.tool_call_id = message.tool_call_id;
+    if (message.name)
+        stripped.name = message.name;
+    if (message.thinkingBlocks)
+        stripped.thinkingBlocks = message.thinkingBlocks;
+    if (message.imageUrls)
+        stripped.imageUrls = message.imageUrls;
+    if (message.videoUrls)
+        stripped.videoUrls = message.videoUrls;
+    if (message.audioUrls)
+        stripped.audioUrls = message.audioUrls;
+    if (message.fileIds)
+        stripped.fileIds = message.fileIds;
+    if (message.imageDetail)
+        stripped.imageDetail = message.imageDetail;
+    return stripped;
+}

package/dist/runtime/session/session-schema.d.ts

@@ -0,0 +1,10 @@
+import type { SessionMetadata } from "./session-types.js";
+export interface SessionMetadataDefaults {
+    projectId?: string;
+    createdAt?: string;
+    lastActiveAt?: string;
+    turnCount?: number;
+    messageCount?: number;
+}
+export declare function normalizeSessionMetadata(sessionId: string, input: Partial<SessionMetadata> | null | undefined, defaults?: SessionMetadataDefaults): SessionMetadata;
+export declare function metadataNeedsMigration(input: Partial<SessionMetadata> | null | undefined): boolean;

package/dist/runtime/session/session-schema.js

@@ -0,0 +1,35 @@
+import { SESSION_SCHEMA_VERSION } from "./session-types.js";
+export function normalizeSessionMetadata(sessionId, input, defaults = {}) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: SESSION_SCHEMA_VERSION,
+        sessionId: input?.sessionId ?? sessionId,
+        projectId: input?.projectId ?? defaults.projectId ?? "",
+        createdAt: input?.createdAt ?? defaults.createdAt ?? now,
+        lastActiveAt: input?.lastActiveAt ?? defaults.lastActiveAt ?? now,
+        model: input?.model,
+        agentId: input?.agentId,
+        cwd: input?.cwd,
+        turnCount: input?.turnCount ?? defaults.turnCount ?? 0,
+        messageCount: input?.messageCount ?? defaults.messageCount ?? 0,
+        title: input?.title,
+        taskSummary: input?.taskSummary,
+        taskSummaryGeneratedAt: input?.taskSummaryGeneratedAt,
+        pinnedAt: input?.pinnedAt,
+        archivedAt: input?.archivedAt,
+        sealedAt: input?.sealedAt,
+        previousSessionId: input?.previousSessionId,
+        carryoverSummary: input?.carryoverSummary,
+        type: input?.type ?? "personal",
+        ownerPlatform: input?.ownerPlatform,
+        ownerId: input?.ownerId,
+        groupKey: input?.groupKey,
+        groupName: input?.groupName,
+        groupPlatform: input?.groupPlatform,
+        totalInputTokens: input?.totalInputTokens,
+        totalOutputTokens: input?.totalOutputTokens,
+    };
+}
+export function metadataNeedsMigration(input) {
+    return input?.schemaVersion !== SESSION_SCHEMA_VERSION || input.type == null;
+}

package/dist/runtime/session/session-state.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Session State CC session state parity.
+ *
+ * Unified state container for a single agent session:
+ *   - Token usage / cost accumulation across turns
+ *   - Session trust acceptance (per-session, non-persistent)
+ *   - Session-level settings
+ *
+ * This module is the qlogicagent equivalent of CC's:
+ *   - bootstrap/state.ts (session state fields)
+ *   - cost-tracker.ts (cost accumulation + persistence)
+ *   - sessionRestore.ts (cost restore guard)
+ *
+ * Reference: claude-code src/bootstrap/state.ts, src/cost-tracker.ts
+ */
+import type { WireTokenUsage as TokenUsage } from "../../protocol/wire/index.js";
+/** Per-model usage accumulation CC modelUsage parity */
+export interface ModelUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheRead: number;
+    cacheCreation: number;
+    /** Media generation call count (image/video/music/tts/3d) */
+    mediaCalls: number;
+    /** Total seconds of media output (video, music) */
+    mediaDurationSeconds: number;
+    /** Total characters processed (TTS) */
+    mediaCharacters: number;
+}
+/** Snapshot of the session state for persistence / restore */
+export interface SessionUsageSnapshot {
+    sessionId: string;
+    modelUsage: Record<string, ModelUsage>;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    turnCount: number;
+    lastSavedAt: number;
+}
+export declare class SessionState {
+    readonly sessionId: string;
+    private _trustAccepted;
+    private _modelUsage;
+    private _totalInputTokens;
+    private _totalOutputTokens;
+    private _turnCount;
+    private _toolCallCount;
+    private _listeners;
+    constructor(sessionId: string);
+    get trustAccepted(): boolean;
+    setTrustAccepted(accepted: boolean): void;
+    get totalInputTokens(): number;
+    get totalOutputTokens(): number;
+    get turnCount(): number;
+    get toolCallCount(): number;
+    /** Get usage for a specific model */
+    getModelUsage(model: string): ModelUsage | undefined;
+    /** Get all model usages as a plain object */
+    getAllModelUsage(): Record<string, ModelUsage>;
+    /**
+     * Add usage from an API response CC addToTotalSessionCost() parity.
+     * Tracks token counts only; pricing is handled by Hub/Admin.
+     *
+     * @param usage - Token counts from the API response
+     * @param model - Model identifier
+     */
+    addUsage(usage: TokenUsage, model: string): void;
+    /**
+     * Add usage from a media generation call (non-token billing).
+     * Tracks quantities only (calls, seconds, characters); pricing is Hub/Admin's job.
+     */
+    addMediaUsage(model: string, billingUnit: string, quantity: number): void;
+    /** Record a tool call */
+    recordToolCall(): void;
+    /** Increment turn count */
+    recordTurnCompleted(): void;
+    /**
+     * Create a snapshot for persistence.
+     * CC saveCurrentSessionCosts() parity.
+     */
+    createSnapshot(): SessionUsageSnapshot;
+    /**
+     * Restore from a previous snapshot.
+     * CC setCostStateForRestore() parity.
+     *
+     * GUARD: Only restores if the snapshot's sessionId matches this session.
+     * Prevents cross-session cost leakage (CC's lastSessionId guard).
+     */
+    restoreFromSnapshot(snapshot: SessionUsageSnapshot): boolean;
+    /** Register a state change listener. Returns unsubscribe function. */
+    onStateChange(listener: () => void): () => void;
+    private notifyListeners;
+}
+/**
+ * Create a new session state instance.
+ */
+export declare function createSessionState(sessionId: string): SessionState;

package/dist/runtime/session/session-state.js

@@ -0,0 +1,180 @@
+/**
+ * Session State CC session state parity.
+ *
+ * Unified state container for a single agent session:
+ *   - Token usage / cost accumulation across turns
+ *   - Session trust acceptance (per-session, non-persistent)
+ *   - Session-level settings
+ *
+ * This module is the qlogicagent equivalent of CC's:
+ *   - bootstrap/state.ts (session state fields)
+ *   - cost-tracker.ts (cost accumulation + persistence)
+ *   - sessionRestore.ts (cost restore guard)
+ *
+ * Reference: claude-code src/bootstrap/state.ts, src/cost-tracker.ts
+ */
+// ── Session State Class ────────────────────────────────────
+export class SessionState {
+    sessionId;
+    _trustAccepted = false;
+    _modelUsage = new Map();
+    _totalInputTokens = 0;
+    _totalOutputTokens = 0;
+    _turnCount = 0;
+    _toolCallCount = 0;
+    _listeners = new Set();
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    // ── Trust State ──────────────────────────────────────────
+    get trustAccepted() { return this._trustAccepted; }
+    setTrustAccepted(accepted) {
+        this._trustAccepted = accepted;
+        this.notifyListeners();
+    }
+    // ── Cost / Usage Tracking ────────────────────────────────
+    get totalInputTokens() { return this._totalInputTokens; }
+    get totalOutputTokens() { return this._totalOutputTokens; }
+    get turnCount() { return this._turnCount; }
+    get toolCallCount() { return this._toolCallCount; }
+    /** Get usage for a specific model */
+    getModelUsage(model) {
+        return this._modelUsage.get(model);
+    }
+    /** Get all model usages as a plain object */
+    getAllModelUsage() {
+        const result = {};
+        for (const [model, usage] of this._modelUsage) {
+            result[model] = { ...usage };
+        }
+        return result;
+    }
+    /**
+     * Add usage from an API response CC addToTotalSessionCost() parity.
+     * Tracks token counts only; pricing is handled by Hub/Admin.
+     *
+     * @param usage - Token counts from the API response
+     * @param model - Model identifier
+     */
+    addUsage(usage, model) {
+        this._totalInputTokens += usage.inputTokens;
+        this._totalOutputTokens += usage.outputTokens;
+        // Track per-model usage
+        const existing = this._modelUsage.get(model);
+        if (existing) {
+            existing.inputTokens += usage.inputTokens;
+            existing.outputTokens += usage.outputTokens;
+            existing.cacheRead += usage.cacheRead ?? 0;
+            existing.cacheCreation += usage.cacheWrite ?? 0;
+        }
+        else {
+            this._modelUsage.set(model, {
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheRead: usage.cacheRead ?? 0,
+                cacheCreation: usage.cacheWrite ?? 0,
+                mediaCalls: 0,
+                mediaDurationSeconds: 0,
+                mediaCharacters: 0,
+            });
+        }
+        this.notifyListeners();
+    }
+    /**
+     * Add usage from a media generation call (non-token billing).
+     * Tracks quantities only (calls, seconds, characters); pricing is Hub/Admin's job.
+     */
+    addMediaUsage(model, billingUnit, quantity) {
+        const existing = this._modelUsage.get(model);
+        const entry = existing ?? {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheRead: 0,
+            cacheCreation: 0,
+            mediaCalls: 0,
+            mediaDurationSeconds: 0,
+            mediaCharacters: 0,
+        };
+        if (!existing)
+            this._modelUsage.set(model, entry);
+        entry.mediaCalls += 1; // always count the call
+        switch (billingUnit) {
+            case "per_second":
+                entry.mediaDurationSeconds += quantity;
+                break;
+            case "per_character":
+                entry.mediaCharacters += quantity;
+                break;
+            case "per_token":
+                entry.outputTokens += quantity;
+                break;
+            // per_call, per_pixel: already counted via mediaCalls
+        }
+        this.notifyListeners();
+    }
+    /** Record a tool call */
+    recordToolCall() {
+        this._toolCallCount++;
+    }
+    /** Increment turn count */
+    recordTurnCompleted() {
+        this._turnCount++;
+    }
+    // ── Snapshot / Restore ───────────────────────────────────
+    /**
+     * Create a snapshot for persistence.
+     * CC saveCurrentSessionCosts() parity.
+     */
+    createSnapshot() {
+        return {
+            sessionId: this.sessionId,
+            modelUsage: this.getAllModelUsage(),
+            totalInputTokens: this._totalInputTokens,
+            totalOutputTokens: this._totalOutputTokens,
+            turnCount: this._turnCount,
+            lastSavedAt: Date.now(),
+        };
+    }
+    /**
+     * Restore from a previous snapshot.
+     * CC setCostStateForRestore() parity.
+     *
+     * GUARD: Only restores if the snapshot's sessionId matches this session.
+     * Prevents cross-session cost leakage (CC's lastSessionId guard).
+     */
+    restoreFromSnapshot(snapshot) {
+        if (snapshot.sessionId !== this.sessionId) {
+            return false; // Different session don't restore
+        }
+        this._totalInputTokens = snapshot.totalInputTokens;
+        this._totalOutputTokens = snapshot.totalOutputTokens;
+        this._turnCount = snapshot.turnCount;
+        this._modelUsage.clear();
+        for (const [model, usage] of Object.entries(snapshot.modelUsage)) {
+            this._modelUsage.set(model, { ...usage });
+        }
+        this.notifyListeners();
+        return true;
+    }
+    // ── Listeners ────────────────────────────────────────────
+    /** Register a state change listener. Returns unsubscribe function. */
+    onStateChange(listener) {
+        this._listeners.add(listener);
+        return () => { this._listeners.delete(listener); };
+    }
+    notifyListeners() {
+        for (const listener of this._listeners) {
+            try {
+                listener();
+            }
+            catch { /* ignore listener errors */ }
+        }
+    }
+}
+// ── Factory ────────────────────────────────────────────────
+/**
+ * Create a new session state instance.
+ */
+export function createSessionState(sessionId) {
+    return new SessionState(sessionId);
+}

package/dist/runtime/session/session-summary.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessage } from "../../protocol/wire/index.js";
+import type { SessionMetadata, TaskSummaryDeps } from "./session-types.js";
+export declare function shouldGenerateTaskSummary(metadata: SessionMetadata): boolean;
+export declare function generateSessionTitle(userMessage: string, deps: TaskSummaryDeps): Promise<string | null>;
+export declare function maybeGenerateTaskSummary(sessionId: string, metadata: SessionMetadata, recentMessages: ChatMessage[], deps: TaskSummaryDeps, projectRoot: string): Promise<string | null>;

package/dist/runtime/session/session-summary.js

@@ -0,0 +1,67 @@
+import { TASK_SUMMARY_REGEN_INTERVAL, TASK_SUMMARY_TURN_THRESHOLD, } from "../config/tunable-defaults.js";
+import { persistTaskSummary } from "./session-metadata-store.js";
+const TITLE_GENERATION_PROMPT = "Based on the user's message below, generate a very short session title (2-8 Chinese characters or 3-6 English words). " +
+    "The title should capture the main topic or intent. Reply with ONLY the title text, no quotes, no punctuation.";
+export function shouldGenerateTaskSummary(metadata) {
+    if (metadata.turnCount < TASK_SUMMARY_TURN_THRESHOLD)
+        return false;
+    if (!metadata.taskSummaryGeneratedAt)
+        return true;
+    const turnsSinceLast = metadata.turnCount - (metadata.taskSummaryGeneratedAt ?? 0);
+    return turnsSinceLast >= TASK_SUMMARY_REGEN_INTERVAL;
+}
+export async function generateSessionTitle(userMessage, deps) {
+    if (!userMessage.trim())
+        return null;
+    try {
+        const stream = deps.transport.stream({
+            model: deps.model,
+            messages: [
+                { role: "system", content: TITLE_GENERATION_PROMPT },
+                { role: "user", content: userMessage.slice(0, 500) },
+            ],
+            tools: [],
+            maxTokens: 30,
+        }, deps.apiKey);
+        let title = "";
+        for await (const chunk of stream) {
+            if (chunk.type === "delta")
+                title += chunk.text;
+        }
+        title = title.trim().replace(/^["'""'']+|["'""'']+$/g, "");
+        return title || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function maybeGenerateTaskSummary(sessionId, metadata, recentMessages, deps, projectRoot) {
+    if (!shouldGenerateTaskSummary(metadata))
+        return null;
+    try {
+        const context = recentMessages.slice(-20);
+        const contextStr = context.map((message) => `[${message.role}]: ${typeof message.content === "string" ? message.content.slice(0, 500) : JSON.stringify(message.content).slice(0, 500)}`).join("\n");
+        const stream = deps.transport.stream({
+            model: deps.model,
+            messages: [
+                { role: "system", content: "Generate a concise task summary (~100 words) of what the user is working on in this session. Focus on the goal, key decisions, and current progress. Reply with ONLY the summary." },
+                { role: "user", content: contextStr },
+            ],
+            tools: [],
+            maxTokens: 200,
+        }, deps.apiKey);
+        let summary = "";
+        for await (const chunk of stream) {
+            if (chunk.type === "delta")
+                summary += chunk.text;
+        }
+        summary = summary.trim();
+        if (!summary)
+            return null;
+        await persistTaskSummary(sessionId, projectRoot, summary, metadata.turnCount);
+        return summary;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime/session/session-transcript-store.d.ts

@@ -0,0 +1,13 @@
+import type { ChatMessage } from "../../protocol/wire/index.js";
+import type { MessageDisplayMetadata, PersistedChatMessage, TokenUsage } from "./session-types.js";
+export interface TranscriptLoadResult {
+    messages: PersistedChatMessage[];
+    corruptLines: number;
+}
+export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot: string, turnId?: string, metadata?: {
+    usage?: TokenUsage;
+    displayMetadata?: MessageDisplayMetadata;
+}): Promise<boolean>;
+export declare function loadTranscript(sessionId: string, projectRoot: string, options?: {
+    includeDisplayMetadata?: boolean;
+}): Promise<TranscriptLoadResult | null>;

package/dist/runtime/session/session-transcript-store.js

@@ -0,0 +1,109 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getSessionDir, getTranscriptPath, TRANSCRIPT_FILE, } from "./session-paths.js";
+import { withTranscriptAppendOrder } from "./session-write-queue.js";
+export async function appendMessage(sessionId, message, projectRoot, turnId, metadata) {
+    const queueKey = `${projectRoot}\0${sessionId}`;
+    return withTranscriptAppendOrder(queueKey, async () => {
+        const dir = getSessionDir(sessionId, projectRoot);
+        try {
+            await fs.promises.mkdir(dir, { recursive: true });
+            await fs.promises.appendFile(path.join(dir, TRANSCRIPT_FILE), JSON.stringify(messageToRecord(message, turnId, metadata)) + "\n", "utf8");
+            return true;
+        }
+        catch (err) {
+            console.error(`[session-persistence] appendMessage failed for ${sessionId}: ${err.message}`);
+            return false;
+        }
+    });
+}
+export async function loadTranscript(sessionId, projectRoot, options = {}) {
+    let raw;
+    try {
+        raw = await fs.promises.readFile(getTranscriptPath(sessionId, projectRoot), "utf8");
+    }
+    catch {
+        return null;
+    }
+    const messages = [];
+    let corruptLines = 0;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            messages.push(recordToMessage(JSON.parse(line), options));
+        }
+        catch {
+            corruptLines++;
+        }
+    }
+    return { messages, corruptLines };
+}
+function messageToRecord(message, turnId, metadata) {
+    const record = {
+        role: message.role,
+        content: message.content,
+        ts: Date.now(),
+    };
+    if (turnId)
+        record.turnId = turnId;
+    if (metadata?.usage)
+        record.usage = metadata.usage;
+    if (metadata?.displayMetadata)
+        record.displayMetadata = metadata.displayMetadata;
+    if (message.tool_calls)
+        record.tool_calls = message.tool_calls;
+    if (message.tool_call_id)
+        record.tool_call_id = message.tool_call_id;
+    if (message.name)
+        record.name = message.name;
+    if (message.thinkingBlocks)
+        record.thinkingBlocks = message.thinkingBlocks;
+    if (message.imageUrls)
+        record.imageUrls = message.imageUrls;
+    if (message.videoUrls)
+        record.videoUrls = message.videoUrls;
+    if (message.audioUrls)
+        record.audioUrls = message.audioUrls;
+    if (message.fileIds)
+        record.fileIds = message.fileIds;
+    if (message.imageDetail)
+        record.imageDetail = message.imageDetail;
+    return record;
+}
+function recordToMessage(parsed, options) {
+    const message = {
+        role: parsed.role,
+        content: parsed.content ?? null,
+    };
+    if (parsed.tool_calls)
+        message.tool_calls = parsed.tool_calls;
+    if (parsed.tool_call_id)
+        message.tool_call_id = parsed.tool_call_id;
+    if (parsed.name)
+        message.name = parsed.name;
+    if (parsed.thinkingBlocks)
+        message.thinkingBlocks = parsed.thinkingBlocks;
+    if (parsed.imageUrls)
+        message.imageUrls = parsed.imageUrls;
+    if (parsed.videoUrls)
+        message.videoUrls = parsed.videoUrls;
+    if (parsed.audioUrls)
+        message.audioUrls = parsed.audioUrls;
+    if (parsed.fileIds)
+        message.fileIds = parsed.fileIds;
+    if (parsed.imageDetail)
+        message.imageDetail = parsed.imageDetail;
+    if (options.includeDisplayMetadata) {
+        if (parsed.turnId)
+            message.turnId = parsed.turnId;
+        if (parsed.usage)
+            message.usage = parsed.usage;
+        if (parsed.displayMetadata && typeof parsed.displayMetadata === "object") {
+            message.displayMetadata = parsed.displayMetadata;
+        }
+        if (typeof parsed.ts === "number")
+            message.timestamp = new Date(parsed.ts).toISOString();
+    }
+    return message;
+}

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

@@ -0,0 +1,77 @@
+import type { ChatMessage } from "../../protocol/wire/index.js";
+import type { TokenUsage } from "../../agent/types.js";
+import type { SessionUsageSnapshot } from "./session-state.js";
+export declare const SESSION_SCHEMA_VERSION = 1;
+export interface SessionMetadata {
+    schemaVersion?: number;
+    sessionId: string;
+    projectId: string;
+    createdAt: string;
+    lastActiveAt: string;
+    model?: string;
+    /** Agent that owns this session (e.g. "qlogicagent", "codex"). */
+    agentId?: string;
+    cwd?: string;
+    turnCount: number;
+    messageCount: number;
+    title?: string;
+    taskSummary?: string;
+    taskSummaryGeneratedAt?: number;
+    pinnedAt?: string;
+    archivedAt?: string;
+    sealedAt?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string;
+    type?: "personal" | "group";
+    ownerPlatform?: string;
+    ownerId?: string;
+    groupKey?: string;
+    groupName?: string;
+    groupPlatform?: string;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
+}
+export interface PersistedSession {
+    metadata: SessionMetadata;
+    messages: PersistedChatMessage[];
+}
+export interface MessageDisplayMetadata {
+    messageId?: string;
+    platform?: string;
+    sourceChannel?: string;
+    source?: string;
+    chatId?: string;
+    userId?: string;
+    userName?: string;
+}
+export interface PersistedChatMessage extends ChatMessage {
+    timestamp?: string;
+    turnId?: string;
+    usage?: TokenUsage;
+    displayMetadata?: MessageDisplayMetadata;
+}
+export interface SessionListEntry {
+    sessionId: string;
+    title?: string;
+    lastActiveAt: string;
+    messageCount: number;
+    model?: string;
+    agentId?: string;
+    pinnedAt?: string;
+    archivedAt?: string;
+    sealedAt?: string;
+    projectId: string;
+    type?: "personal" | "group";
+    createdAt: string;
+    groupKey?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string | null;
+}
+export interface TaskSummaryDeps {
+    transport: import("../ports/index.js").LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export type SessionMetadataPatch = Partial<Record<keyof SessionMetadata, SessionMetadata[keyof SessionMetadata] | null>>;
+export type SessionStateSaveMetadata = Partial<SessionMetadata>;
+export type { ChatMessage, SessionUsageSnapshot, TokenUsage };

package/dist/runtime/session/session-types.js

@@ -0,0 +1 @@
+export const SESSION_SCHEMA_VERSION = 1;

package/dist/runtime/session/session-write-queue.d.ts

@@ -0,0 +1,2 @@
+export declare function withSessionWriteLimit<T>(fn: () => Promise<T>): Promise<T>;
+export declare function withTranscriptAppendOrder<T>(sessionKey: string, fn: () => Promise<T>): Promise<T>;