mixdog 0.9.10 → 0.9.11

package/src/standalone/agent-tool.mjs

@@ -1440,16 +1440,38 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
 
   // True when a tag has a lingering worker-index / role trace but no live
   // session in this terminal (finished worker still inside the reap grace window).
+  function terminalWorkerRowForTag(tag, context = {}) {
+    const value = clean(tag);
+    if (!value) return null;
+    return readWorkerRows(context).find((row) => {
+      if (clean(row.tag) !== value) return false;
+      if (!isTerminalWorkerStatus(row.status || row.stage)) return false;
+      if (getLiveSession(clean(row.sessionId))) return false;
+      return true;
+    }) || null;
+  }
+
   function hasTerminalTrace(tag, context = {}) {
     const value = clean(tag);
     if (!value || value.startsWith('sess_')) return false;
     if (resolveTag(value, context, { excludeTerminalTraces: true })) return false; // live -> reuse, not trace
-    if (tagAgents.has(value)) return true;
-    return readWorkerRows(context).some((row) => clean(row.tag) === value);
+    return Boolean(terminalWorkerRowForTag(value, context));
   }
 
-  function terminalTraceSpawnError(tag) {
-    return new Error(`agent spawn: tag "${tag}" refers to a finished or closed worker; wait for reap or use a new tag`);
+  function reapTerminalTraceForTag(tag, context = {}) {
+    const value = clean(tag);
+    if (!value || value.startsWith('sess_')) return false;
+    if (!hasTerminalTrace(value, context)) return false;
+    refreshTagsFromSessions({ context });
+    let sessionId = tags.get(value) || '';
+    if (!sessionId) {
+      const row = readWorkerRows(context).find((item) => clean(item.tag) === value);
+      sessionId = clean(row?.sessionId) || '';
+    }
+    if (sessionId) cancelReap(sessionId);
+    forgetTag(value);
+    removeWorkerRow({ tag: value, sessionId });
+    return true;
   }
 
   async function execute(args = {}, context = {}) {
@@ -1511,7 +1533,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
         // Explicit-tag spawn priority (auto nextTag always creates a fresh session):
         //   1) live + busy -> queue the prompt (reuse)
         //   2) live + idle -> continue existing session (reuse)
-        //   3) lingering terminal trace -> error (no defensive respawn)
+        //   3) lingering terminal trace -> reap trace and fresh spawn under same tag
         //   4) genuinely new tag -> fresh deferred spawn
         const explicitTag = clean(args.tag);
         if (explicitTag) {
@@ -1533,7 +1555,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
             return dispatchToExistingSession(prepared, notifyContext, { reused: true });
           }
           if (hasTerminalTrace(explicitTag, scopedContext)) {
-            throw terminalTraceSpawnError(explicitTag);
+            reapTerminalTraceForTag(explicitTag, scopedContext);
           }
         }
         const job = startDeferredSpawnJob(args, callerCwd, context, notifyContext);

package/src/standalone/memory-runtime-proxy.mjs

@@ -54,6 +54,38 @@ function delay(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+const TRANSIENT_MEMORY_RPC_BACKOFF_MS = 400;
+
+function isConnResetLikeError(err) {
+  const code = String(err?.code || '');
+  const msg = String(err?.message || err || '');
+  return code === 'ECONNRESET'
+    || code === 'ECONNREFUSED'
+    || /ECONNRESET|socket hang up/i.test(msg);
+}
+
+function isMemoryWorkerNotReadyError(err) {
+  const msg = String(err?.message || err || '');
+  return /memory worker exited before ready|memory worker ready timeout|memory runtime did not become ready|memory worker degraded/i.test(msg);
+}
+
+function isTransientMemoryRpcError(err) {
+  return isConnResetLikeError(err) || isMemoryWorkerNotReadyError(err);
+}
+
+function isMemoryReadOnlyToolCall(name, args = {}) {
+  const tool = String(name || '').trim();
+  if (tool === 'recall' || tool === 'search_memories') return true;
+  if (tool !== 'memory') return false;
+  const action = String(args?.action || '').trim();
+  if (action === 'status') return true;
+  if (action === 'core') {
+    const op = String(args?.op || '').trim();
+    return op === 'list' || op === 'candidates';
+  }
+  return false;
+}
+
 function requestJson({ port, method = 'GET', path = '/', body = null, timeoutMs = 10_000, headers = {} }) {
   return new Promise((resolvePromise, reject) => {
     const payload = body == null ? null : JSON.stringify(body);
@@ -116,6 +148,33 @@ export function createStandaloneMemoryRuntime({
   let child = null;
   let nextCallId = 1;
 
+  function invalidateMemoryRuntimeAfterTransient(err) {
+    portCache = null;
+    if (!isMemoryWorkerNotReadyError(err)) return;
+    startPromise = null;
+    const proc = child;
+    child = null;
+    if (!proc || proc.killed) return;
+    try { proc.kill(); } catch {}
+  }
+
+  function shouldRetryMemoryRpcError(err, { readOnlyRpc = false } = {}) {
+    if (isMemoryWorkerNotReadyError(err)) return true;
+    if (readOnlyRpc && isConnResetLikeError(err)) return true;
+    return false;
+  }
+
+  async function withTransientMemoryRpcRetry(run, { readOnlyRpc = false } = {}) {
+    try {
+      return await run();
+    } catch (err) {
+      if (!shouldRetryMemoryRpcError(err, { readOnlyRpc })) throw err;
+      invalidateMemoryRuntimeAfterTransient(err);
+      await delay(TRANSIENT_MEMORY_RPC_BACKOFF_MS);
+      return await run();
+    }
+  }
+
   async function findLivePort({ allowStarting = false } = {}) {
     const active = readActiveInstance();
     const port = parsePort(active?.memory_port);
@@ -269,31 +328,36 @@ export function createStandaloneMemoryRuntime({
   }
 
   async function handleToolCall(name, args = {}) {
-    await start();
-    const port = portCache || await findLivePort({ allowStarting: true });
-    if (!port) throw new Error('memory runtime is not available');
+    const readOnlyRpc = isMemoryReadOnlyToolCall(name, args);
     const callId = `mem_${process.pid}_${nextCallId++}`;
-    return await requestJson({
-      port,
-      method: 'POST',
-      path: '/api/tool',
-      body: { name, arguments: args || {} },
-      timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
-      headers: { 'X-Mixdog-Call-Id': callId },
-    });
+    return await withTransientMemoryRpcRetry(async () => {
+      await start();
+      const port = portCache || await findLivePort({ allowStarting: true });
+      if (!port) throw new Error('memory runtime is not available');
+      return await requestJson({
+        port,
+        method: 'POST',
+        path: '/api/tool',
+        body: { name, arguments: args || {} },
+        timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
+        headers: { 'X-Mixdog-Call-Id': callId },
+      });
+    }, { readOnlyRpc });
   }
 
   async function buildSessionCoreMemoryPayload(sessionCwd) {
-    await start();
-    const port = portCache || await findLivePort({ allowStarting: true });
-    if (!port) throw new Error('memory runtime is not available');
-    return await requestJson({
-      port,
-      method: 'POST',
-      path: '/session-start/core-memory',
-      body: { cwd: sessionCwd || cwd },
-      timeoutMs: 30_000,
-    });
+    return await withTransientMemoryRpcRetry(async () => {
+      await start();
+      const port = portCache || await findLivePort({ allowStarting: true });
+      if (!port) throw new Error('memory runtime is not available');
+      return await requestJson({
+        port,
+        method: 'POST',
+        path: '/session-start/core-memory',
+        body: { cwd: sessionCwd || cwd },
+        timeoutMs: 30_000,
+      });
+    }, { readOnlyRpc: true });
   }
 
   async function stop() {

package/src/tui/App.jsx

@@ -386,7 +386,26 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
     setSettingsPrompt,
     parseMemoryCoreRows,
   });
-  const [disabledSkills, setDisabledSkills] = useState(() => new Set());
+  const [disabledSkills, setDisabledSkillsInner] = useState(() => {
+    try {
+      const { disabled = [] } = store.getDisabledSkills?.() || {};
+      return new Set(disabled);
+    } catch {
+      return new Set();
+    }
+  });
+  const setDisabledSkills = useCallback((next) => {
+    setDisabledSkillsInner((current) => {
+      const base = current instanceof Set ? current : new Set(current);
+      const set = typeof next === 'function' ? next(base) : (next instanceof Set ? next : new Set(next));
+      try {
+        store.setDisabledSkills?.([...set]);
+      } catch (e) {
+        store.pushNotice(`skill disable persist failed: ${e?.message || e}`, 'error');
+      }
+      return set;
+    });
+  }, [store]);
   const {
     openMcpServersPicker,
     openMcpPicker,

package/src/tui/app/extension-pickers.mjs

@@ -177,7 +177,10 @@ export function createExtensionPickers({
       const next = new Set(disabledSet);
       if (item._enabled) next.add(name); else next.delete(name);
       setDisabledSkills(next);
-      store.pushNotice(`skill ${item._enabled ? 'disabled' : 'enabled'}: ${name}`, 'info');
+      store.pushNotice(
+        `skill ${item._enabled ? 'disabled' : 'enabled'}: ${name} (prompt updates next session /clear)`,
+        'info',
+      );
       openSkillsPicker({ highlightValue: name, disabledOverride: next });
     };
     setPicker({
@@ -221,7 +224,7 @@ export function createExtensionPickers({
             next.delete(skill.name);
             return next;
           });
-          store.pushNotice(`skill enabled: ${skill.name}`, 'info');
+          store.pushNotice(`skill enabled: ${skill.name} (prompt updates next session /clear)`, 'info');
           openSkillsPicker();
           return;
         }
@@ -231,7 +234,7 @@ export function createExtensionPickers({
             next.add(skill.name);
             return next;
           });
-          store.pushNotice(`skill disabled: ${skill.name}`, 'info');
+          store.pushNotice(`skill disabled: ${skill.name} (prompt updates next session /clear)`, 'info');
           openSkillsPicker();
           return;
         }

package/src/tui/dist/index.mjs

@@ -13232,7 +13232,10 @@ function createExtensionPickers({
       if (item._enabled) next.add(name);
       else next.delete(name);
       setDisabledSkills(next);
-      store.pushNotice(`skill ${item._enabled ? "disabled" : "enabled"}: ${name}`, "info");
+      store.pushNotice(
+        `skill ${item._enabled ? "disabled" : "enabled"}: ${name} (prompt updates next session /clear)`,
+        "info"
+      );
       openSkillsPicker({ highlightValue: name, disabledOverride: next });
     };
     setPicker({
@@ -13275,7 +13278,7 @@ function createExtensionPickers({
             next.delete(skill.name);
             return next;
           });
-          store.pushNotice(`skill enabled: ${skill.name}`, "info");
+          store.pushNotice(`skill enabled: ${skill.name} (prompt updates next session /clear)`, "info");
           openSkillsPicker();
           return;
         }
@@ -13285,7 +13288,7 @@ function createExtensionPickers({
             next.add(skill.name);
             return next;
           });
-          store.pushNotice(`skill disabled: ${skill.name}`, "info");
+          store.pushNotice(`skill disabled: ${skill.name} (prompt updates next session /clear)`, "info");
           openSkillsPicker();
           return;
         }
@@ -18296,7 +18299,26 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
     setSettingsPrompt,
     parseMemoryCoreRows
   });
-  const [disabledSkills, setDisabledSkills] = useState8(() => /* @__PURE__ */ new Set());
+  const [disabledSkills, setDisabledSkillsInner] = useState8(() => {
+    try {
+      const { disabled = [] } = store.getDisabledSkills?.() || {};
+      return new Set(disabled);
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  });
+  const setDisabledSkills = useCallback6((next) => {
+    setDisabledSkillsInner((current) => {
+      const base = current instanceof Set ? current : new Set(current);
+      const set = typeof next === "function" ? next(base) : next instanceof Set ? next : new Set(next);
+      try {
+        store.setDisabledSkills?.([...set]);
+      } catch (e) {
+        store.pushNotice(`skill disable persist failed: ${e?.message || e}`, "error");
+      }
+      return set;
+    });
+  }, [store]);
   const {
     openMcpServersPicker,
     openMcpPicker,
@@ -23512,6 +23534,8 @@ async function createEngineSession({
         set({ commandBusy: false });
       }
     },
+    getDisabledSkills: () => runtime.getDisabledSkills?.() || { disabled: [] },
+    setDisabledSkills: (disabled) => runtime.setDisabledSkills?.(disabled) || { disabled: [] },
     skillsStatus: () => {
       return runtime.skillsStatus?.() || { cwd: state.cwd, count: 0, skills: [] };
     },

package/src/tui/engine.mjs

@@ -2098,6 +2098,8 @@ export async function createEngineSession({
         set({ commandBusy: false });
       }
     },
+    getDisabledSkills: () => runtime.getDisabledSkills?.() || { disabled: [] },
+    setDisabledSkills: (disabled) => runtime.setDisabledSkills?.(disabled) || { disabled: [] },
     skillsStatus: () => {
       return runtime.skillsStatus?.() || { cwd: state.cwd, count: 0, skills: [] };
     },