dsh-session-guard 0.4.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-guard",
-  "version": "0.4.0",
+  "version": "3.0.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
@@ -78,6 +78,7 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-client-locale": ">=0.1.5-rc.2 <0.2.0-0",
+    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.5-rc.2 <0.2.0-0",
     "@deepseek-ai/dsh-client-ui-settings": ">=0.1.5-rc.2 <0.2.0-0",
     "@deepseek-ai/dsh-client-ui-slots": ">=0.1.5-rc.2 <0.2.0-0"
   },
@@ -88,6 +89,9 @@
     "@deepseek-ai/dsh-client-locale": {
       "optional": true
     },
+    "@deepseek-ai/dsh-client-ui-renderer": {
+      "optional": true
+    },
     "@deepseek-ai/dsh-client-ui-settings": {
       "optional": true
     },

package/src/bridge.js

@@ -1,136 +1,136 @@
-/**
- * dsh-session-guard — sessionGuard 冗余端口（D5/D6/D8）。
- *
- * `ctx.provide('sessionGuard', service)`：
- * - stopNextTurn / resume：会话门（透传 taskControl，或回退锁队列）。
- * - lockQueue / unlockQueue：显式队列锁（供 input-traffic 冻结按钮桥接，
- *   或未来手动触发）。
- * - state(sessionId)：{ queueLocked, lockReason, taskControlAvailable, taskControl }。
- *
- * input-traffic（方案 A，基于 feat/absorb-auto-continue 分支改造）在冻结按钮
- * 触发时调用 stopNextTurn；本服务不存在时 input-traffic 静默跳过（fail-open，D8）。
- */
-import { idleState } from './store.js'
-
-/**
- * @param {object} ctx host context
- * @param {ReturnType<import('./gate.js').createGate>} gate
- * @param {ReturnType<import('./store.js').createStore>} store
- * @param {ReturnType<import('./pause-gate.js').createPauseGate>} [pauseGate]
- * @param {ReturnType<import('./step-gate.js').createStepGate>} [stepGate] step 级门控（v0.2.0）
- */
-export function createBridge(ctx, gate, store, pauseGate, stepGate) {
-  function taskControlState(sessionId) {
-    let tcState = null
-    try {
-      const tc = ctx && typeof ctx.get === 'function' ? ctx.get('taskControl') : undefined
-      if (tc && typeof tc.state === 'function') {
-        const s = tc.state(sessionId)
-        tcState = {
-          status: s && s.status,
-          paused: !!(s && s.paused),
-          forced: !!(s && s.forced),
-        }
-      }
-    } catch {
-      /* 状态读取失败 → 保持 null，fail-open */
-    }
-    return tcState
-  }
-
-  return {
-    /** 停掉 session 下一回合（会话门 / 回退锁队列）。 */
-    stopNextTurn(sessionId, opts) {
-      return gate.stopNextTurn(sessionId, opts)
-    },
-    /** 恢复。 */
-    resume(sessionId, opts) {
-      return gate.resume(sessionId, opts)
-    },
-    /** 显式锁队列（手动触发）。 */
-    lockQueue(sessionId, reason = 'manual') {
-      const next = gate.lockQueue(sessionId, reason)
-      return { ok: true, state: next }
-    },
-    /** 显式解锁队列。 */
-    unlockQueue(sessionId) {
-      const next = gate.unlockQueue(sessionId)
-      return { ok: true, state: next }
-    },
-    /**
-     * 手动请求 step 级暂停（「暂停会话」按钮）。
-     * 不打断当前 step：在下一次 `agent/pre-step` 边界拉门（step 1 也拦，且不受峰谷/provider 限制）。
-     * @param {string} sessionId
-     */
-    stepPause(sessionId) {
-      if (!stepGate || typeof stepGate.requestPause !== 'function') {
-        return { requested: false, held: false, reason: 'no-step-gate' }
-      }
-      try {
-        return stepGate.requestPause(sessionId)
-      } catch {
-        return { requested: false, held: false, reason: 'error' }
-      }
-    },
-    /**
-     * 解开 step 门（v0.2.0）：放行被挂起的 step。
-     * 默认 `bypass=true`（用户手动「继续」）——本高峰窗口内不再拦该会话；
-     * 退峰/非官方切换等自动释放请用 `{ bypass: false }`。
-     * @param {string} sessionId
-     * @param {{bypass?:boolean, reason?:string}} [opts]
-     */
-    stepResume(sessionId, opts = {}) {
-      if (!stepGate || typeof stepGate.release !== 'function') {
-        return { released: false, bypass: false, reason: 'no-step-gate' }
-      }
-      const reason = opts.reason ?? 'manual'
-      let r
-      try {
-        r = stepGate.release(sessionId, reason)
-      } catch {
-        return { released: false, bypass: false, reason }
-      }
-      const released = !!(r && r.released === true)
-      let bypassed = false
-      if (released && opts.bypass !== false && typeof stepGate.markBypass === 'function') {
-        try {
-          stepGate.markBypass(sessionId)
-          bypassed = true
-        } catch {
-          /* ignore */
-        }
-      }
-      return { released, bypass: bypassed, reason }
-    },
-    /** 读一会话状态。 */
-    state(sessionId) {
-      const cur = store.get(sessionId)
-      const base = cur || idleState(sessionId)
-      const pausedState = pauseGate ? (pauseGate.state(sessionId) || {}) : {}
-      let stepState = {}
-      if (stepGate && typeof stepGate.state === 'function') {
-        try {
-          stepState = stepGate.state(sessionId) || {}
-        } catch {
-          stepState = {}
-        }
-      }
-      return {
-        sessionId: String(sessionId),
-        queueLocked: base.queueLocked === true,
-        lockReason: base.lockReason ?? null,
-        // 自研会话门真暂停状态（脱离 task-control）。
-        paused: pausedState.paused === true,
-        pausedForced: pausedState.forced === true,
-        // step 级门控（v0.2.0）：paused 保持布尔以兼容既有消费者，step 态用独立字段。
-        pausedStep: stepState.held === true,
-        stepHeldSince: stepState.since ?? null,
-        stepBypass: stepState.bypass === true,
-        stepManual: stepState.manual === true,
-        taskControlAvailable: gate.taskControlAvailable(),
-        taskControl: taskControlState(sessionId),
-        updatedAt: base.updatedAt ?? null,
-      }
-    },
-  }
-}
+/**
+ * dsh-session-guard — sessionGuard 冗余端口（D5/D6/D8）。
+ *
+ * `ctx.provide('sessionGuard', service)`：
+ * - stopNextTurn / resume：会话门（透传 taskControl，或回退锁队列）。
+ * - lockQueue / unlockQueue：显式队列锁（供 input-traffic 冻结按钮桥接，
+ *   或未来手动触发）。
+ * - state(sessionId)：{ queueLocked, lockReason, taskControlAvailable, taskControl }。
+ *
+ * input-traffic（方案 A，基于 feat/absorb-auto-continue 分支改造）在冻结按钮
+ * 触发时调用 stopNextTurn；本服务不存在时 input-traffic 静默跳过（fail-open，D8）。
+ */
+import { idleState } from './store.js'
+
+/**
+ * @param {object} ctx host context
+ * @param {ReturnType<import('./gate.js').createGate>} gate
+ * @param {ReturnType<import('./store.js').createStore>} store
+ * @param {ReturnType<import('./pause-gate.js').createPauseGate>} [pauseGate]
+ * @param {ReturnType<import('./step-gate.js').createStepGate>} [stepGate] step 级门控（v0.2.0）
+ */
+export function createBridge(ctx, gate, store, pauseGate, stepGate) {
+  function taskControlState(sessionId) {
+    let tcState = null
+    try {
+      const tc = ctx && typeof ctx.get === 'function' ? ctx.get('taskControl') : undefined
+      if (tc && typeof tc.state === 'function') {
+        const s = tc.state(sessionId)
+        tcState = {
+          status: s && s.status,
+          paused: !!(s && s.paused),
+          forced: !!(s && s.forced),
+        }
+      }
+    } catch {
+      /* 状态读取失败 → 保持 null，fail-open */
+    }
+    return tcState
+  }
+
+  return {
+    /** 停掉 session 下一回合（会话门 / 回退锁队列）。 */
+    stopNextTurn(sessionId, opts) {
+      return gate.stopNextTurn(sessionId, opts)
+    },
+    /** 恢复。 */
+    resume(sessionId, opts) {
+      return gate.resume(sessionId, opts)
+    },
+    /** 显式锁队列（手动触发）。 */
+    lockQueue(sessionId, reason = 'manual') {
+      const next = gate.lockQueue(sessionId, reason)
+      return { ok: true, state: next }
+    },
+    /** 显式解锁队列。 */
+    unlockQueue(sessionId) {
+      const next = gate.unlockQueue(sessionId)
+      return { ok: true, state: next }
+    },
+    /**
+     * 手动请求 step 级暂停（「暂停会话」按钮）。
+     * 不打断当前 step：在下一次 `agent/pre-step` 边界拉门（step 1 也拦，且不受峰谷/provider 限制）。
+     * @param {string} sessionId
+     */
+    stepPause(sessionId) {
+      if (!stepGate || typeof stepGate.requestPause !== 'function') {
+        return { requested: false, held: false, reason: 'no-step-gate' }
+      }
+      try {
+        return stepGate.requestPause(sessionId)
+      } catch {
+        return { requested: false, held: false, reason: 'error' }
+      }
+    },
+    /**
+     * 解开 step 门（v0.2.0）：放行被挂起的 step。
+     * 默认 `bypass=true`（用户手动「继续」）——本高峰窗口内不再拦该会话；
+     * 退峰/非官方切换等自动释放请用 `{ bypass: false }`。
+     * @param {string} sessionId
+     * @param {{bypass?:boolean, reason?:string}} [opts]
+     */
+    stepResume(sessionId, opts = {}) {
+      if (!stepGate || typeof stepGate.release !== 'function') {
+        return { released: false, bypass: false, reason: 'no-step-gate' }
+      }
+      const reason = opts.reason ?? 'manual'
+      let r
+      try {
+        r = stepGate.release(sessionId, reason)
+      } catch {
+        return { released: false, bypass: false, reason }
+      }
+      const released = !!(r && r.released === true)
+      let bypassed = false
+      if (released && opts.bypass !== false && typeof stepGate.markBypass === 'function') {
+        try {
+          stepGate.markBypass(sessionId)
+          bypassed = true
+        } catch {
+          /* ignore */
+        }
+      }
+      return { released, bypass: bypassed, reason }
+    },
+    /** 读一会话状态。 */
+    state(sessionId) {
+      const cur = store.get(sessionId)
+      const base = cur || idleState(sessionId)
+      const pausedState = pauseGate ? (pauseGate.state(sessionId) || {}) : {}
+      let stepState = {}
+      if (stepGate && typeof stepGate.state === 'function') {
+        try {
+          stepState = stepGate.state(sessionId) || {}
+        } catch {
+          stepState = {}
+        }
+      }
+      return {
+        sessionId: String(sessionId),
+        queueLocked: base.queueLocked === true,
+        lockReason: base.lockReason ?? null,
+        // 自研会话门真暂停状态（脱离 task-control）。
+        paused: pausedState.paused === true,
+        pausedForced: pausedState.forced === true,
+        // step 级门控（v0.2.0）：paused 保持布尔以兼容既有消费者，step 态用独立字段。
+        pausedStep: stepState.held === true,
+        stepHeldSince: stepState.since ?? null,
+        stepBypass: stepState.bypass === true,
+        stepManual: stepState.manual === true,
+        taskControlAvailable: gate.taskControlAvailable(),
+        taskControl: taskControlState(sessionId),
+        updatedAt: base.updatedAt ?? null,
+      }
+    },
+  }
+}

package/src/client/index.ts

@@ -1,66 +1,66 @@
-/**
- * dsh-session-guard — 浏览器 half。
- *
- * 职责（全部 fail-open，D8）：
- * - 在 composer 输入区右侧注册一个**纯展示**状态徽标（高峰/谷时/周末），轮询
- *   /session-guard/status；
- * - 注册 `settings.plugin.item` 设置卡片，经 `settingsScope.bind({ namespace })`
- *   绑定 host 已注册的 `session-guard` 命名空间——这正是“插件配置”面板显示本
- *   插件的**必要**机制（对齐 dsh-thinking-levels / dsh-context）；
- * - **不做**冻结/会话动作——冻结按钮由 input-traffic 接管并经 /session-guard/rpc
- *   桥接 host 会话门；本插件客户端不注册任何按钮，避免与 input-traffic 冲突。
- *
- * 构建：tsdown → lib/client.js（__ModuleLoader__.load 注册，与 input-traffic 同构）。
- */
-import { StatusBadge } from './status-badge'
-import { SessionGuardCard } from './settings-card'
-import { PauseButton } from './pause-button'
-
-/** 客户端所需服务：slots（状态徽标 + 设置卡片）+ locale + settingsScope（设置卡片绑定）。 */
-export const inject = ['slots', 'locale', 'settingsScope']
-
-/** 轻量 ctx 类型（仅本客户端用到的方法；构建时类型被剥离）。 */
-interface SlotsFace {
-  inject: (_name: string, _fn: () => unknown) => () => void
-  register: (_options: Record<string, unknown>, _component: unknown) => () => void
-}
-interface SettingsScopeFace {
-  bind: (_spec: { namespace: string }) => unknown
-}
-interface ClientCtx {
-  slots: SlotsFace
-  settingsScope: SettingsScopeFace
-}
-
-/** host 侧 src/settings.js 注册的命名空间（保持一致）。 */
-const NS = 'session-guard'
-
-export function apply(ctx: ClientCtx) {
-  // 暂停会话按钮（v0.2.0）：step 级门控的状态显示 + 手动解除。
-  // order 20 < input-traffic 冻结按钮的 30 → 排在左侧，两者并列互不取代（ADR-001/002）。
-  ctx.slots.inject('conversation.input.right', () => ctx.slots.register({
-    name: 'conversation.input.right',
-    id: 'session-guard-pause',
-    order: 20,
-    locale: 'session-guard',
-  }, PauseButton))
-
-  // 状态徽标：输入区右侧，纯展示。
-  ctx.slots.inject('conversation.input.right', () => ctx.slots.register({
-    name: 'conversation.input.right',
-    id: 'session-guard-status',
-    order: 40,
-    locale: 'session-guard',
-  }, StatusBadge))
-
-  // 插件配置卡片：绑定 session-guard 命名空间，经 settingsScope 渲染并提交。
-  ctx.slots.inject('settings.plugin.item', () => ctx.slots.register({
-    name: 'settings.plugin.item',
-    id: NS,
-    key: NS,
-    locale: 'session-guard',
-    inject: () => ({
-      scope: ctx.settingsScope.bind({ namespace: NS }),
-    }),
-  }, SessionGuardCard))
-}
+/**
+ * dsh-session-guard — 浏览器 half。
+ *
+ * 职责（全部 fail-open，D8）：
+ * - 在 composer 输入区右侧注册一个**纯展示**状态徽标（高峰/谷时/周末），轮询
+ *   /session-guard/status；
+ * - 注册 `settings.plugin.item` 设置卡片，经 `settingsScope.bind({ namespace })`
+ *   绑定 host 已注册的 `session-guard` 命名空间——这正是“插件配置”面板显示本
+ *   插件的**必要**机制（对齐 dsh-thinking-levels / dsh-context）；
+ * - **不做**冻结/会话动作——冻结按钮由 input-traffic 接管并经 /session-guard/rpc
+ *   桥接 host 会话门；本插件客户端不注册任何按钮，避免与 input-traffic 冲突。
+ *
+ * 构建：tsdown → lib/client.js（__ModuleLoader__.load 注册，与 input-traffic 同构）。
+ */
+import { StatusBadge } from './status-badge'
+import { SessionGuardCard } from './settings-card'
+import { PauseButton } from './pause-button'
+
+/** 客户端所需服务：slots（状态徽标 + 设置卡片）+ locale + settingsScope（设置卡片绑定）。 */
+export const inject = ['slots', 'locale', 'settingsScope']
+
+/** 轻量 ctx 类型（仅本客户端用到的方法；构建时类型被剥离）。 */
+interface SlotsFace {
+  inject: (_name: string, _fn: () => unknown) => () => void
+  register: (_options: Record<string, unknown>, _component: unknown) => () => void
+}
+interface SettingsScopeFace {
+  bind: (_spec: { namespace: string }) => unknown
+}
+interface ClientCtx {
+  slots: SlotsFace
+  settingsScope: SettingsScopeFace
+}
+
+/** host 侧 src/settings.js 注册的命名空间（保持一致）。 */
+const NS = 'session-guard'
+
+export function apply(ctx: ClientCtx) {
+  // 暂停会话按钮（v0.2.0）：step 级门控的状态显示 + 手动解除。
+  // order 20 < input-traffic 冻结按钮的 30 → 排在左侧，两者并列互不取代（ADR-001/002）。
+  ctx.slots.inject('conversation.input.right', () => ctx.slots.register({
+    name: 'conversation.input.right',
+    id: 'session-guard-pause',
+    order: 20,
+    locale: 'session-guard',
+  }, PauseButton))
+
+  // 状态徽标：输入区右侧，纯展示。
+  ctx.slots.inject('conversation.input.right', () => ctx.slots.register({
+    name: 'conversation.input.right',
+    id: 'session-guard-status',
+    order: 40,
+    locale: 'session-guard',
+  }, StatusBadge))
+
+  // 插件配置卡片：绑定 session-guard 命名空间，经 settingsScope 渲染并提交。
+  ctx.slots.inject('settings.plugin.item', () => ctx.slots.register({
+    name: 'settings.plugin.item',
+    id: NS,
+    key: NS,
+    locale: 'session-guard',
+    inject: () => ({
+      scope: ctx.settingsScope.bind({ namespace: NS }),
+    }),
+  }, SessionGuardCard))
+}

package/src/client/pause-button-text.ts

@@ -1,60 +1,60 @@
-/**
- * dsh-session-guard — 暂停/继续按钮文案与状态投影（纯函数，零依赖，可单测）。
- *
- * 交互（v0.2.0 修订）：
- * - 未暂停 → 「暂停会话」（**可点**：点击 = 在下一次 step 边界手动暂停该会话）；
- * - 已暂停（step 门已拉 / 已请求但未到边界）→ 「继续会话」（点击 = 放行并本峰不再拦）。
- * 按钮不置灰：step 暂停虽然会自动发生，但按钮同时是**手动暂停**入口。
- */
-
-/** 按钮状态。 */
-export interface PauseButtonState {
-  /** 是否处于暂停态（step 门已挂起，或已请求暂停但还没到边界） */
-  paused: boolean
-  /** 挂起起始时间戳（毫秒）；未知为 null */
-  heldSince?: number | null
-  /** 暂停是否来自用户手动请求（而非高峰自动拉门） */
-  manual?: boolean
-}
-
-/** 按钮文案。 */
-export function pauseButtonLabel(state: PauseButtonState): string {
-  return state.paused === true ? '继续会话' : '暂停会话'
-}
-
-/** 悬浮说明：写清当前状态与点击后的语义。 */
-export function pauseButtonTitle(state: PauseButtonState): string {
-  if (state.paused !== true) {
-    return '暂停会话：在下一次 step 的模型请求前暂停（高峰 + 官方源时会自动暂停）'
-  }
-  const since = typeof state.heldSince === 'number' && Number.isFinite(state.heldSince) ? new Date(state.heldSince) : null
-  const at = since === null ? null : `${String(since.getHours()).padStart(2, '0')}:${String(since.getMinutes()).padStart(2, '0')}`
-  const why = state.manual === true ? '手动暂停' : '高峰自动暂停'
-  const base = at === null ? `已暂停（${why}）` : `已暂停（${why}，自 ${at}）`
-  return `${base} · 点击继续：放行当前 step，且本高峰内不再拦该会话`
-}
-
-/** 把 `/session-guard/state` 的响应体投影为按钮状态（形状异常 → 未暂停，fail-open）。 */
-export function readPauseState(body: unknown): PauseButtonState {
-  const b = (body ?? {}) as {
-    ok?: unknown
-    paused?: { step?: unknown; manual?: unknown }
-    stepGate?: { since?: unknown; manual?: unknown }
-    state?: { pausedStep?: unknown; stepHeldSince?: unknown; stepManual?: unknown }
-  }
-  if (b.ok !== true) return { paused: false, heldSince: null, manual: false }
-  const manual = b.paused?.manual === true || b.stepGate?.manual === true || b.state?.stepManual === true
-  const paused = b.paused?.step === true || b.state?.pausedStep === true || manual
-  const raw = b.stepGate?.since ?? b.state?.stepHeldSince ?? null
-  const heldSince = typeof raw === 'number' && Number.isFinite(raw) ? raw : null
-  return { paused, heldSince, manual }
-}
-
-/** 把 SSE `/session-guard/events` 的 `state` 快照投影为按钮状态。 */
-export function readStepSnapshot(snapshot: unknown): PauseButtonState {
-  const s = (snapshot ?? {}) as { held?: unknown; since?: unknown; manual?: unknown }
-  const manual = s.manual === true
-  const paused = s.held === true || manual
-  const heldSince = typeof s.since === 'number' && Number.isFinite(s.since) ? s.since : null
-  return { paused, heldSince, manual }
-}
+/**
+ * dsh-session-guard — 暂停/继续按钮文案与状态投影（纯函数，零依赖，可单测）。
+ *
+ * 交互（v0.2.0 修订）：
+ * - 未暂停 → 「暂停会话」（**可点**：点击 = 在下一次 step 边界手动暂停该会话）；
+ * - 已暂停（step 门已拉 / 已请求但未到边界）→ 「继续会话」（点击 = 放行并本峰不再拦）。
+ * 按钮不置灰：step 暂停虽然会自动发生，但按钮同时是**手动暂停**入口。
+ */
+
+/** 按钮状态。 */
+export interface PauseButtonState {
+  /** 是否处于暂停态（step 门已挂起，或已请求暂停但还没到边界） */
+  paused: boolean
+  /** 挂起起始时间戳（毫秒）；未知为 null */
+  heldSince?: number | null
+  /** 暂停是否来自用户手动请求（而非高峰自动拉门） */
+  manual?: boolean
+}
+
+/** 按钮文案。 */
+export function pauseButtonLabel(state: PauseButtonState): string {
+  return state.paused === true ? '继续会话' : '暂停会话'
+}
+
+/** 悬浮说明：写清当前状态与点击后的语义。 */
+export function pauseButtonTitle(state: PauseButtonState): string {
+  if (state.paused !== true) {
+    return '暂停会话：在下一次 step 的模型请求前暂停（高峰 + 官方源时会自动暂停）'
+  }
+  const since = typeof state.heldSince === 'number' && Number.isFinite(state.heldSince) ? new Date(state.heldSince) : null
+  const at = since === null ? null : `${String(since.getHours()).padStart(2, '0')}:${String(since.getMinutes()).padStart(2, '0')}`
+  const why = state.manual === true ? '手动暂停' : '高峰自动暂停'
+  const base = at === null ? `已暂停（${why}）` : `已暂停（${why}，自 ${at}）`
+  return `${base} · 点击继续：放行当前 step，且本高峰内不再拦该会话`
+}
+
+/** 把 `/session-guard/state` 的响应体投影为按钮状态（形状异常 → 未暂停，fail-open）。 */
+export function readPauseState(body: unknown): PauseButtonState {
+  const b = (body ?? {}) as {
+    ok?: unknown
+    paused?: { step?: unknown; manual?: unknown }
+    stepGate?: { since?: unknown; manual?: unknown }
+    state?: { pausedStep?: unknown; stepHeldSince?: unknown; stepManual?: unknown }
+  }
+  if (b.ok !== true) return { paused: false, heldSince: null, manual: false }
+  const manual = b.paused?.manual === true || b.stepGate?.manual === true || b.state?.stepManual === true
+  const paused = b.paused?.step === true || b.state?.pausedStep === true || manual
+  const raw = b.stepGate?.since ?? b.state?.stepHeldSince ?? null
+  const heldSince = typeof raw === 'number' && Number.isFinite(raw) ? raw : null
+  return { paused, heldSince, manual }
+}
+
+/** 把 SSE `/session-guard/events` 的 `state` 快照投影为按钮状态。 */
+export function readStepSnapshot(snapshot: unknown): PauseButtonState {
+  const s = (snapshot ?? {}) as { held?: unknown; since?: unknown; manual?: unknown }
+  const manual = s.manual === true
+  const paused = s.held === true || manual
+  const heldSince = typeof s.since === 'number' && Number.isFinite(s.since) ? s.since : null
+  return { paused, heldSince, manual }
+}