@goodandready/dsh-time-machine 0.1.8 → 0.1.10

package/README.md

@@ -119,6 +119,21 @@ dsh-time-machine:
 
 ## 📋 Release Notes
 
+### v0.1.10 — Stability, Dynamic CWD, Unified Diff & Architecture Polish
+* **Added in v0.1.10**: Dynamic / session-aware `cwd` resolution: TimeMachine tools and REST endpoints automatically locate the active session workspace or accept explicit target directory.
+* **Added in v0.1.10**: Unified diff support (`format: "patch" | "stat"`) with size limits (up to 256KB) and clean truncation warnings.
+* **Added in v0.1.10**: Async execution queue on Git mutation engine to completely eliminate lockfile collisions under concurrent agent operations.
+* **Added in v0.1.10**: Single-batch Git ref querying using `git for-each-ref` replacing $O(N)$ sequential `git log` processes for instant snapshot listings.
+* **Added in v0.1.10**: Redundant commit deduplication: auto-snapshots are safely skipped if the working tree has not changed.
+* **Added in v0.1.10**: Startup cleanup of temporary `tm_index_*` staging files.
+* **Changed in v0.1.10**: Settings UI card streamlined, directing snapshot inspection to the dedicated Time Machine sidebar tab.
+* **Changed in v0.1.10**: Comprehensive error logging replacing silent exceptions.
+
+### v0.1.9 — Event Bus Harmonization & Dependency Cleanup
+* **Changed in v0.1.9**: Harmonized event bus subscriptions to prevent duplicate checkpoints. Native DSH `session/event` bus takes precedence, with legacy `ctx.events` used strictly as a fallback when `ctx.on` is unavailable.
+* **Changed in v0.1.9**: Removed unused `@deepseek-ai/dsh-credentials` from `peerDependencies`.
+* **Added in v0.1.9**: Standardized project design contract in `docs/design/DESIGN.md`.
+
 ### v0.1.7 — Critical Safety, Staging Isolation & Native Event Bus
 * **Changed in v0.1.7**: Safe workspace rollback via `read-tree` + `checkout-index` + `clean -fd`. Rolling back to a checkpoint never modifies branch `HEAD` or severs git commit history.
 * **Changed in v0.1.7**: User staging area protection. Checkpoints now isolate git index creation through `GIT_INDEX_FILE`, preventing disruption of pre-staged files in `.git/index`.

package/README.ru.md

@@ -119,6 +119,21 @@ dsh-time-machine:
 
 ## 📋 История версий (Release Notes)
 
+### v0.1.10 — Стабильность, динамический CWD, Unified Diff и оптимизация архитектуры
+* **Added in v0.1.10**: Динамическое определение рабочей директории (`cwd`): инструменты и REST API автоматически определяют каталог активной сессии либо принимают явный путь.
+* **Added in v0.1.10**: Поддержка Unified Diff (`format: "patch" | "stat"`) с лимитом размера (до 256 КБ) и защитой от переполнения контекста.
+* **Added in v0.1.10**: Асинхронная очередь мутаций Git, исключающая конфликты блокировок `index.lock` при одновременных запросах.
+* **Added in v0.1.10**: Пакетная вычитка ссылок через `git for-each-ref` вместо $O(N)$ отдельных вызовов `git log`, ускоряющая загрузку списка чекпоинтов.
+* **Added in v0.1.10**: Дедупликация снапшотов: авто-сохранение пропускается, если дерево файлов не изменилось с момента прошлого чекпоинта.
+* **Added in v0.1.10**: Автоматическая очистка сиротских временных индексов `tm_index_*` при запуске плагина.
+* **Changed in v0.1.10**: Оптимизирована карточка настроек: удалено дублирование ленты, добавлено указание на вкладку в боковой панели.
+* **Changed in v0.1.10**: Полное логирование ошибок через `console.warn` вместо тихого подавления исключений.
+
+### v0.1.9 — Гармонизация шины событий и очистка зависимостей
+* **Changed in v0.1.9**: Устранено потенциальное дублирование авто-снапшотов. Нативная шина событий DSH `session/event` теперь имеет приоритет, а legacy `ctx.events` подключается строго как fallback при отсутствии `ctx.on`.
+* **Changed in v0.1.9**: Удалена неиспользуемая зависимость `@deepseek-ai/dsh-credentials` из `peerDependencies`.
+* **Added in v0.1.9**: Добавлен дизайн-контракт проекта `docs/design/DESIGN.md`.
+
 ### v0.1.7 — Безопасность истории веток, изоляция индекса и события DSH
 * **Changed in v0.1.7**: Безопасный откат рабочего каталога через `read-tree` + `checkout-index` + `clean -fd`. Устранена критическая проблема переноса `HEAD` ветки на сиротский коммит.
 * **Changed in v0.1.7**: Защита пользовательского индекса Git. Чекпоинты создаются с изолированным `GIT_INDEX_FILE`, предотвращая перезапись подготовленных файлов в `.git/index`.

package/README.zh.md

@@ -94,6 +94,21 @@ dsh-time-machine:
 
 ## 📋 版本更新记录 (Release Notes)
 
+### v0.1.10 — 稳定性、动态工作目录、统一 Diff 与架构优化
+* **Added in v0.1.10**: 动态工作区感知（`cwd`）：时光机工具与 REST 接口自动关联当前会话目录或支持显式工作区路径。
+* **Added in v0.1.10**: 统一补丁支持（`format: "patch" | "stat"`），带输出截断保护（最大 256KB）。
+* **Added in v0.1.10**: Git 变动操作异步排队队列，彻底解决高并发下的 `index.lock` 竞争冲突。
+* **Added in v0.1.10**: 采用 `git for-each-ref` 批量查询引用，消除 $O(N)$ 次 `git log` 进程生成，极大加速快照加载。
+* **Added in v0.1.10**: 空提交去重：若工作树无变化，自动跳过重复快照创建。
+* **Added in v0.1.10**: 启动时自动清理遗留的 `tm_index_*` 临时暂存索引文件。
+* **Changed in v0.1.10**: 精简设置卡片界面，引导在侧边栏时光机标签页查看时间线。
+* **Changed in v0.1.10**: 完善错误告警日志（`console.warn`），替换静默吞并异常。
+
+### v0.1.9 — 事件总线统一与依赖清理
+* **Changed in v0.1.9**: 统一事件总线监听逻辑，杜绝自动快照重复触发。优先使用原生 DSH `session/event` 总线，仅在缺失 `ctx.on` 时启用 legacy `ctx.events` 回退。
+* **Changed in v0.1.9**: 从 `peerDependencies` 中移除未使用的 `@deepseek-ai/dsh-credentials`。
+* **Added in v0.1.9**: 新增项目设计规范文档 `docs/design/DESIGN.md`。
+
 ### v0.1.7 — 分支历史安全、暂存区隔离与 DSH 原生事件总线
 * **Changed in v0.1.7**: 安全工作区回滚。改用 `read-tree` + `checkout-index` + `clean -fd`，彻底杜绝回滚时误将分支 `HEAD` 覆盖为孤立提交的严重缺陷。
 * **Changed in v0.1.7**: 保护用户 Git 暂存区。快照操作通过独立的 `GIT_INDEX_FILE` 执行，不会覆盖 `.git/index` 中已暂存的文件。

package/lib/client.js

@@ -64,6 +64,7 @@ window.__ModuleLoader__.load({
       autoHeal: 'Prompt recovery on failure',
       unavailable: 'Settings unavailable',
       tabTitle: 'Time Machine',
+      sidebarNotice: 'Checkpoints and timeline are available in the Time Machine sidebar tab.',
     };
     const ru = {
       title: 'Машина времени и чекпоинты',
@@ -86,6 +87,7 @@ window.__ModuleLoader__.load({
       autoHeal: 'Предлагать восстановление при ошибке',
       unavailable: 'Настройки недоступны',
       tabTitle: 'Машина времени',
+      sidebarNotice: 'Лента чекпоинтов и управление снимками доступны во вкладке «Машина времени» боковой панели.',
     };
     const zh = {
       title: '时光机与检查点',
@@ -108,6 +110,7 @@ window.__ModuleLoader__.load({
       autoHeal: '命令失败时提示恢复',
       unavailable: '设置不可用',
       tabTitle: '时光机',
+      sidebarNotice: '检查点时间线与管理可在侧边栏“时光机”标签页中查看。',
     };
 
     let ChevronIcon = null;
@@ -176,7 +179,7 @@ window.__ModuleLoader__.load({
       };
       const onDiff = (id) => {
         setBusy(true); setErr('');
-        fetch('/dsh-time-machine/diff?from=' + encodeURIComponent(id)).then(r => r.json()).then(j => {
+        fetch('/dsh-time-machine/diff?from=' + encodeURIComponent(id) + '&format=patch').then(r => r.json()).then(j => {
           if (!j.success) throw new Error(j.error || 'diff failed');
           setDiffText(j.diff || '');
         }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
@@ -317,9 +320,8 @@ window.__ModuleLoader__.load({
               React.createElement('button', { className: 'tm-save', disabled: !writable || saving, onClick: onSave }, saving ? t.loading : t.save)
             )
           ),
-          React.createElement('div', { className: 'tm-field' },
-            React.createElement('div', { className: 'tm-label' }, t.list),
-            React.createElement(Timeline, { t, ctx })
+          React.createElement('div', { className: 'tm-field', style: { borderTop: '1px solid var(--dsw-alias-border-subtle, rgba(255,255,255,0.08))', paddingTop: 10, marginTop: 6 } },
+            React.createElement('div', { className: 'tm-label', style: { color: 'var(--dsw-alias-label-secondary)', fontStyle: 'italic' } }, t.sidebarNotice)
           )
         ) : null
       );

package/lib/index.js

@@ -12,112 +12,124 @@ export const Config = Schema.object({
 
 const NS = '@goodandready/dsh-time-machine';
 
-function sessionIdOf(execution, ctx) {
+function cwdOf(execution, ctx) {
   try {
-    if (execution && execution.sessionId) return String(execution.sessionId);
-    if (execution && execution.session) {
-      return String(execution.session.id || execution.session.header?.id || '');
-    }
-    if (execution && execution.data && execution.data.sessionId) {
-      return String(execution.data.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 {}
+    if (execution?.cwd) return String(execution.cwd);
+    if (execution?.session?.workspace?.cwd) return String(execution.session.workspace.cwd);
+    if (execution?.session?.cwd) return String(execution.session.cwd);
+    if (ctx?.workspace?.cwd) return String(ctx.workspace.cwd);
+    if (typeof ctx?.get === 'function') {
+      const ws = ctx.get('workspace');
+      if (ws?.cwd) return String(ws.cwd);
     }
   } catch {}
+  return undefined;
+}
+
+function sessionIdOf(execution, ctx) {
+  try {
+    if (execution?.sessionId) return String(execution.sessionId);
+    if (execution?.session?.id) return String(execution.session.id);
+    if (execution?.data?.sessionId) return String(execution.data.sessionId);
+    if (ctx?.session?.id) return String(ctx.session.id);
+  } catch {}
   return '';
 }
 
 export function apply(ctx, config) {
   let getConfig = () => config;
-  let engine = new ShadowSnapshotEngine({ maxSnapshots: config?.maxSnapshots ?? 20 });
-  engine.loadFromRefs().catch(() => {});
+  const initialCwd = cwdOf(null, ctx);
+  let engine = new ShadowSnapshotEngine({ maxSnapshots: config?.maxSnapshots ?? 20, cwd: initialCwd });
+  engine.loadFromRefs({ cwd: initialCwd }).catch(() => {});
 
   ctx.inject(['settings'], (sctx) => {
     const scope = sctx.settings.register(NS, Config, { base: config });
     getConfig = () => scope.get() ?? config;
-    const syncMax = () => engine.setMax(getConfig().maxSnapshots ?? 20);
+    const syncMax = () => engine.setMax(getConfig().maxSnapshots ?? 20, cwdOf(null, ctx));
     syncMax();
     const stop = scope.watch ? scope.watch(syncMax) : () => {};
     sctx.effect(() => () => { try { stop(); } catch {} }, 'dsh-time-machine: settings watch');
   });
 
   // auto-snapshot on turn/start and approval/asked (session-scoped)
-  const autoSnap = async (label, sessId) => {
+  const autoSnap = async (label, sessId, customCwd) => {
     if (!getConfig().autoSnapshotEnabled) return;
     try {
       const sid = String(sessId || '').trim();
-      await engine.createSnapshot(label, { sessionId: sid });
+      const targetCwd = customCwd || cwdOf(null, ctx);
+      await engine.createSnapshot(label, { sessionId: sid, cwd: targetCwd, skipIfNoChanges: true });
     } catch {}
   };
 
   // 1. Native DSH session/event bus (Cordis standard in DSH)
-  ctx.effect(() => {
-    const off = ctx.on && ctx.on('session/event', (session, event) => {
-      const sid = (session && session.id) || sessionIdOf(event, ctx);
-      const type = event && event.type;
-      if (type === 'turn/start') {
-        const turnId = event.turnId || event.data?.turnId || Date.now();
-        autoSnap(`auto:turn:${turnId}`, sid);
-      } else if (type === 'approval/asked') {
-        const tool = event.tool || event.data?.toolName || event.data?.tool || 'approval';
-        autoSnap(`auto:approval:${tool}`, sid);
-      } else if (type === 'turn/end') {
-        if (!getConfig().autoSnapshotEnabled) return;
-        const outcome = String((event && (event.outcome || event.data?.outcome || event.result?.outcome || event.result?.status)) || '');
-        if (!sid) return;
-        if (outcome === 'success' || outcome === 'ok' || outcome === 'done') {
-          engine.pruneSnapshots(sid, 3).catch(() => {});
-        }
-      } else if (type === 'tool/error' || type === 'command/error') {
-        if (getConfig().autoHealPrompt) {
-          const tool = event.tool || event.data?.toolName || 'command';
-          autoSnap(`auto:error:${tool}`, sid);
+  // When native session/event bus is present, use it exclusively to prevent double-fire.
+  const hasNativeEvents = typeof ctx.on === 'function';
+
+  if (hasNativeEvents) {
+    ctx.effect(() => {
+      const off = ctx.on('session/event', (session, event) => {
+        const sid = (session && session.id) || sessionIdOf(event, ctx);
+        const sessionCwd = session?.workspace?.cwd || session?.cwd || cwdOf(event, ctx);
+        const type = event && event.type;
+        if (type === 'turn/start') {
+          const turnId = event.turnId || event.data?.turnId || Date.now();
+          autoSnap(`auto:turn:${turnId}`, sid, sessionCwd);
+        } else if (type === 'approval/asked') {
+          const tool = event.tool || event.data?.toolName || event.data?.tool || 'approval';
+          autoSnap(`auto:approval:${tool}`, sid, sessionCwd);
+        } else if (type === 'turn/end') {
+          if (!getConfig().autoSnapshotEnabled) return;
+          const outcome = String((event && (event.outcome || event.data?.outcome || event.result?.outcome || event.result?.status)) || '');
+          if (!sid) return;
+          if (outcome === 'success' || outcome === 'ok' || outcome === 'done') {
+            engine.pruneSnapshots(sid, 3, { cwd: sessionCwd }).catch(() => {});
+          }
+        } else if (type === 'tool/error' || type === 'command/error') {
+          if (getConfig().autoHealPrompt) {
+            const tool = event.tool || event.data?.toolName || 'command';
+            autoSnap(`auto:error:${tool}`, sid, sessionCwd);
+          }
         }
+      });
+      return () => { try { typeof off === 'function' && off(); } catch {} };
+    }, 'dsh-time-machine: native session events');
+  } else {
+    // 2. Legacy/mock events bus fallback (for unit tests and non-standard environments without ctx.on)
+    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(() => {});
+              }
+            }));
+          } catch {}
+          return () => { for (const off of offs) try { typeof off === 'function' && off(); } catch {} };
+        }, 'dsh-time-machine: auto snapshot events fallback');
       }
-    });
-    return () => { try { typeof off === 'function' && off(); } catch {} };
-  }, 'dsh-time-machine: native session events');
-
-  // 2. Legacy/mock events bus fallback (for unit tests and non-standard environments)
-  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(() => {});
-            }
-          }));
-        } catch {}
-        return () => { for (const off of offs) try { typeof off === 'function' && off(); } catch {} };
-      }, 'dsh-time-machine: auto snapshot events');
-    }
-  } catch {}
+    } catch {}
+  }
 
-  // tools (session-aware)
+  // tools (session-aware and cwd-aware)
   const registerTools = (tctx) => {
     tctx.tools.register({
       name: 'time_machine_checkpoint_create',
@@ -127,11 +139,13 @@ export function apply(ctx, config) {
         properties: {
           label: { type: 'string', description: 'Human label for checkpoint' },
           sessionId: { type: 'string', description: 'Session id to scope checkpoint (auto-detected if omitted)' },
+          cwd: { type: 'string', description: 'Target workspace directory (auto-detected if omitted)' },
         },
       },
       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 });
+        const sid = String(args.sessionId || sessionIdOf(execution, tctx) || '').trim();
+        const targetCwd = args.cwd ? String(args.cwd) : cwdOf(execution, tctx);
+        const snap = await engine.createSnapshot(args.label, { sessionId: sid, cwd: targetCwd });
         return { success: true, snapshot: snap };
       },
     });
@@ -160,28 +174,36 @@ export function apply(ctx, config) {
         properties: {
           id: { type: 'string', description: 'Snapshot id to rollback to' },
           confirm: { type: 'boolean', description: 'Must be true to confirm destructive rollback' },
+          cwd: { type: 'string', description: 'Target workspace directory' },
         },
         required: ['id', 'confirm'],
       },
-      execute: async ({ id, confirm } = {}) => {
-        const res = await engine.rollbackSnapshot(String(id ?? ''), { confirm });
+      execute: async ({ id, confirm, cwd } = {}, execution) => {
+        const targetCwd = cwd ? String(cwd) : cwdOf(execution, tctx);
+        const res = await engine.rollbackSnapshot(String(id ?? ''), { confirm, cwd: targetCwd });
         return { success: true, ...res };
       },
     });
 
     tctx.tools.register({
       name: 'time_machine_diff',
-      description: 'Show diff between checkpoint and current or another checkpoint.',
+      description: 'Show unified diff or stat between checkpoint and current or another checkpoint.',
       parameters: {
         type: 'object',
         properties: {
           from: { type: 'string', description: 'Source snapshot id' },
           to: { type: 'string', description: 'Target snapshot id (default HEAD)' },
+          format: { type: 'string', enum: ['patch', 'stat'], description: 'Format of diff: patch (unified diff) or stat (summary)' },
+          cwd: { type: 'string', description: 'Target workspace directory' },
         },
         required: ['from'],
       },
-      execute: async ({ from, to } = {}) => {
-        const res = await engine.diff(String(from ?? ''), to ? String(to) : undefined);
+      execute: async ({ from, to, format, cwd } = {}, execution) => {
+        const targetCwd = cwd ? String(cwd) : cwdOf(execution, tctx);
+        const res = await engine.diff(String(from ?? ''), to ? String(to) : undefined, {
+          cwd: targetCwd,
+          format: format === 'stat' ? 'stat' : 'patch',
+        });
         return { success: true, ...res };
       },
     });
@@ -194,11 +216,13 @@ export function apply(ctx, config) {
         properties: {
           id: { type: 'string', description: 'Snapshot id to delete' },
           confirm: { type: 'boolean', description: 'Must be true to confirm deletion' },
+          cwd: { type: 'string', description: 'Target workspace directory' },
         },
         required: ['id', 'confirm'],
       },
-      execute: async ({ id, confirm } = {}) => {
-        const res = await engine.deleteSnapshot(String(id ?? ''), { confirm });
+      execute: async ({ id, confirm, cwd } = {}, execution) => {
+        const targetCwd = cwd ? String(cwd) : cwdOf(execution, tctx);
+        const res = await engine.deleteSnapshot(String(id ?? ''), { confirm, cwd: targetCwd });
         return { success: true, ...res };
       },
     });
@@ -211,11 +235,13 @@ export function apply(ctx, config) {
         properties: {
           sessionId: { type: 'string', description: 'Session id to prune (default current session)' },
           keep: { type: 'number', description: 'How many newest checkpoints to keep (default 3)' },
+          cwd: { type: 'string', description: 'Target workspace directory' },
         },
       },
       execute: async (args = {}, execution) => {
         const sid = String(args.sessionId || sessionIdOf(execution, tctx) || '').trim();
-        const out = await engine.pruneSnapshots(sid, args.keep);
+        const targetCwd = args.cwd ? String(args.cwd) : cwdOf(execution, tctx);
+        const out = await engine.pruneSnapshots(sid, args.keep, { cwd: targetCwd });
         return { success: true, sessionId: sid, ...out };
       },
     });
@@ -253,7 +279,7 @@ export function apply(ctx, config) {
     });
   };
 
-  // web routes for UI (session-aware via ?sessionId=)
+  // web routes for UI (session-aware via ?sessionId= and ?format=)
   ctx.effect(() => {
     const disposals = [];
     try {
@@ -275,8 +301,12 @@ export function apply(ctx, config) {
           const url = new URL(req.url, 'http://localhost');
           const from = url.searchParams.get('from') || '';
           const to = url.searchParams.get('to') || undefined;
+          const format = url.searchParams.get('format') || 'patch';
           try {
-            const out = await engine.diff(String(from), to ? String(to) : undefined);
+            const out = await engine.diff(String(from), to ? String(to) : undefined, {
+              cwd: cwdOf(null, ctx),
+              format: format === 'stat' ? 'stat' : 'patch',
+            });
             res.setHeader('content-type', 'application/json');
             res.end(JSON.stringify({ success: true, ...out }));
           } catch (e) {
@@ -293,7 +323,8 @@ export function apply(ctx, config) {
           readJsonBody(req, res, async (parsed) => {
             try {
               const sid = String(parsed.sessionId || new URL(req.url, 'http://localhost').searchParams.get('sessionId') || '').trim();
-              const snap = await engine.createSnapshot(parsed.label, { sessionId: sid });
+              const targetCwd = parsed.cwd ? String(parsed.cwd) : cwdOf(null, ctx);
+              const snap = await engine.createSnapshot(parsed.label, { sessionId: sid, cwd: targetCwd });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, snapshot: snap }));
             } catch (e) {
@@ -310,7 +341,8 @@ export function apply(ctx, config) {
         handler: (req, res) => {
           readJsonBody(req, res, async (parsed) => {
             try {
-              const out = await engine.deleteSnapshot(String(parsed.id || ''), { confirm: parsed.confirm });
+              const targetCwd = parsed.cwd ? String(parsed.cwd) : cwdOf(null, ctx);
+              const out = await engine.deleteSnapshot(String(parsed.id || ''), { confirm: parsed.confirm, cwd: targetCwd });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, ...out }));
             } catch (e) {
@@ -328,7 +360,8 @@ export function apply(ctx, config) {
           readJsonBody(req, res, async (parsed) => {
             try {
               const sid = String(parsed.sessionId || new URL(req.url, 'http://localhost').searchParams.get('sessionId') || '');
-              const out = await engine.pruneSnapshots(sid, parsed.keep);
+              const targetCwd = parsed.cwd ? String(parsed.cwd) : cwdOf(null, ctx);
+              const out = await engine.pruneSnapshots(sid, parsed.keep, { cwd: targetCwd });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, sessionId: sid, ...out }));
             } catch (e) {
@@ -345,7 +378,8 @@ export function apply(ctx, config) {
         handler: (req, res) => {
           readJsonBody(req, res, async (parsed) => {
             try {
-              const out = await engine.rollbackSnapshot(String(parsed.id || ''), { confirm: parsed.confirm });
+              const targetCwd = parsed.cwd ? String(parsed.cwd) : cwdOf(null, ctx);
+              const out = await engine.rollbackSnapshot(String(parsed.id || ''), { confirm: parsed.confirm, cwd: targetCwd });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, ...out }));
             } catch (e) {

package/lib/snapshot.js

@@ -18,159 +18,164 @@ async function defaultExec(cmd, args, opts = {}) {
   }
 }
 
+const MAX_DIFF_LENGTH = 256 * 1024; // 256 KB safety limit
+
 // 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 = []; // {id, label, sessionId, createdAt, commit, ref}
+    this.snapshots = []; // {id, label, sessionId, createdAt, commit, ref, treeHash}
     this.seq = 0;
+    this._queue = Promise.resolve();
   }
 
   _now() { return Date.now(); }
 
-  async _trimFor(sessionId) {
-    if (!sessionId) {
-      while (this.snapshots.length > this.maxSnapshots) {
-        const oldest = this.snapshots.shift();
-        if (oldest?.ref) {
-          try { await this.exec('git', ['update-ref', '-d', oldest.ref], this.cwd ? { cwd: this.cwd } : {}); } catch {}
-        }
-      }
-      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);
-        if (oldest?.ref) {
-          try { await this.exec('git', ['update-ref', '-d', oldest.ref], this.cwd ? { cwd: this.cwd } : {}); } catch {}
-        }
-      }
-    }
+  _enqueue(operation) {
+    const next = this._queue.then(() => operation(), () => operation());
+    this._queue = next.catch(() => {});
+    return next;
   }
 
-  async _isGitRepo() {
-    try {
-      await this.exec('git', ['rev-parse', '--is-inside-work-tree'], this.cwd ? { cwd: this.cwd } : {});
-      return true;
-    } catch { return false; }
+  _resolveCwd(customCwd) {
+    return customCwd || this.cwd || process.cwd();
   }
 
-  async _gitDir() {
+  async _hasGit(targetCwd) {
     try {
-      const { stdout } = await this.exec('git', ['rev-parse', '--git-dir'], this.cwd ? { cwd: this.cwd } : {});
-      const gdir = String(stdout ?? '').trim();
-      if (!gdir) return null;
-      return path.isAbsolute(gdir) ? gdir : path.resolve(this.cwd || process.cwd(), gdir);
+      const cwd = this._resolveCwd(targetCwd);
+      const { stdout } = await this.exec('git', ['rev-parse', '--is-inside-work-tree'], { cwd });
+      return stdout.trim() === 'true';
     } catch {
-      return null;
+      return false;
     }
   }
 
-  // Restore checkpoint metadata from git shadow refs after a restart.
-  // git is the durable store; memory is rebuilt from refs/dsh-time-machine/*.
-  async loadFromRefs() {
-    if (!(await this._isGitRepo())) return 0;
-    let refs = [];
+  async cleanupOrphanedIndices(targetCwd) {
+    const cwd = this._resolveCwd(targetCwd);
     try {
-      const { stdout } = await this.exec(
-        'git',
-        ['for-each-ref', '--format=%(refname)%00%(objectname)', 'refs/dsh-time-machine/'],
-        this.cwd ? { cwd: this.cwd } : {},
-      );
-      refs = String(stdout ?? '').trim().split('\n').filter(Boolean);
-    } catch { return 0; }
-    const restored = [];
-    for (const line of refs) {
-      const [ref, commit] = line.split('\0');
-      if (!ref || !commit) continue;
-      if (this.snapshots.some(s => s.ref === ref)) continue;
-      let createdAt = 0;
-      let label = ref.split('/').pop();
-      try {
-        const { stdout } = await this.exec(
-          'git',
-          ['log', '-1', '--format=%ct%00%s', ref],
-          this.cwd ? { cwd: this.cwd } : {},
-        );
-        const [ct, msg] = String(stdout ?? '').split('\0');
-        createdAt = Number(ct) * 1000 || 0;
-        if (msg && String(msg).trim()) label = String(msg).trim();
-      } catch {}
-      const short = ref.replace(/^refs\/dsh-time-machine\//, '');
-      const slash = short.indexOf('/');
-      const sessionId = slash === -1 ? '' : short.slice(0, slash);
-      const id = slash === -1 ? short : short.slice(slash + 1);
-      restored.push({ id: id || short, label, sessionId, createdAt, commit, ref, seq: 0 });
+      const { stdout } = await this.exec('git', ['rev-parse', '--git-dir'], { cwd });
+      const gitDir = stdout.trim();
+      const resolvedGitDir = path.isAbsolute(gitDir) ? gitDir : path.resolve(cwd, gitDir);
+      const files = await fs.readdir(resolvedGitDir).catch(() => []);
+      for (const file of files) {
+        if (file.startsWith('tm_index_')) {
+          await fs.unlink(path.join(resolvedGitDir, file)).catch(() => {});
+        }
+      }
+    } catch (e) {
+      console.warn('[dsh-time-machine] cleanupOrphanedIndices warning:', e.message || e);
     }
-    // stable order: oldest first, tie-break by ref name
-    restored.sort((a, b) => a.createdAt - b.createdAt || (a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0));
-    for (const snap of restored) snap.seq = ++this.seq;
-    this.snapshots.push(...restored);
-    const sessions = [...new Set(this.snapshots.map(s => s.sessionId))];
-    for (const sid of sessions) await this._trimFor(sid);
-    if (sessions.length === 0) {
+  }
+
+  async _trimFor(sessionId, targetCwd) {
+    const cwd = this._resolveCwd(targetCwd);
+    if (!sessionId) {
       while (this.snapshots.length > this.maxSnapshots) {
         const oldest = this.snapshots.shift();
         if (oldest?.ref) {
-          try { await this.exec('git', ['update-ref', '-d', oldest.ref], this.cwd ? { cwd: this.cwd } : {}); } catch {}
+          try {
+            await this.exec('git', ['update-ref', '-d', oldest.ref], { cwd });
+          } catch (e) {
+            console.warn('[dsh-time-machine] failed to delete evicted ref:', oldest.ref, e.message || e);
+          }
         }
       }
+      return;
+    }
+    const sessionSnaps = this.snapshots.filter(s => s.sessionId === sessionId);
+    const toRemoveCount = sessionSnaps.length - this.maxSnapshots;
+    if (toRemoveCount > 0) {
+      const toRemove = sessionSnaps.slice(0, toRemoveCount);
+      const removeIds = new Set(toRemove.map(s => s.id));
+      for (const snap of toRemove) {
+        if (snap.ref) {
+          try {
+            await this.exec('git', ['update-ref', '-d', snap.ref], { cwd });
+          } catch (e) {
+            console.warn('[dsh-time-machine] failed to delete session ref:', snap.ref, e.message || e);
+          }
+        }
+      }
+      this.snapshots = this.snapshots.filter(s => !removeIds.has(s.id));
     }
-    return restored.length;
   }
 
-  async createSnapshot(label = '', { sessionId = '' } = {}) {
-    const id = crypto.randomUUID().slice(0, 8);
-    const createdAt = this._now();
-    const safeLabel = String(label ?? '').trim() || `checkpoint-${id}`;
-    const rawSid = String(sessionId || '').trim();
-    const safeSid = rawSid ? rawSid.replace(/[^a-zA-Z0-9_-]/g, '_') : '';
+  createSnapshot(label, { sessionId = '', cwd: customCwd } = {}) {
+    return this._enqueue(() => this._doCreateSnapshot(label, { sessionId, cwd: customCwd }));
+  }
+
+  async _doCreateSnapshot(label, { sessionId = '', cwd: customCwd } = {}) {
+    const cwd = this._resolveCwd(customCwd);
+    const id = `snap-${this._now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const cleanLabel = String(label || 'checkpoint').slice(0, 100);
+    const cleanSession = String(sessionId || '').trim();
     let commit = null;
     let ref = null;
-    const inGit = await this._isGitRepo();
-    if (inGit) {
-      let shadowIndex = null;
+    let treeHash = null;
+
+    if (await this._hasGit(cwd)) {
+      const gitDirRes = await this.exec('git', ['rev-parse', '--git-dir'], { cwd });
+      const gitDir = gitDirRes.stdout.trim();
+      const resolvedGitDir = path.isAbsolute(gitDir) ? gitDir : path.resolve(cwd, gitDir);
+      const tempIndexFile = path.join(resolvedGitDir, `tm_index_${crypto.randomBytes(4).toString('hex')}`);
+
+      const gitEnv = {
+        ...process.env,
+        GIT_INDEX_FILE: tempIndexFile,
+        GIT_AUTHOR_NAME: 'DSH Time Machine',
+        GIT_AUTHOR_EMAIL: 'time-machine@deepseek.local',
+        GIT_COMMITTER_NAME: 'DSH Time Machine',
+        GIT_COMMITTER_EMAIL: 'time-machine@deepseek.local',
+      };
+
       try {
-        const gitDir = await this._gitDir();
-        const baseOpts = this.cwd ? { cwd: this.cwd } : {};
-        const execEnv = {
-          ...process.env,
-          GIT_AUTHOR_NAME: 'DSH Time Machine',
-          GIT_AUTHOR_EMAIL: 'time-machine@dsh.local',
-          GIT_COMMITTER_NAME: 'DSH Time Machine',
-          GIT_COMMITTER_EMAIL: 'time-machine@dsh.local',
-        };
-
-        if (gitDir) {
-          shadowIndex = path.join(gitDir, `tm_index_${id}`);
-          execEnv.GIT_INDEX_FILE = shadowIndex;
+        await this.exec('git', ['add', '-A'], { cwd, env: gitEnv });
+        const treeRes = await this.exec('git', ['write-tree'], { cwd, env: gitEnv });
+        treeHash = treeRes.stdout.trim();
+
+        // Check if identical to last snapshot for this session to avoid redundant commits
+        const lastSnap = this.snapshots.filter(s => s.sessionId === cleanSession).slice(-1)[0];
+        if (lastSnap && lastSnap.treeHash && lastSnap.treeHash === treeHash) {
+          return lastSnap;
         }
 
-        const shadowOpts = { ...baseOpts, env: execEnv };
-        await this.exec('git', ['add', '-A'], shadowOpts);
-        const { stdout: tree } = await this.exec('git', ['write-tree'], shadowOpts);
-        const treeHash = String(tree).trim();
-        const { stdout: commitHash } = await this.exec('git', ['commit-tree', treeHash, '-m', safeLabel], shadowOpts);
-        commit = String(commitHash).trim();
-        ref = safeSid ? `refs/dsh-time-machine/${safeSid}/${id}` : `refs/dsh-time-machine/${id}`;
-        await this.exec('git', ['update-ref', ref, commit], baseOpts);
-      } catch {
-        commit = null;
-        ref = null;
-      } finally {
-        if (shadowIndex) {
-          try { await fs.unlink(shadowIndex); } catch {}
+        const headCommitRes = await this.exec('git', ['rev-parse', '--verify', 'HEAD'], { cwd }).catch(() => ({ stdout: '' }));
+        const headCommit = headCommitRes.stdout.trim();
+
+        const commitArgs = ['commit-tree', treeHash, '-m', `[dsh-time-machine] ${cleanLabel}`];
+        if (headCommit) {
+          commitArgs.push('-p', headCommit);
         }
+        const commitRes = await this.exec('git', commitArgs, { cwd, env: gitEnv });
+        commit = commitRes.stdout.trim();
+
+        const refPath = cleanSession
+          ? `refs/dsh-time-machine/${cleanSession}/${id}`
+          : `refs/dsh-time-machine/${id}`;
+        await this.exec('git', ['update-ref', refPath, commit], { cwd });
+        ref = refPath;
+      } catch (e) {
+        console.warn('[dsh-time-machine] git snapshot creation failed, falling back to memory record:', e.message || e);
+      } finally {
+        await fs.unlink(tempIndexFile).catch(() => {});
       }
     }
-    const snap = { id, label: safeLabel, sessionId: rawSid, createdAt, commit, ref, seq: ++this.seq };
+
+    const snap = {
+      id,
+      label: cleanLabel,
+      sessionId: cleanSession,
+      createdAt: this._now(),
+      commit,
+      ref,
+      treeHash,
+      seq: ++this.seq,
+    };
     this.snapshots.push(snap);
-    await this._trimFor(rawSid);
+    await this._trimFor(cleanSession, cwd);
     return snap;
   }
 
@@ -184,111 +189,177 @@ export class ShadowSnapshotEngine {
     return this.snapshots.find(s => s.id === id) || null;
   }
 
-  async rollbackSnapshot(id, { confirm } = {}) {
-    if (confirm !== true) {
-      const err = new Error('confirm:true required to rollback');
-      err.code = 'CONFIRM_REQUIRED';
-      throw err;
-    }
+  deleteSnapshot(id, { confirm = false, cwd: customCwd } = {}) {
+    return this._enqueue(async () => {
+      if (!confirm) throw new Error('confirm required to delete snapshot');
+      const idx = this.snapshots.findIndex(s => s.id === id);
+      if (idx === -1) throw new Error(`Snapshot not found: ${id}`);
+      const snap = this.snapshots[idx];
+      const cwd = this._resolveCwd(customCwd);
+      if (snap.ref && await this._hasGit(cwd)) {
+        try {
+          await this.exec('git', ['update-ref', '-d', snap.ref], { cwd });
+        } catch (e) {
+          console.warn('[dsh-time-machine] failed to delete ref on deleteSnapshot:', snap.ref, e.message || e);
+        }
+      }
+      this.snapshots.splice(idx, 1);
+      return { deleted: true, id };
+    });
+  }
+
+  pruneSnapshots(sessionId = '', keep = 3, { cwd: customCwd } = {}) {
+    return this._enqueue(async () => {
+      const sid = sessionId != null ? String(sessionId).trim() : '';
+      const list = this.listSnapshots(sid); // newest first
+      const minKeep = Math.max(0, Number.isFinite(Number(keep)) ? Number(keep) : 3);
+      const toRemove = list.slice(minKeep);
+      const removed = [];
+      const cwd = this._resolveCwd(customCwd);
+      for (const snap of toRemove) {
+        const idx = this.snapshots.findIndex(s => s.id === snap.id);
+        if (idx !== -1) {
+          if (snap.ref && await this._hasGit(cwd)) {
+            try {
+              await this.exec('git', ['update-ref', '-d', snap.ref], { cwd });
+            } catch (e) {
+              console.warn('[dsh-time-machine] failed to delete ref on pruneSnapshots:', snap.ref, e.message || e);
+            }
+          }
+          this.snapshots.splice(idx, 1);
+          removed.push(snap.id);
+        }
+      }
+      return { removed, kept: list.length - removed.length };
+    });
+  }
+
+  rollbackSnapshot(id, { confirm = false, cwd: customCwd } = {}) {
+    return this._enqueue(() => this._doRollbackSnapshot(id, { confirm, cwd: customCwd }));
+  }
+
+  async _doRollbackSnapshot(id, { confirm = false, cwd: customCwd } = {}) {
+    if (!confirm) throw new Error('confirm required for rollback');
     const snap = this.getSnapshot(id);
-    if (!snap) {
-      const err = new Error(`snapshot ${id} not found`);
-      err.code = 'NOT_FOUND';
-      throw err;
-    }
-    const inGit = await this._isGitRepo();
-    if (inGit && snap.commit) {
-      const opts = this.cwd ? { cwd: this.cwd } : {};
+    if (!snap) throw new Error(`Snapshot not found: ${id}`);
+    const cwd = this._resolveCwd(customCwd);
+    if (snap.commit && await this._hasGit(cwd)) {
       try {
-        // Safe rollback: restore index and working tree to snapshot without moving branch HEAD
-        await this.exec('git', ['read-tree', snap.commit], opts);
-        await this.exec('git', ['checkout-index', '-a', '-f'], opts);
-        await this.exec('git', ['clean', '-fd'], opts);
+        await this.exec('git', ['read-tree', snap.commit], { cwd });
+        await this.exec('git', ['checkout-index', '-a', '-f'], { cwd });
+        await this.exec('git', ['clean', '-fd'], { cwd });
       } catch (e) {
-        // Fallback: checkout files directly from commit tree
-        await this.exec('git', ['checkout', snap.commit, '--', '.'], opts).catch(() => {});
-        await this.exec('git', ['clean', '-fd'], opts).catch(() => {});
+        console.warn('[dsh-time-machine] rollback error:', e.message || e);
+        throw new Error(`Rollback execution failed: ${e.message || e}`);
       }
     }
-    return { rolledBack: true, snapshot: snap };
+    return { rolledBack: true, id, commit: snap.commit };
   }
 
-  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 {}
+  async diff(fromId, toId = undefined, { cwd: customCwd, format = 'patch' } = {}) {
+    const snapFrom = this.getSnapshot(fromId);
+    if (!snapFrom) throw new Error(`Snapshot not found: ${fromId}`);
+    const snapTo = toId ? this.getSnapshot(toId) : null;
+    if (toId && !snapTo) throw new Error(`Target snapshot not found: ${toId}`);
+
+    const cwd = this._resolveCwd(customCwd);
+    if (!(await this._hasGit(cwd)) || !snapFrom.commit) {
+      const toLabel = snapTo ? snapTo.label : "current";
+      return { from: fromId, to: toId || "HEAD", diff: `diff ${snapFrom.label} -> ${toLabel} (no git repo)`, format };
     }
-    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.isFinite(Number(keep)) ? 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 {}
+    try {
+      const fromRef = snapFrom.commit || snapFrom.ref;
+      let diffArgs = ['diff'];
+      if (format === 'stat') {
+        diffArgs.push('--stat');
+      }
+
+      if (snapTo) {
+        const toRef = snapTo.commit || snapTo.ref;
+        diffArgs.push(fromRef, toRef);
+      } else {
+        diffArgs.push(fromRef);
+      }
+
+      const { stdout } = await this.exec('git', diffArgs, { cwd });
+      let diffOutput = stdout;
+      let truncated = false;
+      if (diffOutput.length > MAX_DIFF_LENGTH) {
+        diffOutput = diffOutput.slice(0, MAX_DIFF_LENGTH) + '\n\n... [diff truncated: output exceeded limit]';
+        truncated = true;
+      }
+      return { diff: diffOutput, from: fromId, to: toId || 'HEAD', format, truncated };
+    } catch (e) {
+      console.warn('[dsh-time-machine] diff computation error:', e.message || e);
+      return { diff: `[diff error: ${e.message || e}]`, from: fromId, to: toId || 'HEAD', format };
     }
-    return { removed, kept: list.length - removed.length };
   }
 
-  async diff(fromId, toId) {
-    const from = this.getSnapshot(fromId);
-    if (!from) {
-      const err = new Error(`snapshot ${fromId} not found`);
-      err.code = 'NOT_FOUND';
-      throw err;
-    }
-    let to = toId ? this.getSnapshot(toId) : null;
-    const inGit = await this._isGitRepo();
-    if (inGit && from.commit) {
-      const opts = this.cwd ? { cwd: this.cwd } : {};
-      try {
-        const args = to?.commit
-          ? ['diff', '--stat', `${from.commit}..${to.commit}`]
-          : ['diff', '--stat', from.commit];
-        const { stdout } = await this.exec('git', args, opts);
-        const diffStat = String(stdout ?? '').trim();
-        if (diffStat) return { from: fromId, to: toId || 'HEAD', diff: diffStat };
-      } catch {}
-      try {
-        const args = to?.commit
-          ? ['diff', '--name-only', `${from.commit}..${to.commit}`]
-          : ['diff', '--name-only', from.commit];
-        const { stdout } = await this.exec('git', args, opts);
-        return { from: fromId, to: toId || 'HEAD', diff: String(stdout ?? '').trim() || '(no changes)' };
-      } catch {}
+  async loadFromRefs(targetCwd) {
+    const cwd = this._resolveCwd(targetCwd);
+    if (!(await this._hasGit(cwd))) return 0;
+    let refs = [];
+    try {
+      // Support both single-batch with committerdate/subject and basic for-each-ref
+      const { stdout } = await this.exec('git', [
+        'for-each-ref',
+        '--format=%(refname)%00%(objectname)%00%(committerdate:raw)%00%(contents:subject)',
+        'refs/dsh-time-machine'
+      ], { cwd });
+      refs = String(stdout ?? '').trim().split('\n').filter(Boolean);
+    } catch {
+      return 0;
     }
-    const toLabel = to ? to.label : 'current';
-    return { from: fromId, to: toId || 'HEAD', diff: `diff ${from.label} -> ${toLabel} (no git repo)` };
-  }
 
-  setMax(n) {
-    this.maxSnapshots = Math.max(1, Number(n) || 20);
-    const sessions = [...new Set(this.snapshots.map(s => s.sessionId))];
-    for (const sid of sessions) this._trimFor(sid).catch(() => {});
-    if (sessions.length === 0) {
-      while (this.snapshots.length > this.maxSnapshots) {
-        const oldest = this.snapshots.shift();
-        if (oldest?.ref) {
-          this.exec('git', ['update-ref', '-d', oldest.ref], this.cwd ? { cwd: this.cwd } : {}).catch(() => {});
-        }
+    let restoredCount = 0;
+    for (const line of refs) {
+      const parts = line.split('\0');
+      const ref = parts[0]?.trim();
+      const commit = parts[1]?.trim();
+      if (!ref || !commit) continue;
+      if (this.snapshots.some(s => s.ref === ref)) continue;
+
+      let createdAt = 0;
+      let label = ref.split('/').pop();
+
+      // If parts has date and subject from single-batch
+      if (parts.length >= 4 && parts[2] && parts[3] !== undefined) {
+        const timestampSeconds = parseInt(parts[2].split(' ')[0], 10);
+        if (!isNaN(timestampSeconds)) createdAt = timestampSeconds * 1000;
+        const sub = parts[3].trim().replace(/^\[dsh-time-machine\]\s*/, '');
+        if (sub) label = sub;
+      } else {
+        // Fallback for tests or git versions returning minimal for-each-ref
+        try {
+          const { stdout } = await this.exec('git', ['log', '-1', '--format=%ct%00%s', ref], { cwd });
+          const [ct, msg] = String(stdout ?? '').split('\0');
+          createdAt = Number(ct) * 1000 || 0;
+          if (msg && String(msg).trim()) label = String(msg).trim();
+        } catch {}
       }
+
+      const short = ref.replace(/^refs\/dsh-time-machine\//, '');
+      const slash = short.indexOf('/');
+      const sessionId = slash === -1 ? '' : short.slice(0, slash);
+      const id = slash === -1 ? short : short.slice(slash + 1);
+
+      this.snapshots.push({
+        id: id || short,
+        label,
+        sessionId,
+        createdAt,
+        commit,
+        ref,
+        seq: ++this.seq,
+      });
+      restoredCount++;
     }
+
+    this.snapshots.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0) || a.seq - b.seq);
+    const sessions = [...new Set(this.snapshots.map(s => s.sessionId))];
+    for (const sid of sessions) await this._trimFor(sid, cwd);
+    if (sessions.length === 0) await this._trimFor('', cwd);
+    return restoredCount;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-time-machine",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "DSH plugin for smart checkpoints, workspace safety guards, and instant rollback",
   "type": "module",
   "main": "lib/index.js",
@@ -47,7 +47,6 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",