mixdog 0.9.23 → 0.9.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.23",
+  "version": "0.9.25",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -33,6 +33,7 @@
   ],
   "scripts": {
     "prepack": "npm run build:tui",
+    "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run the Release workflow: gh workflow run release -f bump=patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
     "smoke": "node scripts/smoke.mjs",
     "smoke:all": "npm run smoke && npm run smoke:boot && npm run smoke:tools && npm run smoke:output && npm run smoke:tui && npm run smoke:freevars && npm run smoke:logguard",

package/scripts/boot-smoke.mjs

@@ -64,7 +64,7 @@ const rows = [
     try {
       const status = runtime.toolsStatus();
       const active = new Set(status.activeTools || []);
-      for (const name of ['read','code_graph','grep','find','glob','list','apply_patch','explore','agent','shell','task','cwd','recall','search','web_fetch','Skill','tool_search']) {
+      for (const name of ['read','code_graph','grep','find','glob','list','apply_patch','explore','agent','shell','task','cwd','recall','search','web_fetch','Skill','load_tool']) {
         if (!active.has(name)) throw new Error('missing ' + name + ' in ' + [...active].join(','));
       }
       for (const name of ['bash']) {

package/scripts/channel-daemon-smoke.mjs

@@ -11,10 +11,13 @@
 // Run: node scripts/channel-daemon-smoke.mjs
 import os from 'node:os';
 import path from 'node:path';
+import http from 'node:http';
+import { spawn } from 'node:child_process';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { createChannelDaemonTransport } from '../src/standalone/channel-daemon-transport.mjs';
 import { attachToDaemon } from '../src/standalone/channel-daemon-client.mjs';
+import { createParentBridge, setChannelNotifySink } from '../src/runtime/channels/lib/parent-bridge.mjs';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const STUB_ENTRY = path.join(HERE, 'channel-daemon-stub.mjs');
@@ -70,18 +73,20 @@ async function main() {
   const rB = await clientB.call('fetch', { q: 2 });
   check('client B call round-trips', rB?.ok === true && rB?.name === 'fetch');
 
-  // (3) notify targets the pointer client. First registrant (A) is the pointer.
-  transport.notify('notifications/claude/channel', { content: 'to-A' });
+  // (3) LAST-WINS register: the NEWEST registrant (B) steals the ownership seat,
+  // so an inbound notify targets B — NOT the first registrant. (Under the old
+  // first-wins model this went to A.)
+  transport.notify('notifications/claude/channel', { content: 'to-B' });
   await delay(120);
-  check('notify #1 delivered to A only',
-    notA.length === 1 && notA[0]?.params?.content === 'to-A' && notB.length === 0);
+  check('notify #1 targets newest registrant (B) only',
+    notB.length === 1 && notB[0]?.params?.content === 'to-B' && notA.length === 0);
 
-  // (4) bind-intent call moves the pointer to B.
-  await clientB.call('rebind_current_transcript', { transcriptPath: '/tmp/b.jsonl' });
-  transport.notify('notifications/claude/channel', { content: 'to-B' });
+  // (4) bind-intent call moves the pointer back to A.
+  await clientA.call('rebind_current_transcript', { transcriptPath: '/tmp/a.jsonl' });
+  transport.notify('notifications/claude/channel', { content: 'to-A' });
   await delay(120);
-  check('notify #2 delivered to B only after rebind',
-    notB.length === 1 && notB[0]?.params?.content === 'to-B' && notA.length === 1);
+  check('notify #2 delivered to A only after rebind',
+    notA.length === 1 && notA[0]?.params?.content === 'to-A' && notB.length === 1);
 
   // (fix 1) idempotent replay: two /call with the SAME callId (a retried
   // transport failure) must run the non-idempotent side-effect exactly once.
@@ -93,6 +98,54 @@ async function main() {
   check('idempotent replay: same callId → exactly one side-effect',
     sideEffects === 1 && d1?.ok === true && d2?.ok === true);
 
+  // (targeted) the 'acquired' badge goes ONLY to the current owner (pointer=A
+  // after the rebind), never broadcast — a displaced/non-owner TUI (B) must not
+  // light its remote badge. Still sticky for a late owner attach (below).
+  const remoteBefore = { A: notA.length, B: notB.length };
+  transport.notify('notifications/mixdog/remote', { state: 'acquired' });
+  await delay(120);
+  const gotA = notA.slice(remoteBefore.A).filter((m) => m?.method === 'notifications/mixdog/remote');
+  const gotB = notB.slice(remoteBefore.B).filter((m) => m?.method === 'notifications/mixdog/remote');
+  check('remote-state acquired targets owner (A) only, not broadcast',
+    gotA.length === 1 && gotB.length === 0);
+
+  // A late client that registers becomes the NEWEST owner (steals the pointer),
+  // so on attach it replays the sticky 'acquired' badge for itself.
+  const notC = [];
+  const clientC = await attachToDaemon({ discovery, leadPid: process.pid, cwd: 'C', onNotify: (m) => notC.push(m) });
+  await waitFor(() => notC.some((m) => m?.method === 'notifications/mixdog/remote'), 1000);
+  check('late owner receives replayed remote-state on attach',
+    notC.filter((m) => m?.method === 'notifications/mixdog/remote' && m?.params?.state === 'acquired').length === 1);
+  await clientC.close();
+
+  // (replay) 'superseded' CLEARS the sticky: a client attaching after it must
+  // receive NO remote-state replay (else it would wrongly stop a fresh client).
+  transport.notify('notifications/mixdog/remote', { state: 'superseded' });
+  await delay(60);
+  const notD = [];
+  const clientD = await attachToDaemon({ discovery, leadPid: process.pid, cwd: 'D', onNotify: (m) => notD.push(m) });
+  await delay(150);
+  check('attach after superseded receives no remote-state replay',
+    notD.filter((m) => m?.method === 'notifications/mixdog/remote').length === 0);
+  await clientD.close();
+
+  // (sink) daemon-mode wiring: owned-runtime routes remote-state through the
+  // parent bridge's sendNotifyToParent (NOT raw process.send). The daemon
+  // installs a sink -> transport.notify (channel-daemon.mjs:106). Assert an
+  // 'acquired' emitted via that sink reaches the transport and replays to a
+  // late client — the exact daemon-mode path a raw process.send would drop.
+  const { sendNotifyToParent } = createParentBridge({ getInstanceId: () => 'smoke' });
+  setChannelNotifySink((method, params) => transport.notify(method, params));
+  sendNotifyToParent('notifications/mixdog/remote', { state: 'acquired' });
+  await delay(60);
+  const notE = [];
+  const clientE = await attachToDaemon({ discovery, leadPid: process.pid, cwd: 'E', onNotify: (m) => notE.push(m) });
+  await waitFor(() => notE.some((m) => m?.method === 'notifications/mixdog/remote'), 1000);
+  check('daemon-mode acquire via notify sink reaches transport + replays',
+    notE.filter((m) => m?.method === 'notifications/mixdog/remote' && m?.params?.state === 'acquired').length === 1);
+  await clientE.close();
+  setChannelNotifySink(null);
+
   // (5) deregister both → self-shutdown fires after the client grace window.
   await clientA.close();
   await clientB.close();
@@ -103,6 +156,10 @@ async function main() {
   try { rmSync(tmp, { recursive: true, force: true }); } catch {}
 
   await flipTest();
+  await pointerStealTest();
+  await reattachBufferTest();
+  await pointerFailoverTest();
+  await pointerReconnectFollowsTest();
 
   console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILURE(S)`);
   process.exit(failures === 0 ? 0 : 1);
@@ -162,4 +219,265 @@ async function flipTest() {
   try { rmSync(tmp, { recursive: true, force: true }); } catch {}
 }
 
+// Last-wins ownership steal coverage with DISTINCT alive leadPids (two sleeper
+// child processes) — the only way to observe the targeted 'superseded' frame,
+// which is skipped when old/new client share a leadPid (same-TUI rebind).
+async function pointerStealTest() {
+  const tmp = mkdtempSync(path.join(os.tmpdir(), 'mixdog-steal-smoke-'));
+  const discoveryPath = path.join(tmp, 'channel-daemon.json');
+  const transport = createChannelDaemonTransport({
+    handleCall: async (name, args, ctx) => ({ ok: true, name, leadPid: ctx.leadPid }),
+    discoveryPath,
+    clientGraceMs: 2000,
+    sweepMs: 5000,
+    onClientsEmpty: () => {},
+    log: (m) => process.env.DAEMON_SMOKE_VERBOSE && console.log(`[steal] ${m}`),
+  });
+  const { port, token } = await transport.start();
+  const discovery = { port, token, pid: process.pid };
+  const REMOTE = 'notifications/mixdog/remote';
+
+  // Two long-lived children give us two DISTINCT alive lead pids.
+  const sleeperA = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  const sleeperB = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  await delay(80);
+
+  const notA = [];
+  const notB = [];
+  const clientA = await attachToDaemon({ discovery, leadPid: sleeperA.pid, cwd: 'A', onNotify: (m) => notA.push(m) });
+  await delay(100); // A registers → A is the owner
+  const clientB = await attachToDaemon({ discovery, leadPid: sleeperB.pid, cwd: 'B', onNotify: (m) => notB.push(m) });
+  await delay(150); // B registers → steals the seat, A gets targeted superseded
+
+  check('steal: newest registrant (B) becomes the owner pointer',
+    transport._resolveTargetForTest()?.leadPid === sleeperB.pid);
+  check('steal: displaced owner (A) got a TARGETED superseded on register',
+    notA.filter((m) => m?.method === REMOTE && m?.params?.state === 'superseded').length === 1);
+  check('steal: new owner (B) got no superseded',
+    notB.filter((m) => m?.method === REMOTE).length === 0);
+
+  // 'acquired' now targets the owner (B) only — never broadcast to A.
+  transport.notify(REMOTE, { state: 'acquired' });
+  await delay(120);
+  check('steal: acquired targets owner (B) only, not broadcast',
+    notB.filter((m) => m?.params?.state === 'acquired').length === 1 &&
+    notA.filter((m) => m?.params?.state === 'acquired').length === 0);
+
+  // A bind-intent /call from A steals the seat back → B (displaced) superseded.
+  await clientA.call('activate_channel_bridge', {});
+  await delay(120);
+  check('steal: bind /call moves pointer back to A',
+    transport._resolveTargetForTest()?.leadPid === sleeperA.pid);
+  check('steal: displaced owner (B) got targeted superseded on bind /call',
+    notB.filter((m) => m?.method === REMOTE && m?.params?.state === 'superseded').length === 1);
+
+  // superseded via notify() (seat lost to another daemon) still BROADCASTS to
+  // every live client, regardless of pointer.
+  const aBefore = notA.length;
+  const bBefore = notB.length;
+  transport.notify(REMOTE, { state: 'superseded' });
+  await delay(120);
+  check('steal: superseded via notify broadcasts to ALL live clients',
+    notA.slice(aBefore).some((m) => m?.params?.state === 'superseded') &&
+    notB.slice(bBefore).some((m) => m?.params?.state === 'superseded'));
+
+  await clientA.close();
+  await clientB.close();
+  try { sleeperA.kill(); } catch {}
+  try { sleeperB.kill(); } catch {}
+  await transport.stop();
+  try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+}
+
+// Low-level helpers: register/attach WITHOUT the auto-attach client, so a
+// client can be registered but leave its SSE stream closed (to exercise the
+// buffered-superseded + reattach paths that attachToDaemon hides).
+function rawPost(port, serverToken, p, body) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request({
+      hostname: '127.0.0.1', port, path: p, method: 'POST',
+      headers: { 'X-Mixdog-Daemon-Token': serverToken, 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+    }, (res) => { let d = ''; res.setEncoding('utf8'); res.on('data', (c) => { d += c; }); res.on('end', () => { try { resolve(JSON.parse(d)); } catch { resolve({}); } }); });
+    req.on('error', reject); req.write(payload); req.end();
+  });
+}
+function rawSse(port, serverToken, clientToken, onNotify) {
+  const req = http.request({
+    hostname: '127.0.0.1', port,
+    path: `/events?token=${encodeURIComponent(clientToken)}&server_token=${encodeURIComponent(serverToken)}`,
+    method: 'GET', headers: { Accept: 'text/event-stream', 'X-Mixdog-Daemon-Token': serverToken },
+  }, (res) => {
+    res.setEncoding('utf8'); let buf = '';
+    res.on('data', (chunk) => {
+      buf += chunk; let idx;
+      while ((idx = buf.indexOf('\n\n')) >= 0) {
+        const raw = buf.slice(0, idx); buf = buf.slice(idx + 2);
+        for (const line of raw.split('\n')) {
+          if (!line.startsWith('data:')) continue;
+          const j = line.slice(5).trim(); if (!j) continue;
+          let m = null; try { m = JSON.parse(j); } catch { continue; }
+          if (m?.type === 'notify') onNotify(m);
+        }
+      }
+    });
+  });
+  req.end(); return req;
+}
+
+// Fix coverage: (1) an SSE-reconnect re-register must NOT steal ownership;
+// (2) a targeted 'superseded' emitted while the displaced client has no live
+// stream is buffered and flushed when its stream (re)attaches.
+async function reattachBufferTest() {
+  const tmp = mkdtempSync(path.join(os.tmpdir(), 'mixdog-reattach-smoke-'));
+  const discoveryPath = path.join(tmp, 'channel-daemon.json');
+  const transport = createChannelDaemonTransport({
+    handleCall: async () => ({ ok: true }),
+    discoveryPath, clientGraceMs: 2000, sweepMs: 5000, onClientsEmpty: () => {},
+    log: (m) => process.env.DAEMON_SMOKE_VERBOSE && console.log(`[reattach] ${m}`),
+  });
+  const { port, token } = await transport.start();
+  const REMOTE = 'notifications/mixdog/remote';
+  const s1 = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  const s2 = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  await delay(80);
+
+  // (1) reconnect with the SAME leadPid: the pointer FOLLOWS to the fresh token
+  // (its old dead-stream entry is dropped), never stealing from a DIFFERENT
+  // owner. Register X (fresh) → owner; re-register reattach:true → pointer moves
+  // to the new token and the old entry is gone (no dead-stream blackhole).
+  const regX = await rawPost(port, token, '/client/register', { leadPid: s1.pid, cwd: 'X' });
+  await delay(40);
+  check('reattach: fresh register X becomes owner',
+    transport._resolveTargetForTest()?.token === regX.token);
+  const regReconnect = await rawPost(port, token, '/client/register', { leadPid: s1.pid, cwd: 'X', reattach: true });
+  await delay(40);
+  check('reattach: reconnect (same pid) pointer follows fresh token, old dropped',
+    transport._resolveTargetForTest()?.token === regReconnect.token &&
+    !transport._clientsForTest.has(regX.token));
+
+  // (2) X's current entry never opened a stream; a fresh register Y steals the
+  // seat → X's targeted 'superseded' is BUFFERED, then delivered on late attach.
+  const regY = await rawPost(port, token, '/client/register', { leadPid: s2.pid, cwd: 'Y' });
+  await delay(40);
+  check('reattach: fresh Y steals the seat from X',
+    transport._resolveTargetForTest()?.token === regY.token);
+  const notX = [];
+  const sseX = rawSse(port, token, regReconnect.token, (m) => notX.push(m));
+  await waitFor(() => notX.some((m) => m?.method === REMOTE && m?.params?.state === 'superseded'), 1000);
+  check('reattach: buffered superseded flushed to X after late SSE attach',
+    notX.filter((m) => m?.method === REMOTE && m?.params?.state === 'superseded').length === 1);
+
+  try { sseX.destroy(); } catch {}
+  try { s1.kill(); } catch {}
+  try { s2.kill(); } catch {}
+  await transport.stop();
+  try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+}
+
 main().catch((err) => { console.error(err); process.exit(1); });
+
+// Pointer-failover coverage: the pointer client dies (deregister) while a
+// live client remains. The transport must move the pointer to the survivor
+// (reason 'failover'), deliver the sticky 'acquired' badge to it, and
+// re-dispatch the survivor's stored bind intent via the injected dispatchBind
+// so the output forwarder rebinds to the survivor's transcript.
+async function pointerFailoverTest() {
+  const tmp = mkdtempSync(path.join(os.tmpdir(), 'mixdog-failover-smoke-'));
+  const discoveryPath = path.join(tmp, 'channel-daemon.json');
+  const REMOTE = 'notifications/mixdog/remote';
+  const rebinds = []; // failover re-dispatches routed through dispatchBind
+  const handleCall = async (name, args, ctx) => ({ ok: true, name, args, leadPid: ctx.leadPid });
+  const dispatchBind = (name, args, ctx) => {
+    rebinds.push({ name, args, leadPid: ctx.leadPid });
+    return handleCall(name, args, ctx);
+  };
+  const transport = createChannelDaemonTransport({
+    handleCall,
+    dispatchBind,
+    discoveryPath, clientGraceMs: 2000, sweepMs: 5000, onClientsEmpty: () => {},
+    log: (m) => process.env.DAEMON_SMOKE_VERBOSE && console.log(`[failover] ${m}`),
+  });
+  const { port, token } = await transport.start();
+  const discovery = { port, token, pid: process.pid };
+
+  const sleeperA = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  const sleeperB = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  await delay(80);
+
+  const notA = [];
+  const notB = [];
+  const clientA = await attachToDaemon({ discovery, leadPid: sleeperA.pid, cwd: 'A', onNotify: (m) => notA.push(m) });
+  await clientA.call('rebind_current_transcript', { transcriptPath: '/tmp/a.jsonl' }); // A stores bind intent
+  const clientB = await attachToDaemon({ discovery, leadPid: sleeperB.pid, cwd: 'B', onNotify: (m) => notB.push(m) });
+  await clientB.call('rebind_current_transcript', { transcriptPath: '/tmp/b.jsonl' }); // B owner + bind intent
+  await delay(120);
+  check('failover: newest binder (B) owns the pointer', transport._resolveTargetForTest()?.leadPid === sleeperB.pid);
+
+  const aBefore = notA.length;
+  await clientB.close(); // pointer client dies → failover to survivor A
+  await waitFor(() => transport._resolveTargetForTest()?.leadPid === sleeperA.pid, 1000);
+  check('failover: pointer moves to surviving client (A)',
+    transport._resolveTargetForTest()?.leadPid === sleeperA.pid);
+  await waitFor(() => notA.slice(aBefore).some((m) => m?.method === REMOTE && m?.params?.state === 'acquired'), 1000);
+  check('failover: survivor (A) receives the sticky acquired badge',
+    notA.slice(aBefore).filter((m) => m?.method === REMOTE && m?.params?.state === 'acquired').length === 1);
+  await waitFor(() => rebinds.some((r) => r.leadPid === sleeperA.pid), 1000);
+  check('failover: survivor bind intent re-dispatched to its transcript',
+    rebinds.some((r) => r.name === 'rebind_current_transcript'
+      && r.args?.transcriptPath === '/tmp/a.jsonl' && r.leadPid === sleeperA.pid));
+
+  await clientA.close();
+  try { sleeperA.kill(); } catch {}
+  try { sleeperB.kill(); } catch {}
+  await transport.stop();
+  try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+}
+
+// Reattach-after-pointer-loss: the pointer client's SSE drops and it
+// re-registers (reattach:true, SAME leadPid) with a FRESH token. The pointer
+// must FOLLOW to the new token (old dead-stream entry dropped, no failover/
+// self-superseded), and a notify must reach the NEW stream — not blackhole on
+// the old entry.
+async function pointerReconnectFollowsTest() {
+  const tmp = mkdtempSync(path.join(os.tmpdir(), 'mixdog-reconnect-smoke-'));
+  const discoveryPath = path.join(tmp, 'channel-daemon.json');
+  const transport = createChannelDaemonTransport({
+    handleCall: async () => ({ ok: true }),
+    discoveryPath, clientGraceMs: 2000, sweepMs: 5000, onClientsEmpty: () => {},
+    log: (m) => process.env.DAEMON_SMOKE_VERBOSE && console.log(`[reconnect] ${m}`),
+  });
+  const { port, token } = await transport.start();
+  const s1 = spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 60000)'], { stdio: 'ignore' });
+  await delay(80);
+
+  // Register X (fresh) → owner; open its SSE, then let the stream drop.
+  const regX = await rawPost(port, token, '/client/register', { leadPid: s1.pid, cwd: 'X' });
+  const notOld = [];
+  const sseOld = rawSse(port, token, regX.token, (m) => notOld.push(m));
+  await delay(60);
+  try { sseOld.destroy(); } catch {}
+  await delay(40);
+
+  // Reconnect re-register (same leadPid) → fresh token; pointer must FOLLOW it.
+  const regNew = await rawPost(port, token, '/client/register', { leadPid: s1.pid, cwd: 'X', reattach: true });
+  await delay(40);
+  check('reconnect: pointer follows the fresh reconnect token',
+    transport._resolveTargetForTest()?.token === regNew.token && regNew.token !== regX.token);
+  check('reconnect: dead old entry was dropped', !transport._clientsForTest.has(regX.token));
+
+  // A notify must reach the NEW stream (no blackhole on the old dead entry).
+  const notNew = [];
+  const sseNew = rawSse(port, token, regNew.token, (m) => notNew.push(m));
+  await delay(60);
+  transport.notify('notifications/claude/channel', { content: 'to-reconnect' });
+  await waitFor(() => notNew.some((m) => m?.params?.content === 'to-reconnect'), 1000);
+  check('reconnect: notify reaches the new stream, not the dead old entry',
+    notNew.some((m) => m?.params?.content === 'to-reconnect') &&
+    !notOld.some((m) => m?.params?.content === 'to-reconnect'));
+
+  try { sseNew.destroy(); } catch {}
+  try { s1.kill(); } catch {}
+  await transport.stop();
+  try { rmSync(tmp, { recursive: true, force: true }); } catch {}
+}

package/scripts/channel-daemon-stub.mjs

@@ -8,7 +8,7 @@ process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 
 import os from 'node:os';
 import path from 'node:path';
-import { mkdirSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { claimSingletonOwner, releaseSingletonOwner } from '../src/runtime/shared/singleton-owner.mjs';
 import { createChannelDaemonTransport } from '../src/standalone/channel-daemon-transport.mjs';
 
@@ -40,6 +40,17 @@ async function main() {
   if (!claim.owned) { process.exit(0); } // race loser → spawner attaches to winner
   process.on('exit', () => { try { releaseSingletonOwner(OWNER_PATH, process.pid); } catch {} });
 
+  // Optional env dump for the tool smoke: proves daemonEnv() spawned us with
+  // the daemon-mode flags (MIXDOG_CHANNEL_DAEMON=1, MIXDOG_CLI_OWNED=0).
+  if (process.env.SMOKE_CHANNEL_ENV_OUT) {
+    try {
+      writeFileSync(process.env.SMOKE_CHANNEL_ENV_OUT, JSON.stringify({
+        cliOwned: process.env.MIXDOG_CLI_OWNED,
+        daemon: process.env.MIXDOG_CHANNEL_DAEMON,
+      }));
+    } catch { /* smoke-only, best-effort */ }
+  }
+
   // Stub runtime: echo the call + caller identity, and (for 'fetch') emit a
   // notify AFTER responding so the smoke can assert targeted routing.
   const handleCall = async (name, args, ctx) => {

package/scripts/debounced-skills-async-save-test.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// Proves the debounced skills save persists through the ASYNC config path and
+// that the debounce-timer flush routes through async I/O (async icacls), never
+// the sync icacls, on the timer path.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SRC = resolve(__dirname, '../src');
+
+test('patchSkillsDisabledAsync persists agent.skills.disabled to disk (async path)', async () => {
+  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-skills-async-'));
+  process.env.MIXDOG_DATA_DIR = dataDir;
+  // Keep the test hermetic: skip the user-data backup copy tree.
+  process.env.MIXDOG_SKIP_USER_DATA_BACKUP = '1';
+  try {
+    // Import AFTER env is set: shared/config.mjs resolves DATA_DIR at load.
+    const cfg = await import(pathToFileURL(join(SRC, 'runtime/agent/orchestrator/config.mjs')).href);
+    const out = await cfg.patchSkillsDisabledAsync(['zeta', 'alpha']);
+    assert.deepEqual(out.disabled, ['alpha', 'zeta']); // normalized + sorted
+    const onDisk = JSON.parse(readFileSync(join(dataDir, 'mixdog-config.json'), 'utf8'));
+    assert.deepEqual(onDisk.agent.skills.disabled, ['alpha', 'zeta']);
+    // A second async patch must last-writer-win, not append.
+    await cfg.patchSkillsDisabledAsync(['beta']);
+    const onDisk2 = JSON.parse(readFileSync(join(dataDir, 'mixdog-config.json'), 'utf8'));
+    assert.deepEqual(onDisk2.agent.skills.disabled, ['beta']);
+  } finally {
+    try { rmSync(dataDir, { recursive: true, force: true }); } catch {}
+    delete process.env.MIXDOG_DATA_DIR;
+    delete process.env.MIXDOG_SKIP_USER_DATA_BACKUP;
+  }
+});
+
+test('debounce timer path routes through the async flush (async icacls), sync flush retained', () => {
+  const lifecycle = readFileSync(`${SRC}/session-runtime/config-lifecycle.mjs`, 'utf8');
+  // Skills timer schedules the ASYNC flush, and the async runner uses the async
+  // persist twin — so the timer path never hits the sync icacls RMW.
+  assert.match(lifecycle, /scheduleSkillsSave\(names\)[\s\S]*?setTimeout\(\(\) => \{ flushSkillsSaveAsync\(\); \}/);
+  assert.match(lifecycle, /runSkillsFlushAsync[\s\S]*?cfgMod\.patchSkillsDisabledAsync\(names\)/);
+  // Config/backend/outputStyle timers likewise fire the async flush.
+  assert.match(lifecycle, /setTimeout\(\(\) => \{ flushConfigSaveAsync\(\); \}/);
+  assert.match(lifecycle, /setTimeout\(\(\) => \{ flushBackendSaveAsync\(\); \}/);
+  assert.match(lifecycle, /setTimeout\(\(\) => \{ flushOutputStyleSaveAsync\(\); \}/);
+  // Sync flushes stay for reloadFullConfig/teardown durability.
+  assert.match(lifecycle, /function flushConfigSave\(\)/);
+  assert.match(lifecycle, /function flushSkillsSave\(\)/);
+  assert.match(lifecycle, /reloadFullConfig[\s\S]*?flushConfigSave\(\);/);
+
+  const atomic = readFileSync(`${SRC}/runtime/shared/atomic-file.mjs`, 'utf8');
+  // The async writer enforces the owner-only ACL via the async icacls variant.
+  assert.match(atomic, /export async function writeFileAtomicAsync[\s\S]*?await _enforceOwnerOnlyAclWin32Async\(tmp\)/);
+  assert.match(atomic, /_enforceOwnerOnlyAclWin32Async[\s\S]*?_execFileAsync\(icacls/);
+});

package/scripts/explore-bench-tmp.mjs

@@ -0,0 +1,17 @@
+import { runExplore } from '../src/standalone/explore-tool.mjs';
+const queries = [
+  'standalone explore tool implementation entry point',
+  'V4A patch format parsing/conversion implementation',
+  'recall memory entries persistent store (sqlite) read/query implementation',
+  'output styles: how style definitions are loaded and applied at session runtime',
+  'Discord backend outbound message send implementation',
+  'shell command destructive/danger policy scan before execution',
+  'where does mixdog store per-user data and sessions on this machine (out of repo)',
+  'channel runtime crash logging write path',
+];
+const t0 = Date.now();
+const res = await runExplore({ query: queries, cwd: 'C:/Project/mixdog' }, { callerCwd: 'C:/Project/mixdog' });
+console.log('BATCH_ELAPSED_MS', Date.now() - t0);
+const txt = res.content?.[0]?.text || '';
+console.log('FAILED_COUNT', (txt.match(/EXPLORATION_FAILED/g) || []).length);
+process.exit(0);

package/scripts/find-fuzzy-hidden-test.mjs

@@ -0,0 +1,145 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fuzzyRank } from '../src/runtime/agent/orchestrator/tools/builtin/fuzzy-match.mjs';
+import { executeFuzzyFindTool } from '../src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs';
+import { runRg } from '../src/runtime/agent/orchestrator/tools/builtin/rg-runner.mjs';
+
+// ── fuzzyRank score floor ────────────────────────────────────────────────
+
+test('fuzzyRank keeps an exact basename/substring hit and drops scattered noise', () => {
+    const items = [
+        { path: '.mixdog/data/tool-events.log' },
+        // subsequence-only junk: the query chars appear in order but scattered
+        // mid-word across dirs, no contiguity or word boundaries.
+        { path: 'pgadmin/xtx/oxoxl/exvxexnxtx/sxlxoxg/records.dat' },
+    ];
+    const ranked = fuzzyRank('tool-events.log', items);
+    assert.ok(ranked.length >= 1, 'the real file must survive the floor');
+    assert.equal(ranked[0].item.path, '.mixdog/data/tool-events.log');
+    assert.ok(
+        !ranked.some((r) => r.item.path.startsWith('pgadmin/')),
+        'scattered subsequence junk must be filtered out',
+    );
+});
+
+test('fuzzyRank floor drops a purely scattered subsequence but keeps a substring', () => {
+    const strong = { path: 'src/abcdef.txt' };
+    const junk = { path: 'xax/xbxcx/xdxexfx/z.bin' };
+    const ranked = fuzzyRank('abcdef', [strong, junk]);
+    assert.deepEqual(ranked.map((r) => r.item.path), ['src/abcdef.txt']);
+});
+
+// ── hidden-directory discovery via the find tool ─────────────────────────
+
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-find-hidden-'));
+    mkdirSync(join(root, '.mixdog', 'data'), { recursive: true });
+    writeFileSync(join(root, '.mixdog', 'data', 'tool-events.log'), 'x\n');
+    mkdirSync(join(root, 'src'), { recursive: true });
+    writeFileSync(join(root, 'src', 'unrelated.txt'), 'x\n');
+    // .git noise must stay pruned even with hidden default true.
+    mkdirSync(join(root, '.git'), { recursive: true });
+    writeFileSync(join(root, '.git', 'tool-events.log'), 'x\n');
+    return root;
+}
+
+test('find surfaces a file under a dot-directory top-ranked (hidden default true)', async () => {
+    const root = makeRepo();
+    try {
+        const out = await executeFuzzyFindTool({ query: 'tool-events.log' }, root);
+        const lines = out.split('\n').filter(Boolean);
+        assert.ok(lines.length >= 1, `expected a hit, got: ${out}`);
+        assert.equal(lines[0], '.mixdog/data/tool-events.log');
+        assert.ok(!out.includes('.git/'), '.git must stay pruned as noise');
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('find hidden:false skips dot-directories', async () => {
+    const root = makeRepo();
+    try {
+        const out = await executeFuzzyFindTool({ query: 'tool-events.log', hidden: false }, root);
+        assert.ok(!out.includes('.mixdog'), `hidden:false must not descend dot-dirs: ${out}`);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+// ── narrowed-pass merge / dedup backstop ─────────────────────────────────
+
+test('exact-name hit survives among many decoys and is not duplicated', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-find-merge-'));
+    try {
+        // A deep exact-name target plus a pile of unrelated decoys. The target
+        // matches both the broad enumeration and the query-narrowed pass, so it
+        // exercises the merge+dedup path.
+        mkdirSync(join(root, 'deep', 'nested', 'here'), { recursive: true });
+        writeFileSync(join(root, 'deep', 'nested', 'here', 'tool-events.log'), 'x\n');
+        mkdirSync(join(root, 'noise'), { recursive: true });
+        for (let i = 0; i < 200; i++) {
+            writeFileSync(join(root, 'noise', `decoy-${i}.bin`), 'x\n');
+        }
+        const out = await executeFuzzyFindTool({ query: 'tool-events.log' }, root);
+        const lines = out.split('\n').filter(Boolean);
+        assert.equal(lines[0], 'deep/nested/here/tool-events.log');
+        const hits = lines.filter((l) => l === 'deep/nested/here/tool-events.log');
+        assert.equal(hits.length, 1, `merge must dedup, got ${hits.length}: ${out}`);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+// ── truncation warning surfaces when the broad pass reports .truncated ────
+
+test('truncated broad enumeration emits a visible warning, still ranks the exact hit, and is not cached', async () => {
+    const root = makeRepo();
+    try {
+        // Test-only seam: wrap the real runRg so the BROAD pass (the one without
+        // `--iglob`) reports truncation via the boxed-String contract the tool
+        // relies on (.truncated=true), while the narrowed pass is left intact.
+        // Production options never carry __runRg, so the real path is unchanged.
+        const truncatingRunRg = async (argsList, execOptions) => {
+            const out = await runRg(argsList, execOptions);
+            if (argsList.includes('--iglob')) return out; // narrowed backstop unchanged
+            const boxed = new String(String(out));
+            boxed.truncated = true;
+            return boxed;
+        };
+        const out = await executeFuzzyFindTool(
+            { query: 'tool-events.log' }, root, { __runRg: truncatingRunRg },
+        );
+        assert.ok(out.includes('[warning]'), `truncated broad pass must warn: ${out}`);
+        assert.ok(out.includes('truncated at 20MB cap'), `warning text must surface: ${out}`);
+        const lines = out.split('\n').filter(Boolean);
+        assert.equal(lines[0], '.mixdog/data/tool-events.log', 'exact hit must still rank first');
+        // Not cached: a normal follow-up run (no injected truncation) must NOT
+        // return the warning — proving the truncated result was never cached.
+        const out2 = await executeFuzzyFindTool({ query: 'tool-events.log' }, root);
+        assert.ok(!out2.includes('[warning]'), `truncated result must not be cached/served: ${out2}`);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+// ── narrowed backstop treats the query as a literal (glob metachars) ──────
+
+test('a query with glob metachars still gets the narrowed backstop', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-find-glob-'));
+    try {
+        // "[slug].tsx" contains a character-class metachar; a raw *[slug].tsx*
+        // iglob would match one of s/l/u/g, not the literal filename. The tool
+        // must escape it so the exact-name file is still surfaced.
+        mkdirSync(join(root, 'app'), { recursive: true });
+        writeFileSync(join(root, 'app', '[slug].tsx'), 'x\n');
+        writeFileSync(join(root, 'app', 'slug.tsx'), 'x\n'); // class-match decoy
+        const out = await executeFuzzyFindTool({ query: '[slug].tsx' }, root);
+        const lines = out.split('\n').filter(Boolean);
+        assert.ok(lines.includes('app/[slug].tsx'), `literal metachar hit must surface: ${out}`);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});