dsh-pause-resume 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.4.2
+
+- The dot now means one thing: something is waiting on you (a paused plan with commands that will not restart, or a stop/restore that failed). A clean idle page has no dot, and killed jobs live in the restore record instead of becoming a permanent red light.
+- Restore mounts sessions in bounded parallel batches, so wall time is the slowest batch instead of the sum of every session.
+- Duplicate attention rows for the same item are collapsed.
+
+## 0.4.1
+
+A stop that could not finish no longer traps the button, and the dot stops lying after a resume.
+
+* An unfinished stop now always offers the resume that releases it. The button used to prefer
+  `pause` whenever live work remained, so a partial stop re-ran the same stop on the same
+  uncancellable turn: the icon never changed, the attention dot stayed, and pressing it did
+  nothing a person could see.
+* Work that starts while a plan waits no longer flips the button back to pause. The plan owns the
+  action until it is consumed.
 ## 0.4.0
 
 The crash path is now a first-class restore path, and a dead button after a restart is fixed.

package/index.js

@@ -7,7 +7,7 @@ import { createHeartbeat } from './lib/heartbeat.js'
 import { createProbe, listRunning } from './lib/probe.js'
 
 export const name = 'dsh-pause-resume'
-export const VERSION = '0.4.0'
+export const VERSION = '0.4.1'
 
 const BASE_PATH = '/dsh-pause-resume'
 const BUTTON_HEADER = 'x-dsh-pause-resume'

package/lib/engine.js

@@ -28,6 +28,18 @@ function emptyLive() {
   return { sessions: [], goals: [], jobs: [], readable: false, source: 'none' }
 }
 
+/** One row per item: a retried stop must not multiply the same unfinished job in the dot. */
+function dedupeRows(rows) {
+  const seen = new Set()
+  return rows.filter((row) => {
+    if (row === null || row === undefined) return false
+    const key = `${row.kind ?? ''}|${row.id ?? ''}|${row.detail ?? ''}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
 export function createEngine({ store, probe, heartbeat = null, bootId = 'boot', epoch = null, now = () => Date.now(), graceMs = 2000, log = () => {} }) {
   /**
    * A reload creates a new instance and bumps the shared epoch. An old instance's press may still
@@ -139,11 +151,19 @@ export function createEngine({ store, probe, heartbeat = null, bootId = 'boot',
     const work = workOf(current)
     const busy = TRANSIENT.has(phase)
     const workCount = liveWorkCount(work)
+    // A plan is an unfinished stop: the only way forward is to resume it, even when the stop left
+    // work behind. Preferring `pause` there used to trap a partial stop forever: every press
+    // re-ran the same stop, the residue could never be cancelled, and the button never offered the
+    // resume that would have released the plan.
     let action = 'none'
     if (busy) action = 'busy'
-    else if (current.readable === true && workCount > 0) action = 'pause'
     else if (plan !== null) action = 'resume'
-    const attentionRows = plan !== null ? plan.attention : result?.attention
+    else if (current.readable === true && workCount > 0) action = 'pause'
+    // The dot means "something still needs you". A clean idle page has nothing to point at: the
+    // jobs a pause killed stay in the last-restore record, but they are not an open obligation.
+    const attentionRows = plan !== null
+      ? dedupeRows(Array.isArray(plan.attention) ? plan.attention : [])
+      : phase === 'idle' && lastError === null ? null : result?.attention
     const attention = Array.isArray(attentionRows) ? attentionRows.length : 0
     const first = attention > 0 ? attentionRows[0] : null
     const focus = first === null ? null : (typeof first === 'string' ? first : (first.id || first.detail || null))
@@ -338,16 +358,17 @@ export function createEngine({ store, probe, heartbeat = null, bootId = 'boot',
       const match = new RegExp(`^${kind} ([^:]+):`).exec(String(detail))
       return match === null ? '' : match[1].trim()
     }
-    plan.attention = [
+    plan.attention = dedupeRows([
       ...(Array.isArray(basePlan?.attention) ? basePlan.attention : []),
       ...stillRunning.map((id) => ({ kind: 'session', id, detail: 'still running' })),
+      ...(stopped.killedJobs ?? []).map((job) => ({ kind: 'job', id: job.id, detail: 'stopped, not restarted' })),
       ...(stopped.goalErrors ?? []).map((detail) => {
         const goalId = errorId('goal', detail)
         const owner = [...(basePlan?.goals ?? []), ...(current.goals ?? [])].find((row) => row.goalId === goalId)
         return { kind: 'goal', id: owner?.sessionId ?? goalId, detail }
       }),
       ...(stopped.jobErrors ?? []).map((detail) => ({ kind: 'job', id: errorId('job', detail), detail })),
-    ]
+    ])
     if (isCrashPlan(basePlan) === true) {
       // The crash record described work that was not paused. This press did pause it, so the plan
       // becomes a normal pause plan and the crash evidence is no longer a separate obligation.
@@ -372,7 +393,7 @@ export function createEngine({ store, probe, heartbeat = null, bootId = 'boot',
   }
 
   function summaryOf(plan) {
-    return { planId: plan.planId, source: plan.source ?? 'pause', restored: [], skipped: [], failed: [], attention: [], jobs: 0, at: new Date(now()).toISOString() }
+    return { planId: plan.planId, source: plan.source ?? 'pause', restored: [], skipped: [], failed: [], attention: [], jobs: 0, jobsStopped: [], at: new Date(now()).toISOString() }
   }
 
   /**
@@ -423,9 +444,20 @@ export function createEngine({ store, probe, heartbeat = null, bootId = 'boot',
       return outcome
     }
 
-    for (const session of plan.sessions ?? []) {
-      await step(`s:${session.sessionId}`, `session ${session.sessionId}`, () => probe.restoreSession(session, { plan }))
+    const sessionRows = plan.sessions ?? []
+    const sessionDone = new Array(sessionRows.length)
+    let nextSession = 0
+    const sessionWorker = async () => {
+      while (nextSession < sessionRows.length) {
+        const index = nextSession
+        nextSession += 1
+        const session = sessionRows[index]
+        sessionDone[index] = await step(`s:${session.sessionId}`, `session ${session.sessionId}`, () => probe.restoreSession(session, { plan }))
+      }
     }
+    // Bounded fan-out: every mount asks the same registry for its own session, so a handful in
+    // flight turns a long serial restore into one batch without flooding the Harness.
+    await Promise.all(Array.from({ length: Math.min(4, sessionRows.length) }, sessionWorker))
     for (const goal of plan.goals ?? []) {
       const key = `g:${goal.sessionId}:${goal.goalId ?? ''}`
       const outcome = await step(key, `goal ${goal.goalId ?? goal.sessionId}`, () => probe.restoreGoal(goal, { plan }))
@@ -440,7 +472,7 @@ export function createEngine({ store, probe, heartbeat = null, bootId = 'boot',
     }
     // A killed job cannot be replayed: the same command may have had an unknown effect, so it is
     // reported once and left to the person. It never blocks the plan and is never restarted.
-    for (const job of plan.jobs ?? []) summary.attention.push(`job ${job.id}: stopped, not restarted`)
+    for (const job of plan.jobs ?? []) summary.jobsStopped.push(`job ${job.id}: stopped, not restarted`)
 
     result = summary
     if (summary.failed.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pause-resume",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "description": "One header button stops running turns, goals and jobs, writes a plan to disk, and restores that work after a restart or crash; the button shape is the only status.",
   "license": "MIT",