@try-works/dsh-memory 0.1.11 → 0.1.12

package/package.json

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

@@ -400,9 +400,13 @@ export function readScheduleStore(path) {
  * 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.
  */
-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
@@ -429,7 +433,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 +550,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
+}