paseo-acp-agy 1.2.6 → 1.2.7

package/dist/paseo-patcher.js

@@ -716,35 +716,70 @@ export async function fetchAntigravityUsage() {
 
         for (const rawLine of lines) {
             const line = rawLine.trim();
-            if (!line) continue;
+            if (!line || line.toLowerCase().startsWith("quota:")) continue;
 
-            if (line.endsWith(":") && !line.includes("%")) {
-                currentModel = line.slice(0, -1).trim();
-                continue;
-            }
-
-            const isGemini = /gemini/i.test(currentModel) || !/claude/i.test(currentModel);
-            const match = line.match(/^([A-Za-z0-9\\s_-]+):\\s*(\\d+)%\\s*(?:used)?(?:\\s*\\((?:resets?\\s+in\\s+)?([^)]+)\\))?/i);
-            if (match) {
-                const limitType = match[1].trim();
-                const usedPct = parseInt(match[2], 10);
-                const resetStr = match[3] ? match[3].trim() : null;
+            let scope = currentModel;
+            let limitType = "";
+            let remainingPct = null;
+            let resetsAt = null;
 
-                let resetsAt = null;
-                if (resetStr) {
-                    const durMatch = resetStr.match(/(?:(\\d+)h)?\\s*(?:(\\d+)m)?/i);
-                    if (durMatch && (durMatch[1] || durMatch[2])) {
-                        const h = parseInt(durMatch[1] || "0", 10);
-                        const m = parseInt(durMatch[2] || "0", 10);
-                        resetsAt = new Date(Date.now() + (h * 3600 + m * 60) * 1000).toISOString();
-                    } else {
-                        const parsed = Date.parse(resetStr);
-                        if (!isNaN(parsed)) resetsAt = new Date(parsed).toISOString();
+            // Format 1: Table format e.g. "Gemini Models   Weekly Limit Remaining   56%   2026-10-14 04:37 UTC"
+            const m = line.match(/^(.*?)\\s{2,}(.*?Remaining)\\s+(\\d+)%(?:\\s+(.*))?$/i);
+            if (m) {
+                scope = m[1].trim();
+                limitType = m[2].trim();
+                remainingPct = parseInt(m[3], 10);
+                if (m[4]) {
+                    try {
+                        const d = new Date(m[4].trim());
+                        resetsAt = isNaN(d.getTime()) ? null : d.toISOString();
+                    } catch {}
+                }
+            } else {
+                // Format 2: Tab / multi-space separated
+                const parts = line.split(/\\t+|\\s{2,}/).map(p => p.trim());
+                if (parts.length >= 3 && parts[1]?.toLowerCase().includes("remaining")) {
+                    scope = parts[0];
+                    limitType = parts[1];
+                    const remMatch = parts[2].match(/(\\d+)%/);
+                    if (remMatch) remainingPct = parseInt(remMatch[1], 10);
+                    if (parts[3]) {
+                        try {
+                            const d = new Date(parts[3]);
+                            resetsAt = isNaN(d.getTime()) ? null : d.toISOString();
+                        } catch {}
+                    }
+                } else if (line.endsWith(":") && !line.includes("%")) {
+                    currentModel = line.slice(0, -1).trim();
+                    continue;
+                } else {
+                    // Format 3: Colon format e.g. "Session: 20% used (resets in 2h)"
+                    const colonMatch = line.match(/^([A-Za-z0-9\\s_-]+):\\s*(\\d+)%\\s*(?:used)?(?:\\s*\\((?:resets?\\s+in\\s+)?([^)]+)\\))?/i);
+                    if (colonMatch) {
+                        limitType = colonMatch[1].trim();
+                        const usedVal = parseInt(colonMatch[2], 10);
+                        remainingPct = Math.max(0, 100 - usedVal);
+                        const resetStr = colonMatch[3] ? colonMatch[3].trim() : null;
+                        if (resetStr) {
+                            const durMatch = resetStr.match(/(?:(\\d+)h)?\\s*(?:(\\d+)m)?/i);
+                            if (durMatch && (durMatch[1] || durMatch[2])) {
+                                const h = parseInt(durMatch[1] || "0", 10);
+                                const m = parseInt(durMatch[2] || "0", 10);
+                                resetsAt = new Date(Date.now() + (h * 3600 + m * 60) * 1000).toISOString();
+                            } else {
+                                const parsed = Date.parse(resetStr);
+                                if (!isNaN(parsed)) resetsAt = new Date(parsed).toISOString();
+                            }
+                        }
                     }
                 }
+            }
 
-                const isFiveHour = /session|5-?hour|5h/i.test(limitType);
+            if (remainingPct !== null && !isNaN(remainingPct)) {
+                const usedPct = Math.max(0, Math.min(100, 100 - remainingPct));
+                const isFiveHour = /session|five\\s*hour|5-?hour|5h/i.test(limitType);
                 const isWeekly = /week|7-?day/i.test(limitType);
+                const isGemini = /gemini/i.test(scope) || !/claude/i.test(scope);
 
                 let id = isFiveHour ? "session" : isWeekly ? "weekly" : "quota";
                 let label = isFiveHour ? "Session" : isWeekly ? "Weekly" : limitType.replace(/\\s+Remaining$/i, "");
@@ -759,7 +794,7 @@ export async function fetchAntigravityUsage() {
                     shortLabel: isFiveHour ? "5h" : isWeekly ? "wk" : "",
                     summary: true,
                     usedPct,
-                    remainingPct: Math.max(0, 100 - usedPct),
+                    remainingPct,
                     resetsAt,
                     tone: toneFromUsedPct(usedPct),
                     isFiveHour,
@@ -826,7 +861,7 @@ export function registerAntigravityUsageSource(server) {
             icon: "icon.svg",
             input: z.object({}).passthrough(),
             discover: async (scope) => {
-                if (scope && scope.kind === "session" && scope.provider && scope.provider !== "antigravity") {
+                if (scope && scope.kind === "session" && scope.provider && scope.provider !== "antigravity" && scope.provider !== "acp") {
                     return [];
                 }
                 return [{ key: "default", label: "Antigravity", input: {} }];
@@ -903,19 +938,18 @@ export function patchPaseoServer(serverDir) {
                         indexModified = true;
                     }
                     // Inject registration call into contribute function
-                    const contributeMatch = indexCode.match(/(export\s+default\s+function\s+contribute\s*\([^)]*\)\s*\{)([\s\S]*?)(\})/);
-                    if (contributeMatch) {
-                        const before = contributeMatch[1];
-                        const body = contributeMatch[2];
-                        const after = contributeMatch[3];
-                        if (!body.includes("registerAntigravityUsageSource")) {
-                            const patchedBody = body.replace(/return\s+\(\)\s*=>\s*\{[^}]*\};?/, (m) => `server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n  ${m}`);
-                            if (patchedBody !== body) {
-                                indexCode = indexCode.replace(contributeMatch[0], `${before}${patchedBody}${after}`);
-                                indexModified = true;
-                            }
-                            else {
-                                indexCode = indexCode.replace(contributeMatch[0], `${before}${body}\n  server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n${after}`);
+                    if (!indexCode.includes("registerAntigravityUsageSource(server)")) {
+                        if (/return\s*\(\)\s*=>/.test(indexCode)) {
+                            indexCode = indexCode.replace(/return\s*\(\)\s*=>/, "server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n  return () =>");
+                            indexModified = true;
+                        }
+                        else {
+                            const lastBraceIndex = indexCode.lastIndexOf("}");
+                            if (lastBraceIndex !== -1) {
+                                indexCode =
+                                    indexCode.slice(0, lastBraceIndex) +
+                                        "  server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n" +
+                                        indexCode.slice(lastBraceIndex);
                                 indexModified = true;
                             }
                         }
@@ -1101,11 +1135,112 @@ ${indent}}`;
                     }
                 }
             }
+            // Patch usageSession() in ACPAgentSession for Paseo 0.11+ usage reporting
+            if (!acpCode.includes("usageSession()")) {
+                const constructorEndMatch = acpCode.match(/(?:^|\n)([ \t]*)this\.extensionCommandsParser\s*=[^;\n]*;[ \t]*\r?\n([ \t]*)\}/);
+                if (constructorEndMatch && constructorEndMatch.index !== undefined) {
+                    const indent = constructorEndMatch[1] || "        ";
+                    const braceIndent = constructorEndMatch[2] || "    ";
+                    const usageSnippet = `this.usageSessionKey = typeof randomUUID === "function" ? randomUUID() : Math.random().toString(36).slice(2);
+${braceIndent}}
+${braceIndent}usageSession() {
+${braceIndent}    if (this.closed)
+${braceIndent}        return null;
+${braceIndent}    if (!this.usageSessionKey) {
+${braceIndent}        this.usageSessionKey = typeof randomUUID === "function" ? randomUUID() : Math.random().toString(36).slice(2);
+${braceIndent}    }
+${braceIndent}    return {
+${braceIndent}        provider: this.provider,
+${braceIndent}        model: this.currentModel ?? this.config?.model,
+${braceIndent}        env: (this.launchEnv && typeof this.launchEnv === "object") ? this.launchEnv : {},
+${braceIndent}        sessionKey: this.usageSessionKey,
+${braceIndent}    };
+${braceIndent}}`;
+                    acpCode = acpCode.replace(/(?:^|\n)([ \t]*)this\.extensionCommandsParser\s*=[^;\n]*;[ \t]*\r?\n([ \t]*)\}/, (match, ind1) => `\n${ind1}this.extensionCommandsParser = options.extensionCommandsParser;\n${ind1}${usageSnippet}`);
+                    acpModified = true;
+                }
+                else {
+                    const sessionClassMatch = acpCode.match(/(?:export\s+)?class\s+ACPAgentSession\b[^{]*\{/);
+                    if (sessionClassMatch && sessionClassMatch.index !== undefined) {
+                        const insertPos = sessionClassMatch.index + sessionClassMatch[0].length;
+                        const usageSnippet = `\n    usageSession() {
+        if (this.closed)
+            return null;
+        if (!this.usageSessionKey) {
+            this.usageSessionKey = typeof randomUUID === "function" ? randomUUID() : Math.random().toString(36).slice(2);
+        }
+        return {
+            provider: this.provider,
+            model: this.currentModel ?? this.config?.model,
+            env: (this.launchEnv && typeof this.launchEnv === "object") ? this.launchEnv : {},
+            sessionKey: this.usageSessionKey,
+        };
+    }`;
+                        acpCode = acpCode.slice(0, insertPos) + usageSnippet + acpCode.slice(insertPos);
+                        acpModified = true;
+                    }
+                }
+            }
             if (acpModified) {
                 fs.writeFileSync(acpFile, acpCode, "utf-8");
                 changes.push(`Patched ${acpFile} for context-window token telemetry and usage updates`);
             }
         }
+        // 4. Locate and patch plugin-provider.js (if present) for Paseo 0.11+
+        const pluginProviderCandidates = [
+            path.join(serverDir, "dist", "server", "server", "agent", "plugin-provider.js"),
+            path.join(serverDir, "dist", "server", "agent", "plugin-provider.js"),
+            path.join(serverDir, "dist", "agent", "plugin-provider.js"),
+        ];
+        let pluginProviderFile = pluginProviderCandidates.find((f) => fs.existsSync(f));
+        if (!pluginProviderFile && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findPluginProvider = (dir, depth = 0) => {
+                if (depth > 5)
+                    return null;
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const e of entries) {
+                        const full = path.join(dir, e.name);
+                        if (e.isDirectory() && e.name !== "node_modules") {
+                            const found = findPluginProvider(full, depth + 1);
+                            if (found)
+                                return found;
+                        }
+                        else if (e.isFile() && e.name === "plugin-provider.js") {
+                            return full;
+                        }
+                    }
+                }
+                catch { }
+                return null;
+            };
+            pluginProviderFile = findPluginProvider(path.join(serverDir, "dist")) || undefined;
+        }
+        if (pluginProviderFile) {
+            let ppCode = fs.readFileSync(pluginProviderFile, "utf-8");
+            if (!ppCode.includes("usageSession()")) {
+                const ppClassMatch = ppCode.match(/(?:export\s+)?class\s+PluginAgentSession\b[^{]*\{/);
+                if (ppClassMatch && ppClassMatch.index !== undefined) {
+                    const insertPos = ppClassMatch.index + ppClassMatch[0].length;
+                    const ppUsage = `\n    usageSession() {
+        if (this.closed)
+            return null;
+        if (!this.usageSessionKey) {
+            this.usageSessionKey = typeof randomUUID === "function" ? randomUUID() : Math.random().toString(36).slice(2);
+        }
+        return {
+            provider: this.provider,
+            model: this.bridge?.config?.model,
+            env: (this.bridge?.launch?.env && typeof this.bridge?.launch?.env === "object") ? this.bridge.launch.env : {},
+            sessionKey: this.usageSessionKey,
+        };
+    }`;
+                    ppCode = ppCode.slice(0, insertPos) + ppUsage + ppCode.slice(insertPos);
+                    fs.writeFileSync(pluginProviderFile, ppCode, "utf-8");
+                    changes.push(`Patched ${pluginProviderFile} with usageSession for plugin provider sessions`);
+                }
+            }
+        }
         return { success: true, changes };
     }
     catch (err) {
@@ -1540,6 +1675,9 @@ export function isPaseoServerPatched(serverDir) {
             if (!content.includes("this.currentTurnUsage =") || !content.includes("contextWindowMaxTokens")) {
                 return false;
             }
+            if (pluginDir && !content.includes("usageSession()")) {
+                return false;
+            }
         }
         return true;
     }

package/dist/protocol.d.ts

@@ -106,6 +106,11 @@ export declare const ACP_METHODS: {
     readonly SESSION_LOAD_ALIAS: "loadSession";
     readonly SESSION_RESUME: "session/resume";
     readonly SESSION_RESUME_ALIAS: "unstable_resumeSession";
+    readonly SESSION_LIST: "session/list";
+    readonly SESSION_LIST_CAMEL: "session/listSessions";
+    readonly SESSION_LIST_ALIAS: "sessionList";
+    readonly SESSION_FORK: "session/fork";
+    readonly SESSION_FORK_ALIAS: "forkSession";
     readonly SESSION_PROMPT: "session/prompt";
     readonly SESSION_PROMPT_ALIAS: "prompt";
     readonly SESSION_CANCEL: "session/cancel";
@@ -123,6 +128,13 @@ export declare const ACP_METHODS: {
     readonly SESSION_SET_CONFIG_OPTION_ALIAS: "setSessionConfigOption";
     readonly SESSION_UPDATE: "session/update";
 };
+export interface SessionInfo {
+    sessionId: string;
+    cwd: string;
+    title?: string | null;
+    updatedAt?: string | null;
+    _meta?: Record<string, unknown> | null;
+}
 export type ToolKind = "read" | "edit" | "execute" | "fetch" | "other";
 export declare function mapToolNameToKind(toolName: string): ToolKind;
 export declare function extractPromptText(promptInput: unknown): string;

package/dist/protocol.js

@@ -16,6 +16,11 @@ export const ACP_METHODS = {
     SESSION_LOAD_ALIAS: "loadSession",
     SESSION_RESUME: "session/resume",
     SESSION_RESUME_ALIAS: "unstable_resumeSession",
+    SESSION_LIST: "session/list",
+    SESSION_LIST_CAMEL: "session/listSessions",
+    SESSION_LIST_ALIAS: "sessionList",
+    SESSION_FORK: "session/fork",
+    SESSION_FORK_ALIAS: "forkSession",
     SESSION_PROMPT: "session/prompt",
     SESSION_PROMPT_ALIAS: "prompt",
     SESSION_CANCEL: "session/cancel",
@@ -136,6 +141,8 @@ export const MODEL_PRICING = {
     "gemini-3.7-flash": { inputCostPerM: 0.10, outputCostPerM: 0.40, cachedInputCostPerM: 0.025 },
     "gemini-3.6-flash": { inputCostPerM: 0.10, outputCostPerM: 0.40, cachedInputCostPerM: 0.025 },
     "gemini-3.1-pro": { inputCostPerM: 1.25, outputCostPerM: 5.00, cachedInputCostPerM: 0.3125 },
+    "claude-opus-5-5": { inputCostPerM: 15.00, outputCostPerM: 75.00, cachedInputCostPerM: 1.50 },
+    "claude-sonnet-5-5": { inputCostPerM: 3.00, outputCostPerM: 15.00, cachedInputCostPerM: 0.30 },
     "claude-sonnet-4-6": { inputCostPerM: 3.00, outputCostPerM: 15.00, cachedInputCostPerM: 0.30 },
     "claude-opus-4-6-thinking": { inputCostPerM: 15.00, outputCostPerM: 75.00, cachedInputCostPerM: 1.50 },
     "gpt-oss-120b": { inputCostPerM: 0.15, outputCostPerM: 0.60, cachedInputCostPerM: 0.0375 },
@@ -145,6 +152,8 @@ export const MODEL_CONTEXT_WINDOWS = {
     "gemini-3.7-flash": 1_048_576,
     "gemini-3.6-flash": 1_048_576,
     "gemini-3.1-pro": 2_097_152,
+    "claude-opus-5-5": 200_000,
+    "claude-sonnet-5-5": 200_000,
     "claude-sonnet-4-6": 200_000,
     "claude-opus-4-6-thinking": 200_000,
     "gpt-oss-120b": 128_000,
@@ -178,14 +187,14 @@ export function getModelPricing(modelId) {
     if (lower.includes("pro"))
         return MODEL_PRICING["gemini-3.1-pro"];
     if (lower.includes("flash"))
-        return MODEL_PRICING["gemini-3.7-flash"];
+        return MODEL_PRICING["gemini-3.8-flash"];
     if (lower.includes("gpt-oss"))
         return MODEL_PRICING["gpt-oss-120b"];
     return null;
 }
 // Keep costs at full JavaScript floating-point precision. Rounding happens
 // only when values are serialized for the UI so micro-costs accumulate.
-export function calculateUsageCostUsd(modelId = "gemini-3.7-flash", inputTokens = 0, outputTokens = 0, cachedInputTokens = 0) {
+export function calculateUsageCostUsd(modelId = "gemini-3.8-flash", inputTokens = 0, outputTokens = 0, cachedInputTokens = 0) {
     const pricing = getModelPricing(modelId);
     if (!pricing)
         return 0;
@@ -389,6 +398,8 @@ export const FALLBACK_MODELS = [
     { modelId: "gemini-3.7-flash", name: "Gemini 3.7 Flash", description: "Google Gemini 3.7 Flash", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 1_048_576 },
     { modelId: "gemini-3.6-flash", name: "Gemini 3.6 Flash", description: "Google Gemini 3.6 Flash", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 1_048_576 },
     { modelId: "gemini-3.1-pro", name: "Gemini 3.1 Pro", description: "Google Gemini 3.1 Pro", supportedEfforts: ["high", "low"], contextWindowMaxTokens: 2_097_152 },
+    { modelId: "claude-opus-5-5", name: "Claude Opus 5.5 (Thinking)", description: "Anthropic Claude Opus 5.5 (Thinking)", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 200_000 },
+    { modelId: "claude-sonnet-5-5", name: "Claude Sonnet 5.5 (Thinking)", description: "Anthropic Claude Sonnet 5.5 (Thinking)", supportedEfforts: ["high", "medium", "low"], contextWindowMaxTokens: 200_000 },
     { modelId: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (Thinking)", description: "Anthropic Claude Sonnet 4.6 (Thinking)", supportedEfforts: [], contextWindowMaxTokens: 200_000 },
     { modelId: "claude-opus-4-6-thinking", name: "Claude Opus 4.6 (Thinking)", description: "Anthropic Claude Opus 4.6 (Thinking)", supportedEfforts: [], contextWindowMaxTokens: 200_000 },
     { modelId: "gpt-oss-120b", name: "GPT-OSS 120B", description: "GPT-OSS 120B (Medium)", supportedEfforts: ["medium"], contextWindowMaxTokens: 128_000 },
@@ -401,8 +412,12 @@ const MODEL_CACHE_TTL_MS = 60_000;
 export function parseAgyModelsOutput(rawOutput) {
     const modelsMap = new Map();
     for (const line of rawOutput.split(/[\r\n]+/)) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.includes("Fetching available models"))
+        const trimmed = line
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+            .replace(/[\u2800-\u28ff]+/g, "")
+            .replace(/Fetching available models\.\.\./gi, "")
+            .trim();
+        if (!trimmed)
             continue;
         const parts = trimmed.split(/\t+|\s{2,}/).map((p) => p.trim()).filter(Boolean);
         if (parts.length < 2)
@@ -456,10 +471,20 @@ export async function fetchAvailableModels(binaryPath = "agy", force = false) {
                 windowsHide: true,
             });
             const parsed = parseAgyModelsOutput(stdout);
-            cachedModels = parsed;
+            const mergedMap = new Map();
+            for (const m of parsed) {
+                mergedMap.set(m.modelId, m);
+            }
+            for (const fallback of FALLBACK_MODELS) {
+                if (!mergedMap.has(fallback.modelId)) {
+                    mergedMap.set(fallback.modelId, fallback);
+                }
+            }
+            const merged = Array.from(mergedMap.values());
+            cachedModels = merged;
             cachedModelsBinaryPath = binaryPath;
             lastModelFetch = Date.now();
-            return parsed;
+            return merged;
         }
         catch (err) {
             logger.warn("Failed to fetch models from agy CLI, using fallback models", {

package/dist/session-store.d.ts

@@ -11,6 +11,7 @@ export interface PersistedSessionState {
     sessionId: string;
     conversationId?: string;
     cwd: string;
+    title?: string;
     model: string;
     effort: string;
     mode: string;
@@ -21,8 +22,11 @@ export interface PersistedSessionState {
 export declare class SessionStore {
     private dir;
     constructor(dir?: string);
+    get storageDir(): string;
     private pathFor;
     load(sessionId: string): PersistedSessionState | null;
     save(state: PersistedSessionState): void;
+    delete(sessionId: string): boolean;
+    list(cwd?: string): PersistedSessionState[];
 }
 export declare const sessionStore: SessionStore;

package/dist/session-store.js

@@ -28,6 +28,9 @@ export class SessionStore {
         }
         catch { }
     }
+    get storageDir() {
+        return this.dir;
+    }
     pathFor(sessionId) {
         return path.join(this.dir, fileNameForSession(sessionId));
     }
@@ -80,5 +83,61 @@ export class SessionStore {
             });
         }
     }
+    delete(sessionId) {
+        const filePath = this.pathFor(sessionId);
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                return true;
+            }
+            return false;
+        }
+        catch (err) {
+            logger.warn("Failed to delete persisted ACP session", {
+                sessionId,
+                error: err.message,
+            });
+            return false;
+        }
+    }
+    list(cwd) {
+        if (!fs.existsSync(this.dir))
+            return [];
+        const results = [];
+        const normalizedTargetCwd = cwd ? path.resolve(cwd).toLowerCase() : undefined;
+        try {
+            const files = fs.readdirSync(this.dir);
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const fullPath = path.join(this.dir, file);
+                try {
+                    const content = fs.readFileSync(fullPath, "utf8");
+                    const parsed = JSON.parse(content);
+                    if (!parsed.sessionId)
+                        continue;
+                    if (normalizedTargetCwd && parsed.cwd) {
+                        const sessionCwd = path.resolve(parsed.cwd).toLowerCase();
+                        if (sessionCwd !== normalizedTargetCwd)
+                            continue;
+                    }
+                    results.push(parsed);
+                }
+                catch {
+                    // ignore corrupted individual files
+                }
+            }
+            // Sort by updatedAt descending
+            results.sort((a, b) => {
+                const timeA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+                const timeB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+                return timeB - timeA;
+            });
+        }
+        catch (err) {
+            logger.warn("Failed to list persisted ACP sessions", { error: err.message });
+        }
+        return results;
+    }
 }
 export const sessionStore = new SessionStore();

package/dist/session.d.ts

@@ -1,8 +1,10 @@
 import { AntigravityProcess } from "./antigravity-process.js";
+import { SessionInfo } from "./protocol.js";
 import { SessionStore, SessionUsageState } from "./session-store.js";
 export interface SessionOptions {
     id?: string;
     cwd?: string;
+    title?: string;
     model?: string;
     effort?: string;
     mode?: string;
@@ -18,6 +20,7 @@ export interface SessionOptions {
 export declare class Session {
     readonly id: string;
     cwd: string;
+    title?: string;
     model: string;
     effort: string;
     mode: string;
@@ -31,6 +34,7 @@ export declare class Session {
     private promptOperationActive;
     constructor(options?: SessionOptions);
     private persistedState;
+    setTitle(title: string): void;
     persist(): void;
     get isPromptOperationActive(): boolean;
     tryBeginPromptOperation(): boolean;
@@ -65,5 +69,6 @@ export declare class SessionManager {
     hasPersistedSession(id: string): boolean;
     closeSession(id: string): Promise<boolean>;
     closeAll(): Promise<void>;
-    listSessions(): Session[];
+    listActiveSessions(): Session[];
+    listSessions(cwd?: string): SessionInfo[];
 }

package/dist/session.js

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import path from "node:path";
 import { AntigravityProcess } from "./antigravity-process.js";
 import { logger } from "./logger.js";
 import { resolvePermissionSettings } from "./permissions.js";
@@ -7,6 +8,7 @@ import { sessionStore, } from "./session-store.js";
 export class Session {
     id;
     cwd;
+    title;
     model;
     effort;
     mode;
@@ -21,7 +23,8 @@ export class Session {
     constructor(options = {}) {
         this.id = options.id || crypto.randomUUID();
         this.cwd = options.cwd || process.cwd();
-        this.model = options.model || "gemini-3.7-flash";
+        this.title = options.title;
+        this.model = options.model || "gemini-3.8-flash";
         this.effort = options.effort || "high";
         this.mode = options.mode || "default";
         this.permission =
@@ -65,6 +68,7 @@ export class Session {
         });
         this.process.on("init", () => this.persist());
         this.process.on("result", () => this.persist());
+        this.process.on("conversation_healed", () => this.persist());
         this.persist();
     }
     persistedState() {
@@ -72,6 +76,7 @@ export class Session {
             sessionId: this.id,
             conversationId: this.process.currentConversationId,
             cwd: this.cwd,
+            title: this.title,
             model: this.model,
             effort: this.effort,
             mode: this.mode,
@@ -80,6 +85,12 @@ export class Session {
             updatedAt: new Date().toISOString(),
         };
     }
+    setTitle(title) {
+        if (this.title !== title) {
+            this.title = title;
+            this.persist();
+        }
+    }
     persist() {
         this.store.save(this.persistedState());
     }
@@ -224,6 +235,7 @@ export class SessionManager {
             id: options.id,
             binaryPath: options.binaryPath || this.defaultBinaryPath,
             cwd: options.cwd || persisted?.cwd,
+            title: options.title || persisted?.title,
             model: options.model || persisted?.model,
             effort: options.effort || persisted?.effort,
             mode: options.mode || persisted?.mode,
@@ -264,7 +276,40 @@ export class SessionManager {
         await Promise.allSettled(Array.from(this.sessions.values(), (session) => session.close()));
         this.sessions.clear();
     }
-    listSessions() {
+    listActiveSessions() {
         return Array.from(this.sessions.values());
     }
+    listSessions(cwd) {
+        const persisted = this.store.list(cwd);
+        const sessionMap = new Map();
+        for (const p of persisted) {
+            sessionMap.set(p.sessionId, {
+                sessionId: p.sessionId,
+                cwd: p.cwd,
+                title: p.title || (p.cwd ? path.basename(p.cwd) : "Antigravity Session"),
+                updatedAt: p.updatedAt,
+            });
+        }
+        for (const active of this.sessions.values()) {
+            if (cwd) {
+                const targetCwd = path.resolve(cwd).toLowerCase();
+                const activeCwd = path.resolve(active.cwd).toLowerCase();
+                if (targetCwd !== activeCwd)
+                    continue;
+            }
+            sessionMap.set(active.id, {
+                sessionId: active.id,
+                cwd: active.cwd,
+                title: active.title || (active.cwd ? path.basename(active.cwd) : "Antigravity Session"),
+                updatedAt: active.lastActivity.toISOString(),
+            });
+        }
+        const list = Array.from(sessionMap.values());
+        list.sort((a, b) => {
+            const timeA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+            const timeB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+            return timeB - timeA;
+        });
+        return list;
+    }
 }

package/dist/transcript.d.ts

@@ -0,0 +1,25 @@
+import { ToolKind } from "./protocol.js";
+export interface ReplayItem {
+    type: "user_message" | "agent_message" | "agent_thought" | "tool_call" | "tool_call_update";
+    text?: string;
+    toolCallId?: string;
+    title?: string;
+    kind?: ToolKind;
+    rawInput?: Record<string, unknown>;
+    rawOutput?: string;
+    status?: "completed" | "failed";
+}
+/**
+ * Strips XML-like tags injected by harness or system prompts (e.g., <USER_REQUEST>, <ADDITIONAL_METADATA>)
+ * to recover the clean user prompt for history display in clients like Paseo.
+ */
+export declare function extractCleanUserPrompt(rawText: string): string;
+/**
+ * Resolves the path to the Antigravity conversation directory in ~/.gemini/antigravity-cli/brain/<conversationId>
+ */
+export declare function resolveConversationBrainDir(conversationId: string): string | null;
+/**
+ * Loads and parses transcript.jsonl (or transcript_full.jsonl) for a conversation,
+ * transforming each step into ordered ACP replay events.
+ */
+export declare function loadConversationTranscript(conversationId: string): ReplayItem[];