dsh-pause-resume 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 regrevia
+
+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

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# dsh-pause-resume
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+One button in the DeepSeek Harness session header. It stops everything that is running, and after a
+restart the same button puts that work back.
+
+* ⏸ — work is running. Press to stop it.
+* ▶ — work is stopped, or a previous run ended mid-turn. Press to restore it.
+* ⏸ dimmed — nothing to stop and nothing to restore.
+
+The glyph is the only status. There is no counter, no panel and no toast, because a status badge next
+to the button would be a second source of truth for the same fact.
+
+## What it restores
+
+| Work | Pause | Restore |
+| --- | --- | --- |
+| A session with an unfinished turn | turn cancelled, session recorded | session resumed |
+| An armed goal | paused, with its revision | resumed with the same revision; the goal driver continues on its own |
+| A running background job | killed and recorded | recorded only: a job is a live process, not replayable |
+| A terminal | untouched | untouched — that process is not the plugin's to end |
+| An open tab / finished session | untouched | untouched |
+
+A session that ended normally is never restored: the decision is made from the turn the session's log
+ends with, not from how the session list happens to colour it.
+
+## Crash, not just a press
+
+A press writes a snapshot. A crash writes nothing, so the plugin keeps a heartbeat instead:
+`running.json` holds the sessions whose turn is open right now and the id of the process that wrote
+it. A new process finds the previous one's heartbeat and offers ▶ with no press needed. The same
+process reloading the plugin (hot reload) sees its own id and knows there is nothing to restore.
+
+## Installing
+
+```bash
+plugin_manager install_bundle dsh-pause-resume
+```
+
+or install the bundle from the Harness plugin manager with the package name. The plugin needs no
+configuration and holds no credentials.
+
+## Guarantees and limits
+
+* **Exclusive.** The phase lives on the Host and is written before any work starts, so two windows,
+  a double press and a tool call cannot overlap. The second caller is told `busy`.
+* **Idempotent.** A restore journals every item it finished. A crash in the middle of a restore
+  continues with the remainder instead of restoring the same session twice.
+* **Honest.** Disk that cannot be written never reports `paused`. A session deleted by hand, a goal
+  changed by hand, a session already running: each is skipped and named in the outcome.
+* **Schedules are not paused.** The schedule service has no disable operation, only delete, and
+  deleting a person's schedule to pause it is not a trade this plugin makes. A schedule that fires
+  while paused starts a turn; the button then shows ⏸ again, truthfully.
+* **No third-party plugin state.** A plugin's in-process state belongs to that plugin's mount. There
+  is a seam for a plugin that owns durable state, but nothing is restored on someone else's behalf.
+* **No synthetic prompts.** Nothing is typed into a person's session on their behalf. A goal
+  continues because the Harness has a mechanism for that; a plain session is put back at the turn it
+  was interrupted in.
+
+## Files
+
+All state lives under `$DSH_HOME/pause-resume/`:
+
+| File | Purpose |
+| --- | --- |
+| `snapshot.json` | the work a press stopped |
+| `running.json` | sessions with an open turn, for crash residue |
+| `restore.jsonl` | restore steps already done |
+| `last-restore.json` | record of the last restore |
+
+Every write is temp file + `fsync` + `rename`. State is never inside the package.
+
+## Development
+
+```bash
+node --test --test-timeout=15000 'test/*.test.mjs'
+```
+
+`lib/engine.js` performs no I/O, `lib/snapshot.js` persists, `lib/probe.js` holds every Harness service
+contract (listing shape, goal addressing, per-owner jobs), and `index.js` only wires them to the web
+routes. All four are testable without a Harness: `test/apply.test.mjs` mounts the plugin against a fake
+registry and fails if a service call is stale, which is how the `{ items }` listing bug was caught.
+
+MIT.
+
+---
+
+一行说明：会话头一个按钮，⏸ 停掉正在跑的回合、目标与后台任务；重启后同一个按钮变 ▶，把上次的工作
+接回来。崩溃也能识别：靠心跳文件，不靠人按过按钮。日程不会被动（该服务只有删除，没有停用），
+后台命令只记录不重跑。

package/client.js

@@ -0,0 +1,191 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-pause-resume',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    const zh = /^zh/i.test(navigator.language || '')
+    const COPY = zh
+      ? { pause: '暂停', resume: '继续', busy: '正在处理' }
+      : { pause: 'Pause', resume: 'Resume', busy: 'Working' }
+
+    const HOST_BASE = '/dsh-pause-resume' // ui-copy-ignore
+    const POLL_MS = 2000 // ui-copy-ignore
+    const REQUEST_MS = 30000 // ui-copy-ignore
+
+    /**
+     * The glyph is the whole status, so it may not be guessed from anything the page can see: the
+     * Host owns the phase and this asks for it. Until an answer arrives the button renders the // ui-copy-ignore
+     * settled state (`none`), never a spinner, so a slow Host cannot look like a running press. // ui-copy-ignore
+     */
+    const EMPTY = { phase: 'idle', action: 'none', source: null, complete: null, counts: { sessions: 0, goals: 0, schedules: 0, jobs: 0 }, live: { sessions: 0, goals: 0, jobs: 0 }, error: null }
+
+    function withTimeout(promise, ms = REQUEST_MS) {
+      let id = null
+      const timer = new Promise((_resolve, reject) => {
+        id = setTimeout(() => reject(new Error('timeout')), ms) // ui-copy-ignore
+      })
+      return Promise.race([promise, timer]).finally(() => clearTimeout(id))
+    }
+
+    async function readState() {
+      try {
+        const response = await withTimeout(fetch(`${HOST_BASE}/state`, { cache: 'no-store', credentials: 'same-origin' }))
+        if (!response.ok) return null
+        const data = await withTimeout(response.json())
+        return data !== null && typeof data === 'object' ? data : null
+      } catch {
+        return null
+      }
+    }
+
+    async function press(action) {
+      try {
+        const response = await withTimeout(fetch(`${HOST_BASE}/${action}`, {
+          method: 'POST', // ui-copy-ignore
+          credentials: 'same-origin',
+          headers: { 'content-type': 'application/json', 'x-dsh-pause-resume': '1' }, // ui-copy-ignore
+          body: '{}', // ui-copy-ignore
+        }))
+        if (!response.ok) return null
+        const data = await withTimeout(response.json())
+        return data !== null && typeof data === 'object' ? data : null
+      } catch {
+        return null
+      }
+    }
+
+    // One style element for the whole page: the in-place spinner is the only motion, and it is
+    // defined once instead of on every render.
+    const STYLE_ID = 'dsh-pause-resume-style' // ui-copy-ignore
+    function ensureStyle() {
+      try {
+        if (document.getElementById(STYLE_ID) !== null) return
+        const style = document.createElement('style')
+        style.id = STYLE_ID
+        style.textContent = '@keyframes dsh-pr-spin{to{transform:rotate(360deg)}}'
+        document.head.appendChild(style)
+      } catch {}
+    }
+
+    const BUTTON_STYLE = {
+      display: 'inline-flex', // ui-copy-ignore
+      alignItems: 'center',
+      justifyContent: 'center',
+      width: 28, // ui-copy-ignore
+      height: 28, // ui-copy-ignore
+      padding: 0, // ui-copy-ignore
+      border: 'none', // ui-copy-ignore
+      borderRadius: 6,
+      background: 'transparent',
+      color: 'inherit', // ui-copy-ignore
+      cursor: 'pointer', // ui-copy-ignore
+      opacity: 0.75, // ui-copy-ignore
+      position: 'relative', // ui-copy-ignore
+    }
+
+    const DOT_STYLE = {
+      position: 'absolute', // ui-copy-ignore
+      top: 4, // ui-copy-ignore
+      right: 4, // ui-copy-ignore
+      width: 5, // ui-copy-ignore
+      height: 5, // ui-copy-ignore
+      borderRadius: '50%',
+      background: 'var(--dsh-color-danger, #d1242f)',
+    }
+
+    const SPIN_STYLE = { display: 'inline-flex', animation: 'dsh-pr-spin 900ms linear infinite' } // ui-copy-ignore
+
+    function icon(paths, extra) {
+      return h('svg', {
+        width: 16, height: 16, viewBox: '0 0 16 16', fill: 'none',
+        stroke: 'currentColor', strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round',
+        'aria-hidden': true, style: extra,
+      }, paths.map((d) => h('path', { key: d, d })))
+    }
+
+    const PAUSE_GLYPH = icon(['M6 3.5v9', 'M10 3.5v9'])
+    const PLAY_GLYPH = h('svg', {
+      width: 16, height: 16, viewBox: '0 0 16 16', fill: 'currentColor', 'aria-hidden': true,
+    }, h('path', { d: 'M5.2 3.4a.7.7 0 0 0-1.05.6v8a.7.7 0 0 0 1.05.6l6.9-4a.7.7 0 0 0 0-1.2l-6.9-4z' }))
+    const SPIN_GLYPH = icon(['M8 2.5a5.5 5.5 0 1 1-4.3 2.06'], SPIN_STYLE)
+
+    function Button() {
+      const [state, setState] = React.useState(EMPTY)
+      const [hover, setHover] = React.useState(false)
+      const mounted = React.useRef(true)
+
+      React.useEffect(() => {
+        ensureStyle()
+        mounted.current = true
+        let timer = null
+        const pull = async () => {
+          const next = await readState()
+          if (!mounted.current) return
+          if (next !== null) setState({ ...EMPTY, ...next })
+        }
+        pull()
+        timer = setInterval(() => {
+          if (document.visibilityState === 'visible') pull()
+        }, POLL_MS)
+        const onVisible = () => {
+          if (document.visibilityState === 'visible') pull()
+        }
+        document.addEventListener('visibilitychange', onVisible)
+        return () => {
+          mounted.current = false
+          if (timer !== null) clearInterval(timer)
+          document.removeEventListener('visibilitychange', onVisible)
+        }
+      }, [])
+
+      const busy = state.action === 'busy'
+      const action = state.action === 'pause' || state.action === 'resume' ? state.action : null
+      const disabled = action === null && !busy
+
+      const onClick = async () => {
+        if (busy || action === null) return
+        // The phase is set from the Host's answer, never optimistically: the spinner appears when // ui-copy-ignore
+        // the Host says it started, so two windows can never show different phases. // ui-copy-ignore
+        setState((current) => ({ ...current, action: 'busy' }))
+        const answer = await press(action)
+        const next = await readState()
+        if (!mounted.current) return
+        if (next !== null) setState({ ...EMPTY, ...next })
+        else if (answer === null) setState((current) => ({ ...current, action }))
+      }
+
+      const style = busy || disabled
+        ? { ...BUTTON_STYLE, opacity: 0.4 }
+        : hover
+          ? { ...BUTTON_STYLE, opacity: 1, background: 'var(--dsh-color-surface-hover, rgba(127,127,127,0.14))' }
+          : BUTTON_STYLE
+
+      const glyph = busy ? SPIN_GLYPH : action === 'resume' ? PLAY_GLYPH : PAUSE_GLYPH
+      const label = busy ? COPY.busy : action === 'resume' ? COPY.resume : COPY.pause
+
+      return h('button', {
+        type: 'button', // ui-copy-ignore
+        style,
+        onClick,
+        disabled,
+        'aria-label': label,
+        'aria-busy': busy,
+        onMouseEnter: () => setHover(true),
+        onMouseLeave: () => setHover(false),
+      }, glyph, state.error === null || state.error === undefined ? null : h('span', { style: DOT_STYLE, 'aria-hidden': true }))
+    }
+
+    return {
+      inject: ['slots'], // ui-copy-ignore
+      apply(ctx) {
+        ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+          name: 'conversation.session.header.utilities',
+          id: 'dsh-pause-resume', // ui-copy-ignore
+          order: 31, // ui-copy-ignore
+          label: () => COPY.pause, // ui-copy-ignore
+        }, Button))
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-pause-resume
+      name: 'dsh-pause-resume'

package/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" role="img" aria-label="Pause and resume">
+  <rect x="1" y="1" width="22" height="22" rx="6" fill="#1f6feb"/>
+  <rect x="6.5" y="6" width="3.2" height="12" rx="1.2" fill="#ffffff"/>
+  <path d="M13.2 6.6v10.8a.6.6 0 0 0 .92.5l8.06-5.4a.7.7 0 0 0 0-1.16l-8.06-5.4a.6.6 0 0 0-.92.5z" fill="#ffffff" fill-opacity="0.55"/>
+  <path d="M12.3 6.4v11.2a.5.5 0 0 0 .77.42l5.6-5.6a.6.6 0 0 0 0-.85l-5.6-5.6a.5.5 0 0 0-.77.42z" fill="#ffffff"/>
+</svg>

package/index.js

@@ -0,0 +1,213 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { createStore } from './lib/snapshot.js'
+import { createEngine } from './lib/engine.js'
+import { createHeartbeat } from './lib/heartbeat.js'
+import { createProbe, listRunning } from './lib/probe.js'
+
+export const name = 'dsh-pause-resume'
+export const VERSION = '0.1.0'
+
+const BASE_PATH = '/dsh-pause-resume'
+const BUTTON_HEADER = 'x-dsh-pause-resume'
+const BOOT_KEY = Symbol.for('dsh-pause-resume.boot')
+
+/** A page this machine may have opened. A public name that resolves here is the rebinding case. */
+const LOCAL_ADDRESS =
+  /^(127\.\d+\.\d+\.\d+|localhost|\[::1\]|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|169\.254\.\d+\.\d+|[a-z0-9-]+\.local)(:\d+)?$/u
+
+function log(message) {
+  try {
+    console.log(`[dsh-pause-resume] ${message}`)
+  } catch {
+    /* a closed stdout is not worth a throw */
+  }
+}
+
+function dataDir() {
+  const home = typeof process.env.DSH_HOME === 'string' && process.env.DSH_HOME !== '' ? process.env.DSH_HOME : join(homedir(), '.dsh')
+  return join(home, 'pause-resume')
+}
+
+/** One id per process: a reload of this plugin is the same process and the same boot. */
+function bootId() {
+  const existing = globalThis[BOOT_KEY]
+  if (typeof existing === 'string') return existing
+  const created = `${process.pid}-${Date.now().toString(36)}`
+  globalThis[BOOT_KEY] = created
+  return created
+}
+
+
+function service(ctx, key) {
+  try {
+    return ctx.get(key)
+  } catch {
+    return undefined
+  }
+}
+
+function sendJson(res, status, value) {
+  try {
+    const body = JSON.stringify(value ?? { status: 'error' })
+    if (res?.headersSent === true) return res.end()
+    res.writeHead(status, {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'no-store',
+      'content-length': Buffer.byteLength(body),
+    })
+    res.end(body)
+  } catch {
+    try {
+      if (res?.writableEnded !== true && res?.destroyed !== true) res.end()
+    } catch {
+      /* the socket is already gone */
+    }
+  }
+}
+
+/** Whether one request may act for the button: a header a cross-site form cannot set, same origin. */
+function buttonAllowed(req) {
+  try {
+    const header = req?.headers?.[BUTTON_HEADER]
+    if (typeof header !== 'string' || header === '') return false
+    const site = typeof req?.headers?.host === 'string' ? req.headers.host.trim().toLowerCase() : '' // ui-copy-ignore
+    if (site !== '' && LOCAL_ADDRESS.test(site) === false) return false
+    const origin = typeof req?.headers?.origin === 'string' ? req.headers.origin.trim().toLowerCase() : ''
+    if (origin === 'null') return false
+    if (origin !== '') {
+      let originSite = ''
+      try {
+        originSite = new URL(origin).host.toLowerCase() // ui-copy-ignore
+      } catch {
+        return false
+      }
+      if (originSite !== site) return false
+    }
+    return true
+  } catch {
+    return false
+  }
+}
+
+function guard(handler) {
+  return (req, res) => {
+    const fallback = (error) => {
+      log(`route failed: ${error?.message ?? error}`)
+      try {
+        if (res?.headersSent !== true) sendJson(res, 503, { status: 'error' })
+        else if (res?.writableEnded !== true && res?.destroyed !== true) res.end()
+      } catch {
+        /* already answered */
+      }
+    }
+    try {
+      const answer = handler(req, res)
+      if (answer !== null && typeof answer === 'object' && typeof answer.then === 'function') answer.then(undefined, fallback)
+      return answer
+    } catch (error) {
+      fallback(error)
+      return undefined
+    }
+  }
+}
+
+function serve(ctx, engine, heartbeat) {
+  const server = service(ctx, 'webServer')
+  if (server === undefined || server === null || typeof server.register !== 'function') {
+    log('no web server: the header button cannot ask for a pause')
+    return () => {}
+  }
+  const handlers = [
+    [
+      `${BASE_PATH}/state`,
+      async (req, res) => {
+        const method = String(req?.method ?? 'GET').toUpperCase()
+        if (method !== 'GET' && method !== 'HEAD') return sendJson(res, 405, { status: 'method' })
+        sendJson(res, 200, await engine.describe())
+      },
+    ],
+    [
+      `${BASE_PATH}/pause`,
+      async (req, res) => {
+        const method = String(req?.method ?? 'GET').toUpperCase()
+        if (method !== 'POST') return sendJson(res, 405, { status: 'method' })
+        if (buttonAllowed(req) === false) return sendJson(res, 403, { status: 'forbidden' })
+        const outcome = await engine.pause()
+        log(`pause: ${outcome.status}${outcome.status === 'busy' ? ` (${outcome.phase})` : ''}`)
+        if (outcome.status === 'paused') heartbeat.release()
+        sendJson(res, 200, { ...(await engine.describe()), outcome })
+      },
+    ],
+    [
+      `${BASE_PATH}/resume`,
+      async (req, res) => {
+        const method = String(req?.method ?? 'GET').toUpperCase()
+        if (method !== 'POST') return sendJson(res, 405, { status: 'method' })
+        if (buttonAllowed(req) === false) return sendJson(res, 403, { status: 'forbidden' })
+        const outcome = await engine.resume()
+        log(`resume: ${outcome.status}`)
+        if (outcome.status === 'resumed') heartbeat.release()
+        sendJson(res, 200, { ...(await engine.describe()), outcome })
+      },
+    ],
+  ]
+  const disposers = []
+  for (const [path, handler] of handlers) {
+    try {
+      const dispose = server.register({ kind: 'exact', path, handler: guard(handler) })
+      if (typeof dispose === 'function') disposers.push(dispose)
+    } catch (error) {
+      log(`cannot answer ${path}: ${error?.message ?? error}`)
+    }
+  }
+  return () => {
+    for (const dispose of disposers) {
+      try {
+        dispose()
+      } catch {}
+    }
+  }
+}
+
+export function apply(ctx, config = {}) {
+  const dir = dataDir()
+  const store = createStore(dir)
+  const heartbeat = createHeartbeat({
+    dir,
+    bootId: bootId(),
+    listRunning: () => listRunning(ctx),
+    log,
+  })
+  const engine = createEngine({
+    store,
+    probe: createProbe(ctx, heartbeat),
+    graceMs: Number.isFinite(config?.graceMs) ? config.graceMs : 2000,
+    gapMs: Number.isFinite(config?.gapMs) ? config.gapMs : 150,
+    log,
+  })
+
+  let disposeRoutes = () => {}
+  const cleanup = () => {
+    try {
+      disposeRoutes()
+    } catch {}
+    heartbeat.stop()
+  }
+
+  if (typeof ctx.effect === 'function') ctx.effect(() => cleanup)
+  else if (typeof ctx.on === 'function') ctx.on('dispose', cleanup)
+
+  void (async () => {
+    try {
+      await engine.hydrate()
+      heartbeat.start()
+      disposeRoutes = serve(ctx, engine, heartbeat)
+      log(`ready (${engine.phase})`)
+    } catch (error) {
+      log(`cannot start: ${error?.message ?? error}`)
+    }
+  })()
+
+  return { store, engine, heartbeat }
+}

package/lib/engine.js

@@ -0,0 +1,219 @@
+/**
+ * The only place the button's shape comes from.
+ *
+ * One phase value, written before any work starts and after it ends, plus a durable snapshot. The
+ * two transient phases are exclusive by construction: `pause()` and `resume()` refuse while either
+ * is set, so two windows, a double press and a tool call can never overlap. The client is not
+ * allowed to infer a phase: it asks, and renders the answer.
+ *
+ * The engine performs no I/O of its own. `store` persists, `probe` reads and acts on the running
+ * Harness, so every transition here is testable without a Harness.
+ */
+
+const TRANSIENT = new Set(['pausing', 'resuming'])
+
+export function createEngine({ store, probe, now = () => Date.now(), graceMs = 2000, gapMs = 150, log = () => {} }) {
+  let phase = 'idle'
+  let lastError = null
+  let result = null
+  /** Set while a press runs, so a second caller joins the answer instead of starting work again. */
+  let inflight = null
+
+  const emptyLive = { sessions: [], goals: [], schedules: [], jobs: [], terminals: [] }
+
+  function pendingSnapshot() {
+    const snapshot = store.read()
+    // `pausing` is included on purpose: it means the last press stopped halfway, so the work in it
+    // still has to be restored. Reporting it as nothing to restore would hide a half-done pause.
+    return snapshot
+  }
+
+  async function live() {
+    try {
+      const value = await probe.live()
+      return { ...emptyLive, ...(value ?? {}) }
+    } catch (error) {
+      log(`cannot read live work: ${error?.message ?? error}`)
+      return emptyLive
+    }
+  }
+
+  async function crashPlan() {
+    try {
+      const plan = await probe.crashPlan()
+      return plan ?? null
+    } catch (error) {
+      log(`cannot read crash residue: ${error?.message ?? error}`)
+      return null
+    }
+  }
+
+  function countsOf(plan) {
+    if (plan === null || plan === undefined) return { sessions: 0, goals: 0, schedules: 0, jobs: 0 }
+    return {
+      sessions: Array.isArray(plan.sessions) ? plan.sessions.length : 0,
+      goals: Array.isArray(plan.goals) ? plan.goals.length : 0,
+      schedules: Array.isArray(plan.schedules) ? plan.schedules.length : 0,
+      jobs: Array.isArray(plan.jobs) ? plan.jobs.length : 0,
+    }
+  }
+
+  /**
+   * What the button shows. `action` is the one decision the client may not make itself:
+   * `none` (nothing to do), `pause`, `resume`, or `busy` (an operation is running).
+   */
+  async function describe() {
+    const snapshot = pendingSnapshot()
+    const current = await live()
+    const plan = snapshot ?? (await crashPlan())
+    const busy = TRANSIENT.has(phase)
+    const canPause = !busy && current.sessions.length + current.goals.length > 0
+    const action = busy ? 'busy' : plan !== null ? 'resume' : canPause ? 'pause' : 'none'
+    return {
+      phase,
+      action,
+      source: plan === null ? null : plan.status === 'pausing' ? 'crash' : snapshot !== null ? 'pause' : plan.source ?? 'crash',
+      complete: plan === null ? null : plan.status === 'paused',
+      counts: countsOf(plan), // ui-copy-ignore
+      live: { // ui-copy-ignore
+        sessions: current.sessions.length,
+        goals: current.goals.length,
+        jobs: current.jobs.length,
+      },
+      error: lastError, // ui-copy-ignore
+      result,
+    }
+  }
+
+  function snapshotOf(current) {
+    return {
+      version: 1, // ui-copy-ignore
+      status: 'pausing', // ui-copy-ignore
+      createdAt: new Date(now()).toISOString(),
+      sessions: current.sessions, // ui-copy-ignore
+      goals: current.goals, // ui-copy-ignore
+      schedules: current.schedules,
+      jobs: current.jobs, // ui-copy-ignore
+      terminals: current.terminals,
+    }
+  }
+
+  async function runPause() {
+    const current = await live()
+    if (current.sessions.length === 0 && current.goals.length === 0) {
+      phase = 'idle'
+      return { status: 'idle', action: 'none' }
+    }
+    lastError = null
+    // The snapshot exists before anything is stopped: a crash between the two is then visible as
+    // `pausing` on the next boot instead of being reported as a clean pause.
+    const draft = snapshotOf(current)
+    if (store.write(draft) === null) {
+      phase = 'idle'
+      lastError = 'store'
+      return { status: 'failed', reason: 'store' }
+    }
+    let stopped = null
+    try {
+      stopped = await probe.stop(current, { graceMs })
+    } catch (error) {
+      log(`stopping work failed: ${error?.message ?? error}`)
+      stopped = { canceled: [], unknown: [] }
+    }
+    draft.status = 'paused'
+    draft.stoppedAt = new Date(now()).toISOString()
+    draft.stopped = stopped
+    if (store.write(draft) === null) {
+      // The durable copy still says `pausing`, which is the truth: the next boot reports it.
+      lastError = 'store'
+    }
+    phase = 'paused'
+    const counts = countsOf(draft)
+    return { status: 'paused', counts }
+  }
+
+  async function runResume(plan) {
+    lastError = null
+    const done = store.readJournal()
+    const summary = { restored: [], skipped: [], failed: [], jobs: countsOf(plan).jobs }
+    const mark = (key) => {
+      store.appendJournal(key)
+      done.add(key)
+    }
+    const step = async (key, label, run) => {
+      if (done.has(key)) return
+      try {
+        const outcome = await run()
+        if (outcome === 'restored') summary.restored.push(label)
+        else summary.skipped.push(label)
+      } catch (error) {
+        summary.failed.push(`${label}: ${String(error?.message ?? error).slice(0, 120)}`)
+      }
+      mark(key)
+    }
+
+    for (const session of plan.sessions ?? []) {
+      await step(`s:${session.sessionId}`, `session ${session.sessionId}`, () => probe.restoreSession(session, { plan }))
+    }
+    for (const goal of plan.goals ?? []) {
+      await step(`g:${goal.goalId ?? goal.sessionId}`, `goal ${goal.goalId ?? goal.sessionId}`, () => probe.restoreGoal(goal, { plan }))
+    }
+    for (const schedule of plan.schedules ?? []) {
+      await step(`c:${schedule.id}`, `schedule ${schedule.id}`, () => probe.restoreSchedule(schedule, { plan }))
+    }
+    store.consume(summary)
+    store.clearJournal()
+    result = summary
+    phase = 'idle'
+    return { status: 'resumed', summary }
+  }
+
+  /** Join a press already running: the second caller is told it is busy and never starts work again. */
+  function once(kind, run) {
+    if (inflight !== null) return Promise.resolve({ status: 'busy', phase })
+    const running = (async () => {
+      try {
+        return await run()
+      } catch (error) {
+        log(`${kind} failed: ${error?.message ?? error}`)
+        lastError = 'internal'
+        phase = 'idle'
+        return { status: 'failed', reason: 'internal' }
+      } finally {
+        inflight = null
+      }
+    })()
+    inflight = running
+    return running
+  }
+
+  async function pause() {
+    if (TRANSIENT.has(phase) || inflight !== null) return { status: 'busy', phase }
+    if (phase === 'paused') return { status: 'already' }
+    // Set synchronously, before the first await: two windows pressing at once are then exclusive
+    // in the same tick they were dispatched, not one microtask later.
+    phase = 'pausing'
+    return once('pause', runPause)
+  }
+
+  async function resume() {
+    if (TRANSIENT.has(phase) || inflight !== null) return { status: 'busy', phase }
+    phase = 'resuming'
+    return once('resume', async () => {
+      const plan = pendingSnapshot() ?? (await crashPlan())
+      if (plan === null) {
+        phase = 'idle'
+        return { status: 'empty' }
+      }
+      return runResume(plan)
+    })
+  }
+
+  /** A reload of this plugin must not invent a phase: the disk and the running Harness decide it. */
+  async function hydrate() {
+    // A reloaded plugin must not invent a phase: the disk decides whether work is still stopped.
+    phase = pendingSnapshot() !== null ? 'paused' : 'idle'
+  }
+
+  return { describe, pause, resume, hydrate, get phase() { return phase }, pendingSnapshot, gapMs }
+}

package/lib/heartbeat.js

@@ -0,0 +1,95 @@
+import { mkdirSync, openSync, closeSync, fsyncSync, readFileSync, renameSync, writeSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Crash residue without reading logs.
+ *
+ * A snapshot only exists because a person pressed the button. A crash has no press, so this file
+ * answers the other half: which sessions had a turn running a few seconds ago. It is written on a
+ * timer from the same list the button already reads, and only when the set changes.
+ *
+ * The file carries the id of the process that wrote it. The same process reloading the plugin (HMR)
+ * therefore sees its own heartbeat and nothing to restore, while a new process sees the previous
+ * one's and offers ▶.
+ */
+export function createHeartbeat({ dir, bootId, intervalMs = 5000, listRunning, now = () => Date.now(), log = () => {} }) {
+  const file = join(dir, 'running.json')
+  let timer = null
+  let last = ''
+  let residue = null
+  let stopped = false
+
+  function write(sessions) {
+    const body = JSON.stringify({ version: 1, bootId, updatedAt: now(), sessions })
+    try {
+      mkdirSync(dir, { recursive: true })
+      const tmp = `${file}.${process.pid}.tmp`
+      const fd = openSync(tmp, 'w')
+      try {
+        writeSync(fd, body)
+        fsyncSync(fd)
+      } finally {
+        closeSync(fd)
+      }
+      renameSync(tmp, file)
+      return true
+    } catch (error) {
+      log(`cannot record running sessions: ${error?.message ?? error}`)
+      return false
+    }
+  }
+
+  /** Claims the previous process's heartbeat once, at start, before this process overwrites it. */
+  function capture() {
+    try {
+      const parsed = JSON.parse(readFileSync(file, 'utf8'))
+      if (parsed === null || typeof parsed !== 'object' || parsed.version !== 1) return null
+      if (typeof parsed.bootId === 'string' && parsed.bootId === bootId) return null
+      const sessions = Array.isArray(parsed.sessions) ? parsed.sessions.filter((row) => typeof row?.sessionId === 'string') : []
+      if (sessions.length === 0) return null
+      residue = { sessions, at: typeof parsed.updatedAt === 'number' ? parsed.updatedAt : null }
+      return residue
+    } catch {
+      return null
+    }
+  }
+
+  async function tick() {
+    if (stopped || residue !== null) return
+    let sessions
+    try {
+      sessions = await listRunning()
+    } catch (error) {
+      log(`cannot list running sessions: ${error?.message ?? error}`)
+      return
+    }
+    const body = JSON.stringify(sessions.map((sessionId) => ({ sessionId })))
+    if (body === last) return
+    last = body
+    write(sessions.map((sessionId) => ({ sessionId })))
+  }
+
+  function start() {
+    if (stopped || timer !== null) return
+    capture()
+    void tick()
+    timer = setInterval(() => void tick(), intervalMs)
+    if (typeof timer.unref === 'function') timer.unref()
+  }
+
+  /** The residue was restored: from here on the heartbeat describes this process again. */
+  function release() {
+    residue = null
+    last = ''
+    write([])
+  }
+
+  function stop() {
+    stopped = true
+    if (timer !== null) clearInterval(timer)
+    timer = null
+    if (residue === null) write([])
+  }
+
+  return { start, stop, release, get residue() { return residue } }
+}

package/lib/probe.js

@@ -0,0 +1,238 @@
+/**
+ * What the Harness is doing right now, and how to stop one piece of it without losing the pieces
+ * behind it. Only service contracts are used here, and every service is reached through the
+ * registry this module is given: one that is missing, or that answers nothing, is a smaller set of
+ * work rather than a failed press.
+ */
+
+function service(services, key) {
+  try {
+    return services.get(key)
+  } catch {
+    return undefined
+  }
+}
+
+function agentOf(services, sessionId) {
+  const agents = service(services, 'agents')
+  if (agents === undefined || agents === null || typeof agents.get !== 'function') return undefined
+  try {
+    const handle = agents.get(sessionId)
+    if (handle === undefined || handle === null) return undefined
+    return handle.agent ?? handle
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Live agents are the cheap truth for "who is attached right now": a couple of dozen handles in
+ * memory, against a listing that walks every session ever recorded on disk. It answers `undefined`
+ * when the registry cannot be read, so the listing stays the fallback rather than a second opinion.
+ */
+function agentsOf(services) {
+  const agents = service(services, 'agents')
+  if (agents === undefined || agents === null || typeof agents.list !== 'function') return undefined
+  try {
+    const handles = agents.list()
+    if (!Array.isArray(handles)) return undefined
+    const live = handles.map((handle) => handle?.agent ?? handle).filter((agent) => agent !== null && typeof agent?.id === 'string')
+    return live
+  } catch {
+    return undefined
+  }
+}
+
+/** One row per attached agent: running says whether its turn is open, and every one is attached. */
+async function attachedRows(services) {
+  const agents = agentsOf(services)
+  if (agents !== undefined) {
+    return agents.map((agent) => ({ sessionId: agent.id, running: agent.status === 'running', agentAvailable: true }))
+  }
+  const rows = await listSessions(services)
+  return rows.filter((row) => row.running === true || row.agentAvailable === true)
+}
+
+/** The session ids whose turn is open right now: the heartbeat's only question. */
+export async function listRunning(services) {
+  const agents = agentsOf(services)
+  if (agents !== undefined) return agents.filter((agent) => agent.status === 'running').map((agent) => agent.id)
+  const rows = await listSessions(services)
+  return rows.filter((row) => row.running === true).map((row) => row.sessionId)
+}
+
+/**
+ * The goal service addresses one live agent, and every agent it accepts names itself by session
+ * id, so a session id is the whole handle. It throws for an agent that is not live: that is the
+ * ordinary answer for a closed session, not an error worth surfacing.
+ */
+function goalAgent(sessionId) {
+  return { id: sessionId }
+}
+
+async function goalOf(services, sessionId) {
+  const goals = service(services, 'goals')
+  if (goals === undefined || goals === null || typeof goals.get !== 'function') return undefined
+  try {
+    const view = await goals.get(goalAgent(sessionId))
+    return view === undefined || view === null ? undefined : view
+  } catch {
+    return undefined
+  }
+}
+
+/** The listing service answers `{ items }` through its remote facade and a bare array in tests. */
+async function listSessions(services) {
+  const controller = service(services, 'sessionController')
+  if (controller === undefined || controller === null || typeof controller.list !== 'function') return []
+  const value = await controller.list({})
+  const rows = Array.isArray(value) ? value : value?.items ?? value?.sessions ?? []
+  return rows.filter((row) => row !== null && typeof row?.sessionId === 'string')
+}
+
+/**
+ * Owned jobs are invisible to a caller-less `list`, so every attached session is asked for its own
+ * bucket as well. One job can only be owned by one session, and the id map keeps the union exact.
+ */
+function listJobs(services, owners = []) {
+  const jobs = service(services, 'jobs')
+  if (jobs === undefined || jobs === null || typeof jobs.list !== 'function') return []
+  const seen = new Map()
+  const collect = (rows) => {
+    if (!Array.isArray(rows)) return
+    for (const row of rows) if (row !== null && typeof row?.id === 'string' && !seen.has(row.id)) seen.set(row.id, row)
+  }
+  try {
+    collect(jobs.list())
+  } catch {
+    // An unusable registry contributes nothing; the state shows no jobs.
+  }
+  for (const owner of owners) {
+    try {
+      collect(jobs.list(owner))
+    } catch {
+      // A bucket that cannot be read is not work this press can stop.
+    }
+  }
+  return [...seen.values()]
+}
+
+/**
+ * The Harness half of the plugin: what is running now, how to stop it, how to put it back. Every
+ * method answers `restored` / `skipped` rather than throwing, because one item that cannot be put
+ * back must not stop the items behind it.
+ */
+export function createProbe(services, heartbeat) {
+  const graceMs = 1500
+
+  async function live() {
+    const attached = await attachedRows(services)
+    const views = await Promise.all(attached.map((row) => goalOf(services, row.sessionId)))
+    const sessions = []
+    const goals = []
+    attached.forEach((row, index) => {
+      const running = row.running === true
+      const goal = views[index]
+      const active = goal !== undefined && goal.phase === 'active'
+      // A session is part of the work in two cases only: a turn is running, or a goal is armed and
+      // can start one. A session the person merely has open is a tab, not work.
+      if (running || active) sessions.push({ sessionId: row.sessionId, running })
+      if (active) goals.push({ sessionId: row.sessionId, goalId: goal.id, revision: goal.revision })
+    })
+    const jobs = listJobs(services, attached.map((row) => row.sessionId))
+      .filter((job) => job.status === 'running' || job.status === 'stopping')
+      .map((job) => ({ id: job.id, label: job.label ?? job.kind ?? '', owner: job.owner }))
+    return { sessions, goals, schedules: [], jobs, terminals: [] }
+  }
+
+  async function stop(current, { graceMs: grace } = {}) {
+    const controller = service(services, 'sessionController')
+    const goals = service(services, 'goals')
+    const jobs = service(services, 'jobs')
+    const canceled = []
+    const unknown = []
+
+    for (const session of current.sessions ?? []) {
+      if (session.running !== true) continue
+      try {
+        controller?.cancel?.({ sessionId: session.sessionId })
+        canceled.push(session.sessionId)
+      } catch (error) {
+        unknown.push(`session ${session.sessionId}: ${String(error?.message ?? error).slice(0, 80)}`)
+      }
+    }
+    for (const goal of current.goals ?? []) {
+      try {
+        await goals?.pause?.(goalAgent(goal.sessionId), { id: goal.goalId, revision: goal.revision })
+      } catch (error) {
+        unknown.push(`goal ${goal.goalId}: ${String(error?.message ?? error).slice(0, 80)}`)
+      }
+    }
+    for (const job of current.jobs ?? []) {
+      try {
+        jobs?.kill?.(job.id, job.owner)
+      } catch {
+        try {
+          jobs?.kill?.(job.id)
+        } catch (error) {
+          unknown.push(`job ${job.id}: ${String(error?.message ?? error).slice(0, 80)}`)
+        }
+      }
+    }
+
+    // A turn ends when its tools return: the press waits a bounded moment for that instead of
+    // claiming a stop that has not happened yet.
+    const deadline = Date.now() + (grace ?? graceMs)
+    let pending = current.sessions?.filter((session) => session.running === true).map((session) => session.sessionId) ?? []
+    while (pending.length > 0 && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 80))
+      const stillRunning = new Set(await listRunning(services).catch(() => []))
+      pending = pending.filter((id) => stillRunning.has(id))
+    }
+    for (const id of pending) unknown.push(`session ${id}: still running`)
+    return { canceled, unknown }
+  }
+
+  async function rearm(sessionId) {
+    const goals = service(services, 'goals')
+    const goal = await goalOf(services, sessionId)
+    if (goal === undefined) return false
+    if (goal.phase === 'active' && goal.activation !== 'armed') {
+      goals?.resume?.(goalAgent(sessionId), { id: goal.id, revision: goal.revision })
+      return true
+    }
+    return false
+  }
+
+  async function restoreSession(session) {
+    const agents = service(services, 'agents')
+    if (agents === undefined || agents === null || typeof agents.resume !== 'function') throw new Error('agents unavailable')
+    if (agentOf(services, session.sessionId) !== undefined) return 'skipped'
+    await agents.resume({ resumeSessionId: session.sessionId })
+    await rearm(session.sessionId)
+    return 'restored'
+  }
+
+  async function restoreGoal(goal) {
+    const goals = service(services, 'goals')
+    const view = await goalOf(services, goal.sessionId)
+    if (view === undefined || view.id !== goal.goalId) return 'skipped'
+    if (view.phase === 'active') return (await rearm(goal.sessionId)) ? 'restored' : 'skipped'
+    // The revision is the person's veto: a goal they changed by hand is not resurrected.
+    if (view.phase !== 'paused' || view.revision !== goal.revision) return 'skipped'
+    goals?.resume?.(goalAgent(goal.sessionId), { id: view.id, revision: view.revision })
+    return 'restored'
+  }
+
+  async function crashPlan() {
+    const captured = heartbeat.residue
+    if (captured === null) return null
+    const rows = await listSessions(services)
+    const existing = new Set(rows.map((row) => row.sessionId))
+    const sessions = captured.sessions.filter((row) => existing.has(row.sessionId)).map((row) => ({ sessionId: row.sessionId, running: true }))
+    if (sessions.length === 0) return null
+    return { version: 1, status: 'paused', source: 'crash', sessions, goals: [], schedules: [], jobs: [], terminals: [] }
+  }
+
+  return { live, stop, restoreSession, restoreGoal, restoreSchedule: async () => 'skipped', crashPlan }
+}

package/lib/snapshot.js

@@ -0,0 +1,133 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * The one durable fact this plugin owns: a snapshot of the work a press stopped, plus a journal
+ * of what the following restore already put back.
+ *
+ * Every write is temp-file + fsync + rename, so a reader never sees half a snapshot and a crash
+ * leaves the previous complete one in place. Nothing here throws: a disk that cannot be written
+ * is reported as `null`, and the caller decides to stay in its current phase instead of claiming
+ * a state it could not record.
+ */
+export function createStore(dir) {
+  const file = join(dir, 'snapshot.json')
+  const journal = join(dir, 'restore.jsonl')
+  const consumed = join(dir, 'last-restore.json')
+  let ready = false
+
+  function ensure() {
+    if (ready) return true
+    try {
+      mkdirSync(dir, { recursive: true })
+      ready = true
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  function read() {
+    try {
+      const raw = readFileSync(file, 'utf8')
+      const parsed = JSON.parse(raw)
+      if (parsed === null || typeof parsed !== 'object') return null
+      if (parsed.version !== 1) return null
+      if (parsed.status !== 'paused' && parsed.status !== 'pausing') return null
+      return parsed
+    } catch {
+      return null
+    }
+  }
+
+  function write(value) {
+    if (!ensure()) return null
+    const body = JSON.stringify({ ...value, version: 1 })
+    const tmp = `${file}.${process.pid}.tmp`
+    let fd = null
+    try {
+      fd = openSync(tmp, 'w')
+      writeSync(fd, body)
+      fsyncSync(fd)
+      closeSync(fd)
+      fd = null
+      renameSync(tmp, file)
+      return value
+    } catch {
+      if (fd !== null) {
+        try {
+          closeSync(fd)
+        } catch {}
+      }
+      try {
+        rmSync(tmp, { force: true })
+      } catch {}
+      return null
+    }
+  }
+
+  /** The snapshot is spent: the same press must not restore the same work twice. */
+  function consume(summary) {
+    if (!ensure()) return null
+    try {
+      const current = read()
+      const record = current === null ? { status: 'restored' } : { ...current, status: 'restored', restoredAt: new Date().toISOString(), summary }
+      const tmp = `${consumed}.${process.pid}.tmp`
+      writeSync(openSync(tmp, 'w'), JSON.stringify(record))
+      renameSync(tmp, consumed)
+    } catch {}
+    try {
+      rmSync(file, { force: true })
+    } catch {}
+    return summary
+  }
+
+  /** Journals are append-only lines of `{"k":"s:<id>"}`; a torn last line is dropped on read. */
+  function readJournal() {
+    const done = new Set()
+    let raw = ''
+    try {
+      raw = readFileSync(journal, 'utf8')
+    } catch {
+      return done
+    }
+    for (const line of raw.split('\n')) {
+      if (line === '') continue
+      try {
+        const row = JSON.parse(line)
+        if (typeof row?.k === 'string') done.add(row.k)
+      } catch {}
+    }
+    return done
+  }
+
+  function appendJournal(key) {
+    if (!ensure()) return false
+    try {
+      writeSync(openSync(journal, 'a'), `${JSON.stringify({ k: key })}\n`)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  function clearJournal() {
+    try {
+      rmSync(journal, { force: true })
+    } catch {}
+  }
+
+  function lastRestore() {
+    try {
+      return JSON.parse(readFileSync(consumed, 'utf8'))
+    } catch {
+      return null
+    }
+  }
+
+  function hasSnapshot() {
+    return existsSync(file)
+  }
+
+  return { dir, file, read, write, consume, readJournal, appendJournal, clearJournal, lastRestore, hasSnapshot }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Pause and Resume",
+    "description": "One header button stops every running turn and goal and puts the same work back on the next boot."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "暂停与恢复",
+    "description": "一个按钮停下所有在跑的回合与目标，下次启动把它们放回去。"
+  }
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "dsh-pause-resume",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "One header button stops every running turn and goal, writes a snapshot, and puts the same work back on the next boot; the button's shape is the only status.",
+  "license": "MIT",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "lib/*.js",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis",
+    "pause",
+    "resume",
+    "snapshot",
+    "crash-recovery"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regrevia/dsh-pause-resume.git"
+  },
+  "homepage": "https://github.com/regrevia/dsh-pause-resume#readme",
+  "bugs": {
+    "url": "https://github.com/regrevia/dsh-pause-resume/issues"
+  },
+  "engines": {
+    "dsh": ">=0.2.0-rc.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "audit": "eslint --no-config-lookup --rule '{\"no-undef\":\"error\",\"no-unused-vars\":[\"error\",{\"args\":\"none\",\"caughtErrors\":\"none\"}]}' --global window --global performance --global document --global navigator --global location --global sessionStorage --global localStorage --global fetch --global Response --global Request --global URL --global URLSearchParams --global AbortController --global CustomEvent --global Event --global setTimeout --global clearTimeout --global setInterval --global clearInterval --global requestAnimationFrame --global queueMicrotask --global structuredClone --global Buffer --global process --global console index.js client.js lib/*.js"
+  },
+  "devDependencies": {
+    "eslint": "9.39.0"
+  }
+}