@qlingzzy/qling 1.0.0

package/dist/session/session-goal-manager.js

@@ -0,0 +1,118 @@
+import * as fs from "fs/promises";
+import { existsSync } from "fs";
+import * as path from "path";
+function cloneGoal(goal) {
+    return goal ? { ...goal } : null;
+}
+export class SessionGoalManager {
+    goalsDir;
+    stateFile;
+    clock;
+    goal = null;
+    constructor(options) {
+        this.goalsDir = path.join(options.stateDir, "session-goals");
+        this.stateFile = path.join(this.goalsDir, `${options.sessionId}.json`);
+        this.clock = options.clock ?? (() => Date.now());
+    }
+    async init() {
+        await fs.mkdir(this.goalsDir, { recursive: true });
+        await this.loadGoal();
+    }
+    async setGoal(condition, baseline, options = {}) {
+        const now = this.clock();
+        this.goal = {
+            condition: condition.trim(),
+            status: "active",
+            runner: options.runner ?? "session",
+            pending: options.pending ?? false,
+            createdAt: now,
+            updatedAt: now,
+            baselineTurns: baseline.turnCount,
+            baselineTokens: baseline.tokens,
+            evaluatedTurns: 0,
+            lastReason: "goal_activated",
+            lastDecision: null,
+        };
+        await this.saveGoal();
+        return cloneGoal(this.goal);
+    }
+    async markEvaluation(result) {
+        const goal = this.getGoalOrThrow();
+        const now = this.clock();
+        goal.updatedAt = now;
+        goal.evaluatedTurns += 1;
+        goal.lastReason = result.reason;
+        goal.lastDecision = result.done ? "done" : "continue";
+        goal.pending = goal.runner === "daemon" ? !result.done : false;
+        if (result.done) {
+            goal.status = "achieved";
+            goal.achievedAt = now;
+        }
+        await this.saveGoal();
+        return cloneGoal(goal);
+    }
+    async clearGoal(reason) {
+        const goal = this.goal;
+        const now = this.clock();
+        if (!goal) {
+            const cleared = {
+                condition: "",
+                status: "cleared",
+                runner: "session",
+                pending: false,
+                createdAt: now,
+                updatedAt: now,
+                clearedAt: now,
+                baselineTurns: 0,
+                baselineTokens: 0,
+                evaluatedTurns: 0,
+                lastReason: reason,
+                lastDecision: "cleared",
+            };
+            this.goal = cleared;
+            await this.saveGoal();
+            return cloneGoal(cleared);
+        }
+        goal.status = "cleared";
+        goal.pending = false;
+        goal.updatedAt = now;
+        goal.clearedAt = now;
+        goal.lastReason = reason;
+        goal.lastDecision = "cleared";
+        await this.saveGoal();
+        return cloneGoal(goal);
+    }
+    async getGoalStatus() {
+        await this.loadGoal();
+        return cloneGoal(this.goal);
+    }
+    getActiveGoal(runner) {
+        if (!this.goal || this.goal.status !== "active") {
+            return null;
+        }
+        if (runner && (this.goal.runner ?? "session") !== runner) {
+            return null;
+        }
+        return cloneGoal(this.goal);
+    }
+    getGoalOrThrow() {
+        if (!this.goal) {
+            throw new Error("session goal not found");
+        }
+        return this.goal;
+    }
+    async loadGoal() {
+        if (!existsSync(this.stateFile))
+            return;
+        const raw = await fs.readFile(this.stateFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        this.goal = {
+            ...parsed,
+            runner: parsed.runner ?? "session",
+            pending: parsed.pending ?? false,
+        };
+    }
+    async saveGoal() {
+        await fs.writeFile(this.stateFile, JSON.stringify(this.goal, null, 2), "utf-8");
+    }
+}

package/dist/session/session-registry.d.ts

@@ -0,0 +1,40 @@
+import type { Message } from "../types.js";
+export interface SavedSessionSnapshot {
+    version: number;
+    name: string;
+    sessionId: string;
+    workspaceDir: string | null;
+    createdAt: string;
+    updatedAt: string;
+    messages: Message[];
+    turnCount: number;
+    sessionTokens: number;
+    compactionCount: number;
+}
+export interface SavedSessionSummary {
+    name: string;
+    sessionId: string;
+    workspaceDir: string | null;
+    createdAt: string;
+    updatedAt: string;
+    turnCount: number;
+    messageCount: number;
+    sessionTokens: number;
+    compactionCount: number;
+}
+export interface SessionRegistryOptions {
+    stateDir: string;
+}
+export declare class SessionRegistry {
+    private readonly sessionsDir;
+    constructor(options: SessionRegistryOptions);
+    save(snapshot: Omit<SavedSessionSnapshot, "version">): Promise<string>;
+    list(): Promise<SavedSessionSummary[]>;
+    load(nameOrSessionId: string): Promise<SavedSessionSnapshot | null>;
+    loadLatest(): Promise<SavedSessionSnapshot | null>;
+    private getSnapshotPath;
+    private normalizeName;
+    private normalizeSnapshot;
+    private readSnapshot;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/session/session-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-registry.d.ts","sourceRoot":"","sources":["../../src/session/session-registry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAoBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAEzB,OAAO,EAAE,sBAAsB;IAIrC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAQtE,IAAI,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAmBtC,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAmBnE,UAAU,IAAI,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAQxD,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,iBAAiB;YAeX,YAAY;CAmC3B"}

package/dist/session/session-registry.js

@@ -0,0 +1,124 @@
+import * as fs from "fs/promises";
+import { existsSync } from "fs";
+import * as path from "path";
+function cloneMessages(messages) {
+    return messages.map((message) => ({ ...message }));
+}
+function toSummary(snapshot) {
+    return {
+        name: snapshot.name,
+        sessionId: snapshot.sessionId,
+        workspaceDir: snapshot.workspaceDir,
+        createdAt: snapshot.createdAt,
+        updatedAt: snapshot.updatedAt,
+        turnCount: snapshot.turnCount,
+        messageCount: snapshot.messages.length,
+        sessionTokens: snapshot.sessionTokens,
+        compactionCount: snapshot.compactionCount,
+    };
+}
+export class SessionRegistry {
+    sessionsDir;
+    constructor(options) {
+        this.sessionsDir = path.join(options.stateDir, "sessions");
+    }
+    async save(snapshot) {
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+        const normalized = this.normalizeSnapshot(snapshot);
+        const filePath = this.getSnapshotPath(normalized.name);
+        await fs.writeFile(filePath, JSON.stringify(normalized, null, 2), "utf-8");
+        return filePath;
+    }
+    async list() {
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+        const files = await fs.readdir(this.sessionsDir);
+        const snapshots = [];
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            const snapshot = await this.readSnapshot(path.join(this.sessionsDir, file));
+            if (!snapshot)
+                continue;
+            snapshots.push(toSummary(snapshot));
+        }
+        return snapshots.sort((left, right) => {
+            const diff = Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+            if (diff !== 0)
+                return diff;
+            return right.name.localeCompare(left.name);
+        });
+    }
+    async load(nameOrSessionId) {
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+        const normalizedRef = this.normalizeName(nameOrSessionId);
+        const directPath = this.getSnapshotPath(normalizedRef);
+        const direct = await this.readSnapshot(directPath);
+        if (direct) {
+            return direct;
+        }
+        const summaries = await this.list();
+        const matched = summaries.find((summary) => summary.name === normalizedRef || summary.sessionId === normalizedRef);
+        if (!matched) {
+            return null;
+        }
+        return this.readSnapshot(this.getSnapshotPath(matched.name));
+    }
+    async loadLatest() {
+        const summaries = await this.list();
+        if (summaries.length === 0) {
+            return null;
+        }
+        return this.readSnapshot(this.getSnapshotPath(summaries[0].name));
+    }
+    getSnapshotPath(name) {
+        return path.join(this.sessionsDir, `${this.normalizeName(name)}.json`);
+    }
+    normalizeName(name) {
+        return path.basename(name).replace(/\.json$/i, "");
+    }
+    normalizeSnapshot(snapshot) {
+        return {
+            version: 1,
+            name: this.normalizeName(snapshot.name),
+            sessionId: snapshot.sessionId.trim(),
+            workspaceDir: snapshot.workspaceDir ?? null,
+            createdAt: snapshot.createdAt,
+            updatedAt: snapshot.updatedAt,
+            messages: cloneMessages(snapshot.messages ?? []),
+            turnCount: snapshot.turnCount ?? 0,
+            sessionTokens: snapshot.sessionTokens ?? 0,
+            compactionCount: snapshot.compactionCount ?? 0,
+        };
+    }
+    async readSnapshot(filePath) {
+        if (!existsSync(filePath)) {
+            return null;
+        }
+        try {
+            const raw = JSON.parse(await fs.readFile(filePath, "utf-8"));
+            const name = this.normalizeName(path.basename(filePath));
+            const savedAt = typeof raw.savedAt === "string" ? raw.savedAt : new Date(0).toISOString();
+            const createdAt = typeof raw.createdAt === "string" ? raw.createdAt : savedAt;
+            const updatedAt = typeof raw.updatedAt === "string" ? raw.updatedAt : savedAt;
+            return {
+                version: typeof raw.version === "number" ? raw.version : 1,
+                name: typeof raw.name === "string" && raw.name.trim() ? this.normalizeName(raw.name) : name,
+                sessionId: typeof raw.sessionId === "string" && raw.sessionId.trim()
+                    ? raw.sessionId
+                    : name,
+                workspaceDir: typeof raw.workspaceDir === "string" && raw.workspaceDir.trim()
+                    ? raw.workspaceDir
+                    : null,
+                createdAt,
+                updatedAt,
+                messages: Array.isArray(raw.messages) ? cloneMessages(raw.messages) : [],
+                turnCount: typeof raw.turnCount === "number" ? raw.turnCount : 0,
+                sessionTokens: typeof raw.sessionTokens === "number" ? raw.sessionTokens : 0,
+                compactionCount: typeof raw.compactionCount === "number" ? raw.compactionCount : 0,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/session/session-scheduler.d.ts

@@ -0,0 +1,59 @@
+export type SessionTaskKind = "loop";
+export type SessionTaskMode = "fixed" | "default";
+export type SessionTaskStatus = "active" | "running" | "completed" | "canceled";
+export type SessionTaskRunner = "session" | "daemon";
+export interface SessionTask {
+    id: string;
+    kind: SessionTaskKind;
+    prompt: string;
+    intervalMs: number;
+    mode: SessionTaskMode;
+    runner: SessionTaskRunner;
+    status: SessionTaskStatus;
+    pending: boolean;
+    createdAt: number;
+    updatedAt: number;
+    lastRunAt?: number;
+    nextRunAt: number;
+}
+export interface SessionSchedulerOptions {
+    stateDir: string;
+    sessionId: string;
+    onDue?: (task: SessionTask) => Promise<void>;
+    clock?: () => number;
+    pollIntervalMs?: number;
+    runner?: SessionTaskRunner;
+}
+export interface DueRunResult {
+    triggered: number;
+}
+export declare class SessionScheduler {
+    private readonly tasksDir;
+    private readonly stateFile;
+    private readonly onDue;
+    private readonly clock;
+    private readonly pollIntervalMs;
+    private readonly runner;
+    private readonly tasks;
+    private busy;
+    private timer;
+    constructor(options: SessionSchedulerOptions);
+    init(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+    setBusy(value: boolean): void;
+    createLoopTask(options: {
+        prompt: string;
+        intervalMs: number;
+        mode: SessionTaskMode;
+        runner?: SessionTaskRunner;
+    }): Promise<SessionTask>;
+    listTasks(): Promise<SessionTask[]>;
+    cancelTask(id: string): Promise<SessionTask>;
+    cancelAllTasks(): Promise<number>;
+    runDueTasksOnce(): Promise<DueRunResult>;
+    private getTaskOrThrow;
+    private loadTasks;
+    private saveTasks;
+}
+//# sourceMappingURL=session-scheduler.d.ts.map

package/dist/session/session-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-scheduler.d.ts","sourceRoot":"","sources":["../../src/session/session-scheduler.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AACrC,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,SAAS,CAAC;AAClD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;AAChF,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,eAAe,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAA+C;gBAEhD,OAAO,EAAE,uBAAuB;IAStC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,KAAK,IAAI,IAAI;IAOP,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIvB,cAAc,CAAC,OAAO,EAAE;QAC5B,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,eAAe,CAAC;QACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC;KAC5B,GAAG,OAAO,CAAC,WAAW,CAAC;IAqBlB,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAOnC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAU5C,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAiBjC,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC;IAqD9C,OAAO,CAAC,cAAc;YAQR,SAAS;YAaT,SAAS;CAMxB"}

package/dist/session/session-scheduler.js

@@ -0,0 +1,170 @@
+import * as fs from "fs/promises";
+import { existsSync } from "fs";
+import * as path from "path";
+function cloneTask(task) {
+    return { ...task };
+}
+export class SessionScheduler {
+    tasksDir;
+    stateFile;
+    onDue;
+    clock;
+    pollIntervalMs;
+    runner;
+    tasks = new Map();
+    busy = false;
+    timer = null;
+    constructor(options) {
+        this.tasksDir = path.join(options.stateDir, "session-tasks");
+        this.stateFile = path.join(this.tasksDir, `${options.sessionId}.json`);
+        this.onDue = options.onDue ?? (async () => { });
+        this.clock = options.clock ?? (() => Date.now());
+        this.pollIntervalMs = options.pollIntervalMs ?? 1000;
+        this.runner = options.runner ?? "session";
+    }
+    async init() {
+        await fs.mkdir(this.tasksDir, { recursive: true });
+        await this.loadTasks();
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.runDueTasksOnce();
+        }, this.pollIntervalMs);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    setBusy(value) {
+        this.busy = value;
+    }
+    async createLoopTask(options) {
+        await this.loadTasks();
+        const now = this.clock();
+        const task = {
+            id: `tsk_loop_${now.toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+            kind: "loop",
+            prompt: options.prompt,
+            intervalMs: Math.max(1_000, Math.floor(options.intervalMs)),
+            mode: options.mode,
+            runner: options.runner ?? this.runner,
+            status: "active",
+            pending: false,
+            createdAt: now,
+            updatedAt: now,
+            nextRunAt: now + Math.max(1_000, Math.floor(options.intervalMs)),
+        };
+        this.tasks.set(task.id, task);
+        await this.saveTasks();
+        return cloneTask(task);
+    }
+    async listTasks() {
+        await this.loadTasks();
+        return Array.from(this.tasks.values())
+            .sort((a, b) => a.createdAt - b.createdAt)
+            .map(cloneTask);
+    }
+    async cancelTask(id) {
+        await this.loadTasks();
+        const task = this.getTaskOrThrow(id);
+        task.status = "canceled";
+        task.pending = false;
+        task.updatedAt = this.clock();
+        await this.saveTasks();
+        return cloneTask(task);
+    }
+    async cancelAllTasks() {
+        await this.loadTasks();
+        let count = 0;
+        for (const task of this.tasks.values()) {
+            if (task.status === "active" || task.status === "running") {
+                task.status = "canceled";
+                task.pending = false;
+                task.updatedAt = this.clock();
+                count++;
+            }
+        }
+        if (count > 0) {
+            await this.saveTasks();
+        }
+        return count;
+    }
+    async runDueTasksOnce() {
+        await this.loadTasks();
+        const now = this.clock();
+        let triggered = 0;
+        let dirty = false;
+        const tasks = Array.from(this.tasks.values()).sort((a, b) => a.nextRunAt - b.nextRunAt);
+        for (const task of tasks) {
+            if (task.status === "canceled" || task.status === "completed") {
+                continue;
+            }
+            if ((task.runner ?? "session") !== this.runner) {
+                continue;
+            }
+            const isDue = task.pending || task.nextRunAt <= now;
+            if (!isDue)
+                continue;
+            if (this.busy) {
+                if (!task.pending) {
+                    task.pending = true;
+                    task.updatedAt = now;
+                    dirty = true;
+                }
+                continue;
+            }
+            task.pending = false;
+            task.status = "running";
+            task.updatedAt = now;
+            await this.saveTasks();
+            try {
+                await this.onDue(cloneTask(task));
+                triggered++;
+            }
+            finally {
+                const currentTask = this.tasks.get(task.id);
+                if (currentTask && currentTask.status !== "canceled") {
+                    currentTask.status = "active";
+                    currentTask.lastRunAt = now;
+                    currentTask.nextRunAt = now + currentTask.intervalMs;
+                    currentTask.updatedAt = this.clock();
+                }
+                await this.saveTasks();
+            }
+        }
+        if (dirty) {
+            await this.saveTasks();
+        }
+        return { triggered };
+    }
+    getTaskOrThrow(id) {
+        const task = this.tasks.get(id);
+        if (!task) {
+            throw new Error(`session task not found: ${id}`);
+        }
+        return task;
+    }
+    async loadTasks() {
+        if (!existsSync(this.stateFile))
+            return;
+        const raw = await fs.readFile(this.stateFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        this.tasks.clear();
+        for (const task of parsed) {
+            this.tasks.set(task.id, {
+                ...task,
+                runner: task.runner ?? "session",
+            });
+        }
+    }
+    async saveTasks() {
+        const payload = Array.from(this.tasks.values())
+            .sort((a, b) => a.createdAt - b.createdAt)
+            .map(cloneTask);
+        await fs.writeFile(this.stateFile, JSON.stringify(payload, null, 2), "utf-8");
+    }
+}

package/dist/session-checkpoint-report.d.ts

@@ -0,0 +1,22 @@
+export interface LocalSessionCheckpointRequest {
+    name?: string;
+    sessionRef?: string;
+    force?: boolean;
+}
+export interface LocalSessionCheckpointResult {
+    stateDir: string;
+    sessionsDir: string;
+    sourceName: string;
+    sourceSessionId: string;
+    checkpointName: string;
+    checkpointPath: string;
+    updatedAt: string;
+    turnCount: number;
+    messageCount: number;
+    sessionTokens: number;
+    compactionCount: number;
+}
+export declare function parseLocalSessionCheckpointArgs(args: string[]): LocalSessionCheckpointRequest;
+export declare function createLocalSessionCheckpoint(stateDir: string, request?: LocalSessionCheckpointRequest, now?: Date): Promise<LocalSessionCheckpointResult>;
+export declare function formatLocalSessionCheckpointResult(result: LocalSessionCheckpointResult): string[];
+//# sourceMappingURL=session-checkpoint-report.d.ts.map

package/dist/session-checkpoint-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-checkpoint-report.d.ts","sourceRoot":"","sources":["../src/session-checkpoint-report.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,6BAA6B;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,6BAA6B,CA0B7F;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,6BAAkC,EAC3C,GAAG,OAAa,GACf,OAAO,CAAC,4BAA4B,CAAC,CAmCvC;AAED,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,4BAA4B,GAAG,MAAM,EAAE,CAmBjG"}

package/dist/session-checkpoint-report.js

@@ -0,0 +1,99 @@
+import { join } from "path";
+import { SessionRegistry } from "./session/session-registry.js";
+export function parseLocalSessionCheckpointArgs(args) {
+    const nameParts = [];
+    let sessionRef;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--force" || arg === "-f") {
+            continue;
+        }
+        if (arg === "--session" || arg === "-s") {
+            sessionRef = args[i + 1];
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--session=")) {
+            sessionRef = arg.slice("--session=".length).trim() || undefined;
+            continue;
+        }
+        nameParts.push(arg);
+    }
+    return {
+        name: nameParts.join(" ").trim() || undefined,
+        sessionRef,
+        force: args.includes("--force") || args.includes("-f"),
+    };
+}
+export async function createLocalSessionCheckpoint(stateDir, request = {}, now = new Date()) {
+    const registry = new SessionRegistry({ stateDir });
+    const source = request.sessionRef
+        ? await registry.load(request.sessionRef)
+        : await registry.loadLatest();
+    if (!source) {
+        const suffix = request.sessionRef ? `: ${request.sessionRef}` : "";
+        throw new Error(`未找到可保存的本地会话快照${suffix}`);
+    }
+    const checkpointName = request.name?.trim() || defaultCheckpointName(now);
+    if (request.name?.trim() && !request.force) {
+        const existing = await registry.load(checkpointName);
+        if (existing) {
+            throw new Error(`本地检查点已存在: ${checkpointName}。如需覆盖，请显式添加 --force。`);
+        }
+    }
+    const updatedAt = now.toISOString();
+    const checkpointPath = await registry.save(copySnapshot(source, checkpointName, updatedAt));
+    return {
+        stateDir,
+        sessionsDir: join(stateDir, "sessions"),
+        sourceName: source.name,
+        sourceSessionId: source.sessionId,
+        checkpointName,
+        checkpointPath,
+        updatedAt,
+        turnCount: source.turnCount,
+        messageCount: source.messages.length,
+        sessionTokens: source.sessionTokens,
+        compactionCount: source.compactionCount,
+    };
+}
+export function formatLocalSessionCheckpointResult(result) {
+    return [
+        "",
+        "💾 本地会话检查点",
+        "-----------------------------------------",
+        `State dir : ${result.stateDir}`,
+        `Sessions  : ${result.sessionsDir}`,
+        `Source    : ${result.sourceName} | ${result.sourceSessionId}`,
+        `Checkpoint: ${result.checkpointName}`,
+        `Path      : ${result.checkpointPath}`,
+        `Updated   : ${formatTime(result.updatedAt)}`,
+        `Turns     : ${result.turnCount}`,
+        `Messages  : ${result.messageCount}`,
+        `Tokens    : ${result.sessionTokens.toLocaleString()}`,
+        `Compacts  : ${result.compactionCount}`,
+        "-----------------------------------------",
+        "说明      : 只复制本地会话快照；不输出消息正文、不调用模型、不联网。",
+        "",
+    ];
+}
+function copySnapshot(source, name, updatedAt) {
+    return {
+        name,
+        sessionId: source.sessionId,
+        workspaceDir: source.workspaceDir,
+        createdAt: source.createdAt,
+        updatedAt,
+        messages: source.messages.map((message) => ({ ...message })),
+        turnCount: source.turnCount,
+        sessionTokens: source.sessionTokens,
+        compactionCount: source.compactionCount,
+    };
+}
+function defaultCheckpointName(now) {
+    return `checkpoint-${now.toISOString().replace(/[:.]/g, "-")}`;
+}
+function formatTime(value) {
+    const ts = Date.parse(value);
+    return Number.isNaN(ts) ? value : new Date(ts).toLocaleString();
+}

package/dist/session-export-index.d.ts

@@ -0,0 +1,23 @@
+import type { SlashCommandContext } from "./commands/runtime.js";
+export interface SessionExportIndexEntry {
+    name: string;
+    path: string;
+    sizeBytes: number;
+    modifiedAt: string;
+    modifiedAtMs: number;
+}
+export interface SessionExportIndexReport {
+    exportsDir: string;
+    entries: SessionExportIndexEntry[];
+    total: number;
+    requestedCount: number;
+    truncated: boolean;
+}
+export interface SessionExportIndexOptions {
+    count?: number;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}
+export declare function parseSessionExportCount(value?: string | number): number;
+export declare function listSessionExportFiles(context: SlashCommandContext, options?: SessionExportIndexOptions): Promise<SessionExportIndexReport>;
+export declare function formatSessionExportIndex(report: SessionExportIndexReport): string[];
+//# sourceMappingURL=session-export-index.d.ts.map

package/dist/session-export-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-export-index.d.ts","sourceRoot":"","sources":["../src/session-export-index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAMjE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC9D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAKvE;AAkBD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,mBAAmB,EAC5B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,wBAAwB,CAAC,CAsCnC;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,MAAM,EAAE,CAiCnF"}