qlogicagent 2.7.0 → 2.10.0

package/dist/types/runtime/pet/pet-consistency.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Pet Consistency Scorer — Vision model evaluation for character consistency (design §14.4).
+ *
+ * After generating SVGs (via skeleton or direct LLM), this module:
+ *   1. Renders each SVG state to compare against the reference/base
+ *   2. Uses Vision model to score visual consistency (0-10)
+ *   3. Retries generation if score < threshold
+ *
+ * Strategies used:
+ *   - Structured Prompt: fixed character description + only vary action
+ *   - Post-processing validation: Vision model scores after generation
+ *   - Part presence check: verify required DOM structure exists
+ */
+export interface ConsistencyResult {
+    state: string;
+    score: number;
+    passed: boolean;
+    feedback?: string;
+}
+export interface ConsistencyReport {
+    overallScore: number;
+    results: ConsistencyResult[];
+    passedAll: boolean;
+    retryStates: string[];
+}
+export interface ConsistencyOptions {
+    /** Minimum score to pass (0-10). Default: 6 */
+    threshold?: number;
+    /** Max retries per state. Default: 2 */
+    maxRetries?: number;
+    /** Reference SVG (base/idle state) to compare against */
+    referenceSvg: string;
+    /** Character description for context */
+    characterDesc: string;
+}
+declare const DEFAULT_THRESHOLD = 6;
+declare const DEFAULT_MAX_RETRIES = 2;
+/**
+ * Quick structural check: verify the SVG has consistent DOM structure.
+ * Returns a score 0-10 based on structural similarity to reference.
+ */
+export declare function structuralConsistencyScore(referenceSvg: string, candidateSvg: string): number;
+/**
+ * Build the Vision model prompt for consistency scoring.
+ */
+export declare function buildConsistencyPrompt(characterDesc: string, stateName: string): string;
+/**
+ * Parse Vision model response to extract score and feedback.
+ */
+export declare function parseConsistencyResponse(response: string): {
+    score: number;
+    feedback: string;
+};
+/**
+ * Run the full consistency check pipeline.
+ * Takes generated SVGs, scores each against reference, returns report.
+ *
+ * The `visionScore` callback is optional — if not provided, only structural
+ * scoring is used (faster, no LLM cost, but less accurate).
+ */
+export declare function evaluateConsistency(referenceSvg: string, stateSvgs: Record<string, string>, options?: {
+    threshold?: number;
+}): ConsistencyReport;
+/**
+ * Async consistency evaluation using Vision model for high-accuracy scoring.
+ * Falls back to structural scoring if Vision call fails.
+ */
+export declare function evaluateConsistencyWithVision(referenceSvg: string, stateSvgs: Record<string, string>, visionScore: (referenceSvg: string, candidateSvg: string, state: string) => Promise<{
+    score: number;
+    feedback: string;
+}>, options?: {
+    threshold?: number;
+}): Promise<ConsistencyReport>;
+/**
+ * Retry strategy: regenerate failed states with enhanced prompt.
+ * Returns a prompt modifier string that emphasizes consistency.
+ */
+export declare function buildRetryPrompt(characterDesc: string, state: string, feedback: string, attempt: number): string;
+export { DEFAULT_THRESHOLD, DEFAULT_MAX_RETRIES };

package/dist/types/runtime/pet/pet-context-injection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pet Context Injection — injects pet soul into agent system prompt.
+ *
+ * When a pet is hatched, this adds a brief section to the system prompt
+ * so the LLM "knows" the pet exists and can occasionally respond in character.
+ */
+import type { PetSoul } from "./pet-soul-service.js";
+export declare function petContextInjection(soul: PetSoul | null): string;

package/dist/types/runtime/pet/pet-file-loader.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pet File Loader — loads, validates, and sanitizes .pet bundles.
+ *
+ * Design §14.2: .pet is a zip file containing manifest.json + SVG states + thumbnail.
+ * Design §16.2: Security — SVG sanitize (remove scripts, foreign objects, event handlers).
+ *
+ * This module handles:
+ * - Zip extraction
+ * - Manifest JSON Schema validation
+ * - SVG sanitization (whitelist-based)
+ * - File size enforcement
+ */
+export interface PetManifest {
+    version: number;
+    name: string;
+    author: string;
+    created: string;
+    generator?: string;
+    source?: {
+        type: "image" | "text" | "dialogue";
+        prompt?: string;
+    };
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    states: Record<string, {
+        file: string;
+        loop: boolean;
+        duration?: number;
+    }>;
+    eyeTracking?: {
+        enabled: boolean;
+        pupils: string[];
+        maxOffset: number;
+    };
+    colors?: {
+        primary: string;
+        secondary?: string;
+        accent?: string;
+    };
+}
+export interface PetFileBundle {
+    manifest: PetManifest;
+    svgs: Record<string, string>;
+    thumbnail?: string;
+    hash: string;
+}
+/**
+ * Load and validate a .pet file from disk.
+ * Returns a PetFileBundle with sanitized SVGs, or throws on validation failure.
+ */
+export declare function loadPetFile(filePath: string): Promise<PetFileBundle>;
+/**
+ * Validate manifest structure. Throws on invalid.
+ */
+export declare function validatePetManifest(manifest: unknown): asserts manifest is PetManifest;
+/**
+ * Sanitize SVG content — remove dangerous elements and attributes.
+ * Whitelist-based approach (design §16.2).
+ */
+export declare function sanitizeSvg(svgContent: string): string;

package/dist/types/runtime/pet/pet-growth-engine.d.ts

@@ -0,0 +1,60 @@
+/**
+ * PetGrowthEngine — handles pet leveling, molting (脱壳升级), and ability unlocks.
+ *
+ * Design §13: Growth system
+ * - XP curve: level * 100 (linear P0, polynomial later)
+ * - Molting: every 5 levels triggers a "molt" event with visual upgrade
+ * - Abilities: unlocked at specific levels
+ * - Stats growth: each level-up slightly boosts one stat
+ */
+import type { PetStats, PetSoul } from "./pet-soul-service.js";
+export interface PetAbility {
+    id: string;
+    name: string;
+    description: string;
+    unlockedAtLevel: number;
+}
+export interface GrowthEvent {
+    type: "level_up" | "molt" | "ability_unlock";
+    level: number;
+    ability?: PetAbility;
+    moltStage?: number;
+}
+export interface MoltResult {
+    stage: number;
+    description: string;
+    statBoost: Partial<PetStats>;
+}
+export declare class PetGrowthEngine {
+    /**
+     * Calculate XP needed for next level.
+     * P0: linear 100*level
+     */
+    static xpForLevel(level: number): number;
+    /**
+     * Process XP gain and return all triggered growth events.
+     * Does NOT mutate the soul — caller is responsible for persisting.
+     */
+    static processXpGain(soul: PetSoul, xpGain: number): {
+        newLevel: number;
+        newXp: number;
+        events: GrowthEvent[];
+        statBoosts: Partial<PetStats>;
+    };
+    /**
+     * Get molt result for a given stage.
+     */
+    static getMoltResult(stage: number, currentStats: PetStats): MoltResult;
+    /**
+     * Get all unlocked abilities for a given level.
+     */
+    static getUnlockedAbilities(level: number): PetAbility[];
+    /**
+     * Get next upcoming ability.
+     */
+    static getNextAbility(level: number): PetAbility | null;
+    /**
+     * XP gain rules for different events.
+     */
+    static xpForEvent(event: string): number;
+}

package/dist/types/runtime/pet/pet-reaction-service.d.ts

@@ -0,0 +1,33 @@
+/**
+ * PetReactionService — probabilistic reaction generation after turns.
+ *
+ * P0: Local template pools (no LLM).
+ * P1+: LLM-generated personalized reactions via small model.
+ */
+import type { PetSoul } from "./pet-soul-service.js";
+export type ReactionPool = "greeting" | "completion" | "error" | "curiosity" | "bored" | "memory" | "tool_success";
+export type ReactionStyle = "normal" | "thinking" | "excited" | "sleepy";
+/**
+ * Determine whether a reaction should fire, and if so, return it.
+ * P0: uses local template pools.
+ */
+export declare function maybeGenerateReaction(eventMethod: string): {
+    text: string;
+    style: ReactionStyle;
+} | null;
+export interface LLMReactionContext {
+    turnSummary: string;
+    soul: PetSoul;
+}
+/**
+ * Generate a personalized reaction via small LLM call.
+ * Returns null on failure or timeout (graceful degradation to template pool).
+ * Max 50 tokens, under 2s.
+ *
+ * @param ctx Context for the reaction
+ * @param llmGenerate External function to call LLM (injected to avoid coupling)
+ */
+export declare function generateLLMReaction(ctx: LLMReactionContext, llmGenerate: (prompt: string, maxTokens: number) => Promise<string | null>): Promise<{
+    text: string;
+    style: ReactionStyle;
+} | null>;

package/dist/types/runtime/pet/pet-skeleton.d.ts

@@ -0,0 +1,70 @@
+/**
+ * PetSkeleton — SVG skeleton parameterization system (design §14.3 Plan A).
+ *
+ * Core idea: generate ONE base skeleton via LLM, then render each state by
+ * only varying animation parameters (pose, expression, effects).
+ * This ensures visual consistency across states without repeated LLM calls.
+ *
+ * Pipeline:
+ *   1. LLM generates a base SVG skeleton with labeled parts
+ *   2. We parse and decompose it into movable parts
+ *   3. Each state applies different CSS @keyframes to the same skeleton
+ */
+export interface PetSkeleton {
+    /** Raw SVG of the base pose (idle-like neutral pose) */
+    baseSvg: string;
+    /** Extracted part IDs found in the SVG */
+    parts: SkeletonPart[];
+    /** Color palette extracted from the base SVG */
+    colors: {
+        primary: string;
+        secondary: string;
+        accent?: string;
+    };
+    /** Character description used to generate this skeleton */
+    characterDesc: string;
+}
+export interface SkeletonPart {
+    id: string;
+    type: "body" | "head" | "left-eye" | "right-eye" | "left-arm" | "right-arm" | "accessory" | "effect";
+    /** CSS selector for this part within the SVG */
+    selector: string;
+}
+export interface StateAnimationParams {
+    body: BodyAnimation;
+    eyes: EyeExpression;
+    arms: ArmPose;
+    effects?: EffectOverlay[];
+}
+export type BodyAnimation = "breathe" | "sway" | "lean" | "tilt" | "shrink" | "bounce" | "still" | "float";
+export type EyeExpression = "blink" | "lookup" | "focus" | "closed" | "wide" | "sparkle" | "dizzy" | "sleepy";
+export type ArmPose = "sway" | "still" | "hammer" | "wave" | "raised" | "covering" | "hold" | "eat";
+export type EffectOverlay = "zzz" | "sparkle" | "sweat" | "question" | "ellipsis" | "heart" | "exclaim" | "music";
+export declare const STATE_ANIMATION_MAP: Record<string, StateAnimationParams>;
+/**
+ * Generate the base skeleton prompt for LLM.
+ * The LLM generates ONE SVG with labeled groups that we can animate differently per state.
+ */
+export declare function buildSkeletonPrompt(characterDesc: string): string;
+/**
+ * Parse a skeleton SVG and identify parts.
+ */
+export declare function parseSkeleton(svgText: string): SkeletonPart[];
+/**
+ * Render a specific state by injecting CSS animations into the skeleton SVG.
+ * The skeleton remains identical — only the <style> block changes.
+ */
+export declare function renderState(skeleton: PetSkeleton, state: string): string;
+/**
+ * Extract primary/secondary colors from an SVG string.
+ * Looks for fill/stop-color attributes and picks the two most frequent.
+ */
+export declare function extractColors(svgText: string): {
+    primary: string;
+    secondary: string;
+};
+/**
+ * Validate that a skeleton SVG has the required part structure.
+ * Returns list of missing parts (empty = valid).
+ */
+export declare function validateSkeleton(svgText: string): string[];

package/dist/types/runtime/pet/pet-soul-service.d.ts

@@ -0,0 +1,71 @@
+/**
+ * PetSoulService — manages pet identity (hatching, persistence, stats).
+ *
+ * Hatching: deterministic identity via hash(userId) + LLM-generated soul.
+ * Persistence: stored in project workspace under .qlogicagent/pet/soul.json
+ */
+export interface PetStats {
+    grip: number;
+    patience: number;
+    curiosity: number;
+    appetite: number;
+    humor: number;
+}
+export interface PetSoul {
+    name: string;
+    species: string;
+    personality: string;
+    catchphrase: string;
+    stats: PetStats;
+    rarity: string;
+    breed?: string;
+    breedColors?: {
+        primary: string;
+        secondary: string;
+    };
+    level: number;
+    experience: number;
+    hatchedAt: string;
+}
+/** Breed system (design §6.2): 7 breeds with deterministic hash selection. */
+export interface PetBreed {
+    name: string;
+    colors: {
+        primary: string;
+        secondary: string;
+    };
+    rarity: string;
+}
+export declare class PetSoulService {
+    private workspaceDir;
+    private soul;
+    private storagePath;
+    constructor(workspaceDir: string);
+    /**
+     * Load existing soul from disk. Returns null if not hatched.
+     */
+    load(): PetSoul | null;
+    /**
+     * Hatch a new pet soul. Uses LLM for name/personality/catchphrase.
+     * If generateSoul is provided, uses it; otherwise falls back to defaults.
+     */
+    hatch(userId: string, generateSoul?: (rarity: string, stats: PetStats) => Promise<{
+        name: string;
+        personality: string;
+        catchphrase: string;
+    }>): Promise<PetSoul>;
+    /**
+     * Add experience points. Returns true if leveled up.
+     */
+    addExperience(xp: number): {
+        leveledUp: boolean;
+        level: number;
+        experience: number;
+    };
+    getSoul(): PetSoul | null;
+    /**
+     * Update soul (e.g., after growth/stat changes) and persist.
+     */
+    updateSoul(soul: PetSoul): void;
+    private persist;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Group Session Auto-Split — detects idle group sessions and creates successor sessions.
+ *
+ * When a group chat message arrives and the last session activity was > N hours ago,
+ * the old session is sealed and a new session is created with:
+ *   - previousSessionId linking to the predecessor
+ *   - carryoverSummary (from predecessor's taskSummary or last messages)
+ *   - Same groupKey, groupName, groupPlatform, projectId
+ *
+ * This prevents unbounded context growth in long-lived group chats.
+ */
+import { type SessionMetadata } from "./session-persistence.js";
+export interface GroupSplitResult {
+    /** Whether a split occurred */
+    split: boolean;
+    /** The session ID to use for the current turn (new or existing) */
+    activeSessionId: string;
+    /** If split, the sealed predecessor session ID */
+    sealedSessionId?: string;
+}
+/**
+ * Check whether a group session should be auto-split due to idle timeout.
+ * If yes, seal the old session and create a new successor.
+ *
+ * @param currentSession - The existing group session metadata
+ * @param projectRoot - The project workspace directory
+ * @returns Split result with the session ID to use
+ */
+export declare function maybeAutoSplitGroupSession(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;
+/**
+ * Check whether a group session has exceeded MAX_TURNS hard limit.
+ * Called AFTER turn.end — soft-splits without interrupting the current turn.
+ *
+ * @param currentSession - The session that just finished a turn
+ * @param projectRoot - The project workspace directory
+ * @returns Split result (new session ready for next message, or no-op)
+ */
+export declare function maybeHardLimitSplit(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;

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

@@ -1,2 +1,4 @@
-export { SessionState, type SessionUsageSnapshot, type SessionCostSnapshot } from "./session-state.js";
-export { appendMessage, saveSessionState, updateSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";
+export { SessionState, type SessionUsageSnapshot } from "./session-state.js";
+export { SessionLocator } from "./session-locator.js";
+export { appendMessage, saveSessionState, updateSessionMetadata, getSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";
+export { maybeAutoSplitGroupSession, type GroupSplitResult } from "./group-session-split.js";

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

@@ -0,0 +1,24 @@
+/**
+ * SessionLocator — resolves session storage paths from projectId.
+ *
+ * Every session operation uses this locator to determine the correct
+ * filesystem path based on the session's owning projectId.
+ * When projectId is missing, falls back to scanning all projects.
+ */
+export declare class SessionLocator {
+    /** Get sessions root directory for a given projectId. */
+    getSessionsRoot(projectId: string): string;
+    /** Get the workspace dir for a project. */
+    getProjectWorkspaceDir(projectId: string): string;
+    /** Get the session directory path for a given projectId + sessionId. */
+    getSessionDir(projectId: string, sessionId: string): string;
+    /**
+     * Resolve the workspaceDir for a session given its projectId.
+     * If projectId is not provided, scans all projects for the session directory.
+     */
+    resolveWorkspaceDir(sessionId: string, projectId?: string): string;
+    /** Get the active project's workspace dir (for new session creation when no projectId specified). */
+    getActiveProjectWorkspaceDir(): string;
+    /** Get the active project's ID. */
+    getActiveProjectId(): string;
+}

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

@@ -1,9 +1,9 @@
 /**
- * SessionMemory 鈥?In-memory session message store with JSONL persistence.
+ * SessionMemoryIn-memory session message store with JSONL persistence.
  *
  * CC alignment: messages live in memory during the session lifetime.
  * JSONL is the sole persistent source of truth (for crash recovery).
- * Gateway never owns message data 鈥?Agent is the single authority.
+ * Gateway never owns message dataAgent is the single authority.
  *
  * Design:
  *   - Map<sessionId, ChatMessage[]> holds active session messages
@@ -15,7 +15,7 @@ import type { ChatMessage } from "../../protocol/wire/index.js";
 export declare class SessionMemory {
     private sessions;
     private projectRoot;
-    constructor(projectRoot?: string);
+    constructor(projectRoot: string);
     setProjectRoot(projectRoot: string): void;
     /**
      * Get messages for a session. Lazy-loads from JSONL on first access.
@@ -35,7 +35,7 @@ export declare class SessionMemory {
     initSession(sessionId: string): void;
     /**
      * Drop a session from memory (e.g., on session.ended).
-     * Does NOT delete JSONL 鈥?data persists for future resume.
+     * Does NOT delete JSONLdata persists for future resume.
      */
     evictSession(sessionId: string): void;
     /**

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

@@ -1,113 +1,113 @@
 /**
- * Session Persistence 鈥?CC sessionRestore.ts + conversationRecovery.ts parity.
+ * Session Persistence — CC sessionRestore.ts + conversationRecovery.ts parity.
  *
  * Enables conversation resume by persisting:
  *   1. Message transcript (JSONL-based, append-only)
- *   2. Cost snapshot (atomic JSON)
- *   3. Session metadata (model, cwd, agent mode)
+ *   2. Session metadata (flat JSON, atomic write)
  *
- * Storage layout:
- *   <project>/.qlogicagent/sessions/<session-id>/   (when projectRoot provided)
- *   ~/.qlogicagent/sessions/<session-id>/            (fallback)
- *     transcript.jsonl   鈥?append-only message log
- *     state.json          鈥?cost snapshot + metadata
+ * Storage layout (ALL data lives under project workspace, NEVER global):
+ *   <project>/.qlogicagent/sessions/<session-id>/
+ *     transcript.jsonl   — append-only message log
+ *     metadata.json      — flat session metadata + usage stats
  *
  * Resume flow (CC processResumedConversation parity):
- *   1. loadSessionForResume(sessionId) 鈫?messages + cost
- *   2. Restore cost state into SessionState
+ *   1. loadSessionForResume(sessionId) → messages + metadata
+ *   2. Restore usage state into SessionState
  *   3. Feed messages as initial context to agent
- *
- * Reference: claude-code src/utils/sessionRestore.ts
- *            claude-code src/utils/conversationRecovery.ts
  */
 import type { ChatMessage } from "../../protocol/wire/index.js";
-import type { SessionCostSnapshot } from "./session-state.js";
+import type { SessionUsageSnapshot } from "./session-state.js";
 export interface SessionMetadata {
     sessionId: string;
-    createdAt: number;
-    lastActiveAt: number;
+    projectId: string;
+    createdAt: string;
+    lastActiveAt: string;
     model?: string;
     cwd?: string;
     turnCount: number;
     messageCount: number;
-    /** Title / description (auto-generated or user-set) */
     title?: string;
-    /** Task summary generated by LLM (CC maybeGenerateTaskSummary parity) */
     taskSummary?: string;
-    /** Timestamp of last task summary generation */
     taskSummaryGeneratedAt?: number;
-    /** ISO timestamp 鈥?session pinned in UI */
     pinnedAt?: string;
-    /** ISO timestamp 鈥?session archived (soft-deleted) */
     archivedAt?: string;
-    /** Project ID this session belongs to */
-    projectId?: string;
-    /** Session type: personal or group */
+    sealedAt?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string;
     type?: "personal" | "group";
-    /** Owner user ID */
     ownerId?: string;
-    /** Group key for group sessions */
     groupKey?: string;
-    /** Group display name */
     groupName?: string;
-    /** Group platform (wechat, dingtalk, etc.) */
     groupPlatform?: string;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
 }
 export interface PersistedSession {
     metadata: SessionMetadata;
     messages: ChatMessage[];
-    costSnapshot?: SessionCostSnapshot;
 }
 export interface SessionListEntry {
     sessionId: string;
     title?: string;
-    lastActiveAt: number;
+    lastActiveAt: string;
     messageCount: number;
     model?: string;
     pinnedAt?: string;
     archivedAt?: string;
-    projectId?: string;
+    sealedAt?: string;
+    projectId: string;
     type?: "personal" | "group";
-    createdAt?: number;
+    createdAt: string;
+    groupKey?: string;
+    previousSessionId?: string;
+    carryoverSummary?: string | null;
 }
+/**
+ * Load session metadata only (lightweight — no transcript loading).
+ * Returns null if session doesn't exist or metadata is unreadable.
+ */
+export declare function getSessionMetadata(sessionId: string, projectRoot: string): SessionMetadata | null;
 /**
  * Append a message to the session transcript.
  * Creates the session directory if it doesn't exist.
  * When turnId is provided, it acts as a per-turn boundary marker enabling
  * reconciliation with Gateway's token_usage records.
+ *
+ * Robustness: catches disk-full and I/O errors without crashing the agent.
+ * Returns false if the write fails.
  */
-export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot?: string, turnId?: string): Promise<void>;
+export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot: string, turnId?: string): Promise<boolean>;
 /**
- * Save session state (cost + metadata) atomically.
+ * Save session metadata + usage stats atomically (flat structure).
  */
-export declare function saveSessionState(sessionId: string, costSnapshot: SessionCostSnapshot, metadata: Partial<SessionMetadata>, projectRoot?: string): Promise<void>;
+export declare function saveSessionState(sessionId: string, usageSnapshot: SessionUsageSnapshot, metadata: Partial<SessionMetadata>, projectRoot: string): Promise<void>;
 /**
  * Update specific metadata fields of a session without touching cost data.
  * Used by session CRUD RPC (rename, pin, archive, move-to-project).
  */
-export declare function updateSessionMetadata(sessionId: string, patch: Partial<SessionMetadata>, projectRoot?: string): Promise<SessionMetadata | null>;
+export declare function updateSessionMetadata(sessionId: string, patch: Partial<Record<keyof SessionMetadata, SessionMetadata[keyof SessionMetadata] | null>>, projectRoot: string): Promise<SessionMetadata | null>;
 /**
- * Load a persisted session for resume 鈥?CC loadConversationForResume parity.
+ * Load a persisted session for resume — CC loadConversationForResume parity.
  *
  * Returns null if the session doesn't exist or is corrupted.
  */
-export declare function loadSessionForResume(sessionId: string, projectRoot?: string): Promise<PersistedSession | null>;
+export declare function loadSessionForResume(sessionId: string, projectRoot: string): Promise<PersistedSession | null>;
 /**
- * List available sessions for resume 鈥?CC ResumeConversation picker.
+ * List available sessions for resume CC ResumeConversation picker.
  * Returns most-recent-first, up to `limit` entries.
  */
-export declare function listSessions(limit?: number, projectRoot?: string): Promise<SessionListEntry[]>;
+export declare function listSessions(limit: number | undefined, projectRoot: string): Promise<SessionListEntry[]>;
 /**
  * Delete a session (cleanup).
  */
-export declare function deleteSession(sessionId: string, projectRoot?: string): Promise<void>;
+export declare function deleteSession(sessionId: string, projectRoot: string): Promise<void>;
 /**
  * Prune old sessions beyond MAX_SESSIONS limit.
  * Deletes oldest sessions first.
  */
-export declare function pruneOldSessions(projectRoot?: string): Promise<number>;
+export declare function pruneOldSessions(projectRoot: string): Promise<number>;
 export interface TaskSummaryDeps {
-    transport: import("../../llm/transport.js").LLMTransport;
+    transport: import("@qlogic/provider-core").LLMTransport;
     apiKey: string;
     model: string;
 }
@@ -117,7 +117,8 @@ export interface TaskSummaryDeps {
  */
 export declare function shouldGenerateTaskSummary(metadata: SessionMetadata): boolean;
 /**
- * Generate and persist a task summary for a long session.
- * Fire-and-forget 鈥?errors are swallowed.
+ * Generate a concise session title from the user's first message.
+ * Lightweight LLM call — one-shot, no tool loop.
  */
-export declare function maybeGenerateTaskSummary(sessionId: string, metadata: SessionMetadata, recentMessages: ChatMessage[], deps: TaskSummaryDeps, projectRoot?: string): Promise<string | null>;
+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>;