@try-works/dsh-memory 0.1.13 → 0.1.15

package/package.json

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

package/src/host.js

@@ -648,20 +648,24 @@ export function wireHost(ctx, store, cfg) {
    * store is left exactly as it is, matched by CONTENT because create() mints a fresh id
    * (schedule index.ts:256) and ids therefore cannot identify anything across a restore.
    */
-  async function maybeRestoreTasks(agent) {
-    if (restoreAttempted) return
-    if (!agent || isSubagentSession(agent.session)) return
+  async function maybeRestoreTasks(agent, { force = false } = {}) {
+    // EVERY early return REPORTS WHY. These used to return silently, and the tool that calls this
+    // reported success regardless - so a manual restore after the boot pass returned immediately at
+    // the once-per-process guard while telling the caller it had restored. An action that does
+    // nothing and says it worked is worse than one that fails.
+    if (restoreAttempted && !force) return { ran: false, reason: 'already restored in this process; pass force to run it again' }
+    if (!agent || isSubagentSession(agent.session)) return { ran: false, reason: 'a restored task needs a main session to own it' }
     const sessionId = agent.session && agent.session.id
-    if (!sessionId) return
+    if (!sessionId) return { ran: false, reason: 'the session has no id to bind the task to' }
     const schedule = ctx.get('schedule')
-    if (!schedule || typeof schedule.create !== 'function') return
+    if (!schedule || typeof schedule.create !== 'function') return { ran: false, reason: 'the schedule service is unavailable' }
     restoreAttempted = true
     try {
       const path = cfg.schedulePath || defaultSchedulePath()
       const live = readScheduleStore(path)
       if (live.error !== null) {
         logRun(store.root, 'tasks-restore', { ok: false, error: live.error })
-        return
+        return { ran: true, owner: sessionId, error: live.error }
       }
       const plan = planRestore(store.root, { liveTasks: live.tasks })
       const added = []
@@ -684,8 +688,10 @@ export function wireHost(ctx, store, cfg) {
         failed: failed.length,
         detail: failed.length ? failed : undefined,
       })
+      return { ran: true, owner: sessionId, added: added.length, present: plan.present.length, paused: plan.paused.length, refused: plan.refused.length, failed: failed.length }
     } catch (error) {
       logRun(store.root, 'tasks-restore', { ok: false, error: String((error && error.message) || error).slice(0, 160) })
+      return { ran: true, owner: sessionId, error: String((error && error.message) || error).slice(0, 160) }
     }
   }
 

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)
@@ -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;
 }

package/src/tools.js

@@ -368,8 +368,11 @@ export function registerTools(ctx, store, extras = {}) {
         changed = { written: r.written, refreshed: r.refreshed, stopped: r.stopped, skipped: r.skipped.length, error: r.error }
       } else if (action === 'restore') {
         if (!tasksRestore) throw new Error('memory_tasks: the restore is unavailable in this context')
-        await tasksRestore(exec.agent)
-        changed = { restored: true }
+        // FORCED, because the once-per-process guard has almost certainly already been consumed by
+        // the boot restore - the manual action exists to run it again on demand.
+        // The outcome is REPORTED rather than assumed: this used to say { restored: true } whatever
+        // happened, including when nothing did.
+        changed = await tasksRestore(exec.agent, { force: true })
       } else if (action === 'pause' || action === 'resume') {
         if (!args.title) throw new Error('memory_tasks: ' + action + ' needs a title')
         const { tasks } = listTasks(store.root)