@try-works/dsh-memory 0.1.21 → 0.1.22

package/STATUS.md

@@ -147,11 +147,12 @@ the flag on did not change what the user sees.
 
 ### Blocked on a restart
 
-- [ ] **Publish 0.1.21, install, restart.** The guard against unmarked `memory/map` events is
-      written and tested (403 pass) but the publish needs npm credentials that were not available
-      in this session (`npm publish` → ENEEDAUTH). Installed 0.1.20 already appends WITH the
-      marker, so nothing is at risk while this waits; the guard only protects against a harness
-      older than the `append(type, data, { ignorable: true })` option.
+- [ ] **Restart to load 0.1.21.** Published and installed: 0.1.21 is on npm (tarball byte-identical to
+      source) and installed in the profile (host.js byte-identical, guard at host.js:727/753). The
+      profile's minimumReleaseAge gate needed its dsh-memory exclusion extended to 0.1.21 in
+      pnpm-workspace.yaml, the same convention as every earlier version. The host half loads at
+      boot, so the guard only takes effect after a restart; installed 0.1.20 already appends WITH
+      the marker, so nothing is at risk while this waits.
 - [x] **Restart, then check the tasks layer — DONE 2026-10-09.** The restart confirmed it. See the
       tasks-layer section above for the two log entries and the counts. It writes to ANOTHER plugin's storage through
       that plugin's service, so it deserves a real observation rather than a passing suite. After

package/package.json

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

@@ -29,15 +29,28 @@ const TASKS_BACKUP_MS = 30 * 60 * 1000
 const IDLE_TICK_MS = 60_000
 
 function makeGitRunner(ctx) {
-  const subprocess = ctx.get('subprocess')
-  if (!subprocess || typeof subprocess.resolveExecutable !== 'function' || typeof subprocess.spawn !== 'function') return null
+  // 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
+  // fiber is active while the composition is still mounting. The first version probed here,
+  // once, at wire time - it cached undefined, returned null, and every git path was dead
+  // forever: zero sync events ever recorded, and the history hook threw "Cannot read
+  // properties of null (reading 'run')" every hour. The service exists by first USE (an agent
+  // pre-step, minutes after boot), so resolve lazily and keep re-probing until it appears.
+  let subprocess
+  const probe = () => {
+    const svc = ctx.get('subprocess')
+    if (svc && typeof svc.resolveExecutable === 'function' && typeof svc.spawn === 'function') subprocess = svc
+    return subprocess
+  }
   let executablePromise
   const run = async (argv, opts = {}) => {
-    if (!executablePromise) executablePromise = subprocess.resolveExecutable('git', undefined, undefined).catch(() => null)
+    const svc = probe()
+    if (!svc) return { exitCode: 127, stdout: '', stderr: 'subprocess service unavailable' }
+    if (!executablePromise) executablePromise = svc.resolveExecutable('git', undefined, undefined).catch(() => null)
     const executable = await executablePromise
     if (!executable) return { exitCode: 127, stdout: '', stderr: 'git unavailable' }
     try {
-      const handle = subprocess.spawn({
+      const handle = svc.spawn({
         argv: [executable, ...argv],
         cwd: opts.cwd,
         stdio: { stdin: 'ignore', stdout: { maxBytes: 4 * 1024 * 1024 }, stderr: { maxBytes: 16 * 1024 } },
@@ -52,7 +65,9 @@ function makeGitRunner(ctx) {
       return { exitCode: 1, stdout: '', stderr: String(error) }
     }
   }
-  return new GitRunner(run)
+  const runner = new GitRunner(run)
+  runner.available = () => Boolean(probe())
+  return runner
 }
 
 function resolveTarget(agent) {
@@ -235,6 +250,9 @@ export function wireHost(ctx, store, cfg) {
     if (!workspace) return { ok: false, reason: 'no workspace for this session', added: 0 }
     const path = readAssociations(store.root)[workspace]?.path
     if (!path) return { ok: false, reason: 'no local folder associated with ' + workspace, added: 0 }
+    // Report the honest reason instead of throwing: a hook that throws hourly because a service
+    // was probed too early must never look like a repository with no commits.
+    if (!git.available()) return { ok: false, reason: 'subprocess service unavailable', added: 0 }
     return ingestHistory(store.root, workspace, path, (argv, opts) => git.run(argv, opts), { limit })
   }
 
@@ -570,6 +588,9 @@ export function wireHost(ctx, store, cfg) {
   }
 
   async function runSync(force = false) {
+    // Not a git failure: no CONFLICT marker, no status record - the capability simply is not
+    // there yet. available() re-probes, so this is true only while the host is still mounting.
+    if (!git.available()) return { initialized: false, committed: false, synced: false, error: 'subprocess service unavailable' }
     const branch = cfg.gitBranch || 'main'
     const hasGit = existsSync(join(store.root, '.git'))
     if (!hasGit) {
@@ -764,7 +785,7 @@ export function wireHost(ctx, store, cfg) {
   }
 
   function maybeSync() {
-    if (syncInFlight || !git) return
+    if (syncInFlight || !git.available()) return
     if (!scheduler.shouldCommit() && !scheduler.shouldSync()) return
     syncInFlight = true
     // Sync wrote its outcome only to state/sync.json, so the log could not answer whether the