@a5c-ai/genty-runtime 5.1.1-staging.00ceebd28cf2

package/dist/session/persistence.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * GAP-STATE-003: Session State Persistence.
+ *
+ * Stores rich persistent state: findings, file modifications, breakpoint patterns,
+ * and user preferences. Follows the same atomic temp-file + rename pattern
+ * as context.ts and history.ts.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_PERSISTENT_SCHEMA_VERSION = void 0;
+exports.getSessionPersistentStatePath = getSessionPersistentStatePath;
+exports.getSessionPersistentState = getSessionPersistentState;
+exports.addFinding = addFinding;
+exports.setPreference = setPreference;
+exports.recordFileModification = recordFileModification;
+exports.recordBreakpointInteraction = recordBreakpointInteraction;
+exports.buildResumeContext = buildResumeContext;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+exports.SESSION_PERSISTENT_SCHEMA_VERSION = "2026.01.session-persistent-v1";
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function emptyPersistentState() {
+    return {
+        schemaVersion: exports.SESSION_PERSISTENT_SCHEMA_VERSION,
+        findings: [],
+        preferences: {},
+        fileModifications: [],
+        breakpointPatterns: [],
+    };
+}
+function nowTimestamp() {
+    return new Date().toISOString();
+}
+async function readRaw(filePath) {
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyPersistentState();
+        return emptyPersistentState();
+    }
+    try {
+        const data = JSON.parse(raw);
+        return {
+            schemaVersion: typeof data.schemaVersion === "string" ? data.schemaVersion : exports.SESSION_PERSISTENT_SCHEMA_VERSION,
+            findings: Array.isArray(data.findings) ? data.findings : [],
+            preferences: data.preferences && typeof data.preferences === "object" ? data.preferences : {},
+            fileModifications: Array.isArray(data.fileModifications) ? data.fileModifications : [],
+            breakpointPatterns: Array.isArray(data.breakpointPatterns) ? data.breakpointPatterns : [],
+        };
+    }
+    catch {
+        return emptyPersistentState();
+    }
+}
+async function writeRaw(filePath, data) {
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(tempPath, JSON.stringify(data, null, 2), "utf8");
+    await node_fs_1.promises.rename(tempPath, filePath);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getSessionPersistentStatePath(stateDir, sessionId) {
+    return path.join(stateDir, `${sessionId}.persistent.json`);
+}
+async function getSessionPersistentState(stateDir, sessionId) {
+    return readRaw(getSessionPersistentStatePath(stateDir, sessionId));
+}
+async function addFinding(stateDir, sessionId, finding) {
+    const filePath = getSessionPersistentStatePath(stateDir, sessionId);
+    const data = await readRaw(filePath);
+    data.findings.push({ ...finding, timestamp: nowTimestamp() });
+    await writeRaw(filePath, data);
+}
+async function setPreference(stateDir, sessionId, key, value) {
+    const filePath = getSessionPersistentStatePath(stateDir, sessionId);
+    const data = await readRaw(filePath);
+    data.preferences[key] = value;
+    await writeRaw(filePath, data);
+}
+async function recordFileModification(stateDir, sessionId, mod) {
+    const filePath = getSessionPersistentStatePath(stateDir, sessionId);
+    const data = await readRaw(filePath);
+    data.fileModifications.push({ ...mod, timestamp: nowTimestamp() });
+    await writeRaw(filePath, data);
+}
+async function recordBreakpointInteraction(stateDir, sessionId, breakpointId, action) {
+    const filePath = getSessionPersistentStatePath(stateDir, sessionId);
+    const data = await readRaw(filePath);
+    const now = nowTimestamp();
+    const existing = data.breakpointPatterns.find((p) => p.breakpointId === breakpointId);
+    if (existing) {
+        if (action === "approved")
+            existing.approvedCount++;
+        else
+            existing.rejectedCount++;
+        existing.lastAction = action;
+        existing.lastInteractionAt = now;
+    }
+    else {
+        data.breakpointPatterns.push({
+            breakpointId,
+            approvedCount: action === "approved" ? 1 : 0,
+            rejectedCount: action === "rejected" ? 1 : 0,
+            lastAction: action,
+            lastInteractionAt: now,
+        });
+    }
+    await writeRaw(filePath, data);
+}
+/**
+ * Render persistent state into a markdown section for resume prompt injection.
+ * Returns empty string when no meaningful data exists.
+ */
+async function buildResumeContext(stateDir, sessionId) {
+    const state = await getSessionPersistentState(stateDir, sessionId);
+    const sections = [];
+    if (state.findings.length > 0) {
+        const lines = state.findings.map((f) => `- [${f.category}] ${f.content}`);
+        sections.push(`### Findings\n${lines.join("\n")}`);
+    }
+    const prefKeys = Object.keys(state.preferences);
+    if (prefKeys.length > 0) {
+        const lines = prefKeys.map((k) => `- **${k}**: ${state.preferences[k]}`);
+        sections.push(`### Preferences\n${lines.join("\n")}`);
+    }
+    if (state.fileModifications.length > 0) {
+        const recent = state.fileModifications.slice(-10);
+        const lines = recent.map((m) => `- ${m.action} \`${m.filePath}\``);
+        sections.push(`### Recent File Changes\n${lines.join("\n")}`);
+    }
+    if (state.breakpointPatterns.length > 0) {
+        const lines = state.breakpointPatterns.map((p) => `- \`${p.breakpointId}\`: ${p.approvedCount} approved, ${p.rejectedCount} rejected (last: ${p.lastAction})`);
+        sections.push(`### Breakpoint Patterns\n${lines.join("\n")}`);
+    }
+    if (sections.length === 0)
+        return "";
+    return `## Session Context\n\n${sections.join("\n\n")}`;
+}

package/dist/session/rewind.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GAP-STATE-006: Session Rewind and History.
+ *
+ * Provides a rewind point manager that works with the SessionTree
+ * to create, list, and navigate to rewind points in the conversation.
+ */
+import type { SessionTree } from './tree.js';
+export interface RewindPoint {
+    /** Unique rewind point identifier. */
+    id: string;
+    /** The tree node at this rewind point. */
+    nodeId: string;
+    /** The branch ID at this rewind point. */
+    branchId: string;
+    /** ISO timestamp when the rewind point was created. */
+    timestamp: string;
+    /** Optional label for the rewind point. */
+    label?: string;
+}
+export declare class SessionRewindManager {
+    private rewindPoints;
+    /**
+     * Create a new rewind point at the current position in the tree.
+     */
+    createRewindPoint(tree: SessionTree, label?: string): RewindPoint;
+    /**
+     * List all rewind points, sorted by creation time (most recent first).
+     */
+    listRewindPoints(): RewindPoint[];
+    /**
+     * Rewind to a specific point by navigating the tree to that node
+     * and forking a new branch from it.
+     * Returns the new branch ID.
+     */
+    rewindTo(tree: SessionTree, pointId: string): string;
+    /**
+     * Check whether there are any rewind points available.
+     */
+    canRewind(): boolean;
+    /**
+     * Get a rewind point by ID.
+     */
+    getRewindPoint(pointId: string): RewindPoint | undefined;
+}
+//# sourceMappingURL=rewind.d.ts.map

package/dist/session/rewind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.d.ts","sourceRoot":"","sources":["../../src/session/rewind.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAO7C,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,YAAY,CAAuC;IAE3D;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW;IAajE;;OAEG;IACH,gBAAgB,IAAI,WAAW,EAAE;IAMjC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAgBpD;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;CAGzD"}

package/dist/session/rewind.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * GAP-STATE-006: Session Rewind and History.
+ *
+ * Provides a rewind point manager that works with the SessionTree
+ * to create, list, and navigate to rewind points in the conversation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRewindManager = void 0;
+const node_crypto_1 = require("node:crypto");
+const tree_js_1 = require("./tree.js");
+// ---------------------------------------------------------------------------
+// SessionRewindManager
+// ---------------------------------------------------------------------------
+class SessionRewindManager {
+    rewindPoints = new Map();
+    /**
+     * Create a new rewind point at the current position in the tree.
+     */
+    createRewindPoint(tree, label) {
+        const point = {
+            id: (0, node_crypto_1.randomUUID)(),
+            nodeId: tree.activeNodeId,
+            branchId: tree.activeBranchId,
+            timestamp: new Date().toISOString(),
+            label,
+        };
+        this.rewindPoints.set(point.id, point);
+        return point;
+    }
+    /**
+     * List all rewind points, sorted by creation time (most recent first).
+     */
+    listRewindPoints() {
+        return [...this.rewindPoints.values()].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    }
+    /**
+     * Rewind to a specific point by navigating the tree to that node
+     * and forking a new branch from it.
+     * Returns the new branch ID.
+     */
+    rewindTo(tree, pointId) {
+        const point = this.rewindPoints.get(pointId);
+        if (!point) {
+            throw new Error(`Rewind point "${pointId}" not found`);
+        }
+        // Verify the node still exists
+        if (!tree.nodes.has(point.nodeId)) {
+            throw new Error(`Node "${point.nodeId}" no longer exists in the tree`);
+        }
+        // Fork from that node to create a new branch
+        const newBranchId = (0, tree_js_1.forkFromNode)(tree, point.nodeId);
+        return newBranchId;
+    }
+    /**
+     * Check whether there are any rewind points available.
+     */
+    canRewind() {
+        return this.rewindPoints.size > 0;
+    }
+    /**
+     * Get a rewind point by ID.
+     */
+    getRewindPoint(pointId) {
+        return this.rewindPoints.get(pointId);
+    }
+}
+exports.SessionRewindManager = SessionRewindManager;

package/dist/session/rewind.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rewind.test.d.ts.map

package/dist/session/rewind.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewind.test.d.ts","sourceRoot":"","sources":["../../src/session/rewind.test.ts"],"names":[],"mappings":""}

package/dist/session/rewind.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const rewind_js_1 = require("./rewind.js");
+const tree_js_1 = require("./tree.js");
+(0, vitest_1.describe)('session/rewind', () => {
+    let tree;
+    let manager;
+    (0, vitest_1.beforeEach)(() => {
+        tree = (0, tree_js_1.createSessionTree)();
+        manager = new rewind_js_1.SessionRewindManager();
+    });
+    // -------------------------------------------------------------------------
+    // createRewindPoint
+    // -------------------------------------------------------------------------
+    (0, vitest_1.describe)('createRewindPoint', () => {
+        (0, vitest_1.it)('creates a rewind point at current position', () => {
+            (0, tree_js_1.addMessage)(tree, 'user', 'Hello');
+            const point = manager.createRewindPoint(tree, 'before-experiment');
+            (0, vitest_1.expect)(point.nodeId).toBe(tree.activeNodeId);
+            (0, vitest_1.expect)(point.branchId).toBe(tree.activeBranchId);
+            (0, vitest_1.expect)(point.label).toBe('before-experiment');
+            (0, vitest_1.expect)(point.timestamp).toBeTruthy();
+            (0, vitest_1.expect)(point.id).toBeTruthy();
+        });
+        (0, vitest_1.it)('creates a point without label', () => {
+            const point = manager.createRewindPoint(tree);
+            (0, vitest_1.expect)(point.label).toBeUndefined();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // listRewindPoints
+    // -------------------------------------------------------------------------
+    (0, vitest_1.describe)('listRewindPoints', () => {
+        (0, vitest_1.it)('returns empty array initially', () => {
+            (0, vitest_1.expect)(manager.listRewindPoints()).toHaveLength(0);
+        });
+        (0, vitest_1.it)('returns points sorted by most recent first', () => {
+            (0, tree_js_1.addMessage)(tree, 'user', 'Step 1');
+            const p1 = manager.createRewindPoint(tree, 'first');
+            // Manually adjust timestamp so ordering is deterministic
+            p1.timestamp = '2026-01-01T00:00:00.000Z';
+            (0, tree_js_1.addMessage)(tree, 'assistant', 'Step 2');
+            const p2 = manager.createRewindPoint(tree, 'second');
+            p2.timestamp = '2026-01-01T00:01:00.000Z';
+            const points = manager.listRewindPoints();
+            (0, vitest_1.expect)(points).toHaveLength(2);
+            (0, vitest_1.expect)(points[0].label).toBe('second');
+            (0, vitest_1.expect)(points[1].label).toBe('first');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // canRewind
+    // -------------------------------------------------------------------------
+    (0, vitest_1.describe)('canRewind', () => {
+        (0, vitest_1.it)('returns false when no rewind points exist', () => {
+            (0, vitest_1.expect)(manager.canRewind()).toBe(false);
+        });
+        (0, vitest_1.it)('returns true when rewind points exist', () => {
+            manager.createRewindPoint(tree);
+            (0, vitest_1.expect)(manager.canRewind()).toBe(true);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // rewindTo
+    // -------------------------------------------------------------------------
+    (0, vitest_1.describe)('rewindTo', () => {
+        (0, vitest_1.it)('forks a new branch from the rewind point', () => {
+            (0, tree_js_1.addMessage)(tree, 'user', 'Question 1');
+            const point = manager.createRewindPoint(tree, 'checkpoint');
+            (0, tree_js_1.addMessage)(tree, 'assistant', 'Answer 1');
+            (0, tree_js_1.addMessage)(tree, 'user', 'Question 2');
+            const newBranch = manager.rewindTo(tree, point.id);
+            (0, vitest_1.expect)(newBranch).toMatch(/^branch-/);
+            (0, vitest_1.expect)(tree.activeNodeId).toBe(point.nodeId);
+            (0, vitest_1.expect)(tree.activeBranchId).toBe(newBranch);
+        });
+        (0, vitest_1.it)('throws for unknown rewind point', () => {
+            (0, vitest_1.expect)(() => manager.rewindTo(tree, 'nonexistent')).toThrow('not found');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // getRewindPoint
+    // -------------------------------------------------------------------------
+    (0, vitest_1.describe)('getRewindPoint', () => {
+        (0, vitest_1.it)('returns the point by ID', () => {
+            const created = manager.createRewindPoint(tree, 'my-point');
+            const fetched = manager.getRewindPoint(created.id);
+            (0, vitest_1.expect)(fetched).toBeDefined();
+            (0, vitest_1.expect)(fetched.label).toBe('my-point');
+        });
+        (0, vitest_1.it)('returns undefined for unknown ID', () => {
+            (0, vitest_1.expect)(manager.getRewindPoint('nope')).toBeUndefined();
+        });
+    });
+});

package/dist/session/tree.d.ts

@@ -0,0 +1,29 @@
+export interface TreeNode {
+    id: string;
+    parentId: string | null;
+    branchId: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+    bookmark?: string;
+}
+export interface SessionTree {
+    rootId: string;
+    activeBranchId: string;
+    activeNodeId: string;
+    nodes: Map<string, TreeNode>;
+    branches: Map<string, string[]>;
+}
+export declare function createSessionTree(): SessionTree;
+export declare function addMessage(tree: SessionTree, role: TreeNode['role'], content: string, metadata?: Record<string, unknown>): TreeNode;
+export declare function forkFromNode(tree: SessionTree, nodeId: string): string;
+export declare function navigateToNode(tree: SessionTree, nodeId: string): void;
+export declare function getPathToNode(tree: SessionTree, nodeId: string): string[];
+export declare function getMessages(tree: SessionTree, branchId?: string): TreeNode[];
+export declare function getBranches(tree: SessionTree): string[];
+export declare function bookmarkNode(tree: SessionTree, nodeId: string, label: string): void;
+export declare function getBookmarks(tree: SessionTree): TreeNode[];
+export declare function serializeTree(tree: SessionTree): string;
+export declare function deserializeTree(json: string): SessionTree;
+//# sourceMappingURL=tree.d.ts.map

package/dist/session/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/session/tree.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACjC;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAmB/C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAkBnI;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAatE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKtE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAUzE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAI5E;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAInF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,QAAQ,EAAE,CAE1D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAQvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CASzD"}

package/dist/session/tree.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionTree = createSessionTree;
+exports.addMessage = addMessage;
+exports.forkFromNode = forkFromNode;
+exports.navigateToNode = navigateToNode;
+exports.getPathToNode = getPathToNode;
+exports.getMessages = getMessages;
+exports.getBranches = getBranches;
+exports.bookmarkNode = bookmarkNode;
+exports.getBookmarks = getBookmarks;
+exports.serializeTree = serializeTree;
+exports.deserializeTree = deserializeTree;
+const node_crypto_1 = require("node:crypto");
+function createSessionTree() {
+    const rootId = (0, node_crypto_1.randomUUID)();
+    const branchId = 'main';
+    const root = {
+        id: rootId,
+        parentId: null,
+        branchId,
+        role: 'system',
+        content: 'Session started',
+        timestamp: new Date().toISOString(),
+    };
+    const nodes = new Map();
+    nodes.set(rootId, root);
+    const branches = new Map();
+    branches.set(branchId, [rootId]);
+    return { rootId, activeBranchId: branchId, activeNodeId: rootId, nodes, branches };
+}
+function addMessage(tree, role, content, metadata) {
+    const node = {
+        id: (0, node_crypto_1.randomUUID)(),
+        parentId: tree.activeNodeId,
+        branchId: tree.activeBranchId,
+        role,
+        content,
+        metadata,
+        timestamp: new Date().toISOString(),
+    };
+    tree.nodes.set(node.id, node);
+    const branch = tree.branches.get(tree.activeBranchId) ?? [];
+    branch.push(node.id);
+    tree.branches.set(tree.activeBranchId, branch);
+    tree.activeNodeId = node.id;
+    return node;
+}
+function forkFromNode(tree, nodeId) {
+    const node = tree.nodes.get(nodeId);
+    if (!node)
+        throw new Error(`Node ${nodeId} not found`);
+    const newBranchId = `branch-${(0, node_crypto_1.randomUUID)().slice(0, 8)}`;
+    // Copy path from root to this node
+    const path = getPathToNode(tree, nodeId);
+    tree.branches.set(newBranchId, [...path]);
+    tree.activeBranchId = newBranchId;
+    tree.activeNodeId = nodeId;
+    return newBranchId;
+}
+function navigateToNode(tree, nodeId) {
+    const node = tree.nodes.get(nodeId);
+    if (!node)
+        throw new Error(`Node ${nodeId} not found`);
+    tree.activeNodeId = nodeId;
+    tree.activeBranchId = node.branchId;
+}
+function getPathToNode(tree, nodeId) {
+    const path = [];
+    let current = nodeId;
+    while (current) {
+        path.unshift(current);
+        const node = tree.nodes.get(current);
+        if (!node?.parentId)
+            break;
+        current = node.parentId;
+    }
+    return path;
+}
+function getMessages(tree, branchId) {
+    const bid = branchId ?? tree.activeBranchId;
+    const nodeIds = tree.branches.get(bid) ?? [];
+    return nodeIds.map(id => tree.nodes.get(id)).filter(Boolean);
+}
+function getBranches(tree) {
+    return [...tree.branches.keys()];
+}
+function bookmarkNode(tree, nodeId, label) {
+    const node = tree.nodes.get(nodeId);
+    if (!node)
+        throw new Error(`Node ${nodeId} not found`);
+    node.bookmark = label;
+}
+function getBookmarks(tree) {
+    return [...tree.nodes.values()].filter(n => n.bookmark);
+}
+function serializeTree(tree) {
+    return JSON.stringify({
+        rootId: tree.rootId,
+        activeBranchId: tree.activeBranchId,
+        activeNodeId: tree.activeNodeId,
+        nodes: Object.fromEntries(tree.nodes),
+        branches: Object.fromEntries(tree.branches),
+    });
+}
+function deserializeTree(json) {
+    const data = JSON.parse(json);
+    return {
+        rootId: data.rootId,
+        activeBranchId: data.activeBranchId,
+        activeNodeId: data.activeNodeId,
+        nodes: new Map(Object.entries(data.nodes)),
+        branches: new Map(Object.entries(data.branches)),
+    };
+}

package/dist/session/tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tree.test.d.ts.map

package/dist/session/tree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.test.d.ts","sourceRoot":"","sources":["../../src/session/tree.test.ts"],"names":[],"mappings":""}

package/dist/session/tree.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tree_js_1 = require("./tree.js");
+(0, vitest_1.describe)('session/tree', () => {
+    (0, vitest_1.it)('creates a tree with a root node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, vitest_1.expect)(tree.rootId).toBeTruthy();
+        (0, vitest_1.expect)(tree.activeBranchId).toBe('main');
+        (0, vitest_1.expect)(tree.nodes.size).toBe(1);
+    });
+    (0, vitest_1.it)('adds messages to the active branch', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, tree_js_1.addMessage)(tree, 'user', 'Hello');
+        (0, tree_js_1.addMessage)(tree, 'assistant', 'Hi there');
+        const messages = (0, tree_js_1.getMessages)(tree);
+        (0, vitest_1.expect)(messages).toHaveLength(3); // root + 2
+        (0, vitest_1.expect)(messages[1].role).toBe('user');
+        (0, vitest_1.expect)(messages[2].content).toBe('Hi there');
+    });
+    (0, vitest_1.it)('forks from a node creating a new branch', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        const m1 = (0, tree_js_1.addMessage)(tree, 'user', 'First question');
+        (0, tree_js_1.addMessage)(tree, 'assistant', 'First answer');
+        const newBranch = (0, tree_js_1.forkFromNode)(tree, m1.id);
+        (0, vitest_1.expect)(newBranch).toMatch(/^branch-/);
+        (0, vitest_1.expect)(tree.activeBranchId).toBe(newBranch);
+        (0, vitest_1.expect)((0, tree_js_1.getBranches)(tree)).toHaveLength(2);
+        (0, tree_js_1.addMessage)(tree, 'user', 'Different question');
+        const branchMessages = (0, tree_js_1.getMessages)(tree, newBranch);
+        (0, vitest_1.expect)(branchMessages[branchMessages.length - 1].content).toBe('Different question');
+    });
+    (0, vitest_1.it)('navigates to a specific node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        const m1 = (0, tree_js_1.addMessage)(tree, 'user', 'Q1');
+        (0, tree_js_1.addMessage)(tree, 'assistant', 'A1');
+        (0, tree_js_1.navigateToNode)(tree, m1.id);
+        (0, vitest_1.expect)(tree.activeNodeId).toBe(m1.id);
+    });
+    (0, vitest_1.it)('gets path from root to a node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, tree_js_1.addMessage)(tree, 'user', 'Step 1');
+        const m2 = (0, tree_js_1.addMessage)(tree, 'assistant', 'Step 2');
+        const path = (0, tree_js_1.getPathToNode)(tree, m2.id);
+        (0, vitest_1.expect)(path).toHaveLength(3); // root → user → assistant
+        (0, vitest_1.expect)(path[0]).toBe(tree.rootId);
+        (0, vitest_1.expect)(path[path.length - 1]).toBe(m2.id);
+    });
+    (0, vitest_1.it)('bookmarks a node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        const m1 = (0, tree_js_1.addMessage)(tree, 'user', 'Important question');
+        (0, tree_js_1.bookmarkNode)(tree, m1.id, 'key-decision');
+        const bookmarks = (0, tree_js_1.getBookmarks)(tree);
+        (0, vitest_1.expect)(bookmarks).toHaveLength(1);
+        (0, vitest_1.expect)(bookmarks[0].bookmark).toBe('key-decision');
+    });
+    (0, vitest_1.it)('serializes and deserializes a tree', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, tree_js_1.addMessage)(tree, 'user', 'Hello');
+        (0, tree_js_1.addMessage)(tree, 'assistant', 'World');
+        const json = (0, tree_js_1.serializeTree)(tree);
+        const restored = (0, tree_js_1.deserializeTree)(json);
+        (0, vitest_1.expect)(restored.nodes.size).toBe(tree.nodes.size);
+        (0, vitest_1.expect)(restored.activeBranchId).toBe(tree.activeBranchId);
+        (0, vitest_1.expect)((0, tree_js_1.getMessages)(restored)).toHaveLength(3);
+    });
+    (0, vitest_1.it)('throws on navigate to nonexistent node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, vitest_1.expect)(() => (0, tree_js_1.navigateToNode)(tree, 'nonexistent')).toThrow('not found');
+    });
+    (0, vitest_1.it)('throws on fork from nonexistent node', () => {
+        const tree = (0, tree_js_1.createSessionTree)();
+        (0, vitest_1.expect)(() => (0, tree_js_1.forkFromNode)(tree, 'nonexistent')).toThrow('not found');
+    });
+});