@try-works/dsh-memory 0.1.14 → 0.1.15

package/package.json

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