@love-moon/ai-sdk 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @love-moon/ai-sdk
 
+## 0.11.2
+
+## 0.11.1
+
 ## 0.11.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -7,4 +7,4 @@ export { assertMediaCapabilities, fileMediaToBase64, fileMediaToDataUri, normali
 export { GOAL_STATUSES, TERMINAL_GOAL_STATUSES, isGoalStatus, isTerminalGoalStatus } from "./shared.js";
 export { AiManager, accountNameFromPath, checkInstall, checkInstallAll, checkNetwork, checkNetworkAll, getClaudeQuota, getCodexQuota, getCopilotQuota, getCurrentCodexAccount, getDshQuota, readCachedDshQuota, resolveDeepSeekCredential, getExternalQuota, getExternalQuotaList, getKimiQuota, listCodexAccounts, loadAiManagerConfig, normalizeExternalQuota, normalizeExternalQuotaList, parseAuthFile, parseAuthFileContents, parseCopilotQuotaSnapshots, readCachedCodexQuota, resolveClaudeCredential, switchCodexAccount } from "./manager/index.js";
 export { getExternalProviderDescriptor, getExternalProviderRegistry, resetExternalProviderRegistryForTests, resolveExternalBackend } from "./external-provider-registry.js";
-export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget } from "./resume/index.js";
+export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget, listSessionsForBackend } from "./resume/index.js";

package/dist/index.js

@@ -7,4 +7,4 @@ export { assertMediaCapabilities, fileMediaToBase64, fileMediaToDataUri, normali
 export { GOAL_STATUSES, TERMINAL_GOAL_STATUSES, isGoalStatus, isTerminalGoalStatus, } from "./shared.js";
 export { AiManager, accountNameFromPath, checkInstall, checkInstallAll, checkNetwork, checkNetworkAll, getClaudeQuota, getCodexQuota, getCopilotQuota, getCurrentCodexAccount, getDshQuota, readCachedDshQuota, resolveDeepSeekCredential, getExternalQuota, getExternalQuotaList, getKimiQuota, listCodexAccounts, loadAiManagerConfig, normalizeExternalQuota, normalizeExternalQuotaList, parseAuthFile, parseAuthFileContents, parseCopilotQuotaSnapshots, readCachedCodexQuota, resolveClaudeCredential, switchCodexAccount, } from "./manager/index.js";
 export { getExternalProviderDescriptor, getExternalProviderRegistry, resetExternalProviderRegistryForTests, resolveExternalBackend, } from "./external-provider-registry.js";
-export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget, } from "./resume/index.js";
+export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget, listSessionsForBackend, } from "./resume/index.js";

package/dist/manager/manager.d.ts

@@ -8,7 +8,7 @@ import type { AiManagerConfig, CodexAccount, CodexQuota, ClaudeQuota, DshQuota,
 export interface AiManagerOptions {
     /** Path to conductor config.yaml. Default: $CONDUCTOR_HOME/config.yaml. */
     configPath?: string;
-    /** Path to the active codex auth.json. Default: ~/.codex/auth.json */
+    /** Path to the active codex auth.json. Default: $CODEX_HOME/auth.json, else ~/.codex/auth.json */
     codexAuthPath?: string;
     /** Pre-loaded config; skips loading from disk if provided. */
     config?: AiManagerConfig;

package/dist/manager/paths.d.ts

@@ -2,6 +2,19 @@ type PathEnv = Record<string, string | undefined>;
 export declare function expandHome(p: string): string;
 export declare function resolveConductorHome(env?: PathEnv): string;
 export declare function resolveDefaultConductorConfig(env?: PathEnv): string;
+/**
+ * Claude Code keeps its config (credentials, projects/, tasks/) under
+ * $CLAUDE_CONFIG_DIR when that is set - shared hosts point it at network
+ * storage - and under ~/.claude otherwise. Returns both, in priority order, so
+ * callers can search the override first and still find pre-existing state that
+ * was written before the variable was introduced.
+ */
+export declare function resolveClaudeConfigDirs(env?: PathEnv, homeDir?: string): string[];
+/**
+ * Codex keeps auth.json/config.toml under $CODEX_HOME when that is set
+ * (identity isolation, multi-instance daemons) and under ~/.codex otherwise.
+ */
+export declare function resolveCodexHome(env?: PathEnv): string;
 export declare function resolveDefaultQuotaCacheDir(env?: PathEnv): string;
 export declare const DEFAULT_CONDUCTOR_CONFIG: string;
 export declare const DEFAULT_CODEX_AUTH: string;

package/dist/manager/paths.js

@@ -34,12 +34,38 @@ export function resolveDefaultConductorConfig(env = process.env) {
     }
     return join(resolveConductorHome(env), "config.yaml");
 }
+/**
+ * Claude Code keeps its config (credentials, projects/, tasks/) under
+ * $CLAUDE_CONFIG_DIR when that is set - shared hosts point it at network
+ * storage - and under ~/.claude otherwise. Returns both, in priority order, so
+ * callers can search the override first and still find pre-existing state that
+ * was written before the variable was introduced.
+ */
+export function resolveClaudeConfigDirs(env = process.env, homeDir) {
+    const fallback = join(homeDir ? resolve(homeDir) : resolve(userHome(env)), ".claude");
+    // An explicit homeDir is a caller/test override that pins the lookup.
+    const configured = homeDir ? "" : optionalString(env.CLAUDE_CONFIG_DIR);
+    if (!configured)
+        return [fallback];
+    const expanded = resolve(expandHomeWithEnv(configured, env));
+    return expanded === fallback ? [fallback] : [expanded, fallback];
+}
+/**
+ * Codex keeps auth.json/config.toml under $CODEX_HOME when that is set
+ * (identity isolation, multi-instance daemons) and under ~/.codex otherwise.
+ */
+export function resolveCodexHome(env = process.env) {
+    const configured = optionalString(env.CODEX_HOME);
+    if (configured)
+        return resolve(expandHomeWithEnv(configured, env));
+    return join(resolve(userHome(env)), ".codex");
+}
 export function resolveDefaultQuotaCacheDir(env = process.env) {
     return join(resolveConductorHome(env), "cache", "ai-manager");
 }
 export const DEFAULT_CONDUCTOR_CONFIG = resolveDefaultConductorConfig();
-export const DEFAULT_CODEX_AUTH = join(homedir(), ".codex", "auth.json");
-export const DEFAULT_CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+export const DEFAULT_CODEX_AUTH = join(resolveCodexHome(), "auth.json");
+export const DEFAULT_CODEX_CONFIG = join(resolveCodexHome(), "config.toml");
 export const DEFAULT_KIMI_CODE_HOME = process.env.KIMI_CODE_HOME?.trim() || join(homedir(), ".kimi-code");
 export const DEFAULT_KIMI_CREDENTIAL = join(DEFAULT_KIMI_CODE_HOME, "credentials", "kimi-code.json");
 export const LEGACY_KIMI_CREDENTIAL = join(homedir(), ".kimi", "credentials", "kimi-code.json");

package/dist/manager/quota/claude.d.ts

@@ -4,6 +4,15 @@ export interface ClaudeCredential {
     token: string;
     /** JSON source string (for fingerprinting). */
     fingerprintInput: string;
+    /** OAuth expiry in epoch ms, when the source reports one. */
+    expiresAt?: number;
+}
+export interface ResolveClaudeCredentialOptions {
+    env?: Record<string, string | undefined>;
+    /** Pins the lookup to one home, ignoring CLAUDE_CONFIG_DIR (tests). */
+    homeDir?: string;
+    platform?: string;
+    readKeychain?: () => Promise<string | null>;
 }
 export interface GetClaudeQuotaOptions {
     /** Cache TTL in seconds. Default 60. */
@@ -15,5 +24,5 @@ export interface GetClaudeQuotaOptions {
     /** Override credential resolution (mainly for tests). */
     credential?: ClaudeCredential;
 }
-export declare function resolveClaudeCredential(): Promise<ClaudeCredential | null>;
+export declare function resolveClaudeCredential(opts?: ResolveClaudeCredentialOptions): Promise<ClaudeCredential | null>;
 export declare function getClaudeQuota(opts?: GetClaudeQuotaOptions): Promise<ClaudeQuota>;

package/dist/manager/quota/claude.js

@@ -1,40 +1,58 @@
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { headersToMap, num, str } from "./headers.js";
 import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
+import { resolveClaudeConfigDirs } from "../paths.js";
 const MESSAGES_URL = "https://api.anthropic.com/v1/messages";
 const DEFAULT_TTL = 60;
 const DEFAULT_TIMEOUT_MS = 20000;
 const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
-export async function resolveClaudeCredential() {
-    const envKey = process.env.ANTHROPIC_API_KEY;
+export async function resolveClaudeCredential(opts = {}) {
+    const env = opts.env ?? process.env;
+    const envKey = env.ANTHROPIC_API_KEY;
     if (envKey && envKey.length > 10) {
         return { kind: "api-key", token: envKey, fingerprintInput: envKey };
     }
-    if (process.platform === "darwin") {
-        const raw = await readMacKeychain();
-        if (raw) {
-            try {
-                const parsed = JSON.parse(raw);
-                const oauth = parsed?.claudeAiOauth ?? parsed;
-                if (oauth?.accessToken) {
-                    return {
-                        kind: "oauth",
-                        token: oauth.accessToken,
-                        fingerprintInput: oauth.accessToken,
-                    };
-                }
-            }
-            catch {
-                // fall through
-            }
-        }
+    // Candidates in priority order:
+    //   $CLAUDE_CONFIG_DIR  - explicitly chosen, so it outranks the machine-wide
+    //                         Keychain, which belongs to a different account.
+    //   Keychain (macOS)    - where Claude Code refreshes tokens to.
+    //   ~/.claude           - last, because on macOS it is the stale-file trap:
+    //                         refreshes go to the Keychain, so a leftover file
+    //                         here holds a dead token.
+    const dirs = resolveClaudeConfigDirs(env, opts.homeDir);
+    const overrideDir = dirs.length > 1 ? dirs[0] : undefined;
+    const homeDir = dirs[dirs.length - 1];
+    const readFileCred = (dir) => () => oauthFromFile(join(dir, ".credentials.json"));
+    const sources = [];
+    if (overrideDir)
+        sources.push(readFileCred(overrideDir));
+    if ((opts.platform ?? process.platform) === "darwin") {
+        const readKeychain = opts.readKeychain ?? readMacKeychain;
+        sources.push(async () => {
+            const raw = await readKeychain();
+            return raw ? oauthFromJson(raw) : null;
+        });
     }
-    // Linux/Windows fallback: look for ~/.claude/.credentials.json (best-effort).
+    sources.push(readFileCred(homeDir));
+    // Prefer the first live credential. An expired one is remembered but not
+    // returned yet, so a stale file cannot shadow a working Keychain entry.
+    let expired = null;
+    for (const read of sources) {
+        const cred = await read();
+        if (!cred)
+            continue;
+        if (!cred.expiresAt || cred.expiresAt > Date.now())
+            return cred;
+        expired ??= cred;
+    }
+    // Everything on offer is expired: return it anyway so the caller surfaces an
+    // auth error rather than a misleading "no credential found".
+    return expired;
+}
+function oauthFromJson(raw) {
     try {
-        const raw = await readFile(join(homedir(), ".claude", ".credentials.json"), "utf8");
         const parsed = JSON.parse(raw);
         const oauth = parsed?.claudeAiOauth ?? parsed;
         if (oauth?.accessToken) {
@@ -42,14 +60,23 @@ export async function resolveClaudeCredential() {
                 kind: "oauth",
                 token: oauth.accessToken,
                 fingerprintInput: oauth.accessToken,
+                expiresAt: typeof oauth.expiresAt === "number" ? oauth.expiresAt : undefined,
             };
         }
     }
     catch {
-        // ignore
+        // not JSON, or no token in it
     }
     return null;
 }
+async function oauthFromFile(path) {
+    try {
+        return oauthFromJson(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
 function readMacKeychain() {
     return new Promise((resolve) => {
         const user = process.env.USER ?? "";
@@ -99,7 +126,7 @@ export async function getClaudeQuota(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const credential = opts.credential ?? (await resolveClaudeCredential());
     if (!credential) {
-        return emptyQuota("unknown", "no Claude credential found (ANTHROPIC_API_KEY env, macOS Keychain, or ~/.claude/.credentials.json)");
+        return emptyQuota("unknown", "no Claude credential found (ANTHROPIC_API_KEY env, $CLAUDE_CONFIG_DIR/.credentials.json, macOS Keychain, or ~/.claude/.credentials.json)");
     }
     const fp = fingerprintKey(["claude", credential.kind, credential.fingerprintInput.slice(0, 32)]);
     const file = cacheFile("claude", fp, opts.cacheDir);

package/dist/resume/claude.d.ts

@@ -1,5 +1,5 @@
 export function buildCliArgs(sessionId: any): string[];
-export function findSessionPath(sessionId: any, options?: {}): Promise<any>;
+export function findSessionPath(sessionId: any, options?: {}): Promise<string | null>;
 export function extractResumeCwd(sessionPath: any, sessionId: any): Promise<string | null>;
 export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
     provider: any;
@@ -11,4 +11,18 @@ export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
         sessionPath: null;
     };
 }>;
+/**
+ * Lists local Claude Code sessions, newest first.
+ *
+ * Candidates are collected with readdir + stat only; session files can be tens
+ * of megabytes, so file contents (cwd/title) are read - head only - for the
+ * `limit` newest files after sorting by mtime.
+ */
+export function listSessions(options?: {}): Promise<{
+    sessionId: any;
+    sessionFilePath: any;
+    cwd: any;
+    title: string | null;
+    updatedAt: any;
+}[]>;
 export const BACKEND: "claude";

package/dist/resume/claude.js

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
-import { buildResumeContext, isExistingDirectory, normalizeSessionId, pathExists, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
+import { resolveClaudeConfigDirs } from "../manager/paths.js";
+import { buildResumeContext, isExistingDirectory, normalizeSessionId, normalizeSessionTitle, pathExists, readJsonlHeadEntries, resolveSessionRunDirectory, } from "./shared.js";
 export const BACKEND = "claude";
 export function buildCliArgs(sessionId) {
     const normalizedSessionId = normalizeSessionId(sessionId);
@@ -16,16 +17,20 @@ export async function findSessionPath(sessionId, options = {}) {
     if (!normalizedSessionId) {
         return null;
     }
-    const homeDir = resolveHomeDir(options);
-    const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-    const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
-    if (sessionEntries.length > 0) {
-        return sessionEntries[0]?.source || null;
-    }
-    const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
-    const directTaskDir = path.join(tasksDir, normalizedSessionId);
-    if (await pathExists(directTaskDir, "directory")) {
-        return directTaskDir;
+    // Search $CLAUDE_CONFIG_DIR first, then ~/.claude, so sessions recorded
+    // before that variable was introduced stay resumable.
+    const configDirs = resolveClaudeConfigDirs(options.env ?? process.env, options.homeDir);
+    for (const configDir of configDirs) {
+        const projectsDir = options.claudeProjectsDir || path.join(configDir, "projects");
+        const sessionPath = await findClaudeSessionPath(projectsDir, normalizedSessionId);
+        if (sessionPath) {
+            return sessionPath;
+        }
+        const tasksDir = options.claudeTasksDir || path.join(configDir, "tasks");
+        const directTaskDir = path.join(tasksDir, normalizedSessionId);
+        if (await pathExists(directTaskDir, "directory")) {
+            return directTaskDir;
+        }
     }
     return null;
 }
@@ -83,14 +88,127 @@ export async function resolveResumeContext(sessionId, options = {}) {
         cwdSource: cwdFromSession ? "session" : "session_path",
     });
 }
-async function findClaudeSessionEntries(projectsDir, sessionId) {
-    const entries = [];
+/**
+ * Lists local Claude Code sessions, newest first.
+ *
+ * Candidates are collected with readdir + stat only; session files can be tens
+ * of megabytes, so file contents (cwd/title) are read - head only - for the
+ * `limit` newest files after sorting by mtime.
+ */
+export async function listSessions(options = {}) {
+    const { limit = 20, env = process.env } = options;
+    const configDirs = resolveClaudeConfigDirs(env, options.homeDir);
+    const scannedProjectsDirs = new Set();
+    const candidatesById = new Map();
+    for (const configDir of configDirs) {
+        const projectsDir = options.claudeProjectsDir || path.join(configDir, "projects");
+        if (scannedProjectsDirs.has(projectsDir)) {
+            continue;
+        }
+        scannedProjectsDirs.add(projectsDir);
+        let projectDirs = [];
+        try {
+            projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const projectDir of projectDirs) {
+            if (!projectDir.isDirectory()) {
+                continue;
+            }
+            const projectPath = path.join(projectsDir, projectDir.name);
+            let files = [];
+            try {
+                files = await fsp.readdir(projectPath, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                if (!file.isFile() || !file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
+                    continue;
+                }
+                const sessionId = file.name.slice(0, -".jsonl".length);
+                // Config dirs are searched in priority order; the first hit wins.
+                if (!sessionId || candidatesById.has(sessionId)) {
+                    continue;
+                }
+                const filePath = path.join(projectPath, file.name);
+                let stats;
+                try {
+                    stats = await fsp.stat(filePath);
+                }
+                catch {
+                    continue;
+                }
+                candidatesById.set(sessionId, {
+                    sessionId,
+                    sessionFilePath: filePath,
+                    updatedAt: Math.round(stats.mtimeMs),
+                });
+            }
+        }
+    }
+    const selected = [...candidatesById.values()]
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, Math.max(0, limit));
+    const sessions = [];
+    for (const candidate of selected) {
+        const entries = await readJsonlHeadEntries(candidate.sessionFilePath);
+        sessions.push({
+            sessionId: candidate.sessionId,
+            sessionFilePath: candidate.sessionFilePath,
+            cwd: extractHeadCwd(entries),
+            title: extractClaudeTitle(entries),
+            updatedAt: candidate.updatedAt,
+        });
+    }
+    return sessions;
+}
+function extractHeadCwd(entries) {
+    for (const entry of entries) {
+        if (typeof entry?.cwd === "string" && entry.cwd.trim()) {
+            return entry.cwd.trim();
+        }
+    }
+    return null;
+}
+function extractClaudeTitle(entries) {
+    for (const entry of entries) {
+        if (entry?.type !== "user" || entry?.isMeta === true) {
+            continue;
+        }
+        const content = entry?.message?.content;
+        let text = "";
+        if (typeof content === "string") {
+            text = content;
+        }
+        else if (Array.isArray(content)) {
+            text = content
+                .filter((item) => item?.type === "text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .join(" ");
+        }
+        const title = normalizeSessionTitle(text);
+        if (title) {
+            return title;
+        }
+    }
+    return null;
+}
+/**
+ * Returns the first session file mentioning `sessionId`. Session ids are
+ * unique, so this stops at the first hit instead of walking the whole history
+ * tree - which now may live on network storage.
+ */
+async function findClaudeSessionPath(projectsDir, sessionId) {
     let projectDirs = [];
     try {
         projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
     }
     catch {
-        return entries;
+        return null;
     }
     for (const projectDir of projectDirs) {
         if (!projectDir.isDirectory()) {
@@ -112,10 +230,8 @@ async function findClaudeSessionEntries(projectsDir, sessionId) {
                 continue;
             }
             const filePath = path.join(projectPath, file.name);
-            const rl = readline.createInterface({
-                input: fs.createReadStream(filePath),
-                crlfDelay: Infinity,
-            });
+            const input = fs.createReadStream(filePath);
+            const rl = readline.createInterface({ input, crlfDelay: Infinity });
             for await (const line of rl) {
                 const trimmed = line.trim();
                 if (!trimmed) {
@@ -129,10 +245,13 @@ async function findClaudeSessionEntries(projectsDir, sessionId) {
                     continue;
                 }
                 if (entry.sessionId === sessionId) {
-                    entries.push({ ...entry, source: filePath });
+                    // Close both: rl.close() alone leaves the fd open.
+                    rl.close();
+                    input.destroy();
+                    return filePath;
                 }
             }
         }
     }
-    return entries;
+    return null;
 }

package/dist/resume/codex.d.ts

@@ -11,4 +11,18 @@ export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
         sessionPath: null;
     };
 }>;
+/**
+ * Lists local Codex sessions, newest first.
+ *
+ * Candidates are collected with readdir + stat only; session files can be tens
+ * of megabytes, so file contents (session_meta/title) are read - head only -
+ * for the `limit` newest files after sorting by mtime.
+ */
+export function listSessions(options?: {}): Promise<{
+    sessionId: string;
+    sessionFilePath: string;
+    cwd: string | null;
+    title: string | null;
+    updatedAt: number;
+}[]>;
 export const BACKEND: "codex";

package/dist/resume/codex.js

@@ -1,6 +1,6 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { buildResumeContext, isExistingDirectory, iterateJsonlEntries, normalizeSessionId, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
+import { buildResumeContext, isExistingDirectory, iterateJsonlEntries, normalizeSessionId, normalizeSessionTitle, readJsonlHeadEntries, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
 export const BACKEND = "codex";
 export function buildCliArgs(sessionId) {
     const normalizedSessionId = normalizeSessionId(sessionId);
@@ -56,6 +56,105 @@ export async function resolveResumeContext(sessionId, options = {}) {
         cwdSource: cwdFromSession ? "session" : "session_path",
     });
 }
+/**
+ * Lists local Codex sessions, newest first.
+ *
+ * Candidates are collected with readdir + stat only; session files can be tens
+ * of megabytes, so file contents (session_meta/title) are read - head only -
+ * for the `limit` newest files after sorting by mtime.
+ */
+export async function listSessions(options = {}) {
+    const { limit = 20 } = options;
+    const homeDir = resolveHomeDir(options);
+    const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
+    const candidates = [];
+    const queue = [sessionsDir];
+    while (queue.length) {
+        const current = queue.pop();
+        let entries = [];
+        try {
+            entries = await fsp.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                let stats;
+                try {
+                    stats = await fsp.stat(fullPath);
+                }
+                catch {
+                    continue;
+                }
+                candidates.push({ filePath: fullPath, updatedAt: Math.round(stats.mtimeMs) });
+            }
+        }
+    }
+    candidates.sort((a, b) => b.updatedAt - a.updatedAt);
+    const maxSessions = Math.max(0, limit);
+    const sessions = [];
+    for (const candidate of candidates) {
+        if (sessions.length >= maxSessions) {
+            break;
+        }
+        const headEntries = await readJsonlHeadEntries(candidate.filePath);
+        const meta = headEntries.find((entry) => entry?.type === "session_meta") || null;
+        const sessionId = normalizeSessionId(meta?.payload?.id)
+            || normalizeSessionId(meta?.payload?.session_id)
+            || extractSessionIdFromFileName(candidate.filePath);
+        if (!sessionId) {
+            continue;
+        }
+        const metaCwd = meta?.payload?.cwd;
+        sessions.push({
+            sessionId,
+            sessionFilePath: candidate.filePath,
+            cwd: typeof metaCwd === "string" && metaCwd.trim() ? metaCwd.trim() : null,
+            title: extractCodexTitle(headEntries),
+            updatedAt: candidate.updatedAt,
+        });
+    }
+    return sessions;
+}
+const SESSION_ID_IN_FILE_NAME = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function extractSessionIdFromFileName(filePath) {
+    const match = path.basename(filePath).match(SESSION_ID_IN_FILE_NAME);
+    return match ? match[0] : "";
+}
+function extractCodexTitle(entries) {
+    for (const entry of entries) {
+        if (entry?.type === "event_msg" && entry?.payload?.type === "user_message") {
+            const title = normalizeSessionTitle(entry.payload.message);
+            if (title) {
+                return title;
+            }
+        }
+    }
+    for (const entry of entries) {
+        const payload = entry?.type === "response_item" ? entry.payload : null;
+        if (payload?.type !== "message" || payload?.role !== "user" || !Array.isArray(payload.content)) {
+            continue;
+        }
+        const text = payload.content
+            .filter((item) => item?.type === "input_text" && typeof item.text === "string")
+            .map((item) => item.text)
+            .join(" ");
+        if (text.trim().startsWith("<")) {
+            // Skip injected wrappers such as <environment_context> / <user_instructions>.
+            continue;
+        }
+        const title = normalizeSessionTitle(text);
+        if (title) {
+            return title;
+        }
+    }
+    return null;
+}
 async function findCodexSessionFile(rootDir, sessionId) {
     const queue = [rootDir];
     while (queue.length) {

package/dist/resume/index.d.ts

@@ -1,6 +1,17 @@
 export function resumeProviderForBackend(backend: any): "codex" | null;
 export function buildResumeArgsForBackend(backend: any, sessionId: any): string[];
 export function findSessionPath(provider: any, sessionId: any, options?: {}): Promise<string | null>;
+/**
+ * Lists local sessions for a backend (aliases resolve like every other resume
+ * entry point). Backends without a `listSessions` implementation yield [].
+ */
+export function listSessionsForBackend(backendType: any, opts?: {}): Promise<{
+    sessionId: string;
+    sessionFilePath: string;
+    cwd: string | null;
+    title: string | null;
+    updatedAt: number;
+}[]>;
 export function resolveResumeContext(backend: any, sessionId: any, options?: {}): Promise<{
     provider: any;
     sessionId: any;

package/dist/resume/index.js

@@ -76,6 +76,17 @@ export async function findSessionPath(provider, sessionId, options = {}) {
     return descriptor.findSessionPath(sessionId, options);
 }
 export { resolveSessionRunDirectory };
+/**
+ * Lists local sessions for a backend (aliases resolve like every other resume
+ * entry point). Backends without a `listSessions` implementation yield [].
+ */
+export async function listSessionsForBackend(backendType, opts = {}) {
+    const provider = lookupBuiltInProvider(backendType);
+    if (!provider || typeof provider.listSessions !== "function") {
+        return [];
+    }
+    return provider.listSessions(opts);
+}
 export async function resolveResumeContext(backend, sessionId, options = {}) {
     const normalizedSessionId = normalizeSessionId(sessionId);
     if (!normalizedSessionId) {

package/dist/resume/kimi.d.ts

@@ -11,4 +11,18 @@ export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
     };
 }>;
 export function md5Hex(value: any): string;
+/**
+ * Lists local Kimi Code sessions, newest first.
+ *
+ * Prefers the session_index.jsonl fast path and falls back to scanning
+ * `<KIMI_CODE_HOME>/sessions/<hash>/<sessionId>/`. Candidates are ranked by
+ * directory mtime; state.json is only read for the `limit` newest sessions.
+ */
+export function listSessions(options?: {}): Promise<{
+    sessionId: any;
+    sessionFilePath: string | null;
+    cwd: any;
+    title: string | null;
+    updatedAt: any;
+}[]>;
 export const BACKEND: "kimi";

package/dist/resume/kimi.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { buildResumeContext, isExistingDirectory, listCandidateWorkingDirectories, normalizeSessionId, pathExists, resolveHomeDir, } from "./shared.js";
+import { buildResumeContext, isExistingDirectory, listCandidateWorkingDirectories, normalizeSessionId, normalizeSessionTitle, pathExists, resolveHomeDir, } from "./shared.js";
 export const BACKEND = "kimi";
 export function buildCliArgs(sessionId) {
     const normalizedSessionId = normalizeSessionId(sessionId);
@@ -68,6 +68,150 @@ async function resolveLegacyKimiResumeCwd(sessionPath, _sessionId, options = {})
     }
     return null;
 }
+/**
+ * Lists local Kimi Code sessions, newest first.
+ *
+ * Prefers the session_index.jsonl fast path and falls back to scanning
+ * `<KIMI_CODE_HOME>/sessions/<hash>/<sessionId>/`. Candidates are ranked by
+ * directory mtime; state.json is only read for the `limit` newest sessions.
+ */
+export async function listSessions(options = {}) {
+    const { limit = 20 } = options;
+    const homeDir = resolveHomeDir(options);
+    const kimiCodeHome = resolveKimiCodeHome(homeDir, options);
+    const sessionsDir = path.join(kimiCodeHome, "sessions");
+    let stated = await statKimiSessionCandidates(await listIndexedKimiCodeSessions(kimiCodeHome, sessionsDir));
+    if (!stated.length) {
+        // The index can go stale wholesale (sessions dir cleaned, index copied from
+        // another machine), so fall back to scanning even when it had records.
+        stated = await statKimiSessionCandidates(await scanKimiCodeSessionDirs(sessionsDir));
+    }
+    stated.sort((a, b) => b.updatedAt - a.updatedAt);
+    const sessions = [];
+    for (const candidate of stated.slice(0, Math.max(0, limit))) {
+        const statePath = path.join(candidate.sessionPath, "state.json");
+        let state = null;
+        try {
+            state = JSON.parse(await fsp.readFile(statePath, "utf8"));
+        }
+        catch {
+            // Fall back to the session index record, which also carries workDir.
+        }
+        const stateWorkDir = typeof state?.workDir === "string" ? state.workDir.trim() : "";
+        // The Kimi Code message log format is not stable; use the title recorded in
+        // state.json / the session index when present instead of parsing messages.
+        const title = normalizeSessionTitle(state?.title) || normalizeSessionTitle(candidate.title) || null;
+        sessions.push({
+            sessionId: candidate.sessionId,
+            sessionFilePath: (await pathExists(statePath, "file")) ? statePath : null,
+            cwd: stateWorkDir || candidate.workDir || null,
+            title,
+            updatedAt: candidate.updatedAt,
+        });
+    }
+    return sessions;
+}
+async function statKimiSessionCandidates(candidates) {
+    const stated = [];
+    for (const candidate of candidates) {
+        let stats;
+        try {
+            stats = await fsp.stat(candidate.sessionPath);
+        }
+        catch {
+            continue;
+        }
+        if (!stats.isDirectory()) {
+            continue;
+        }
+        stated.push({ ...candidate, updatedAt: Math.round(stats.mtimeMs) });
+    }
+    return stated;
+}
+async function listIndexedKimiCodeSessions(kimiCodeHome, sessionsDir) {
+    let raw = "";
+    try {
+        raw = await fsp.readFile(path.join(kimiCodeHome, "session_index.jsonl"), "utf8");
+    }
+    catch {
+        return [];
+    }
+    const recordsBySessionId = new Map();
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let record = null;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const sessionId = typeof record?.sessionId === "string" ? record.sessionId.trim() : "";
+        if (!sessionId) {
+            continue;
+        }
+        if (record?.deleted === true) {
+            recordsBySessionId.delete(sessionId);
+            continue;
+        }
+        const sessionDir = typeof record?.sessionDir === "string" ? record.sessionDir.trim() : "";
+        if (!sessionDir || !path.isAbsolute(sessionDir)) {
+            continue;
+        }
+        const relativePath = path.relative(path.resolve(sessionsDir), path.resolve(sessionDir));
+        if (!relativePath ||
+            relativePath === ".." ||
+            relativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativePath) ||
+            path.basename(sessionDir) !== sessionId) {
+            continue;
+        }
+        recordsBySessionId.set(sessionId, {
+            sessionId,
+            sessionPath: sessionDir,
+            workDir: typeof record?.workDir === "string" && record.workDir.trim() ? record.workDir.trim() : null,
+            title: typeof record?.title === "string" ? record.title : null,
+        });
+    }
+    return [...recordsBySessionId.values()];
+}
+async function scanKimiCodeSessionDirs(sessionsDir) {
+    let hashDirs = [];
+    try {
+        hashDirs = await fsp.readdir(sessionsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const candidates = [];
+    for (const hashDir of hashDirs) {
+        if (!hashDir.isDirectory()) {
+            continue;
+        }
+        let sessionDirs = [];
+        try {
+            sessionDirs = await fsp.readdir(path.join(sessionsDir, hashDir.name), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const sessionDir of sessionDirs) {
+            if (!sessionDir.isDirectory()) {
+                continue;
+            }
+            candidates.push({
+                sessionId: sessionDir.name,
+                sessionPath: path.join(sessionsDir, hashDir.name, sessionDir.name),
+                workDir: null,
+                title: null,
+            });
+        }
+    }
+    return candidates;
+}
 async function findKimiSessionTarget(sessionId, options = {}) {
     const homeDir = resolveHomeDir(options);
     const kimiCodeHome = resolveKimiCodeHome(homeDir, options);

package/dist/resume/shared.d.ts

@@ -3,6 +3,14 @@ export function normalizeSessionId(sessionId: any): string;
 export function resolveHomeDir(options: any): any;
 export function normalizeProjectPathCandidate(value: any): string;
 export function pathExists(targetPath: any, expectedType: any): Promise<boolean>;
+/** Collapses whitespace and truncates a session title for list display. */
+export function normalizeSessionTitle(text: any, maxLength?: number): string | null;
+/**
+ * Parses the head of a jsonl file (bounded by lines and bytes so multi-MB
+ * session files stay cheap to inspect). Unreadable files and unparsable lines
+ * are skipped.
+ */
+export function readJsonlHeadEntries(filePath: any, maxLines?: number, maxBytes?: number): Promise<any[]>;
 export function isExistingDirectory(targetPath: any): Promise<boolean>;
 export function resolveSessionRunDirectory(sessionPath: any): Promise<string>;
 export function listCandidateWorkingDirectories(options?: {}): any[];

package/dist/resume/shared.js

@@ -33,6 +33,51 @@ export async function pathExists(targetPath, expectedType) {
         return false;
     }
 }
+/** Collapses whitespace and truncates a session title for list display. */
+export function normalizeSessionTitle(text, maxLength = 80) {
+    const collapsed = String(text || "").replace(/\s+/g, " ").trim();
+    if (!collapsed) {
+        return null;
+    }
+    return collapsed.length > maxLength ? collapsed.slice(0, maxLength) : collapsed;
+}
+/**
+ * Parses the head of a jsonl file (bounded by lines and bytes so multi-MB
+ * session files stay cheap to inspect). Unreadable files and unparsable lines
+ * are skipped.
+ */
+export async function readJsonlHeadEntries(filePath, maxLines = 50, maxBytes = 128 * 1024) {
+    const entries = [];
+    const input = fs.createReadStream(filePath, { end: maxBytes - 1 });
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
+    try {
+        let lineCount = 0;
+        for await (const line of rl) {
+            if (++lineCount > maxLines) {
+                break;
+            }
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore read errors; callers degrade to null cwd/title.
+    }
+    finally {
+        // Close both: rl.close() alone leaves the fd open.
+        rl.close();
+        input.destroy();
+    }
+    return entries;
+}
 export async function isExistingDirectory(targetPath) {
     const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
     if (!normalizedPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.11.0"
+    "@love-moon/chat-web": "^0.11.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "7d57852"
+  "gitCommitId": "067735d"
 }