@try-works/dsh-memory 0.1.23 → 0.1.25

package/package.json

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

package/src/git.js

@@ -26,12 +26,18 @@ export class GitRunner {
  */
 export function classifyGitResult(result) {
   if (!result) return { ok: false, reason: 'git produced no result' }
-  if (result.code === 0) return { ok: true }
+  // BOTH names, because the two halves disagreed and nobody noticed: the doc comment above the
+  // GitRunner constructor promises a run() result carrying `code`, so this read `result.code` -
+  // while the runner the plugin actually injects returns `exitCode`. Every successful git command
+  // was therefore classified as a failure, every pull and push was reported as failed, and sync had
+  // never once succeeded. A classifier that rejects success is worse than no classifier.
+  const code = result.exitCode ?? result.code
+  if (code === 0) return { ok: true }
   const stdout = String(result.stdout ?? '')
   const stderr = String(result.stderr ?? '')
   const combined = stdout + ' ' + stderr
   const conflicted = /conflict|automatic merge failed|needs merge|could not apply/i.test(combined)
-  const reason = (stderr.trim() || stdout.trim() || 'exit code ' + String(result.code)).slice(0, 400)
+  const reason = (stderr.trim() || stdout.trim() || 'exit code ' + String(code)).slice(0, 400)
   return { ok: false, conflicted, reason }
 }
 

package/src/host.js

@@ -28,6 +28,19 @@ const MAP_PUBLISH_MS = 60 * 1000
 const TASKS_BACKUP_MS = 30 * 60 * 1000
 const IDLE_TICK_MS = 60_000
 
+/**
+ * Did the pull fail only because the remote has no such branch yet?
+ *
+ * The first sync of a store that has been committing to itself - which is every store that has ever
+ * been used - meets a remote with no refs at all. git says so in a few ways depending on version and
+ * transport, and none of them is a real failure: there is simply nothing to pull and everything to
+ * push.
+ */
+function isMissingRemoteBranch(result) {
+  const text = String((result && result.stdout) || '') + ' ' + String((result && result.stderr) || '')
+  return /couldn't find remote ref|could not find remote ref|no such ref|remote branch .* not found|unable to find remote ref/i.test(text)
+}
+
 function makeGitRunner(ctx) {
   // The subprocess service is NOT resolvable during apply. cordis ctx.get() only returns an
   // implementation whose PROVIDING FIBER IS ACTIVE (vendor/cordis reflect.ts _getImpl), and no
@@ -627,7 +640,11 @@ export function wireHost(ctx, store, cfg) {
       }
       const pulled = await git.pull(store.root, branch).catch((error) => ({ code: -1, stderr: String((error && error.message) || error) }))
       const pullVerdict = classifyGitResult(pulled)
-      if (!pullVerdict.ok) return failSync('pull', pullVerdict, committed)
+      // An EMPTY remote has no branch to pull, and that is not a failure - it is the first push.
+      // The store has been committing to itself since it was created, so its very first sync meets a
+      // remote with no refs at all; failing there would mean a freshly configured origin could never
+      // be bootstrapped by the plugin, only by hand.
+      if (!pullVerdict.ok && !isMissingRemoteBranch(pulled)) return failSync('pull', pullVerdict, committed)
       const pushed = await git.push(store.root, branch).catch((error) => ({ code: -1, stderr: String((error && error.message) || error) }))
       const pushVerdict = classifyGitResult(pushed)
       if (!pushVerdict.ok) return failSync('push', pushVerdict, committed)

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) } : {}),
       }