@emqo/claudebridge 0.7.0 → 0.9.0

package/dist/core/schema.d.ts

@@ -0,0 +1,166 @@
+import { z } from "zod";
+declare const EndpointSchema: z.ZodObject<{
+    name: z.ZodDefault<z.ZodString>;
+    model: z.ZodDefault<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const MemoryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    auto_summary: z.ZodDefault<z.ZodBoolean>;
+    max_memories: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const SkillConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const SessionConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    max_per_user: z.ZodDefault<z.ZodNumber>;
+    idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+    classifier_budget: z.ZodDefault<z.ZodNumber>;
+    classifier_model: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const AgentConfigSchema: z.ZodObject<{
+    allowed_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    permission_mode: z.ZodDefault<z.ZodString>;
+    max_turns: z.ZodDefault<z.ZodNumber>;
+    max_budget_usd: z.ZodDefault<z.ZodNumber>;
+    system_prompt: z.ZodDefault<z.ZodString>;
+    cwd: z.ZodDefault<z.ZodString>;
+    timeout_seconds: z.ZodDefault<z.ZodNumber>;
+    max_parallel: z.ZodDefault<z.ZodNumber>;
+    memory: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        auto_summary: z.ZodDefault<z.ZodBoolean>;
+        max_memories: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    skill: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    session: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        max_per_user: z.ZodDefault<z.ZodNumber>;
+        idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+        classifier_budget: z.ZodDefault<z.ZodNumber>;
+        classifier_model: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const WorkspaceConfigSchema: z.ZodObject<{
+    base_dir: z.ZodDefault<z.ZodString>;
+    isolation: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const AccessConfigSchema: z.ZodObject<{
+    allowed_users: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowed_groups: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const TelegramConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    token: z.ZodDefault<z.ZodString>;
+    chunk_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const DiscordConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    token: z.ZodDefault<z.ZodString>;
+    chunk_size: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const RedisConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    url: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const WebhookConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    token: z.ZodDefault<z.ZodString>;
+    github_secret: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const CronEntrySchema: z.ZodObject<{
+    schedule_minutes: z.ZodNumber;
+    user_id: z.ZodString;
+    platform: z.ZodString;
+    chat_id: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export declare const ConfigSchema: z.ZodObject<{
+    endpoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        provider: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    log_level: z.ZodDefault<z.ZodString>;
+    locale: z.ZodDefault<z.ZodString>;
+    agent: z.ZodDefault<z.ZodObject<{
+        allowed_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        permission_mode: z.ZodDefault<z.ZodString>;
+        max_turns: z.ZodDefault<z.ZodNumber>;
+        max_budget_usd: z.ZodDefault<z.ZodNumber>;
+        system_prompt: z.ZodDefault<z.ZodString>;
+        cwd: z.ZodDefault<z.ZodString>;
+        timeout_seconds: z.ZodDefault<z.ZodNumber>;
+        max_parallel: z.ZodDefault<z.ZodNumber>;
+        memory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            auto_summary: z.ZodDefault<z.ZodBoolean>;
+            max_memories: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        skill: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        session: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            max_per_user: z.ZodDefault<z.ZodNumber>;
+            idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+            classifier_budget: z.ZodDefault<z.ZodNumber>;
+            classifier_model: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    workspace: z.ZodDefault<z.ZodObject<{
+        base_dir: z.ZodDefault<z.ZodString>;
+        isolation: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    access: z.ZodDefault<z.ZodObject<{
+        allowed_users: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        allowed_groups: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    redis: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        url: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    platforms: z.ZodDefault<z.ZodObject<{
+        telegram: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            token: z.ZodDefault<z.ZodString>;
+            chunk_size: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        discord: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            token: z.ZodDefault<z.ZodString>;
+            chunk_size: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    webhook: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        token: z.ZodDefault<z.ZodString>;
+        github_secret: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    cron: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schedule_minutes: z.ZodNumber;
+        user_id: z.ZodString;
+        platform: z.ZodString;
+        chat_id: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof ConfigSchema>;
+export type Endpoint = z.infer<typeof EndpointSchema>;
+export type AgentConfig = z.infer<typeof AgentConfigSchema>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+export type SkillConfig = z.infer<typeof SkillConfigSchema>;
+export type SessionConfig = z.infer<typeof SessionConfigSchema>;
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+export type AccessConfig = z.infer<typeof AccessConfigSchema>;
+export type TelegramConfig = z.infer<typeof TelegramConfigSchema>;
+export type DiscordConfig = z.infer<typeof DiscordConfigSchema>;
+export type RedisConfig = z.infer<typeof RedisConfigSchema>;
+export type WebhookConfig = z.infer<typeof WebhookConfigSchema>;
+export type CronEntry = z.infer<typeof CronEntrySchema>;
+export {};

package/dist/core/schema.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+const EndpointSchema = z.object({
+    name: z.string().default("default"),
+    model: z.string().default(""),
+    provider: z.string().default("claude"),
+});
+const MemoryConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    auto_summary: z.boolean().default(true),
+    max_memories: z.number().int().positive().default(50),
+});
+const SkillConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+});
+const SessionConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    max_per_user: z.number().int().positive().default(3),
+    idle_timeout_minutes: z.number().positive().default(30),
+    classifier_budget: z.number().nonnegative().default(0.05),
+    classifier_model: z.string().default(""),
+});
+const AgentConfigSchema = z.object({
+    allowed_tools: z.array(z.string()).default([]),
+    permission_mode: z.string().default("acceptEdits"),
+    max_turns: z.number().int().positive().default(50),
+    max_budget_usd: z.number().nonnegative().default(2.0),
+    system_prompt: z.string().default(""),
+    cwd: z.string().default(""),
+    timeout_seconds: z.number().int().nonnegative().default(0),
+    max_parallel: z.number().int().positive().default(1),
+    memory: MemoryConfigSchema.default(() => ({})),
+    skill: SkillConfigSchema.default(() => ({})),
+    session: SessionConfigSchema.default(() => ({})),
+});
+const WorkspaceConfigSchema = z.object({
+    base_dir: z.string().default("./workspaces"),
+    isolation: z.boolean().default(true),
+});
+const AccessConfigSchema = z.object({
+    allowed_users: z.array(z.string()).default([]),
+    allowed_groups: z.array(z.string()).default([]),
+});
+const TelegramConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    token: z.string().default(""),
+    chunk_size: z.number().int().positive().default(4000),
+});
+const DiscordConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    token: z.string().default(""),
+    chunk_size: z.number().int().positive().default(1900),
+});
+const RedisConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    url: z.string().default(""),
+});
+const WebhookConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    port: z.number().int().positive().default(3100),
+    token: z.string().default(""),
+    github_secret: z.string().default(""),
+});
+const CronEntrySchema = z.object({
+    schedule_minutes: z.number().int().positive(),
+    user_id: z.string(),
+    platform: z.string(),
+    chat_id: z.string(),
+    description: z.string(),
+});
+const PlatformsSchema = z.object({
+    telegram: TelegramConfigSchema.default(() => ({})),
+    discord: DiscordConfigSchema.default(() => ({})),
+});
+export const ConfigSchema = z.object({
+    endpoints: z.array(EndpointSchema).default([]),
+    log_level: z.string().default("info"),
+    locale: z.string().default("en"),
+    agent: AgentConfigSchema.default(() => ({})),
+    workspace: WorkspaceConfigSchema.default(() => ({})),
+    access: AccessConfigSchema.default(() => ({})),
+    redis: RedisConfigSchema.default(() => ({})),
+    platforms: PlatformsSchema.default(() => ({})),
+    webhook: WebhookConfigSchema.default(() => ({})),
+    cron: z.array(CronEntrySchema).default([]),
+});

package/dist/core/session.d.ts

@@ -0,0 +1,50 @@
+import { Store } from "./store.js";
+import { SessionConfig } from "./config.js";
+export interface SubSession {
+    id: string;
+    userId: string;
+    platform: string;
+    chatId: string;
+    claudeSessionId: string | null;
+    label: string;
+    status: "active" | "idle" | "expired" | "closed";
+    createdAt: number;
+    lastActiveAt: number;
+    messageCount: number;
+    totalCost: number;
+}
+export declare class SessionManager {
+    private store;
+    private config;
+    constructor(store: Store, config: SessionConfig);
+    /** Create a new sub-session for the user */
+    create(userId: string, platform: string, chatId: string, label?: string): SubSession;
+    /** Get a sub-session by ID */
+    get(sessionId: string): SubSession | null;
+    /** Get all active (active/idle) sub-sessions for a user+platform */
+    getActive(userId: string, platform: string): SubSession[];
+    /** Update lastActiveAt and increment message count */
+    touch(sessionId: string): void;
+    /** Save the claude CLI session_id for resume */
+    setClaudeSessionId(sessionId: string, claudeId: string): void;
+    /** Update the topic label */
+    updateLabel(sessionId: string, label: string): void;
+    /** Add cost to a sub-session */
+    addCost(sessionId: string, cost: number): void;
+    /** Close a specific sub-session */
+    close(sessionId: string): void;
+    /** Close all active sub-sessions for a user (equivalent to /new) */
+    closeAll(userId: string): void;
+    /** Check if a user can create another sub-session (within limit) */
+    canCreate(userId: string, platform: string): boolean;
+    /** Expire idle sub-sessions and prune old message mappings. Call periodically. */
+    expireIdle(): number;
+    /** Track a platform message → sub-session mapping (for reply-to routing) */
+    trackMessage(platformMsgId: string, chatId: string, subSessionId: string): void;
+    /** Look up which sub-session a platform message belongs to */
+    getSessionByMessage(platformMsgId: string, chatId: string): string | null;
+    /** Check if a sub-session is usable (active or idle) */
+    isUsable(session: SubSession): boolean;
+    /** Get all sub-sessions for a user (all statuses) */
+    getAll(userId: string): SubSession[];
+}

package/dist/core/session.js

@@ -0,0 +1,100 @@
+import { randomUUID } from "crypto";
+import { log as rootLog } from "./logger.js";
+const log = rootLog.child("session");
+/** Maps a DB row to a SubSession domain object */
+function toSubSession(row) {
+    return {
+        id: row.id,
+        userId: row.user_id,
+        platform: row.platform,
+        chatId: row.chat_id,
+        claudeSessionId: row.claude_session_id ?? null,
+        label: row.label,
+        status: row.status,
+        createdAt: row.created_at,
+        lastActiveAt: row.last_active_at,
+        messageCount: row.message_count,
+        totalCost: row.total_cost,
+    };
+}
+export class SessionManager {
+    store;
+    config;
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+    }
+    /** Create a new sub-session for the user */
+    create(userId, platform, chatId, label) {
+        const id = randomUUID();
+        const trimmedLabel = (label || "").slice(0, 50);
+        this.store.createSubSession(id, userId, platform, chatId, trimmedLabel);
+        const row = this.store.getSubSession(id);
+        return toSubSession(row);
+    }
+    /** Get a sub-session by ID */
+    get(sessionId) {
+        const row = this.store.getSubSession(sessionId);
+        return row ? toSubSession(row) : null;
+    }
+    /** Get all active (active/idle) sub-sessions for a user+platform */
+    getActive(userId, platform) {
+        return this.store.getActiveSubSessions(userId, platform).map(toSubSession);
+    }
+    /** Update lastActiveAt and increment message count */
+    touch(sessionId) {
+        this.store.touchSubSession(sessionId);
+    }
+    /** Save the claude CLI session_id for resume */
+    setClaudeSessionId(sessionId, claudeId) {
+        this.store.setSubSessionClaudeId(sessionId, claudeId);
+    }
+    /** Update the topic label */
+    updateLabel(sessionId, label) {
+        this.store.updateSubSessionLabel(sessionId, label.slice(0, 50));
+    }
+    /** Add cost to a sub-session */
+    addCost(sessionId, cost) {
+        if (cost > 0)
+            this.store.updateSubSessionCost(sessionId, cost);
+    }
+    /** Close a specific sub-session */
+    close(sessionId) {
+        this.store.closeSubSession(sessionId);
+    }
+    /** Close all active sub-sessions for a user (equivalent to /new) */
+    closeAll(userId) {
+        this.store.closeAllSubSessions(userId);
+    }
+    /** Check if a user can create another sub-session (within limit) */
+    canCreate(userId, platform) {
+        const active = this.store.getActiveSubSessions(userId, platform);
+        return active.length < this.config.max_per_user;
+    }
+    /** Expire idle sub-sessions and prune old message mappings. Call periodically. */
+    expireIdle() {
+        const timeoutMs = this.config.idle_timeout_minutes * 60 * 1000;
+        const expired = this.store.expireIdleSessions(timeoutMs);
+        // Also prune message mappings older than 24h
+        this.store.pruneSubSessionMessages(24 * 60 * 60 * 1000);
+        if (expired > 0)
+            log.info("expired idle sub-sessions", { count: expired });
+        return expired;
+    }
+    /** Track a platform message → sub-session mapping (for reply-to routing) */
+    trackMessage(platformMsgId, chatId, subSessionId) {
+        this.store.trackSubSessionMessage(platformMsgId, chatId, subSessionId);
+    }
+    /** Look up which sub-session a platform message belongs to */
+    getSessionByMessage(platformMsgId, chatId) {
+        return this.store.getSubSessionByMessage(platformMsgId, chatId);
+    }
+    /** Check if a sub-session is usable (active or idle) */
+    isUsable(session) {
+        return session.status === "active" || session.status === "idle";
+    }
+    /** Get all sub-sessions for a user (all statuses) */
+    getAll(userId) {
+        return this.store.getAllSubSessions(userId).map(toSubSession);
+    }
+}

package/dist/core/store.d.ts

@@ -2,6 +2,8 @@ export declare class Store {
     private db;
     readonly dbPath: string;
     constructor(dbPath?: string);
+    private _migrateFromLegacySessions;
+    close(): void;
     getSession(userId: string): string | null;
     setSession(userId: string, sessionId: string, platform: string): void;
     clearSession(userId: string): void;
@@ -31,14 +33,6 @@ export declare class Store {
     clearMemories(userId: string): void;
     trimMemories(userId: string, max: number): void;
     addTask(userId: string, platform: string, chatId: string, description: string, remindAt?: number, auto?: boolean, parentId?: number, scheduledAt?: number): number;
-    getTasks(userId: string): {
-        id: number;
-        description: string;
-        status: string;
-        remind_at: number | null;
-        created_at: number;
-    }[];
-    completeTask(taskId: number, userId: string): boolean;
     getDueReminders(): {
         id: number;
         user_id: string;
@@ -47,13 +41,6 @@ export declare class Store {
         description: string;
     }[];
     markReminderSent(taskId: number): void;
-    getNextAutoTask(platform?: string): {
-        id: number;
-        user_id: string;
-        platform: string;
-        chat_id: string;
-        description: string;
-    } | null;
     markTaskRunning(taskId: number): void;
     markTaskResult(taskId: number, status: string): void;
     getAutoTasks(userId: string): {
@@ -108,4 +95,54 @@ export declare class Store {
         scheduled_at: number | null;
         created_at: number;
     }[];
+    createSubSession(id: string, userId: string, platform: string, chatId: string, label: string): void;
+    getSubSession(id: string): {
+        id: string;
+        user_id: string;
+        platform: string;
+        chat_id: string;
+        claude_session_id: string | null;
+        label: string;
+        status: string;
+        created_at: number;
+        last_active_at: number;
+        message_count: number;
+        total_cost: number;
+    } | null;
+    getActiveSubSessions(userId: string, platform: string): {
+        id: string;
+        user_id: string;
+        platform: string;
+        chat_id: string;
+        claude_session_id: string | null;
+        label: string;
+        status: string;
+        created_at: number;
+        last_active_at: number;
+        message_count: number;
+        total_cost: number;
+    }[];
+    touchSubSession(id: string): void;
+    setSubSessionClaudeId(id: string, claudeSessionId: string): void;
+    updateSubSessionLabel(id: string, label: string): void;
+    updateSubSessionCost(id: string, cost: number): void;
+    closeSubSession(id: string): void;
+    closeAllSubSessions(userId: string): void;
+    expireIdleSessions(timeoutMs: number): number;
+    trackSubSessionMessage(platformMsgId: string, chatId: string, subSessionId: string): void;
+    getSubSessionByMessage(platformMsgId: string, chatId: string): string | null;
+    pruneSubSessionMessages(maxAgeMs: number): number;
+    getAllSubSessions(userId: string): {
+        id: string;
+        user_id: string;
+        platform: string;
+        chat_id: string;
+        claude_session_id: string | null;
+        label: string;
+        status: string;
+        created_at: number;
+        last_active_at: number;
+        message_count: number;
+        total_cost: number;
+    }[];
 }

package/dist/core/store.js

@@ -1,13 +1,17 @@
 import Database from "better-sqlite3";
 import { mkdirSync } from "fs";
 import { dirname, resolve } from "path";
+import { log as rootLog } from "./logger.js";
+const log = rootLog.child("store");
 const DEFAULT_DB_PATH = "./data/claudebridge.db";
 export class Store {
     db;
     dbPath;
     constructor(dbPath) {
-        this.dbPath = resolve(dbPath || DEFAULT_DB_PATH);
-        mkdirSync(dirname(this.dbPath), { recursive: true });
+        const p = dbPath || DEFAULT_DB_PATH;
+        this.dbPath = p === ":memory:" ? p : resolve(p);
+        if (p !== ":memory:")
+            mkdirSync(dirname(this.dbPath), { recursive: true });
         this.db = new Database(this.dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.exec(`
@@ -54,6 +58,27 @@ export class Store {
       );
       CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id);
       CREATE INDEX IF NOT EXISTS idx_tasks_user ON tasks(user_id, status);
+      CREATE TABLE IF NOT EXISTS sub_sessions (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        platform TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        claude_session_id TEXT,
+        label TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at INTEGER NOT NULL,
+        last_active_at INTEGER NOT NULL,
+        message_count INTEGER NOT NULL DEFAULT 0,
+        total_cost REAL NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_subsess_user ON sub_sessions(user_id, platform, status);
+      CREATE TABLE IF NOT EXISTS sub_session_messages (
+        platform_msg_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        sub_session_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (platform_msg_id, chat_id)
+      );
     `);
         // Schema migration: add parent_id, result, and scheduled_at columns
         try {
@@ -70,11 +95,37 @@ export class Store {
         catch { }
         this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id)");
         // Startup recovery: reset orphaned 'running' tasks back to 'auto' so they get re-executed
-        const recovered = this.db.prepare("UPDATE tasks SET status = 'auto' WHERE status = 'running'").run();
-        if (recovered.changes > 0) {
-            console.log(`[store] recovered ${recovered.changes} orphaned running task(s) back to auto queue`);
+        const orphaned = this.db.prepare("SELECT id, description FROM tasks WHERE status = 'running'").all();
+        for (const t of orphaned) {
+            const desc = t.description.startsWith("[recovered]") ? t.description : `[recovered] Check current state before making changes — previous attempt was interrupted. Original task: ${t.description}`;
+            this.db.prepare("UPDATE tasks SET status = 'auto', description = ? WHERE id = ?").run(desc, t.id);
+        }
+        if (orphaned.length > 0) {
+            log.info("recovered orphaned running tasks", { count: orphaned.length });
+        }
+        // Startup cleanup: prune history/usage older than 30 days
+        const cutoff = Date.now() - 30 * 86400000;
+        this.db.prepare("DELETE FROM history WHERE created_at < ?").run(cutoff);
+        this.db.prepare("DELETE FROM usage WHERE created_at < ?").run(cutoff);
+        // Migrate legacy sessions → sub_sessions (one-time)
+        this._migrateFromLegacySessions();
+    }
+    _migrateFromLegacySessions() {
+        const legacyCount = this.db.prepare("SELECT COUNT(*) as c FROM sessions").get().c;
+        const subCount = this.db.prepare("SELECT COUNT(*) as c FROM sub_sessions").get().c;
+        if (legacyCount > 0 && subCount === 0) {
+            const rows = this.db.prepare("SELECT user_id, session_id, platform, updated_at FROM sessions").all();
+            const crypto = require("crypto");
+            for (const row of rows) {
+                const id = crypto.randomUUID();
+                this.db.prepare("INSERT INTO sub_sessions (id, user_id, platform, chat_id, claude_session_id, label, status, created_at, last_active_at, message_count, total_cost) VALUES (?, ?, ?, '', ?, 'main', 'active', ?, ?, 1, 0)").run(id, row.user_id, row.platform, row.session_id, row.updated_at, row.updated_at);
+            }
+            log.info("migrated legacy sessions to sub_sessions", { count: rows.length });
         }
     }
+    close() {
+        this.db.close();
+    }
     // --- sessions ---
     getSession(userId) {
         const row = this.db
@@ -143,26 +194,12 @@ export class Store {
         const r = this.db.prepare("INSERT INTO tasks (user_id, platform, chat_id, description, status, remind_at, parent_id, scheduled_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(userId, platform, chatId, description, auto ? "auto" : "pending", remindAt ?? null, parentId ?? null, scheduledAt ?? null, Date.now());
         return Number(r.lastInsertRowid);
     }
-    getTasks(userId) {
-        return this.db.prepare("SELECT id, description, status, remind_at, created_at FROM tasks WHERE user_id = ? AND status = 'pending' ORDER BY created_at DESC").all(userId);
-    }
-    completeTask(taskId, userId) {
-        const r = this.db.prepare("UPDATE tasks SET status = 'done' WHERE id = ? AND user_id = ? AND status = 'pending'").run(taskId, userId);
-        return r.changes > 0;
-    }
     getDueReminders() {
         return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'pending' AND remind_at IS NOT NULL AND remind_at <= ? AND reminder_sent = 0").all(Date.now());
     }
     markReminderSent(taskId) {
         this.db.prepare("UPDATE tasks SET reminder_sent = 1 WHERE id = ?").run(taskId);
     }
-    getNextAutoTask(platform) {
-        const now = Date.now();
-        if (platform) {
-            return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'auto' AND platform = ? AND (scheduled_at IS NULL OR scheduled_at <= ?) ORDER BY created_at ASC LIMIT 1").get(platform, now) ?? null;
-        }
-        return this.db.prepare("SELECT id, user_id, platform, chat_id, description FROM tasks WHERE status = 'auto' AND (scheduled_at IS NULL OR scheduled_at <= ?) ORDER BY created_at ASC LIMIT 1").get(now) ?? null;
-    }
     markTaskRunning(taskId) {
         this.db.prepare("UPDATE tasks SET status = 'running' WHERE id = ?").run(taskId);
     }
@@ -223,4 +260,53 @@ export class Store {
     getRecentAutoTasks(platform, limit) {
         return this.db.prepare("SELECT id, user_id, description, status, parent_id, scheduled_at, created_at FROM tasks WHERE platform = ? AND status IN ('auto','running','done','failed','approval_pending','cancelled') ORDER BY created_at DESC LIMIT ?").all(platform, limit);
     }
+    // --- sub_sessions ---
+    createSubSession(id, userId, platform, chatId, label) {
+        const now = Date.now();
+        this.db.prepare("INSERT INTO sub_sessions (id, user_id, platform, chat_id, claude_session_id, label, status, created_at, last_active_at, message_count, total_cost) VALUES (?, ?, ?, ?, NULL, ?, 'active', ?, ?, 0, 0)").run(id, userId, platform, chatId, label, now, now);
+    }
+    getSubSession(id) {
+        return this.db.prepare("SELECT * FROM sub_sessions WHERE id = ?").get(id) ?? null;
+    }
+    getActiveSubSessions(userId, platform) {
+        return this.db.prepare("SELECT * FROM sub_sessions WHERE user_id = ? AND platform = ? AND status IN ('active','idle') ORDER BY last_active_at DESC").all(userId, platform);
+    }
+    touchSubSession(id) {
+        this.db.prepare("UPDATE sub_sessions SET last_active_at = ?, message_count = message_count + 1, status = 'active' WHERE id = ?").run(Date.now(), id);
+    }
+    setSubSessionClaudeId(id, claudeSessionId) {
+        this.db.prepare("UPDATE sub_sessions SET claude_session_id = ? WHERE id = ?").run(claudeSessionId, id);
+    }
+    updateSubSessionLabel(id, label) {
+        this.db.prepare("UPDATE sub_sessions SET label = ? WHERE id = ?").run(label, id);
+    }
+    updateSubSessionCost(id, cost) {
+        this.db.prepare("UPDATE sub_sessions SET total_cost = total_cost + ? WHERE id = ?").run(cost, id);
+    }
+    closeSubSession(id) {
+        this.db.prepare("UPDATE sub_sessions SET status = 'closed' WHERE id = ?").run(id);
+    }
+    closeAllSubSessions(userId) {
+        this.db.prepare("UPDATE sub_sessions SET status = 'closed' WHERE user_id = ? AND status IN ('active','idle')").run(userId);
+    }
+    expireIdleSessions(timeoutMs) {
+        const cutoff = Date.now() - timeoutMs;
+        const r = this.db.prepare("UPDATE sub_sessions SET status = 'expired' WHERE status = 'active' AND last_active_at < ?").run(cutoff);
+        return r.changes;
+    }
+    trackSubSessionMessage(platformMsgId, chatId, subSessionId) {
+        this.db.prepare("INSERT OR REPLACE INTO sub_session_messages (platform_msg_id, chat_id, sub_session_id, created_at) VALUES (?, ?, ?, ?)").run(platformMsgId, chatId, subSessionId, Date.now());
+    }
+    getSubSessionByMessage(platformMsgId, chatId) {
+        const row = this.db.prepare("SELECT sub_session_id FROM sub_session_messages WHERE platform_msg_id = ? AND chat_id = ?").get(platformMsgId, chatId);
+        return row?.sub_session_id ?? null;
+    }
+    pruneSubSessionMessages(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        const r = this.db.prepare("DELETE FROM sub_session_messages WHERE created_at < ?").run(cutoff);
+        return r.changes;
+    }
+    getAllSubSessions(userId) {
+        return this.db.prepare("SELECT * FROM sub_sessions WHERE user_id = ? ORDER BY last_active_at DESC").all(userId);
+    }
 }