mixdog 0.9.150 → 0.9.151

package/src/runtime/shared/pristine-execution-contract.json

@@ -5,12 +5,15 @@
     "MIXDOG_DISABLE_MCP": "1",
     "MIXDOG_DISABLE_SKILLS": "1",
     "MIXDOG_BOOT_CORE_MEMORY": "0",
+    "MIXDOG_DAEMON_SKIP_MEMORY": "1",
+    "MIXDOG_DISABLE_MEMORY_INGEST": "1",
     "MIXDOG_DISABLE_CHANNEL_START": "1",
     "MIXDOG_SKIP_USER_DATA_BACKUP": "1",
     "MIXDOG_DISABLE_STAGED_INSTALL": "1",
     "MIXDOG_DISABLE_STAGED_SWAP": "1",
     "MIXDOG_FEATURE_WEB_SEARCH": "0",
     "MIXDOG_FEATURE_MEMORY": "0",
+    "MIXDOG_MEMORY_DISABLE_CYCLES": "1",
     "MIXDOG_MEMORY_CLIENT_GRACE_MS": "1"
   },
   "approvedExecutionEnv": [

package/src/runtime/shared/pristine-execution.mjs

@@ -244,7 +244,9 @@ export function createPristineExecutionBoundary({
   };
   const rootDir = mkdtempSync(join(tmpdir(), 'mixdog-headless-pristine-'));
   const dataDir = join(rootDir, 'data');
+  const runtimeRoot = join(rootDir, 'runtime-root');
   mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+  mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
   let cleaned = false;
   let restoreAuthBindings = () => {};
   const cleanup = ({ preserveRoot = false, tolerateRootRemovalFailure = false } = {}) => {
@@ -259,7 +261,7 @@ export function createPristineExecutionBoundary({
     // process exits; rmSync retries absorb that EBUSY/EPERM window.
     if (!preserveRoot) {
       try {
-        rmSync(rootDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        rmSync(rootDir, { recursive: true, force: true, maxRetries: 50, retryDelay: 100 });
       } catch (error) {
         if (tolerateRootRemovalFailure) return { rootRemovalError: error };
         throw error;
@@ -306,6 +308,7 @@ export function createPristineExecutionBoundary({
     }
     setEnv('MIXDOG_HOME', rootDir);
     setEnv('MIXDOG_DATA_DIR', dataDir);
+    setEnv('MIXDOG_RUNTIME_ROOT', runtimeRoot);
     for (const [name, value] of Object.entries({
       ...inheritedExecutionEnv,
       ...approvedExecutionEnv,
@@ -358,7 +361,7 @@ export function createPristineExecutionBoundary({
       authMode,
       catalogCount,
     });
-    return { rootDir, dataDir, config, audit, loadConfig, cleanup };
+    return { rootDir, dataDir, runtimeRoot, config, audit, loadConfig, cleanup };
   } catch (error) {
     cleanup();
     throw error;

package/src/session-runtime/lifecycle-api.mjs

@@ -166,6 +166,7 @@ export function createLifecycleApi(deps) {
   // them later). Never loads the memory runtime just for this — a null
   // module promise means memory was never used this run, so skip.
   async function ingestSessionIntoMemory(session) {
+    if (process.env.MIXDOG_DISABLE_MEMORY_INGEST === '1') return;
     try {
       const messages = Array.isArray(session?.messages) ? session.messages : [];
       if (!session?.id || messages.length === 0) return;

package/src/standalone/channel-worker-heartbeat.test.mjs

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { pruneStaleChannelClientHeartbeats } from './channel-worker.mjs';
+
+test('channel heartbeat sweep removes dead and expired rows only', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-channel-heartbeat-test-'));
+  const now = 100_000;
+  try {
+    writeFileSync(join(root, '1.json'), JSON.stringify({ pid: 1, updatedAt: now - 1_000 }));
+    writeFileSync(join(root, '2.json'), JSON.stringify({ pid: 2, updatedAt: now - 60_000 }));
+    writeFileSync(join(root, '3.json'), JSON.stringify({ pid: 3, updatedAt: now - 1_000 }));
+
+    const removed = pruneStaleChannelClientHeartbeats(root, {
+      now,
+      maxAgeMs: 30_000,
+      pidAlive: (pid) => pid !== 3,
+    });
+
+    assert.equal(removed, 2);
+    assert.equal(existsSync(join(root, '1.json')), true);
+    assert.equal(existsSync(join(root, '2.json')), false);
+    assert.equal(existsSync(join(root, '3.json')), false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/standalone/channel-worker.mjs

@@ -1,9 +1,10 @@
 import { fork } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { mkdirSync, rmSync, writeFile } from 'node:fs';
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFile } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { appendBuffered } from '../runtime/shared/buffered-appender.mjs';
+import { isPidAlive } from '../runtime/shared/pid-liveness.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { detachedSpawnOpts } from '../runtime/shared/spawn-flags.mjs';
 import { scrubLoaderVars } from '../runtime/agent/orchestrator/tools/env-scrub.mjs';
@@ -34,6 +35,34 @@ function logLine(path, line) {
 const CHANNEL_WORKER_EXIT_CLEANUPS = new Set();
 let channelWorkerExitHookInstalled = false;
 
+export function pruneStaleChannelClientHeartbeats(clientDir, {
+  now = Date.now(),
+  maxAgeMs = 30_000,
+  pidAlive = isPidAlive,
+} = {}) {
+  let removed = 0;
+  try {
+    for (const name of readdirSync(clientDir)) {
+      if (!/^\d+\.json$/.test(name)) continue;
+      const target = join(clientDir, name);
+      let row = null;
+      try { row = JSON.parse(readFileSync(target, 'utf8')); } catch {}
+      const pid = Number(row?.pid);
+      const updatedAt = Number(row?.updatedAt);
+      const stale = !Number.isInteger(pid) || pid <= 0
+        || !Number.isFinite(updatedAt)
+        || now - updatedAt > Math.max(5_000, Number(maxAgeMs) || 30_000)
+        || !pidAlive(pid);
+      if (!stale) continue;
+      try {
+        rmSync(target, { force: true });
+        removed += 1;
+      } catch {}
+    }
+  } catch {}
+  return removed;
+}
+
 function registerChannelWorkerExitCleanup(cleanup) {
   if (typeof cleanup !== 'function') return () => {};
   CHANNEL_WORKER_EXIT_CLEANUPS.add(cleanup);
@@ -82,6 +111,7 @@ export function createStandaloneChannelWorker({
     try {
       if (!clientDirReady) {
         mkdirSync(clientDir, { recursive: true });
+        pruneStaleChannelClientHeartbeats(clientDir);
         clientDirReady = true;
       }
       writeFile(clientPath, JSON.stringify({

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

@@ -650,9 +650,12 @@ export function createStandaloneMemoryRuntime({
     const ownedChild = child;
     const childExit = waitForExit && ownedChild && ownedChild.exitCode == null
       ? new Promise((resolveExit, rejectExit) => {
-          const onExit = () => {
+          const onExit = (code, signal) => {
             clearTimeout(timer);
-            resolveExit(true);
+            if (code === 0) resolveExit(true);
+            else rejectExit(new Error(
+              `memory runtime exited unsuccessfully (${signal || code || 'unknown'})`,
+            ));
           };
           const timer = setTimeout(() => {
             ownedChild.off('exit', onExit);

package/src/standalone/session-client.mjs

@@ -677,15 +677,35 @@ export async function attachSession({
 
 /** Ask a live daemon to exit. Used by dev/test teardown; normal clients just
  *  detach and let the client-grace shutdown fire. */
-export async function shutdownDaemon(discovery = readSessionDiscovery()) {
+export async function shutdownDaemon(discovery = readSessionDiscovery(), {
+  waitForExit = false,
+  timeoutMs = 15_000,
+} = {}) {
   if (!discovery?.port) return false;
+  const daemonPid = Number(discovery.pid);
   try {
     await request({
       port: discovery.port, token: discovery.token, method: 'POST',
       path: '/shutdown', body: {}, timeoutMs: 3000, control: true,
     });
-    return true;
-  } catch { return false; }
+  } catch {
+    return Number.isInteger(daemonPid) && daemonPid > 0 && !isPidAlive(daemonPid);
+  }
+  if (!waitForExit || !Number.isInteger(daemonPid) || daemonPid <= 0) return true;
+  const deadline = Date.now() + Math.max(1, Number(timeoutMs) || 15_000);
+  while (isPidAlive(daemonPid) && Date.now() < deadline) await delay(50);
+  if (isPidAlive(daemonPid)) {
+    throw new Error(`session daemon pid=${daemonPid} did not exit within ${timeoutMs}ms`);
+  }
+  return true;
+}
+
+export async function shutdownDaemonForRuntimeRoot(root, options = {}) {
+  const runtimeRoot = String(root || '').trim();
+  if (!runtimeRoot) return false;
+  const discovery = readSessionDiscovery(path.join(path.resolve(runtimeRoot), 'daemon.json'));
+  if (!discovery) return false;
+  return shutdownDaemon(discovery, options);
 }
 
 // ── Shared per-process attachment ────────────────────────────────────────────

package/src/tui/session/turn.mjs

@@ -1033,6 +1033,14 @@ export function createRunTurn(bag) {
             invalidateExact: compactChanged,
             compactedEstimateTokens: compactChanged ? event?.afterTokens : null,
           });
+          // syncContextStats only STAGES its patch on the draft (context-state
+          // mjs stages through updateState); publication is the caller's, and
+          // every other compact path already follows with this exact set. The
+          // auto path did not, so the post-compact gauge reached React only if
+          // some later mutation happened to carry it — the manual path
+          // repainted immediately while auto looked stuck on the pre-compact
+          // number (user: 오토 컴팩트 이후에 컨텍스트 원형바가 동기화가 안됨).
+          set({ ...routeState(), stats: { ...getState().stats } });
         },
         onStageChange: async (stage, detail = null) => {
           if (!markTurnProgress(`stage:${String(stage || '')}`)) return;
@@ -1200,6 +1208,10 @@ export function createRunTurn(bag) {
         finalizeToolHeaders();
         flushStreamBatch(); // force-flush any batched streaming text before finalization writes
         syncContextStats({ allowEstimated: true });
+        // Terminal reading for the turn. Without its own publication the last
+        // gauge number React ever saw is the one the previous usage delta
+        // carried, so an idle session sat on a stale count until the next turn.
+        set({ stats: { ...getState().stats } });
 
         const finalText = result?.content != null ? String(result.content) : '';
         // Strip text already sealed as its own item(s) this turn (a tool