@try-works/dsh-memory 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Git-backed, workspace-scoped memory for the DeepSeek Harness (global layer + per-workspace layers)",
   "type": "module",
   "main": "src/index.js",

package/src/tasks.js

@@ -56,14 +56,22 @@ export const TASK_STATES = {
  * without one.
  */
 export const TASK_STATE_EXITS = {
-  active: ['stopped', 'done', 'failed'],
-  pending: ['active'],
+  // Two entries were missing, and NOTHING noticed until writeTask began reading this table.
+  //
+  // 'orphaned': the session holding a live task can disappear while the task itself does not
+  // change, so an armed task can become one that can never fire.
+  //
+  // 'paused' in every row: holding a task back is a DECISION the user makes about a task in any
+  // condition, not a lifecycle step. Writing the table without it left the entire pause path
+  // undeclared - the feature worked, and the declaration that was supposed to describe it did not.
+  active: ['stopped', 'done', 'failed', 'orphaned', 'paused'],
+  pending: ['active', 'paused'],
   paused: ['pending'],
-  stopped: ['pending'],
-  failed: ['active'],
-  orphaned: ['pending'],
-  skipped: ['active'],
-  done: ['active'],
+  stopped: ['pending', 'paused'],
+  failed: ['active', 'paused'],
+  orphaned: ['pending', 'paused'],
+  skipped: ['active', 'paused'],
+  done: ['active', 'paused'],
 }
 
 const STATES = Object.values(TASK_STATES)
@@ -151,7 +159,7 @@ const STATE_MEANING = {
   [TASK_STATES.STOPPED]: 'was armed, and its owning session stopped, so the host deleted it',
   [TASK_STATES.FAILED]: 'was due and has still not delivered; the host records no failure of its own',
   [TASK_STATES.ORPHANED]: 'armed, but the session that owns it cannot be resolved, so it can never fire',
-  [TASK_STATES.SKIPPED]: 'seen in the live store but not captured, because its kind is not one we can read',
+  [TASK_STATES.SKIPPED]: 'captured, but its kind is not one we can re-arm; a restore refuses it rather than guessing',
   [TASK_STATES.DONE]: 'delivered, or its recurrence is exhausted',
 }
 
@@ -183,6 +191,18 @@ function ensureTasksDir(root) {
 export function writeTask(root, record, state, nowIso) {
   ensureTasksDir(root)
   const file = taskFilePath(root, record)
+  // ENFORCED, not documented. This table sat in the file unread since it was written, so a state
+  // could move anywhere and nothing objected - the same shape as the vocabulary states that had a
+  // test and no producer. Refusing here means a task cannot silently leave a state by a route
+  // nobody declared, which is what makes 'every resting state has a working exit' checkable
+  // rather than aspirational.
+  const previous = readTaskFile(file)
+  if (previous && previous.stateKnown && previous.state !== state) {
+    const allowed = TASK_STATE_EXITS[previous.state] ?? []
+    if (!allowed.includes(state)) {
+      throw new Error('tasks: refusing the transition ' + previous.state + ' -> ' + state + ' for "' + String(record.title ?? '') + '"; allowed from ' + previous.state + ': ' + allowed.join(', '))
+    }
+  }
   writeFileSync(file, JSON.stringify({ backedUpAt: nowIso, state, record }, null, 2) + '\n', 'utf8')
   return file;
 }
@@ -397,8 +417,8 @@ export function readScheduleStore(path) {
  * deleted on purpose must stay visible as gone rather than vanish from the record of what this
  * machine used to run.
  *
- * A task whose kind we do not recognise is SKIPPED, not written: storing it would mean restoring
- * it later without understanding it. It is reported, so the omission is visible.
+ * A task whose kind we do not recognise is stored and flagged SKIPPED: dropping it would mean losing
+ * a task from a backup, and flagging it means a restore refuses it rather than guessing.
  */
 export function backupTasks(root, { schedulePath, now = Date.now(), nowIso, sessions } = {}) {
   const at = nowIso ?? new Date(now).toISOString()
@@ -424,7 +444,13 @@ export function backupTasks(root, { schedulePath, now = Date.now(), nowIso, sess
     const record = task.record
     if (!record || typeof record !== 'object') { skipped.push({ id: task.id, reason: 'no record' }); continue }
     if (!KNOWN_KINDS.includes(String(record.kind))) {
+      // CAPTURED, not dropped. An earlier version skipped these entirely, which meant a task whose
+      // kind we did not recognise silently vanished from a BACKUP - the one job this layer has. It
+      // is written and flagged 'skipped' instead, and planRestore refuses that state, so it can
+      // never be blindly re-armed. Preserved, visible, and unrestorable: all three on purpose.
       skipped.push({ id: task.id, reason: 'unrecognised kind: ' + String(record.kind) })
+      writeTask(root, record, TASK_STATES.SKIPPED, byKey.get(contentKey(record))?.backedUpAt ?? at)
+      seen.add(contentKey(record))
       continue
     }
     const key = contentKey(record)