pikiloom 0.4.39 → 0.4.41

package/packages/kernel/dist/ports/defaults.js

@@ -25,11 +25,15 @@ export class FsSessionStore {
         if (!existing) {
             const now = new Date().toISOString();
             await this.save({
-                agent, sessionId, workspacePath,
+                agent, sessionId, workspacePath, workdir: path.resolve(opts.workdir),
                 createdAt: now, updatedAt: now,
                 title: opts.title ?? null, runState: 'running', runDetail: null,
             });
         }
+        else if (!existing.workdir) {
+            existing.workdir = path.resolve(opts.workdir);
+            await this.save(existing);
+        }
         return { sessionId, workspacePath };
     }
     async get(agent, sessionId) {
@@ -74,6 +78,8 @@ export class FsSessionStore {
             rec.nativeSessionId = result.sessionId;
         if (result.text && !rec.title)
             rec.title = result.text.slice(0, 80);
+        if (result.text)
+            rec.preview = result.text.replace(/\s+/g, ' ').trim().slice(0, 200) || rec.preview || null;
         await this.save(rec);
     }
     async appendTurn(agent, sessionId, turn) {

package/packages/kernel/dist/runtime/loom.d.ts

@@ -2,6 +2,10 @@ import type { AgentDriver, TuiSpec } from '../contracts/driver.js';
 import type { SessionStore, ModelResolver, ToolProvider, SystemPromptBuilder, Catalog, InteractionHandler } from '../contracts/ports.js';
 import type { LoomIO, Surface, Plugin } from '../contracts/surface.js';
 import { PtyBridge, type PtyOpenOpts, type PtyExit } from './pty.js';
+import { type LoomPaths } from '../workspace/paths.js';
+import { SessionsManager } from '../workspace/sessions.js';
+import { SkillsManager } from '../workspace/skills.js';
+import { McpRegistry } from '../workspace/mcp.js';
 export interface TuiLaunchOptions {
     agent?: string;
     workdir?: string;
@@ -9,9 +13,11 @@ export interface TuiLaunchOptions {
     sessionId?: string | null;
 }
 export interface LoomConfig {
+    stateDirName?: string;
     appNamespace?: string;
     workdir?: string;
     defaultAgent?: string;
+    agentSkillDirs?: string[];
     drivers?: AgentDriver[];
     surfaces?: Surface[];
     plugins?: Plugin[];
@@ -27,6 +33,10 @@ export interface LoomConfig {
 }
 export interface Loom {
     readonly io: LoomIO;
+    readonly paths: LoomPaths;
+    readonly sessions: SessionsManager;
+    readonly skills: SkillsManager;
+    readonly mcp: McpRegistry;
     registerDriver(driver: AgentDriver): void;
     registerPlugin(plugin: Plugin): void;
     start(): Promise<void>;

package/packages/kernel/dist/runtime/loom.js

@@ -2,8 +2,15 @@ import { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemP
 import { Hub } from './hub.js';
 import { PtyBridge } from './pty.js';
 import { attachTui } from './tui.js';
+import { resolveLoomPaths } from '../workspace/paths.js';
+import { SessionsManager } from '../workspace/sessions.js';
+import { SkillsManager } from '../workspace/skills.js';
+import { McpRegistry } from '../workspace/mcp.js';
 export function createLoom(config = {}) {
-    const appNamespace = config.appNamespace || 'loom';
+    // The top-level dir defaults to 'pikiloom'; appNamespace (the default session-store base)
+    // falls back to it so a single knob configures everything for a fresh consumer.
+    const stateDirName = config.stateDirName || config.appNamespace || 'pikiloom';
+    const appNamespace = config.appNamespace || stateDirName;
     const workdir = config.workdir || process.cwd();
     const log = config.log || (() => { });
     const drivers = new Map();
@@ -12,11 +19,16 @@ export function createLoom(config = {}) {
     const defaultAgent = config.defaultAgent || config.drivers?.[0]?.id || 'echo';
     // Held as a live reference so registerPlugin() mutates the same array the Hub iterates.
     const plugins = [...(config.plugins || [])];
+    const sessionStore = config.sessionStore || new FsSessionStore(defaultBaseDir(appNamespace));
+    const paths = resolveLoomPaths({ stateDirName });
+    const sessions = new SessionsManager({ store: sessionStore, drivers: () => drivers, defaultWorkdir: workdir, log });
+    const skills = new SkillsManager({ paths, agentSkillDirs: config.agentSkillDirs, log });
+    const mcp = new McpRegistry({ log });
     const hub = new Hub({
         drivers,
         defaultAgent,
         workdir,
-        sessionStore: config.sessionStore || new FsSessionStore(defaultBaseDir(appNamespace)),
+        sessionStore,
         modelResolver: config.modelResolver || new NullModelResolver(),
         toolProvider: config.toolProvider || new NoopToolProvider(),
         systemPromptBuilder: config.systemPromptBuilder || new PassthroughSystemPromptBuilder(),
@@ -37,6 +49,10 @@ export function createLoom(config = {}) {
     };
     return {
         io: hub,
+        paths,
+        sessions,
+        skills,
+        mcp,
         registerDriver(driver) { drivers.set(driver.id, driver); },
         registerPlugin(plugin) { plugins.push(plugin); },
         async start() {

package/packages/kernel/dist/workspace/index.d.ts

@@ -0,0 +1,5 @@
+export { resolveLoomPaths, normalizeStateDirName, type LoomPaths, type LoomScope } from './paths.js';
+export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, NATIVE_SESSION_RUNNING_THRESHOLD_MS, type DiscoverOptions, type NativeSessionInfo, } from './native.js';
+export { SessionsManager, type ManagedSessionInfo, type SessionSource, type ListSessionsOptions, type SearchSessionsOptions, type SessionsManagerDeps, } from './sessions.js';
+export { SkillsManager, ensureDirSymlink, type SkillInfo, type SkillSearchResult, type SkillsManagerOptions, } from './skills.js';
+export { McpRegistry, type McpCatalogEntry, type McpSearchResult, type McpRegistryOptions, } from './mcp.js';

package/packages/kernel/dist/workspace/index.js

@@ -0,0 +1,7 @@
+// Workspace subsystem: the unified top-level directory + session/skill/mcp management that
+// a consuming app gets "for free" off createLoom() (exposed as loom.paths/sessions/skills/mcp).
+export { resolveLoomPaths, normalizeStateDirName } from './paths.js';
+export { discoverClaudeNativeSessions, discoverCodexNativeSessions, discoverGeminiNativeSessions, encodeClaudeProjectDir, NATIVE_SESSION_RUNNING_THRESHOLD_MS, } from './native.js';
+export { SessionsManager, } from './sessions.js';
+export { SkillsManager, ensureDirSymlink, } from './skills.js';
+export { McpRegistry, } from './mcp.js';

package/packages/kernel/dist/workspace/mcp.d.ts

@@ -0,0 +1,44 @@
+import type { McpServerSpec } from '../contracts/driver.js';
+export interface McpCatalogEntry {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+    brand?: string;
+    transport: {
+        type: 'stdio';
+        command: string;
+        args?: string[];
+    } | {
+        type: 'http';
+        url: string;
+    };
+    /** Required credential env var names (so a UI can prompt for them). */
+    envKeys?: string[];
+    homepage?: string;
+}
+export interface McpSearchResult {
+    name: string;
+    description: string | null;
+    source: 'registry' | 'npm';
+    npmPackage?: string | null;
+    homepage?: string | null;
+}
+export interface McpRegistryOptions {
+    /** Replace/extend the built-in recommended catalog. */
+    recommended?: McpCatalogEntry[];
+    fetchImpl?: typeof fetch;
+    log?: (msg: string) => void;
+}
+export declare class McpRegistry {
+    private readonly _recommended;
+    private readonly fetchImpl;
+    private readonly log?;
+    constructor(opts?: McpRegistryOptions);
+    /** The curated catalog of well-known servers. */
+    recommended(): McpCatalogEntry[];
+    /** Turn a catalog entry into a kernel McpServerSpec ready to hand to a driver/plugin. */
+    toServerSpec(entry: McpCatalogEntry, env?: Record<string, string>): McpServerSpec;
+    /** Search the public MCP registry, falling back to npm. Best-effort; [] on failure. */
+    search(query: string, limit?: number): Promise<McpSearchResult[]>;
+}

package/packages/kernel/dist/workspace/mcp.js

@@ -0,0 +1,82 @@
+const BUILTIN_RECOMMENDED = [
+    { id: 'filesystem', name: 'Filesystem', description: 'Read/write files under allowed directories.', category: 'core', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem'] }, homepage: 'https://github.com/modelcontextprotocol/servers' },
+    { id: 'github', name: 'GitHub', description: 'GitHub repos, issues, and PRs.', category: 'dev', brand: 'github', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-github'] }, envKeys: ['GITHUB_PERSONAL_ACCESS_TOKEN'], homepage: 'https://github.com/modelcontextprotocol/servers' },
+    { id: 'fetch', name: 'Fetch', description: 'Fetch and convert web pages to markdown.', category: 'web', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-fetch'] }, homepage: 'https://github.com/modelcontextprotocol/servers' },
+    { id: 'git', name: 'Git', description: 'Local git repository operations.', category: 'dev', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-git'] }, homepage: 'https://github.com/modelcontextprotocol/servers' },
+    { id: 'memory', name: 'Memory', description: 'A knowledge-graph memory store.', category: 'core', transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-memory'] }, homepage: 'https://github.com/modelcontextprotocol/servers' },
+    { id: 'playwright', name: 'Playwright', description: 'Drive a real browser for automation.', category: 'web', brand: 'playwright', transport: { type: 'stdio', command: 'npx', args: ['-y', '@playwright/mcp@latest'] }, homepage: 'https://github.com/microsoft/playwright-mcp' },
+    { id: 'context7', name: 'Context7', description: 'Up-to-date library docs & code examples.', category: 'docs', transport: { type: 'http', url: 'https://mcp.context7.com/mcp' }, homepage: 'https://context7.com' },
+];
+export class McpRegistry {
+    _recommended;
+    fetchImpl;
+    log;
+    constructor(opts = {}) {
+        this._recommended = opts.recommended?.length ? opts.recommended : BUILTIN_RECOMMENDED;
+        this.fetchImpl = opts.fetchImpl ?? (typeof fetch === 'function' ? fetch : undefined);
+        this.log = opts.log;
+    }
+    /** The curated catalog of well-known servers. */
+    recommended() {
+        return this._recommended.map(e => ({ ...e }));
+    }
+    /** Turn a catalog entry into a kernel McpServerSpec ready to hand to a driver/plugin. */
+    toServerSpec(entry, env) {
+        if (entry.transport.type === 'http') {
+            return { name: entry.id, type: 'http', url: entry.transport.url };
+        }
+        return { name: entry.id, type: 'stdio', command: entry.transport.command, args: entry.transport.args, env };
+    }
+    /** Search the public MCP registry, falling back to npm. Best-effort; [] on failure. */
+    async search(query, limit = 20) {
+        const q = (query || '').trim();
+        const n = Math.max(1, Math.min(50, limit));
+        const fetchImpl = this.fetchImpl;
+        if (!fetchImpl)
+            return [];
+        // 1) Official MCP registry.
+        try {
+            const url = `https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(q)}&limit=${n}`;
+            const res = await fetchImpl(url, { headers: { accept: 'application/json' } });
+            if (res.ok) {
+                const data = await res.json();
+                const servers = Array.isArray(data?.servers) ? data.servers : Array.isArray(data?.data) ? data.data : [];
+                const mapped = servers.map((s) => ({
+                    name: String(s?.name ?? s?.id ?? ''),
+                    description: s?.description ?? null,
+                    source: 'registry',
+                    npmPackage: s?.packages?.[0]?.identifier ?? s?.npm ?? null,
+                    homepage: s?.repository?.url ?? s?.homepage ?? null,
+                })).filter(s => s.name);
+                if (mapped.length)
+                    return mapped.slice(0, n);
+            }
+        }
+        catch (e) {
+            this.log?.(`[mcp] registry search failed: ${e?.message || e}`);
+        }
+        // 2) npm fallback.
+        try {
+            const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(`mcp server ${q}`.trim())}&size=${n}`;
+            const res = await fetchImpl(url, { headers: { accept: 'application/json' } });
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            const objects = Array.isArray(data?.objects) ? data.objects : [];
+            return objects.map((o) => {
+                const pkg = o?.package ?? {};
+                return {
+                    name: String(pkg.name ?? ''),
+                    description: pkg.description ?? null,
+                    source: 'npm',
+                    npmPackage: pkg.name ?? null,
+                    homepage: pkg.links?.homepage ?? pkg.links?.npm ?? null,
+                };
+            }).filter(s => s.name).slice(0, n);
+        }
+        catch (e) {
+            this.log?.(`[mcp] npm search failed: ${e?.message || e}`);
+            return [];
+        }
+    }
+}

package/packages/kernel/dist/workspace/native.d.ts

@@ -0,0 +1,14 @@
+import type { NativeSessionInfo } from '../contracts/driver.js';
+export type { NativeSessionInfo } from '../contracts/driver.js';
+export interface DiscoverOptions {
+    home?: string;
+    limit?: number;
+    /** A session whose file changed within this window is treated as "running". */
+    runningThresholdMs?: number;
+}
+export declare const NATIVE_SESSION_RUNNING_THRESHOLD_MS = 10000;
+/** Claude encodes a workdir into a project dir name by replacing non-alphanumerics with '-'. */
+export declare function encodeClaudeProjectDir(workdir: string): string;
+export declare function discoverClaudeNativeSessions(workdir: string, opts?: DiscoverOptions): NativeSessionInfo[];
+export declare function discoverCodexNativeSessions(workdir: string, opts?: DiscoverOptions): NativeSessionInfo[];
+export declare function discoverGeminiNativeSessions(workdir: string, opts?: DiscoverOptions): NativeSessionInfo[];

package/packages/kernel/dist/workspace/native.js

@@ -0,0 +1,340 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const NATIVE_SESSION_RUNNING_THRESHOLD_MS = 10_000;
+function homeOf(opts) {
+    return opts?.home || os.homedir();
+}
+function cleanTitle(raw, max = 120) {
+    if (!raw)
+        return null;
+    const s = raw.replace(/\s+/g, ' ').trim();
+    if (!s)
+        return null;
+    return s.length <= max ? s : `${s.slice(0, max - 3).trimEnd()}...`;
+}
+function statSafe(p) {
+    try {
+        return fs.statSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+// ---- Claude: ~/.claude/projects/<encoded-workdir>/<sessionId>.jsonl ----
+/** Claude encodes a workdir into a project dir name by replacing non-alphanumerics with '-'. */
+export function encodeClaudeProjectDir(workdir) {
+    return path.resolve(workdir).replace(/[^a-zA-Z0-9]/g, '-');
+}
+/** Extract plain text from a Claude `message.content` (string or block array). */
+function claudeText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+            parts.push(block.text);
+        }
+    }
+    return parts.join(' ');
+}
+function readClaudeHead(filePath, size) {
+    let title = null;
+    let model = null;
+    let lastUser = null;
+    let lastAssistant = null;
+    let turns = 0;
+    let head = '';
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        const buf = Buffer.alloc(Math.min(256 * 1024, Math.max(65536, size)));
+        const n = fs.readSync(fd, buf, 0, buf.length, 0);
+        fs.closeSync(fd);
+        head = buf.toString('utf8', 0, n);
+    }
+    catch {
+        return { title: null, model: null, preview: null, turns: 0 };
+    }
+    for (const line of head.split('\n')) {
+        if (!line || line[0] !== '{')
+            continue;
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (ev.type === 'user' && ev.isMeta !== true) {
+            const text = claudeText(ev.message?.content).trim();
+            if (text && !text.startsWith('<') && !text.startsWith('[Image:')) {
+                if (!title)
+                    title = cleanTitle(text);
+                lastUser = text;
+                turns++;
+            }
+        }
+        else if (ev.type === 'assistant') {
+            if (!model && ev.message?.model && ev.message.model !== '<synthetic>')
+                model = ev.message.model;
+            const text = claudeText(ev.message?.content).trim();
+            if (text)
+                lastAssistant = text;
+        }
+    }
+    const preview = cleanTitle(lastAssistant || lastUser, 200);
+    return { title, model, preview, turns };
+}
+export function discoverClaudeNativeSessions(workdir, opts = {}) {
+    const home = homeOf(opts);
+    const projectDir = path.join(home, '.claude', 'projects', encodeClaudeProjectDir(workdir));
+    let entries;
+    try {
+        entries = fs.readdirSync(projectDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const threshold = opts.runningThresholdMs ?? NATIVE_SESSION_RUNNING_THRESHOLD_MS;
+    const files = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const filePath = path.join(projectDir, entry.name);
+        const stat = statSafe(filePath);
+        if (stat)
+            files.push({ sessionId: entry.name.slice(0, -6), filePath, stat });
+    }
+    files.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+    const selected = typeof opts.limit === 'number' ? files.slice(0, Math.max(0, opts.limit)) : files;
+    const now = Date.now();
+    return selected.map(({ sessionId, filePath, stat }) => {
+        const { title, model, preview, turns } = readClaudeHead(filePath, stat.size);
+        return {
+            sessionId,
+            title,
+            preview,
+            cwd: path.resolve(workdir),
+            model,
+            createdAt: stat.birthtime.toISOString(),
+            updatedAt: stat.mtime.toISOString(),
+            running: now - stat.mtimeMs < threshold,
+            messageCount: turns || null,
+        };
+    });
+}
+// ---- Codex: ~/.codex/sessions/**/rollout-*.jsonl (filtered by cwd) ----
+function loadCodexTitleIndex(home) {
+    const indexPath = path.join(home, '.codex', 'session_index.jsonl');
+    const map = new Map();
+    let data;
+    try {
+        data = fs.readFileSync(indexPath, 'utf8');
+    }
+    catch {
+        return map;
+    }
+    for (const line of data.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry.id)
+                map.set(entry.id, { threadName: entry.thread_name || '', updatedAt: entry.updated_at || '' });
+        }
+        catch { /* skip */ }
+    }
+    return map;
+}
+function readCodexHead(filePath) {
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        const buf = Buffer.alloc(8 * 1024);
+        const n = fs.readSync(fd, buf, 0, buf.length, 0);
+        fs.closeSync(fd);
+        const head = buf.toString('utf8', 0, n);
+        if (!head.includes('"session_meta"'))
+            return null;
+        const id = head.match(/"id"\s*:\s*"([^"]+)"/);
+        const cwd = head.match(/"cwd"\s*:\s*"([^"]+)"/);
+        const ts = head.match(/"timestamp"\s*:\s*"([^"]+)"/);
+        if (!id || !cwd)
+            return null;
+        return {
+            sessionId: id[1],
+            cwd: cwd[1],
+            timestamp: ts?.[1] || null,
+            isSubagent: /"source"\s*:\s*\{\s*"subagent"\s*:/.test(head) || /"thread_spawn"\s*:/.test(head),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function discoverCodexNativeSessions(workdir, opts = {}) {
+    const home = homeOf(opts);
+    const sessionsDir = path.join(home, '.codex', 'sessions');
+    const resolvedWorkdir = path.resolve(workdir);
+    const titleIndex = loadCodexTitleIndex(home);
+    const threshold = opts.runningThresholdMs ?? NATIVE_SESSION_RUNNING_THRESHOLD_MS;
+    const files = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+                continue;
+            }
+            if (!entry.name.startsWith('rollout-') || !entry.name.endsWith('.jsonl'))
+                continue;
+            const stat = statSafe(full);
+            if (stat)
+                files.push({ filePath: full, stat });
+        }
+    };
+    walk(sessionsDir);
+    files.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+    const out = [];
+    const seen = new Set();
+    for (const { filePath, stat } of files) {
+        const meta = readCodexHead(filePath);
+        if (!meta || meta.isSubagent || path.resolve(meta.cwd) !== resolvedWorkdir)
+            continue;
+        if (seen.has(meta.sessionId))
+            continue;
+        seen.add(meta.sessionId);
+        const idx = titleIndex.get(meta.sessionId);
+        const updatedAt = idx?.updatedAt || stat.mtime.toISOString();
+        out.push({
+            sessionId: meta.sessionId,
+            title: cleanTitle(idx?.threadName || null),
+            preview: null,
+            cwd: meta.cwd,
+            model: null,
+            createdAt: meta.timestamp || stat.birthtime.toISOString(),
+            updatedAt,
+            running: Date.now() - Date.parse(updatedAt) < threshold,
+            messageCount: null,
+        });
+        if (typeof opts.limit === 'number' && out.length >= opts.limit)
+            break;
+    }
+    return out;
+}
+// ---- Gemini: ~/.gemini/projects.json -> tmp/<projectName>/chats/session-*.json[l] ----
+function geminiProjectName(home, workdir) {
+    const projectsPath = path.join(home, '.gemini', 'projects.json');
+    try {
+        const data = JSON.parse(fs.readFileSync(projectsPath, 'utf8'));
+        const projects = data?.projects;
+        if (!projects || typeof projects !== 'object')
+            return null;
+        const resolved = path.resolve(workdir);
+        if (projects[resolved])
+            return projects[resolved];
+        for (const [dir, name] of Object.entries(projects)) {
+            if (path.resolve(dir) === resolved)
+                return name;
+        }
+    }
+    catch { /* none */ }
+    return null;
+}
+function geminiText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (typeof block === 'string')
+                parts.push(block);
+            else if (block && typeof block === 'object' && typeof block.text === 'string')
+                parts.push(block.text);
+        }
+        return parts.join(' ');
+    }
+    return '';
+}
+export function discoverGeminiNativeSessions(workdir, opts = {}) {
+    const home = homeOf(opts);
+    const projectName = geminiProjectName(home, workdir);
+    if (!projectName)
+        return [];
+    const chatsDir = path.join(home, '.gemini', 'tmp', projectName, 'chats');
+    let entries;
+    try {
+        entries = fs.readdirSync(chatsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const threshold = opts.runningThresholdMs ?? NATIVE_SESSION_RUNNING_THRESHOLD_MS;
+    const byId = new Map();
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith('session-'))
+            continue;
+        if (!entry.name.endsWith('.json') && !entry.name.endsWith('.jsonl'))
+            continue;
+        const filePath = path.join(chatsDir, entry.name);
+        const stat = statSafe(filePath);
+        if (!stat)
+            continue;
+        let data;
+        try {
+            data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const sessionId = data?.sessionId ? String(data.sessionId) : null;
+        if (!sessionId)
+            continue;
+        const messages = Array.isArray(data.messages) ? data.messages : [];
+        let title = null;
+        let lastUser = null;
+        let lastAssistant = null;
+        let turns = 0;
+        for (const msg of messages) {
+            if (msg?.type === 'user') {
+                const t = geminiText(msg.content).trim();
+                if (t) {
+                    if (!title)
+                        title = cleanTitle(t);
+                    lastUser = t;
+                    turns++;
+                }
+            }
+            else if (msg?.type === 'model' || msg?.type === 'assistant' || msg?.type === 'gemini') {
+                const t = geminiText(msg.content).trim();
+                if (t)
+                    lastAssistant = t;
+            }
+        }
+        const updatedAt = data.lastUpdated || data.startTime || data.createdAt || stat.mtime.toISOString();
+        const existing = byId.get(sessionId);
+        if (existing && existing.updatedAt && updatedAt && Date.parse(updatedAt) <= Date.parse(existing.updatedAt))
+            continue;
+        byId.set(sessionId, {
+            sessionId,
+            title,
+            preview: cleanTitle(lastAssistant || lastUser, 200),
+            cwd: path.resolve(workdir),
+            model: null,
+            createdAt: data.startTime || data.createdAt || null,
+            updatedAt,
+            running: data.lastUpdated ? Date.now() - Date.parse(data.lastUpdated) < threshold : false,
+            messageCount: turns || null,
+        });
+    }
+    const out = [...byId.values()].sort((a, b) => Date.parse(b.updatedAt || '') - Date.parse(a.updatedAt || ''));
+    return typeof opts.limit === 'number' ? out.slice(0, Math.max(0, opts.limit)) : out;
+}

package/packages/kernel/dist/workspace/paths.d.ts

@@ -0,0 +1,33 @@
+export type LoomScope = 'global' | 'workspace';
+export interface LoomPaths {
+    /** The bare name (no leading dot), e.g. 'pikiloom'. */
+    readonly stateDirName: string;
+    /** The dotted directory name, e.g. '.pikiloom'. */
+    readonly dirName: string;
+    readonly home: string;
+    /** ~/.<stateDirName> */
+    readonly globalRoot: string;
+    /** <workdir>/.<stateDirName> */
+    workspaceRoot(workdir: string): string;
+    /** The root for a scope (workspace requires a workdir). */
+    root(scope: LoomScope, workdir?: string): string;
+    /** <root>/sessions */
+    sessionsDir(scope: LoomScope, workdir?: string): string;
+    /** <root>/skills — the canonical skills registry that agent dirs symlink to. */
+    skillsDir(scope: LoomScope, workdir?: string): string;
+    /** <root>/mcp.json — the unified MCP server config for a scope. */
+    mcpConfigPath(scope: LoomScope, workdir?: string): string;
+    /**
+     * The base under which an agent keeps its own dotfiles for a scope:
+     *   global    -> ~        (so ~/.claude, ~/.agents)
+     *   workspace -> <workdir> (so <workdir>/.claude, <workdir>/.agents)
+     * Used to resolve symlink targets for native agents.
+     */
+    agentHome(scope: LoomScope, workdir?: string): string;
+}
+/** Normalize a state dir name to its bare form: strip a leading dot, trim. */
+export declare function normalizeStateDirName(name: string | null | undefined): string;
+export declare function resolveLoomPaths(opts?: {
+    stateDirName?: string | null;
+    home?: string;
+}): LoomPaths;