@goodandready/dsh-time-machine 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GooDAnDReaDY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# dsh-time-machine
+
+DSH plugin for smart checkpoints, workspace safety guards, and instant rollback for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness).
+
+## Tools
+- `time_machine_checkpoint_create`
+- `time_machine_checkpoint_list`
+- `time_machine_checkpoint_rollback`
+- `time_machine_diff`
+
+## Settings
+Located in **Settings -> Plugins -> Time Machine & Checkpoints**:
+- `autoSnapshotEnabled`: Take automatic checkpoints before file changes (default: `true`)
+- `maxSnapshots`: Maximum snapshots in session history (default: `20`)
+- `autoHealPrompt`: Prompt recovery on command failure (default: `true`)
+
+## Verification
+```bash
+npm test
+```

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-time-machine
+      name: '@goodandready/dsh-time-machine'

package/lib/client.js

@@ -0,0 +1,388 @@
+window.__ModuleLoader__.load({
+  id: '@goodandready/dsh-time-machine',
+  factory: (require) => {
+    var module = { exports: {} };
+    const React = require('react');
+    const NS = '@goodandready/dsh-time-machine';
+
+    const CSS = '.tm-card{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:12px;list-style:none;margin:0;padding:0;overflow:hidden;box-sizing:border-box}'
+      + '.tm-head{appearance:none;width:100%;font:inherit;color:inherit;text-align:left;cursor:pointer;background:0 0;border:0;border-radius:12px;display:flex;align-items:center;gap:12px;padding:14px 16px}'
+      + '.tm-head:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.05))}'
+      + '.tm-head:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:-2px}'
+      + '.tm-head-text{display:flex;flex-direction:column;gap:2px;flex:1;min-width:0}'
+      + '.tm-title{color:var(--dsw-alias-label-primary);font-size:15px;font-weight:600;line-height:1.4}'
+      + '.tm-sub{color:var(--dsw-alias-label-secondary);font-size:13px;line-height:1.45}'
+      + '.tm-chev{margin-left:auto;flex:none;color:var(--dsw-alias-label-tertiary);transition:transform .16s}'
+      + '.tm-chev-open{transform:rotate(180deg)}'
+      + '.tm-body{border-top:1px solid var(--dsw-alias-border-l2);margin:0 16px;padding-bottom:8px;display:flex;flex-direction:column;gap:12px}'
+      + '.tm-field{display:flex;flex-direction:column;gap:6px;padding:12px 0}'
+      + '.tm-label{color:var(--dsw-alias-label-secondary);font-size:12px}'
+      + '.tm-input{height:34px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-primary);border-radius:8px;padding:0 12px;font-size:13px;box-sizing:border-box}'
+      + '.tm-foot{border-top:1px solid var(--dsw-alias-border-l2);display:flex;justify-content:flex-end;align-items:center;gap:8px;padding:12px 0 4px}'
+      + '.tm-save{appearance:none;font:inherit;cursor:pointer;border:1px solid transparent;border-radius:8px;padding:5px 14px;font-size:13px;background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3)}'
+      + '.tm-save:disabled{opacity:.45;cursor:default}'
+      + '.tm-btn{appearance:none;font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:5px 10px;font-size:12px;background:transparent;color:var(--dsw-alias-label-primary)}'
+      + '.tm-btn:hover:not(:disabled){border-color:var(--dsw-alias-brand-primary)}'
+      + '.tm-list{display:flex;flex-direction:column;gap:8px}'
+      + '.tm-row{display:flex;align-items:center;gap:8px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1,transparent)}'
+      + '.tm-row-main{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}'
+      + '.tm-row-title{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);overflow-wrap:anywhere}'
+      + '.tm-row-meta{font-size:11px;color:var(--dsw-alias-label-secondary)}'
+      + '.tm-modal{position:fixed;inset:0;background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;z-index:9999;padding:16px}'
+      + '.tm-modal-box{max-width:760px;width:100%;max-height:80vh;overflow:auto;background:var(--dsw-alias-bg-layer-3);border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:16px;white-space:pre-wrap;font-family:monospace;font-size:12px}'
+      + '.tm-tab{padding:12px;display:flex;flex-direction:column;gap:12px;height:100%;box-sizing:border-box;overflow:auto}';
+
+    function ensureStyles() {
+      if (typeof document === 'undefined' || !document.head) return;
+      const id = 'dsh-time-machine/settings.module.css';
+      if (document.querySelector('style[data-plugin-css="' + id + '"]')) return;
+      const tag = document.createElement('style');
+      tag.textContent = CSS;
+      tag.setAttribute('data-plugin', 'dsh-time-machine');
+      tag.setAttribute('data-plugin-css', id);
+      document.head.appendChild(tag);
+    }
+
+    const en = {
+      title: 'Time Machine & Checkpoints',
+      sub: 'Shadow snapshots, diff and instant rollback for agent safety.',
+      loading: 'Loading…',
+      create: 'Create checkpoint',
+      labelPh: 'Checkpoint label',
+      list: 'Timeline',
+      empty: 'No checkpoints yet.',
+      diff: 'Diff',
+      rollback: 'Rollback',
+      confirmRollback: 'Rollback to this checkpoint? This will reset the workspace.',
+      close: 'Close',
+      save: 'Save',
+      saved: 'Saved',
+      autoSnapshot: 'Auto snapshot before file changes',
+      maxSnapshots: 'Max snapshots',
+      autoHeal: 'Prompt recovery on failure',
+      unavailable: 'Settings unavailable',
+      tabTitle: 'Time Machine',
+    };
+    const ru = {
+      title: 'Машина времени и чекпоинты',
+      sub: 'Теневые снапшоты, diff и мгновенный откат для безопасности агента.',
+      loading: 'Загрузка…',
+      create: 'Создать чекпоинт',
+      labelPh: 'Метка чекпоинта',
+      list: 'Лента',
+      empty: 'Чекпоинтов пока нет.',
+      diff: 'Diff',
+      rollback: 'Откатить',
+      confirmRollback: 'Откатиться к этому чекпоинту? Рабочая копия будет сброшена.',
+      close: 'Закрыть',
+      save: 'Сохранить',
+      saved: 'Сохранено',
+      autoSnapshot: 'Авто-снапшот перед изменениями',
+      maxSnapshots: 'Макс. снапшотов',
+      autoHeal: 'Предлагать восстановление при ошибке',
+      unavailable: 'Настройки недоступны',
+      tabTitle: 'Машина времени',
+    };
+
+    let ChevronIcon = null;
+    try {
+      const primitives = require('@deepseek-ai/dsh-client-ui-primitives');
+      ChevronIcon = primitives && primitives.IconChevronDownOutline14;
+    } catch (e) { ChevronIcon = null; }
+    function FallbackChevron(props) {
+      return React.createElement('svg', { width: 14, height: 14, viewBox: '0 0 14 14', fill: 'none', 'aria-hidden': 'true', ...props },
+        React.createElement('path', { d: 'M11.8486 5.5L11.4238 5.92383L8.69727 8.65137C8.44157 8.90706 8.21562 9.13382 8.01172 9.29785C7.79912 9.46883 7.55595 9.61756 7.25 9.66602C7.08435 9.69222 6.91565 9.69222 6.75 9.66602C6.44405 9.61756 6.20088 9.46883 5.98828 9.29785C5.78438 9.13382 5.55843 8.90706 5.30273 8.65137L2.57617 5.92383L2.15137 5.5L3 4.65137L3.42383 5.07617L6.15137 7.80273C6.42595 8.07732 6.59876 8.24849 6.74023 8.3623C6.87291 8.46904 6.92272 8.47813 6.9375 8.48047C6.97895 8.48703 7.02105 8.48703 7.0625 8.48047C7.07728 8.47813 7.12709 8.46904 7.25977 8.3623C7.40124 8.24849 7.57405 8.07732 7.84863 7.80273L10.5762 5.07617L11 4.65137L11.8486 5.5', fill: 'currentColor' }));
+    }
+    const Chevron = ChevronIcon || FallbackChevron;
+
+    function useLocale(ctx) {
+      if (!ctx || !ctx.locale) return 'en';
+      const lang = React.useSyncExternalStore(
+        React.useMemo(() => (cb) => ctx.locale.subscribe(cb) ?? (() => {}), [ctx]),
+        React.useCallback(() => ctx.locale.getSnapshot().active ?? 'en', [ctx])
+      );
+      return lang;
+    }
+
+    function Timeline({ t }) {
+      const [snapshots, setSnapshots] = React.useState([]);
+      const [loading, setLoading] = React.useState(false);
+      const [label, setLabel] = React.useState('');
+      const [diffText, setDiffText] = React.useState(null);
+      const [busy, setBusy] = React.useState(false);
+      const [err, setErr] = React.useState('');
+
+      const fetchList = React.useCallback(() => {
+        setLoading(true); setErr('');
+        fetch('/dsh-time-machine/snapshots').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));
+      }, []);
+
+      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 }) })
+          .then(r => r.json()).then(j => {
+            if (!j.success) throw new Error(j.error || 'create failed');
+            setLabel(''); fetchList();
+          }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
+      };
+      const onDiff = (id) => {
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/diff?from=' + encodeURIComponent(id)).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));
+      };
+      const onRollback = (id) => {
+        if (!window.confirm(t.confirmRollback)) return;
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/rollback', { 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 || 'rollback 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 } },
+          React.createElement('input', { className: 'tm-input', style: { flex: 1 }, placeholder: t.labelPh, value: label, onChange: (e) => setLabel(e.target.value) }),
+          React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: onCreate }, t.create)
+        ),
+        loading ? React.createElement('div', { className: 'tm-label' }, t.loading) : null,
+        err ? React.createElement('div', { className: 'tm-label', style: { color: 'var(--dsw-alias-state-error-primary)' } }, err) : null,
+        snapshots.length === 0 && !loading ? React.createElement('div', { className: 'tm-label' }, t.empty) : null,
+        React.createElement('div', { className: 'tm-list' },
+          snapshots.map(s => React.createElement('div', { key: s.id, className: 'tm-row' },
+            React.createElement('span', { className: 'tm-row-main' },
+              React.createElement('span', { className: 'tm-row-title' }, s.label + ' · ' + s.id),
+              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)
+          ))
+        ),
+        diffText !== null ? React.createElement('div', { className: 'tm-modal', onClick: () => setDiffText(null) },
+          React.createElement('div', { className: 'tm-modal-box', onClick: (e) => e.stopPropagation() },
+            React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 } },
+              React.createElement('strong', null, 'diff'),
+              React.createElement('button', { className: 'tm-btn', onClick: () => setDiffText(null) }, t.close)
+            ),
+            React.createElement('pre', { style: { margin: 0, whiteSpace: 'pre-wrap' } }, diffText)
+          )
+        ) : null
+      );
+    }
+
+    function PluginCard(props) {
+      const ctx = props.ctx;
+      const [expanded, setExpanded] = React.useState(false);
+      const lang = useLocale(ctx);
+      const t = lang === 'ru' ? ru : en;
+      const [snapshots, setSnapshots] = React.useState([]);
+      const [loading, setLoading] = React.useState(false);
+      const [label, setLabel] = React.useState('');
+      const [diffText, setDiffText] = React.useState(null);
+      const [busy, setBusy] = React.useState(false);
+      const [err, setErr] = React.useState('');
+      const [settingsStatus, setSettingsStatus] = React.useState('loading');
+      const [draft, setDraft] = React.useState({ autoSnapshotEnabled: true, maxSnapshots: 20, autoHealPrompt: true });
+      const [saving, setSaving] = React.useState(false);
+
+      const scope = React.useMemo(() => {
+        try { return ctx.settingsScope ? ctx.settingsScope.bind({ namespace: NS }) : null; } catch { return null; }
+      }, [ctx]);
+
+      React.useEffect(() => { ensureStyles(); }, []);
+
+      React.useEffect(() => {
+        if (!scope) { setSettingsStatus('unavailable'); return; }
+        let alive = true;
+        const sync = () => {
+          try {
+            const snap = scope.getSnapshot ? scope.getSnapshot() : null;
+            if (!snap) { if (alive) setSettingsStatus('loading'); return; }
+            if (snap.status === 'loading') { if (alive) setSettingsStatus('loading'); return; }
+            if (snap.status === 'unavailable') { if (alive) setSettingsStatus('unavailable'); return; }
+            const val = snap.value || snap.data || {};
+            if (alive) {
+              setDraft({
+                autoSnapshotEnabled: val.autoSnapshotEnabled ?? true,
+                maxSnapshots: val.maxSnapshots ?? 20,
+                autoHealPrompt: val.autoHealPrompt ?? true,
+              });
+              setSettingsStatus('ready');
+            }
+          } catch { if (alive) setSettingsStatus('unavailable'); }
+        };
+        sync();
+        const unsub = scope.subscribe ? scope.subscribe(sync) : () => {};
+        return () => { alive = false; try { unsub(); } catch {} };
+      }, [scope]);
+
+      const fetchList = React.useCallback(() => {
+        setLoading(true); setErr('');
+        fetch('/dsh-time-machine/snapshots').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));
+      }, []);
+
+      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 }) })
+          .then(r => r.json()).then(j => {
+            if (!j.success) throw new Error(j.error || 'create failed');
+            setLabel(''); fetchList();
+          }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
+      };
+      const onDiff = (id) => {
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/diff?from=' + encodeURIComponent(id)).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));
+      };
+      const onRollback = (id) => {
+        if (!window.confirm(t.confirmRollback)) return;
+        setBusy(true); setErr('');
+        fetch('/dsh-time-machine/rollback', { 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 || 'rollback failed');
+            fetchList();
+          }).catch(e => setErr(String(e.message || e))).finally(() => setBusy(false));
+      };
+      const onSave = async () => {
+        if (!scope) return;
+        setSaving(true); setErr('');
+        try {
+          const keys = ['autoSnapshotEnabled', 'maxSnapshots', 'autoHealPrompt'];
+          const failures = [];
+          for (const k of keys) {
+            try { await scope.set(k, draft[k]); } catch (e) { failures.push(k + ': ' + String(e.message || e)); }
+          }
+          if (failures.length) setErr(failures.join('; '));
+        } catch (e) { setErr(String(e.message || e)); }
+        finally { setSaving(false); }
+      };
+
+      const writable = settingsStatus === 'ready' || settingsStatus === 'unavailable';
+
+      return React.createElement('li', { className: 'tm-card' },
+        React.createElement('button', { type: 'button', className: 'tm-head', 'aria-expanded': expanded, onClick: () => setExpanded(!expanded) },
+          React.createElement('span', { className: 'tm-head-text' },
+            React.createElement('span', { className: 'tm-title' }, t.title),
+            React.createElement('span', { className: 'tm-sub' }, t.sub)
+          ),
+          React.createElement(Chevron, { className: 'tm-chev' + (expanded ? ' tm-chev-open' : '') })
+        ),
+        expanded ? React.createElement('div', { className: 'tm-body' },
+          React.createElement('div', null,
+            settingsStatus === 'loading' ? React.createElement('div', { className: 'tm-label' }, t.loading) : null,
+            settingsStatus === 'unavailable' ? React.createElement('div', { className: 'tm-label', style: { color: 'var(--dsw-alias-state-warning-primary)' } }, t.unavailable) : null,
+            React.createElement('div', { className: 'tm-field' },
+              React.createElement('label', { className: 'tm-label' },
+                React.createElement('input', { type: 'checkbox', checked: !!draft.autoSnapshotEnabled, disabled: !writable, onChange: (e) => setDraft(d => ({ ...d, autoSnapshotEnabled: e.target.checked })) }), ' ' + t.autoSnapshot
+              ),
+              React.createElement('label', { className: 'tm-label' }, t.maxSnapshots,
+                React.createElement('input', { className: 'tm-input', type: 'number', value: draft.maxSnapshots, disabled: !writable, onChange: (e) => setDraft(d => ({ ...d, maxSnapshots: Number(e.target.value) || 20 })) })
+              ),
+              React.createElement('label', { className: 'tm-label' },
+                React.createElement('input', { type: 'checkbox', checked: !!draft.autoHealPrompt, disabled: !writable, onChange: (e) => setDraft(d => ({ ...d, autoHealPrompt: e.target.checked })) }), ' ' + t.autoHeal
+              )
+            ),
+            React.createElement('div', { className: 'tm-foot' },
+              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', { style: { display: 'flex', gap: 8 } },
+              React.createElement('input', { className: 'tm-input', style: { flex: 1 }, placeholder: t.labelPh, value: label, onChange: (e) => setLabel(e.target.value) }),
+              React.createElement('button', { className: 'tm-btn', disabled: busy, onClick: onCreate }, t.create)
+            )
+          ),
+          React.createElement('div', { className: 'tm-field' },
+            React.createElement('div', { className: 'tm-label' }, t.list),
+            loading ? React.createElement('div', { className: 'tm-label' }, t.loading) : null,
+            err ? React.createElement('div', { className: 'tm-label', style: { color: 'var(--dsw-alias-state-error-primary)' } }, err) : null,
+            snapshots.length === 0 && !loading ? React.createElement('div', { className: 'tm-label' }, t.empty) : null,
+            React.createElement('div', { className: 'tm-list' },
+              snapshots.map(s => React.createElement('div', { key: s.id, className: 'tm-row' },
+                React.createElement('span', { className: 'tm-row-main' },
+                  React.createElement('span', { className: 'tm-row-title' }, s.label + ' · ' + s.id),
+                  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)
+              ))
+            )
+          ),
+          diffText !== null ? React.createElement('div', { className: 'tm-modal', onClick: () => setDiffText(null) },
+            React.createElement('div', { className: 'tm-modal-box', onClick: (e) => e.stopPropagation() },
+              React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 } },
+                React.createElement('strong', null, 'diff'),
+                React.createElement('button', { className: 'tm-btn', onClick: () => setDiffText(null) }, t.close)
+              ),
+              React.createElement('pre', { style: { margin: 0, whiteSpace: 'pre-wrap' } }, diffText)
+            )
+          ) : null
+        ) : null
+      );
+    }
+
+    function TimeMachineTab(props) {
+      const ctx = props.ctx;
+      const lang = useLocale(ctx);
+      const t = lang === 'ru' ? ru : en;
+      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 })
+      );
+    }
+
+    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();
+      try { ctx.locale && ctx.locale.register && ctx.locale.register(NS, { en, ru }); } catch {}
+      const t = (ctx.locale && ctx.locale.bind) ? ctx.locale.bind(NS) : (k) => k;
+      try {
+        ctx.slots.register({ name: 'settings.plugin.item', key: NS, locale: NS, inject: () => ({ ctx }) }, PluginCard);
+      } catch (e) {
+        try {
+          ctx.slots.register({ name: 'settings.section', id: NS, order: 30, label: () => t('title'), inject: () => ({ ctx }) }, PluginCard);
+        } catch {}
+      }
+      // betterSidebar tab — immediate + inject fallback
+      registerBetterSidebar(ctx);
+      try { ctx.inject(['betterSidebar'], () => { registerBetterSidebar(ctx); }); } catch {}
+    };
+    return module.exports;
+  },
+});

package/lib/index.js

@@ -0,0 +1,171 @@
+import Schema from '@deepseek-ai/schemastery';
+import { ShadowSnapshotEngine } from './snapshot.js';
+
+export const name = '@goodandready/dsh-time-machine';
+export const inject = ['tools', 'settings', 'webServer'];
+
+export const Config = Schema.object({
+  autoSnapshotEnabled: Schema.boolean().default(true).description('Take automatic checkpoints before file changes'),
+  maxSnapshots: Schema.number().default(20).description('Maximum snapshots in session history'),
+  autoHealPrompt: Schema.boolean().default(true).description('Prompt recovery on command failure'),
+});
+
+const NS = '@goodandready/dsh-time-machine';
+
+export function apply(ctx, config) {
+  let getConfig = () => config;
+  let engine = new ShadowSnapshotEngine({ maxSnapshots: config?.maxSnapshots ?? 20 });
+
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(NS, Config, { base: config });
+    getConfig = () => scope.get() ?? config;
+    const syncMax = () => engine.setMax(getConfig().maxSnapshots ?? 20);
+    syncMax();
+    const stop = scope.watch ? scope.watch(syncMax) : () => {};
+    sctx.effect(() => () => { try { stop(); } catch {} }, 'dsh-time-machine: settings watch');
+  });
+
+  // tools
+  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.',
+      parameters: {
+        type: 'object',
+        properties: {
+          label: { type: 'string', description: 'Human label for checkpoint' },
+        },
+      },
+      execute: async ({ label } = {}) => {
+        const snap = await engine.createSnapshot(label);
+        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 };
+      },
+    });
+
+    tctx.tools.register({
+      name: 'time_machine_checkpoint_rollback',
+      description: 'Rollback workspace to a checkpoint. Requires confirm:true.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Snapshot id to rollback to' },
+          confirm: { type: 'boolean', description: 'Must be true to confirm destructive rollback' },
+        },
+        required: ['id', 'confirm'],
+      },
+      execute: async ({ id, confirm } = {}) => {
+        const res = await engine.rollbackSnapshot(String(id ?? ''), { confirm });
+        return { success: true, ...res };
+      },
+    });
+
+    tctx.tools.register({
+      name: 'time_machine_diff',
+      description: 'Show diff 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)' },
+        },
+        required: ['from'],
+      },
+      execute: async ({ from, to } = {}) => {
+        const res = await engine.diff(String(from ?? ''), to ? String(to) : undefined);
+        return { success: true, ...res };
+      },
+    });
+  };
+
+  try {
+    if (ctx.tools) registerTools(ctx);
+    else ctx.inject(['tools'], (tctx) => registerTools(tctx));
+  } catch {}
+
+  // web routes for UI
+  ctx.effect(() => {
+    const disposals = [];
+    try {
+      disposals.push(ctx.webServer.register({
+        kind: 'exact',
+        path: '/dsh-time-machine/snapshots',
+        handler: (req, res) => {
+          res.setHeader('content-type', 'application/json');
+          res.end(JSON.stringify({ success: true, snapshots: engine.listSnapshots() }));
+        },
+      }));
+      disposals.push(ctx.webServer.register({
+        kind: 'exact',
+        path: '/dsh-time-machine/diff',
+        handler: async (req, res) => {
+          const url = new URL(req.url, 'http://localhost');
+          const from = url.searchParams.get('from') || '';
+          const to = url.searchParams.get('to') || undefined;
+          try {
+            const out = await engine.diff(String(from), to ? String(to) : undefined);
+            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) }));
+          }
+        },
+      }));
+      disposals.push(ctx.webServer.register({
+        kind: 'exact',
+        path: '/dsh-time-machine/create',
+        handler: async (req, res) => {
+          let body = '';
+          req.on('data', (c) => body += c);
+          req.on('end', async () => {
+            try {
+              const parsed = body ? JSON.parse(body) : {};
+              const snap = await engine.createSnapshot(parsed.label);
+              res.setHeader('content-type', 'application/json');
+              res.end(JSON.stringify({ success: true, snapshot: snap }));
+            } 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',
+        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.rollbackSnapshot(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 || '' }));
+            }
+          });
+        },
+      }));
+    } catch {}
+    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

@@ -0,0 +1,134 @@
+import crypto from 'node:crypto';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCb);
+
+async function defaultExec(cmd, args, opts = {}) {
+  try {
+    const { stdout } = await execFile(cmd, args, { encoding: 'utf8', ...opts });
+    return { stdout: String(stdout ?? ''), stderr: '' };
+  } catch (e) {
+    const err = e;
+    err.stdout = String(err.stdout ?? '');
+    err.stderr = String(err.stderr ?? err.message ?? '');
+    throw err;
+  }
+}
+
+// ponytail: in-memory engine, git shadow refs if repo present; O(n) scan, global lock
+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
+  }
+
+  _now() { return Date.now(); }
+
+  _trim() {
+    while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+  }
+
+  async _isGitRepo() {
+    try {
+      await this.exec('git', ['rev-parse', '--is-inside-work-tree'], this.cwd ? { cwd: this.cwd } : {});
+      return true;
+    } catch { return false; }
+  }
+
+  async createSnapshot(label = '') {
+    const id = crypto.randomUUID().slice(0, 8);
+    const createdAt = this._now();
+    const safeLabel = String(label ?? '').trim() || `checkpoint-${id}`;
+    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}`;
+        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 };
+    this.snapshots.push(snap);
+    this._trim();
+    return snap;
+  }
+
+  listSnapshots() {
+    return [...this.snapshots].sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  getSnapshot(id) {
+    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;
+    }
+    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) {
+      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(()=>{});
+      }
+    }
+    return { rolledBack: true, snapshot: snap };
+  }
+
+  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;
+    // if to not given, diff against current HEAD/working tree
+    const inGit = await this._isGitRepo();
+    if (inGit && from.commit) {
+      try {
+        const range = to?.commit ? `${from.commit}..${to.commit}` : `${from.commit}..HEAD`;
+        const { stdout } = await this.exec('git', ['diff', '--stat', range], this.cwd ? { cwd: this.cwd } : {});
+        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 } : {});
+        return { from: fromId, to: toId || 'HEAD', diff: String(stdout ?? '').trim() || '(no changes)' };
+      } catch {}
+    }
+    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);
+    this._trim();
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@goodandready/dsh-time-machine",
+  "version": "0.1.1",
+  "description": "DSH plugin for smart checkpoints, workspace safety guards, and instant rollback",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "checkpoint",
+    "rollback",
+    "safety",
+    "git-snapshot"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GooDAnDReaDY/dsh-time-machine.git"
+  },
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-time-machine#readme",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-time-machine/issues"
+  },
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "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",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}