mixdog 0.9.83 → 0.9.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.83",
+  "version": "0.9.84",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/runtime/agent/orchestrator/session/manager/idle-cleanup.mjs

@@ -2,7 +2,7 @@
 // Periodic idle-session + tombstone sweep extracted verbatim from manager.mjs.
 // Drives sweepStaleSessions on an unref'd interval; closeSession is imported
 // from session-close.mjs (one-way dependency, no cycle).
-import { sweepStaleSessions, evictIdleLiveSessions } from '../store.mjs';
+import { sweepStaleSessions, sweepStaleSessionsCooperative, evictIdleLiveSessions } from '../store.mjs';
 import { sweepOrphanedPendingMessages } from './pending-messages.mjs';
 import {
     _getRuntimeEntry,
@@ -23,6 +23,7 @@ const CLEANUP_SLOW_LOG_MS = nonNegativeIntEnv('MIXDOG_SESSION_CLEANUP_SLOW_LOG_M
 const TOMBSTONE_MAX_AGE_MS = 60 * 60 * 1000; // 1h
 let _cleanupTimer = null;
 let _cleanupInitialTimer = null;
+let _cleanupRun = null;
 
 // A session is "live" when it still owns a non-closed runtime entry. Passed to
 // the retention cap so the active/current and any in-flight session is never
@@ -65,10 +66,10 @@ const _sweepLog = (line) => {
     if (process.env.MIXDOG_DEBUG_SESSION_LOG) process.stderr.write(line);
 };
 
-function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
+async function sweepIdleSessions({ includeTombstones = true, sweepIdle = true } = {}) {
     const startedAt = Date.now();
     try {
-        const result = sweepStaleSessions({
+        const result = await sweepStaleSessionsCooperative({
             sweepIdle,
             tombstoneMaxAgeMs: includeTombstones ? TOMBSTONE_MAX_AGE_MS : 0,
             isSessionLive: _isSessionLive,
@@ -144,33 +145,43 @@ export function sweepTombstones() {
 }
 
 export function _runCleanupCycle() {
-    // Drain every settled runtime entry on each pass, not just the one or two
-    // sessions whose on-disk idle TTL happened to expire in this interval.
-    _sweepTerminalSessionRuntimes();
-    sweepOrphanedPendingMessages();
-    sweepIdleSessions({ includeTombstones: true });
-    // Reclaim same-process session snapshots whose state is durable on disk
-    // (memory-leak guard: _liveSessions used to grow for process lifetime).
-    try { evictIdleLiveSessions({ isSessionLive: _isSessionLive }); } catch { /* best-effort */ }
+    if (_cleanupRun) return _cleanupRun;
+    const run = (async () => {
+        // Drain every settled runtime entry on each pass, not just the one or two
+        // sessions whose on-disk idle TTL happened to expire in this interval.
+        _sweepTerminalSessionRuntimes();
+        sweepOrphanedPendingMessages();
+        await sweepIdleSessions({ includeTombstones: true });
+        // Reclaim same-process session snapshots whose state is durable on disk
+        // (memory-leak guard: _liveSessions used to grow for process lifetime).
+        try { evictIdleLiveSessions({ isSessionLive: _isSessionLive }); } catch { /* best-effort */ }
+    })().catch((error) => {
+        try { process.stderr.write(`[agent-session] cleanup cycle failed: ${error?.message || error}\n`); } catch {}
+    });
+    const tracked = run.finally(() => {
+        if (_cleanupRun === tracked) _cleanupRun = null;
+    });
+    _cleanupRun = tracked;
+    return tracked;
 }
 
 function _startCleanupInterval() {
     if (_cleanupTimer) return;
     if (CLEANUP_INTERVAL_MS <= 0) return;
-    _cleanupTimer = setInterval(_runCleanupCycle, CLEANUP_INTERVAL_MS);
+    _cleanupTimer = setInterval(() => { void _runCleanupCycle(); }, CLEANUP_INTERVAL_MS);
     if (_cleanupTimer.unref) _cleanupTimer.unref(); // don't block process exit
 }
 
 export function startIdleCleanup() {
     if (_cleanupTimer || _cleanupInitialTimer) return;
     if (CLEANUP_INITIAL_DELAY_MS <= 0) {
-        _runCleanupCycle();
+        void _runCleanupCycle();
         _startCleanupInterval();
         return;
     }
     _cleanupInitialTimer = setTimeout(() => {
         _cleanupInitialTimer = null;
-        _runCleanupCycle();
+        void _runCleanupCycle();
         _startCleanupInterval();
     }, CLEANUP_INITIAL_DELAY_MS);
     if (_cleanupInitialTimer.unref) _cleanupInitialTimer.unref();

package/src/runtime/agent/orchestrator/session/store/listing.mjs

@@ -244,7 +244,7 @@ export function getStoredSessionsRaw() {
  * Background sweep: delete session files idle longer than ttlMs.
  * Returns { cleaned, remaining, details } for logging.
  */
-export function sweepStaleSessions(ttlMs, options = {}) {
+function* sweepStaleSessionSteps(ttlMs, options = {}) {
     if (ttlMs && typeof ttlMs === 'object') {
         options = ttlMs;
         ttlMs = options.ttlMs;
@@ -302,6 +302,9 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     let openPruned = 0;
     const openPrunedDetails = [];
     for (const row of summaries) {
+        // Cooperative callers pause between records so large stores never hold
+        // an interactive host's event loop for the full directory scan.
+        yield undefined;
         try {
             if (!row?.id) continue;
             const jsonPath = sessionPath(row.id);
@@ -593,6 +596,7 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     // session mid-create whose .json write has not landed yet.
     try {
         for (const h of readdirSync(dir).filter(f => f.endsWith('.hb') || f.endsWith('.own'))) {
+            yield undefined;
             if (existsSync(join(dir, h.replace(/\.(hb|own)$/, '.json')))) continue;
             let hbMtime = 0;
             try { hbMtime = statSync(join(dir, h)).mtimeMs; } catch { continue; }
@@ -613,3 +617,36 @@ export function sweepStaleSessions(ttlMs, options = {}) {
     }
     return { cleaned, remaining, details, tombstonesCleaned, tombstoneDetails, tombstoneErrors, openPruned, openPrunedDetails };
 }
+
+/** Synchronous compatibility surface for explicit maintenance commands/tests. */
+export function sweepStaleSessions(ttlMs, options = {}) {
+    const steps = sweepStaleSessionSteps(ttlMs, options);
+    let next = steps.next();
+    while (!next.done) next = steps.next();
+    return next.value;
+}
+
+/**
+ * Interactive-host sweep: preserve the exact synchronous lifecycle decisions
+ * while yielding between records. A single large session remains atomic, but a
+ * directory worth of reads/parses can no longer become one multi-second task.
+ */
+export async function sweepStaleSessionsCooperative(ttlMs, options = {}) {
+    const cooperativeOptions = ttlMs && typeof ttlMs === 'object' ? ttlMs : options;
+    const configuredSliceMs = Number(cooperativeOptions?.cooperativeSliceMs);
+    const sliceMs = Number.isFinite(configuredSliceMs)
+        ? Math.min(50, Math.max(0, configuredSliceMs))
+        : 8;
+    const steps = sweepStaleSessionSteps(ttlMs, options);
+    let next = steps.next();
+    while (!next.done) {
+        const sliceStartedAt = performance.now();
+        do {
+            next = steps.next();
+        } while (!next.done && performance.now() - sliceStartedAt < sliceMs);
+        if (!next.done) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+    return next.value;
+}

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -757,5 +757,6 @@ export {
     listStoredSessionSummaries,
     getStoredSessionsRaw,
     sweepStaleSessions,
+    sweepStaleSessionsCooperative,
 } from './store/listing.mjs';
 export { _savePending };