@goodandready/dsh-time-machine 0.1.3 → 0.1.5

package/lib/client.js

@@ -53,6 +53,8 @@ window.__ModuleLoader__.load({
       empty: 'No checkpoints yet.',
       diff: 'Diff',
       rollback: 'Rollback',
+      delete: 'Delete',
+      confirmDelete: 'Delete this checkpoint?',
       confirmRollback: 'Rollback to this checkpoint? This will reset the workspace.',
       close: 'Close',
       save: 'Save',
@@ -73,6 +75,8 @@ window.__ModuleLoader__.load({
       empty: 'Чекпоинтов пока нет.',
       diff: 'Diff',
       rollback: 'Откатить',
+      delete: 'Удалить',
+      confirmDelete: 'Удалить этот чекпоинт?',
       confirmRollback: 'Откатиться к этому чекпоинту? Рабочая копия будет сброшена.',
       close: 'Закрыть',
       save: 'Сохранить',
@@ -104,7 +108,24 @@ window.__ModuleLoader__.load({
       return lang;
     }
 
-    function Timeline({ t }) {
+    function sessionIdOf(ctx) {
+      try {
+        if (!ctx) return '';
+        if (ctx.scope) {
+          if (ctx.scope.session) return String(ctx.scope.session.id || ctx.scope.session.header?.id || '');
+          if (typeof ctx.scope.id === 'string') return ctx.scope.id;
+        }
+        if (ctx.session) return String(ctx.session.id || ctx.session.header?.id || '');
+        if (ctx.get && typeof ctx.get === 'function') {
+          const s = ctx.get('session');
+          if (s) return String(s.id || s.header?.id || '');
+        }
+      } catch {}
+      return '';
+    }
+
+    function Timeline({ t, ctx }) {
+      const sid = sessionIdOf(ctx);
       const [snapshots, setSnapshots] = React.useState([]);
       const [loading, setLoading] = React.useState(false);
       const [label, setLabel] = React.useState('');
@@ -114,17 +135,18 @@ window.__ModuleLoader__.load({
 
       const fetchList = React.useCallback(() => {
         setLoading(true); setErr('');
-        fetch('/dsh-time-machine/snapshots').then(r => r.json()).then(j => {
+        const q = sid ? '?sessionId=' + encodeURIComponent(sid) : '';
+        fetch('/dsh-time-machine/snapshots' + q).then(r => r.json()).then(j => {
           if (j.success) setSnapshots(j.snapshots || []);
           else setErr(j.error || 'load failed');
         }).catch(e => setErr(String(e.message || e))).finally(() => setLoading(false));
-      }, []);
+      }, [sid]);
 
       React.useEffect(() => { fetchList(); }, [fetchList]);
 
       const onCreate = () => {
         setBusy(true); setErr('');
-        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label }) })
+        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label, sessionId: sid }) })
           .then(r => r.json()).then(j => {
             if (!j.success) throw new Error(j.error || 'create failed');
             setLabel(''); fetchList();
@@ -146,6 +168,15 @@ window.__ModuleLoader__.load({
             fetchList();
           }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
       };
+      const onDelete = (id) => {
+        if (!window.confirm(t.confirmDelete)) return;
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/delete', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id, confirm: true }) })
+          .then(r => r.json()).then(j => {
+            if (!j.success) throw new Error(j.error || 'delete failed');
+            fetchList();
+          }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
+      };
 
       return React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: 12 } },
         React.createElement('div', { style: { display: 'flex', gap: 8 } },
@@ -162,7 +193,8 @@ window.__ModuleLoader__.load({
               React.createElement('span', { className: 'tm-row-meta' }, new Date(s.createdAt).toLocaleString() + (s.commit ? ' · ' + s.commit.slice(0,7) : ''))
             ),
             React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onDiff(s.id) }, t.diff),
-            React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onRollback(s.id) }, t.rollback)
+            React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onRollback(s.id) }, t.rollback),
+            React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onDelete(s.id) }, t.delete)
           ))
         ),
         diffText !== null ? React.createElement('div', { className: 'tm-modal', onClick: () => setDiffText(null) },
@@ -179,6 +211,7 @@ window.__ModuleLoader__.load({
 
     function PluginCard(props) {
       const ctx = props.ctx;
+      const sid = sessionIdOf(ctx);
       const [expanded, setExpanded] = React.useState(false);
       const lang = useLocale(ctx);
       const t = lang === 'ru' ? ru : en;
@@ -225,17 +258,18 @@ window.__ModuleLoader__.load({
 
       const fetchList = React.useCallback(() => {
         setLoading(true); setErr('');
-        fetch('/dsh-time-machine/snapshots').then(r => r.json()).then(j => {
+        const q = sid ? '?sessionId=' + encodeURIComponent(sid) : '';
+        fetch('/dsh-time-machine/snapshots' + q).then(r => r.json()).then(j => {
           if (j.success) setSnapshots(j.snapshots || []);
           else setErr(j.error || 'load failed');
         }).catch(e => setErr(String(e.message || e))).finally(() => setLoading(false));
-      }, []);
+      }, [sid]);
 
       React.useEffect(() => { if (expanded) fetchList(); }, [expanded, fetchList]);
 
       const onCreate = () => {
         setBusy(true); setErr('');
-        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label }) })
+        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label, sessionId: sid }) })
           .then(r => r.json()).then(j => {
             if (!j.success) throw new Error(j.error || 'create failed');
             setLabel(''); fetchList();
@@ -257,6 +291,15 @@ window.__ModuleLoader__.load({
             fetchList();
           }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
       };
+      const onDelete = (id) => {
+        if (!window.confirm(t.confirmDelete)) return;
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/delete', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id, confirm: true }) })
+          .then(r => r.json()).then(j => {
+            if (!j.success) throw new Error(j.error || 'delete failed');
+            fetchList();
+          }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
+      };
       const onSave = async () => {
         if (!scope) return;
         setSaving(true); setErr('');
@@ -318,7 +361,8 @@ window.__ModuleLoader__.load({
                   React.createElement('span', { className: 'tm-row-meta' }, new Date(s.createdAt).toLocaleString() + (s.commit ? ' · ' + s.commit.slice(0,7) : ''))
                 ),
                 React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onDiff(s.id) }, t.diff),
-                React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onRollback(s.id) }, t.rollback)
+                React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onRollback(s.id) }, t.rollback),
+                React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: () => onDelete(s.id) }, t.delete)
               ))
             )
           ),
@@ -342,31 +386,10 @@ window.__ModuleLoader__.load({
       return React.createElement('div', { className: 'tm-tab' },
         React.createElement('div', { style: { fontSize: 13, fontWeight: 600, color: 'var(--dsw-alias-label-primary)' } }, t.tabTitle),
         React.createElement('div', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginBottom: 4 } }, t.sub),
-        React.createElement(Timeline, { t })
+        React.createElement(Timeline, { t, ctx })
       );
     }
 
-    function registerBetterSidebar(ctx) {
-      const svc = (ctx.get && (()=>{ try{return ctx.get('betterSidebar')}catch{return null}})()) || ctx.betterSidebar;
-      if (!svc || typeof svc.registerTab !== 'function') return;
-      try {
-        svc.registerTab({
-          id: 'time-machine',
-          title: () => {
-            const a = ctx.locale && ctx.locale.getSnapshot && ctx.locale.getSnapshot().active || 'en';
-            return a.startsWith('ru') ? 'Машина времени' : 'Time Machine';
-          },
-          order: 30,
-          single: true,
-          icon: (size) => React.createElement('svg', { width: size||16, height: size||16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round' },
-            React.createElement('circle', { cx:12, cy:12, r:10 }),
-            React.createElement('polyline', { points:'12 6 12 12 16 14' })
-          ),
-          component: (p) => React.createElement(TimeMachineTab, { ctx, ...p })
-        });
-      } catch (e) { console.warn('[dsh-time-machine] betterSidebar tab failed', e); }
-    }
-
     module.exports.inject = ['slots', 'locale'];
     module.exports.apply = function apply(ctx) {
       ensureStyles();

package/lib/index.js

@@ -12,6 +12,20 @@ export const Config = Schema.object({
 
 const NS = '@goodandready/dsh-time-machine';
 
+function sessionIdOf(execution, ctx) {
+  try {
+    if (execution && execution.sessionId) return String(execution.sessionId);
+    if (execution && execution.agent && execution.agent.session) {
+      return String(execution.agent.session.id || execution.agent.session.header?.id || '');
+    }
+    if (ctx && ctx.session) return String(ctx.session.id || ctx.session.header?.id || '');
+    if (ctx && ctx.get && typeof ctx.get === 'function') {
+      try { const s = ctx.get('session'); if (s) return String(s.id || s.header?.id || ''); } catch {}
+    }
+  } catch {}
+  return '';
+}
+
 export function apply(ctx, config) {
   let getConfig = () => config;
   let engine = new ShadowSnapshotEngine({ maxSnapshots: config?.maxSnapshots ?? 20 });
@@ -25,30 +39,86 @@ export function apply(ctx, config) {
     sctx.effect(() => () => { try { stop(); } catch {} }, 'dsh-time-machine: settings watch');
   });
 
-  // tools
+  // auto-snapshot on turn/start and approval/asked (session-scoped)
+  const autoSnap = async (label, sessId) => {
+    if (!getConfig().autoSnapshotEnabled) return;
+    try {
+      const sid = String(sessId || '').trim();
+      await engine.createSnapshot(label, { sessionId: sid });
+    } catch {}
+  };
+
+  // listen to DSH events if available
+  try {
+    if (ctx.events && typeof ctx.events.on === 'function') {
+      ctx.effect(() => {
+        const offs = [];
+        try {
+          offs.push(ctx.events.on('turn/start', (ev) => {
+            const sid = sessionIdOf(ev, ctx);
+            autoSnap(`auto:turn:${ev?.turnId || Date.now()}`, sid);
+          }));
+        } catch {}
+        try {
+          offs.push(ctx.events.on('approval/asked', (ev) => {
+            const sid = sessionIdOf(ev, ctx);
+            const tool = ev?.tool || ev?.name || 'approval';
+            autoSnap(`auto:approval:${tool}`, sid);
+          }));
+        } catch {}
+        try {
+          offs.push(ctx.events.on('turn/end', (ev) => {
+            if (!getConfig().autoSnapshotEnabled) return;
+            const outcome = String((ev && (ev.outcome || ev.result?.outcome || ev.result?.status)) || '');
+            const sid = sessionIdOf(ev, ctx);
+            if (!sid) return;
+            if (outcome === 'success' || outcome === 'ok' || outcome === 'done') {
+              engine.pruneSnapshots(sid, 3).catch(() => {});
+            }
+            // failure/blocked: keep all checkpoints for review
+          }));
+        } catch {}
+        return () => { for (const off of offs) try { typeof off === 'function' && off(); } catch {} };
+      }, 'dsh-time-machine: auto snapshot events');
+    }
+  } catch {}
+
+  // tools (session-aware)
   const registerTools = (tctx) => {
     tctx.tools.register({
       name: 'time_machine_checkpoint_create',
-      description: 'Create a workspace checkpoint (shadow git snapshot) before risky changes. Returns id and label.',
+      description: 'Create a workspace checkpoint (shadow git snapshot) before risky changes. Returns id and label. Auto-creates per session if autoSnapshotEnabled.',
       parameters: {
         type: 'object',
         properties: {
           label: { type: 'string', description: 'Human label for checkpoint' },
+          sessionId: { type: 'string', description: 'Session id to scope checkpoint (auto-detected if omitted)' },
         },
       },
-      execute: async ({ label } = {}) => {
-        const snap = await engine.createSnapshot(label);
+      execute: async (args = {}, execution) => {
+        const sid = String(args.sessionId || sessionIdOf(execution, tctx) || sessionIdOf(args, tctx) || '').trim();
+        const snap = await engine.createSnapshot(args.label, { sessionId: sid });
         return { success: true, snapshot: snap };
       },
     });
 
     tctx.tools.register({
       name: 'time_machine_checkpoint_list',
-      description: 'List recent workspace checkpoints newest first.',
-      parameters: { type: 'object', properties: {} },
-      execute: async () => {
-        const list = engine.listSnapshots();
-        return { success: true, snapshots: list };
+      description: 'List recent workspace checkpoints newest first. Filter by sessionId if given.',
+      parameters: {
+        type: 'object',
+        properties: {
+          sessionId: { type: 'string', description: 'Filter by session id' },
+        },
+      },
+      execute: async (args = {}, execution) => {
+        const sid = args.sessionId != null ? String(args.sessionId).trim() : (sessionIdOf(execution, tctx) ? String(sessionIdOf(execution, tctx)).trim() : undefined);
+        const list = sid !== undefined ? engine.listSnapshots(sid) : engine.listSnapshots();
+        // if sid undefined and we want all, return all; but if sessionId was auto-detected, filter
+        // For backward compat, if no sid provided and engine has sessionIds, return all
+        // If sid was auto-detected (execution has session), use it
+        const finalList = (args.sessionId == null && sid !== undefined && sid !== '') ? engine.listSnapshots(sid) : (args.sessionId != null ? engine.listSnapshots(String(args.sessionId)) : engine.listSnapshots());
+        return { success: true, snapshots: finalList, sessionId: sid || '' };
       },
     });
 
@@ -85,6 +155,40 @@ export function apply(ctx, config) {
         return { success: true, ...res };
       },
     });
+
+    tctx.tools.register({
+      name: 'time_machine_checkpoint_delete',
+      description: 'Delete a single checkpoint. Requires confirm:true.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Snapshot id to delete' },
+          confirm: { type: 'boolean', description: 'Must be true to confirm deletion' },
+        },
+        required: ['id', 'confirm'],
+      },
+      execute: async ({ id, confirm } = {}) => {
+        const res = await engine.deleteSnapshot(String(id ?? ''), { confirm });
+        return { success: true, ...res };
+      },
+    });
+
+    tctx.tools.register({
+      name: 'time_machine_checkpoint_prune',
+      description: 'Prune session checkpoints, keeping only the newest N (default 3).',
+      parameters: {
+        type: 'object',
+        properties: {
+          sessionId: { type: 'string', description: 'Session id to prune (default current session)' },
+          keep: { type: 'number', description: 'How many newest checkpoints to keep (default 3)' },
+        },
+      },
+      execute: async (args = {}, execution) => {
+        const sid = String(args.sessionId || sessionIdOf(execution, tctx) || '').trim();
+        const out = await engine.pruneSnapshots(sid, args.keep);
+        return { success: true, sessionId: sid, ...out };
+      },
+    });
   };
 
   try {
@@ -92,7 +196,7 @@ export function apply(ctx, config) {
     else ctx.inject(['tools'], (tctx) => registerTools(tctx));
   } catch {}
 
-  // web routes for UI
+  // web routes for UI (session-aware via ?sessionId=)
   ctx.effect(() => {
     const disposals = [];
     try {
@@ -100,8 +204,11 @@ export function apply(ctx, config) {
         kind: 'exact',
         path: '/dsh-time-machine/snapshots',
         handler: (req, res) => {
+          const url = new URL(req.url, 'http://localhost');
+          const sid = url.searchParams.get('sessionId');
+          const list = sid != null ? engine.listSnapshots(String(sid)) : engine.listSnapshots();
           res.setHeader('content-type', 'application/json');
-          res.end(JSON.stringify({ success: true, snapshots: engine.listSnapshots() }));
+          res.end(JSON.stringify({ success: true, snapshots: list }));
         },
       }));
       disposals.push(ctx.webServer.register({
@@ -131,7 +238,8 @@ export function apply(ctx, config) {
           req.on('end', async () => {
             try {
               const parsed = body ? JSON.parse(body) : {};
-              const snap = await engine.createSnapshot(parsed.label);
+              const sid = String(parsed.sessionId || new URL(req.url, 'http://localhost').searchParams.get('sessionId') || '').trim();
+              const snap = await engine.createSnapshot(parsed.label, { sessionId: sid });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, snapshot: snap }));
             } catch (e) {
@@ -142,6 +250,47 @@ export function apply(ctx, config) {
           });
         },
       }));
+      disposals.push(ctx.webServer.register({
+        kind: 'exact',
+        path: '/dsh-time-machine/delete',
+        handler: async (req, res) => {
+          let body = '';
+          req.on('data', (c) => body += c);
+          req.on('end', async () => {
+            try {
+              const parsed = body ? JSON.parse(body) : {};
+              const out = await engine.deleteSnapshot(String(parsed.id || ''), { confirm: parsed.confirm });
+              res.setHeader('content-type', 'application/json');
+              res.end(JSON.stringify({ success: true, ...out }));
+            } catch (e) {
+              res.statusCode = 400;
+              res.setHeader('content-type', 'application/json');
+              res.end(JSON.stringify({ success: false, error: String(e.message || e), code: e.code || '' }));
+            }
+          });
+        },
+      }));
+      disposals.push(ctx.webServer.register({
+        kind: 'exact',
+        path: '/dsh-time-machine/prune',
+        handler: async (req, res) => {
+          let body = '';
+          req.on('data', (c) => body += c);
+          req.on('end', async () => {
+            try {
+              const parsed = body ? JSON.parse(body) : {};
+              const sid = String(parsed.sessionId || new URL(req.url, 'http://localhost').searchParams.get('sessionId') || '');
+              const out = await engine.pruneSnapshots(sid, parsed.keep);
+              res.setHeader('content-type', 'application/json');
+              res.end(JSON.stringify({ success: true, sessionId: sid, ...out }));
+            } catch (e) {
+              res.statusCode = 400;
+              res.setHeader('content-type', 'application/json');
+              res.end(JSON.stringify({ success: false, error: String(e.message || e) }));
+            }
+          });
+        },
+      }));
       disposals.push(ctx.webServer.register({
         kind: 'exact',
         path: '/dsh-time-machine/rollback',
@@ -166,6 +315,5 @@ export function apply(ctx, config) {
     return () => { for (const d of disposals) try { typeof d === 'function' && d(); } catch {} };
   }, 'dsh-time-machine: web routes');
 
-  // expose engine for tests
   ctx.provide?.('timeMachineEngine', engine);
 }

package/lib/snapshot.js

@@ -16,19 +16,29 @@ async function defaultExec(cmd, args, opts = {}) {
   }
 }
 
-// ponytail: in-memory engine, git shadow refs if repo present; O(n) scan, global lock
+// ponytail: in-memory engine, git shadow refs if repo present; O(n) scan, per-session trim
 export class ShadowSnapshotEngine {
   constructor({ exec = defaultExec, maxSnapshots = 20, cwd } = {}) {
     this.exec = exec;
     this.maxSnapshots = maxSnapshots;
     this.cwd = cwd;
-    this.snapshots = []; // newest last, list returns newest first
+    this.snapshots = []; // {id, label, sessionId, createdAt, commit, ref}
+    this.seq = 0;
   }
 
   _now() { return Date.now(); }
 
-  _trim() {
-    while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+  _trimFor(sessionId) {
+    if (!sessionId) {
+      while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+      return;
+    }
+    const perSession = this.snapshots.filter(s => s.sessionId === sessionId);
+    while (perSession.length > this.maxSnapshots) {
+      const oldest = perSession.shift();
+      const idx = this.snapshots.indexOf(oldest);
+      if (idx !== -1) this.snapshots.splice(idx, 1);
+    }
   }
 
   async _isGitRepo() {
@@ -38,36 +48,38 @@ export class ShadowSnapshotEngine {
     } catch { return false; }
   }
 
-  async createSnapshot(label = '') {
+  async createSnapshot(label = '', { sessionId = '' } = {}) {
     const id = crypto.randomUUID().slice(0, 8);
     const createdAt = this._now();
     const safeLabel = String(label ?? '').trim() || `checkpoint-${id}`;
+    const sid = String(sessionId || '').trim();
     let commit = null;
     let ref = null;
     const inGit = await this._isGitRepo();
     if (inGit) {
       try {
-        // stage working tree without committing to main branch
         await this.exec('git', ['add', '-A'], this.cwd ? { cwd: this.cwd } : {});
         const { stdout: tree } = await this.exec('git', ['write-tree'], this.cwd ? { cwd: this.cwd } : {});
         const treeHash = String(tree).trim();
         const { stdout: commitHash } = await this.exec('git', ['commit-tree', treeHash, '-m', safeLabel], this.cwd ? { cwd: this.cwd } : {});
         commit = String(commitHash).trim();
-        ref = `refs/dsh-time-machine/${id}`;
+        ref = sid ? `refs/dsh-time-machine/${sid}/${id}` : `refs/dsh-time-machine/${id}`;
         await this.exec('git', ['update-ref', ref, commit], this.cwd ? { cwd: this.cwd } : {});
       } catch {
         commit = null;
         ref = null;
       }
     }
-    const snap = { id, label: safeLabel, createdAt, commit, ref };
+    const snap = { id, label: safeLabel, sessionId: sid, createdAt, commit, ref, seq: ++this.seq };
     this.snapshots.push(snap);
-    this._trim();
+    this._trimFor(sid);
     return snap;
   }
 
-  listSnapshots() {
-    return [...this.snapshots].sort((a, b) => b.createdAt - a.createdAt);
+  listSnapshots(sessionId) {
+    const sid = sessionId != null ? String(sessionId).trim() : undefined;
+    const list = sid !== undefined ? this.snapshots.filter(s => String(s.sessionId) === sid) : [...this.snapshots];
+    return [...list].sort((a, b) => b.createdAt - a.createdAt || b.seq - a.seq);
   }
 
   getSnapshot(id) {
@@ -91,7 +103,6 @@ export class ShadowSnapshotEngine {
       try {
         await this.exec('git', ['reset', '--hard', snap.commit], this.cwd ? { cwd: this.cwd } : {});
       } catch (e) {
-        // fallback to checkout of commit tree
         await this.exec('git', ['read-tree', snap.commit], this.cwd ? { cwd: this.cwd } : {}).catch(()=>{});
         await this.exec('git', ['checkout-index', '-a', '-f'], this.cwd ? { cwd: this.cwd } : {}).catch(()=>{});
       }
@@ -99,6 +110,40 @@ export class ShadowSnapshotEngine {
     return { rolledBack: true, snapshot: snap };
   }
 
+  async deleteSnapshot(id, { confirm } = {}) {
+    if (confirm !== true) {
+      const err = new Error('confirm:true required to delete');
+      err.code = 'CONFIRM_REQUIRED';
+      throw err;
+    }
+    const snap = this.getSnapshot(id);
+    if (!snap) {
+      const err = new Error(`snapshot ${id} not found`);
+      err.code = 'NOT_FOUND';
+      throw err;
+    }
+    if (snap.ref) {
+      try {
+        await this.exec('git', ['update-ref', '-d', snap.ref], this.cwd ? { cwd: this.cwd } : {});
+      } catch {}
+    }
+    const idx = this.snapshots.indexOf(snap);
+    if (idx !== -1) this.snapshots.splice(idx, 1);
+    return { deleted: true, snapshot: snap };
+  }
+
+  async pruneSnapshots(sessionId, keep = 3) {
+    const sid = sessionId != null ? String(sessionId).trim() : undefined;
+    const list = this.listSnapshots(sid); // newest first
+    const minKeep = Math.max(0, Number(keep) || 3);
+    const toRemove = list.slice(minKeep);
+    const removed = [];
+    for (const snap of toRemove) {
+      try { await this.deleteSnapshot(snap.id, { confirm: true }); removed.push(snap.id); } catch {}
+    }
+    return { removed, kept: list.length - removed.length };
+  }
+
   async diff(fromId, toId) {
     const from = this.getSnapshot(fromId);
     if (!from) {
@@ -107,7 +152,6 @@ export class ShadowSnapshotEngine {
       throw err;
     }
     let to = toId ? this.getSnapshot(toId) : null;
-    // if to not given, diff against current HEAD/working tree
     const inGit = await this._isGitRepo();
     if (inGit && from.commit) {
       try {
@@ -116,7 +160,6 @@ export class ShadowSnapshotEngine {
         const diffStat = String(stdout ?? '').trim();
         if (diffStat) return { from: fromId, to: toId || 'HEAD', diff: diffStat };
       } catch {}
-      // fallback to name-only
       try {
         const range = to?.commit ? `${from.commit}..${to.commit}` : from.commit;
         const { stdout } = await this.exec('git', ['diff', '--name-only', range], this.cwd ? { cwd: this.cwd } : {});
@@ -129,6 +172,11 @@ export class ShadowSnapshotEngine {
 
   setMax(n) {
     this.maxSnapshots = Math.max(1, Number(n) || 20);
-    this._trim();
+    // trim all sessions
+    const sessions = [...new Set(this.snapshots.map(s => s.sessionId))];
+    for (const sid of sessions) this._trimFor(sid);
+    if (sessions.length === 0) {
+      while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-time-machine",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "DSH plugin for smart checkpoints, workspace safety guards, and instant rollback",
   "type": "module",
   "main": "lib/index.js",