mixdog 0.9.10 → 0.9.12

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,
@@ -23075,6 +23097,16 @@ async function createEngineSession({
           restorable: nonEditable.length === 0,
           requeueOnAbort: nonEditable
         });
+        const scheduledReset = runtime.consumePendingSessionReset?.();
+        if ((scheduledReset === "clear" || scheduledReset === "compact_clear") && turnStatus !== "cancelled" && !state.commandBusy) {
+          await performSessionClear({
+            verb: scheduledReset === "clear" ? "Clearing conversation" : "Compacting and clearing conversation",
+            doneLabel: scheduledReset === "clear" ? "Session cleared" : "Session compacted and cleared",
+            skipLabel: "Session reset skipped",
+            surface: "session-manage",
+            useCompaction: scheduledReset === "compact_clear"
+          });
+        }
         if (turnStatus === "cancelled" && pending.length === 0) break;
       }
     } finally {
@@ -23118,14 +23150,26 @@ async function createEngineSession({
       if (!activityAt) lastUserActivityAt = now;
       return false;
     }
+    return performSessionClear({
+      verb: "Auto-clearing idle conversation",
+      doneLabel: "Auto-clear complete",
+      skipLabel: "Auto-clear skipped",
+      surface: "auto-clear",
+      useCompaction: true
+    });
+  }
+  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
     autoClearRunning = true;
     const startedAt2 = Date.now();
-    set({ commandStatus: { active: true, verb: "Auto-clearing idle conversation", startedAt: startedAt2, mode: "auto-clear" } });
+    set({ commandBusy: true, commandStatus: { active: true, verb, startedAt: startedAt2, mode: "auto-clear" } });
     try {
       await new Promise((resolve5) => setTimeout(resolve5, 0));
-      const compaction = runtime.getCompactionSettings();
-      const compactType = compaction.compactType || compaction.type;
-      await runtime.clear({ compactType, requireCompactSuccess: !!compactType });
+      let compactType = null;
+      if (useCompaction) {
+        const compaction = runtime.getCompactionSettings();
+        compactType = compaction.compactType || compaction.type || null;
+      }
+      await runtime.clear(compactType ? { compactType, requireCompactSuccess: true } : {});
       resetStats();
       clearUiActivityBeforeContextSync();
       syncContextStats({ allowEstimated: true });
@@ -23142,24 +23186,24 @@ async function createEngineSession({
       pushItem({
         kind: "statusdone",
         id: nextId(),
-        label: "Auto-clear complete",
+        label: doneLabel,
         detail: formatElapsedSeconds(Date.now() - startedAt2)
       });
       return true;
     } catch (error) {
-      const message = presentErrorText(error, { surface: "auto-clear" });
+      const message = presentErrorText(error, { surface });
       pushItem({
         kind: "statusdone",
         id: nextId(),
-        label: "Auto-clear skipped",
+        label: skipLabel,
         detail: `conversation kept \xB7 ${message}`
       });
-      pushNotice(`auto-clear skipped: ${message}`, "error");
+      pushNotice(`${surface} skipped: ${message}`, "error");
       return false;
     } finally {
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
-      set({ commandStatus: null });
+      set({ commandBusy: false, commandStatus: null });
       void drain();
     }
   }
@@ -23256,7 +23300,7 @@ async function createEngineSession({
     },
     submit: (text, options = {}) => {
       const t = promptDisplayText(text, options).trim();
-      if (!t || state.commandBusy) return false;
+      if (!t) return false;
       const mode = options.mode || "prompt";
       const priority = options.priority;
       const queueOptions = {
@@ -23265,11 +23309,12 @@ async function createEngineSession({
         displayText: promptDisplayText(text, options),
         priority
       };
-      if (state.busy) {
+      if (autoClearRunning) {
         enqueue(text, queueOptions);
         return true;
       }
-      if (autoClearRunning) {
+      if (state.commandBusy) return false;
+      if (state.busy) {
         enqueue(text, queueOptions);
         return true;
       }
@@ -23512,6 +23557,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

@@ -1624,6 +1624,24 @@ export async function createEngineSession({
           restorable: nonEditable.length === 0,
           requeueOnAbort: nonEditable,
         });
+        // session_manage tool: the model scheduled a reset during this turn.
+        // Run it now, at the turn boundary — same clear body as auto-clear.
+        // Cancelled/interrupted turns drop the reset (consume + discard): the
+        // user aborted the turn that asked for it, so the destructive clear
+        // must not fire. commandBusy guards against a concurrent session
+        // command (resume/new) racing the async clear.
+        const scheduledReset = runtime.consumePendingSessionReset?.();
+        if ((scheduledReset === 'clear' || scheduledReset === 'compact_clear')
+          && turnStatus !== 'cancelled'
+          && !state.commandBusy) {
+          await performSessionClear({
+            verb: scheduledReset === 'clear' ? 'Clearing conversation' : 'Compacting and clearing conversation',
+            doneLabel: scheduledReset === 'clear' ? 'Session cleared' : 'Session compacted and cleared',
+            skipLabel: 'Session reset skipped',
+            surface: 'session-manage',
+            useCompaction: scheduledReset === 'compact_clear',
+          });
+        }
         // If the user re-submits the reclaimed prompt while the cancelled turn
         // is still unwinding, enqueue() cannot start another drain because this
         // drain loop is still active. Continue when pending work appeared during
@@ -1682,18 +1700,40 @@ export async function createEngineSession({
       if (!activityAt) lastUserActivityAt = now;
       return false;
     }
+    return performSessionClear({
+      verb: 'Auto-clearing idle conversation',
+      doneLabel: 'Auto-clear complete',
+      skipLabel: 'Auto-clear skipped',
+      surface: 'auto-clear',
+      useCompaction: true,
+    });
+  }
+
+  // Shared clear body for idle auto-clear and the session_manage tool.
+  // useCompaction=true mirrors auto-clear (summarize via configured
+  // compactType, context carries forward); false is a plain /clear wipe.
+  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
     autoClearRunning = true;
     const startedAt = Date.now();
-    set({ commandStatus: { active: true, verb: 'Auto-clearing idle conversation', startedAt, mode: 'auto-clear' } });
+    // commandBusy blocks concurrent session commands (resume/newSession/
+    // setModel) AND new submits for the duration of the async clear — the
+    // clear swaps the live session object, so racing commands could act on
+    // the wrong session.
+    set({ commandBusy: true, commandStatus: { active: true, verb, startedAt, mode: 'auto-clear' } });
     try {
       // Give Ink one event-loop turn to paint the auto-clear status before the
       // clear/compact path starts doing synchronous session/transcript work.
       // Without this, long idle clears can look like a frozen prompt followed by
       // an already-complete status row.
       await new Promise((resolve) => setTimeout(resolve, 0));
-      const compaction = runtime.getCompactionSettings();
-      const compactType = compaction.compactType || compaction.type;
-      await runtime.clear({ compactType, requireCompactSuccess: !!compactType });
+      let compactType = null;
+      if (useCompaction) {
+        const compaction = runtime.getCompactionSettings();
+        compactType = compaction.compactType || compaction.type || null;
+      }
+      await runtime.clear(compactType
+        ? { compactType, requireCompactSuccess: true }
+        : {});
       resetStats();
       clearUiActivityBeforeContextSync();
       syncContextStats({ allowEstimated: true });
@@ -1710,24 +1750,24 @@ export async function createEngineSession({
       pushItem({
         kind: 'statusdone',
         id: nextId(),
-        label: 'Auto-clear complete',
+        label: doneLabel,
         detail: formatElapsedSeconds(Date.now() - startedAt),
       });
       return true;
     } catch (error) {
-      const message = presentErrorText(error, { surface: 'auto-clear' });
+      const message = presentErrorText(error, { surface });
       pushItem({
         kind: 'statusdone',
         id: nextId(),
-        label: 'Auto-clear skipped',
+        label: skipLabel,
         detail: `conversation kept · ${message}`,
       });
-      pushNotice(`auto-clear skipped: ${message}`, 'error');
+      pushNotice(`${surface} skipped: ${message}`, 'error');
       return false;
     } finally {
       lastUserActivityAt = Date.now();
       autoClearRunning = false;
-      set({ commandStatus: null });
+      set({ commandBusy: false, commandStatus: null });
       void drain();
     }
   }
@@ -1827,7 +1867,7 @@ export async function createEngineSession({
     },
     submit: (text, options = {}) => {
       const t = promptDisplayText(text, options).trim();
-      if (!t || state.commandBusy) return false;
+      if (!t) return false;
       const mode = options.mode || 'prompt';
      // Prompt input queued while a turn is active keeps the
      // default `next` priority, so it is injected at the next tool/model
@@ -1839,11 +1879,14 @@ export async function createEngineSession({
         displayText: promptDisplayText(text, options),
         priority,
       };
-      if (state.busy) {
+      // A running clear (idle auto-clear or session_manage) sets commandBusy;
+      // queue the prompt instead of dropping it — it drains after the clear.
+      if (autoClearRunning) {
         enqueue(text, queueOptions);
         return true;
       }
-      if (autoClearRunning) {
+      if (state.commandBusy) return false;
+      if (state.busy) {
         enqueue(text, queueOptions);
         return true;
       }
@@ -2098,6 +2141,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: [] };
     },