@try-works/dsh-memory 0.1.24 → 0.1.26

package/package.json

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

@@ -326,11 +326,11 @@ export function wireHost(ctx, store, cfg) {
    */
   const recoverNow = {
     plan() {
-      const p = planRecovery(store.root, { thresholdBytes: cfg.recoverApprovalThresholdBytes })
+      const p = planRecovery(store.root, { thresholdBytes: cfg.recoverApprovalThresholdBytes, bytesOf: cfg.recoverBytesOf })
       return { total: p.total, recoverable: p.recoverable, oversized: p.oversized, missing: p.missing, thresholdBytes: p.threshold }
     },
     async run(args, exec) {
-      const p = planRecovery(store.root, { thresholdBytes: cfg.recoverApprovalThresholdBytes })
+      const p = planRecovery(store.root, { thresholdBytes: cfg.recoverApprovalThresholdBytes, bytesOf: cfg.recoverBytesOf })
       const candidates = args.id
         ? p.entries.filter((e) => e.id === args.id)
         : p.entries.filter((e) => !e.needsApproval).sort((a, b) => (a.bytes ?? 0) - (b.bytes ?? 0)).slice(0, args.limit ?? 1)
@@ -357,7 +357,20 @@ export function wireHost(ctx, store, cfg) {
           if (outcome !== 'allowed-once') { declined.push({ id: target.id, why: String(outcome) }); continue }
         }
         try {
-          await recoverOne(store, services, target.id, { cfg, now: () => Date.now() })
+          // Services are resolved at CALL time, never at wire time: cordis ctx.get() returns
+          // undefined while the providing fiber is not active (mount), and this run path executes
+          // inside a tool call, when the host is fully up. The first version referenced a
+          // `services` binding that was never defined - a ReferenceError the catch quietly turned
+          // into "1 declined or refused", which is how 75 recoverable candidates sat behind a
+          // tool that could only refuse them.
+          const sessionQuery = ctx.get('sessionQuery')
+          if (!sessionQuery) { declined.push({ id: target.id, why: 'sessionQuery service unavailable' }); continue }
+          // The recovered session has no live agent to route through, so the summary uses the
+          // plugin's own memory model ladder.
+          await recoverOne(store, {
+            sessionQuery,
+            llm: (prompt) => runLlm(undefined, prompt, 'memory-summary', 1200),
+          }, target.id, { cfg, now: () => Date.now() })
           recovered.push({ id: target.id, bytes: target.bytes })
           logRun(store.root, 'recover', { count: 1, detail: { id: target.id } })
         } catch (error) {

package/src/tools.js

@@ -758,7 +758,12 @@ export function registerTools(ctx, store, extras = {}) {
       if (!syncNow) return { synced: false }
       const status = await syncNow()
       return {
-        synced: Boolean(status && (status.synced || status.committed || status.initialized)),
+        // `synced` means SYNCED, not 'it did something'. It used to include committed and
+        // initialized, so a push that FAILED still reported synced:true whenever the local commit
+        // had succeeded - the result read {"synced":true,"conflict":true}, claiming success and
+        // failure at once. A local commit is progress, not a sync, and saying otherwise is the same
+        // defect as every other one this layer has produced: a green answer over a silent failure.
+        synced: Boolean(status && status.synced),
         ...(status && status.conflict ? { conflict: true } : {}),
         ...(status && status.error ? { error: String(status.error) } : {}),
       }