@try-works/dsh-memory 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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

@@ -151,7 +151,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',
 }
 
@@ -397,12 +397,16 @@ 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 } = {}) {
+export function backupTasks(root, { schedulePath, now = Date.now(), nowIso, sessions } = {}) {
   const at = nowIso ?? new Date(now).toISOString()
   const live = readScheduleStore(schedulePath ?? defaultSchedulePath())
+  // Read once per pass, not per task: it is a directory walk, and every row asks the same question.
+  // Injectable so a test can state the world instead of inheriting this machine's: `null` means
+  // the question cannot be answered and no row is called orphaned.
+  const sessionSet = sessions === undefined ? sessionIdsOnDisk() : sessions
   const before = listTasks(root)
   if (live.error !== null) {
     // The index is still rewritten, so a page from an earlier pass cannot sit on disk describing a
@@ -420,7 +424,13 @@ export function backupTasks(root, { schedulePath, now = Date.now(), nowIso } = {
     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)
@@ -429,7 +439,11 @@ export function backupTasks(root, { schedulePath, now = Date.now(), nowIso } = {
     // A held-back task stays held back across every backup: that state is the user's decision, and
     // a routine pass must not overwrite it with a derived one.
     const held = previous && previous.stateKnown && previous.state === TASK_STATES.PAUSED
-    const derived = deriveState({ stored: held ? TASK_STATES.PAUSED : null, live: task, now })
+    // Without this the ORPHANED state exists in the vocabulary and is never produced by any real
+    // pass - reachable from a unit test and from nothing else. `sessions === null` means the
+    // sessions directory is absent and we cannot tell, so the row is left as active.
+    const ownerResolvable = sessionSet === null || task.sessionId === undefined ? true : sessionSet.has(task.sessionId)
+    const derived = deriveState({ stored: held ? TASK_STATES.PAUSED : null, live: task, now, ownerResolvable })
     writeTask(root, record, derived.state, previous ? previous.backedUpAt : at)
     if (previous) refreshed += 1
     else written += 1
@@ -542,3 +556,37 @@ export function planRestore(root, { liveTasks = [], now = Date.now() } = {}) {
   }
   return { add, present, paused, refused, unreadable }
 }
+
+/** The directory DSH keeps session records in, beside the schedule store's home. */
+export function sessionsRoot(home = homedir()) {
+  const configured = process.env.DSH_HOME
+  const dshHome = configured && configured !== '' ? configured : join(home, '.dsh')
+  return join(dshHome, 'sessions')
+}
+
+/**
+ * Every session id that still has a record on disk.
+ *
+ * Used to tell ORPHANED from ACTIVE. A live task is armed against the session that created it, and
+ * the runtime resolves an agent from that id before every delivery (schedule runtime.ts:101) - so
+ * a task whose session is gone is a row that will never fire while still occupying the store. The
+ * backup cannot see the runtime, but it can see whether the session still exists.
+ *
+ * @returns a Set, or null when the sessions directory is absent
+ *
+ * Null rather than an empty set on purpose: no sessions directory means we cannot tell, and an
+ * empty set would mark every task on the machine orphaned. Refusing to guess is the rule here.
+ */
+export function sessionIdsOnDisk(home = homedir()) {
+  const root = sessionsRoot(home)
+  if (!existsSync(root)) return null
+  const ids = new Set()
+  let projects
+  try { projects = readdirSync(root) } catch { return null }
+  for (const project of projects) {
+    let sessions
+    try { sessions = readdirSync(join(root, project)) } catch { continue }
+    for (const id of sessions) ids.add(id)
+  }
+  return ids
+}