greprag 5.74.21 → 5.76.0

package/dist/commands/arm-reminder.js

@@ -40,7 +40,9 @@ function buildArmReminder(d, env) {
         return null;
     const unread = Number((d.detail && d.detail.unread) || 0);
     const arm = env
-        ? `ToolSearch select:Monitor → persistent Monitor (timeout_ms:3600000) command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic)}\``
+        ? (env.platform === 'grok'
+            ? `Grok \`monitor\` tool persistent:true command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic, 'grok')}\``
+            : `ToolSearch select:Monitor → persistent Monitor (timeout_ms:3600000) command: \`${(0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic)}\``)
         : `arm your Monitor inbox watcher`;
     const grounded = `greprag reads your watcher as DOWN (isLocallyArmed=false — a real pidfile check on your session, NOT a timer; the hook CAN see your watcher)`;
     if (unread > 0) {
@@ -67,7 +69,7 @@ exports.watcherArmModule = {
     // keeps its historical full-registry behavior. opencode is EXCLUDED: its inbox
     // delivery is the plugin-armed relay (startSessionRelay), so "arm your Monitor"
     // is unactionable noise there.
-    harnesses: ['claude-code', 'codex'],
+    harnesses: ['claude-code', 'codex', 'grok'],
     detect: armDetect,
     announce: () => null,
     reminder: (d, env) => buildArmReminder(d, env),

package/dist/commands/codex.js

@@ -62,11 +62,6 @@ Object.defineProperty(exports, "removeCodexStartup", { enumerable: true, get: fu
 Object.defineProperty(exports, "statusCodexStartup", { enumerable: true, get: function () { return codex_startup_2.statusCodexStartup; } });
 const API_URL_DEFAULT = 'https://api.greprag.com';
 const HEARTBEAT_IDLE_MS = 70_000;
-const FULL_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function sameSessionId(left, right) {
-    return !!left && !!right && (FULL_UUID_RE.test(left) && FULL_UUID_RE.test(right)
-        ? left.toLowerCase() === right.toLowerCase() : (0, session_id_1.truncateSessionId)(left) === (0, session_id_1.truncateSessionId)(right));
-}
 function home() {
     return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
@@ -233,12 +228,12 @@ async function handleMessage(msg, opts, session8, codexSession) {
     return result;
 }
 function shouldDeliverToThisSession(msg, sessionId) {
-    if (msg.to_session_id && !sameSessionId(msg.to_session_id, sessionId))
+    if (msg.to_session_id && !(0, session_id_1.sameSessionId)(msg.to_session_id, sessionId))
         return false;
     const fromSession = msg.from?.session_id ?? null;
     if (msg.message_type === mechanic_friction_1.MECHANIC_FRICTION_MESSAGE_TYPE)
         return true;
-    if (fromSession && sameSessionId(fromSession, sessionId))
+    if (fromSession && (0, session_id_1.sameSessionId)(fromSession, sessionId))
         return false;
     return true;
 }

package/dist/commands/grok-spawn.js

@@ -0,0 +1,208 @@
+"use strict";
+/** Open a fresh Grok Build TUI from another agent session.
+ *
+ *  Grok's tool-runner Job Object kills `Start-Process` / `cmd /c start`
+ *  children when the tool call returns. The surviving launch is a scheduled
+ *  task (`schtasks /Create /IT` then `/Run`) that `start`s a new `cmd /k`
+ *  window running grok.exe — a visible command-prompt bootloader outside the
+ *  job. adr: adr/grok-platform.md */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGrokExe = resolveGrokExe;
+exports.buildGrokSpawnScript = buildGrokSpawnScript;
+exports.grokSpawnHelp = grokSpawnHelp;
+exports.runGrokSpawn = runGrokSpawn;
+exports.runGrok = runGrok;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function winQuote(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function resolveGrokExe() {
+    const home = os.homedir();
+    const named = process.platform === 'win32' ? 'grok.exe' : 'grok';
+    const pinned = path.join(home, '.grok', 'bin', named);
+    if (fs.existsSync(pinned))
+        return pinned;
+    try {
+        const out = (0, child_process_1.execFileSync)(process.platform === 'win32' ? 'where.exe' : 'which', ['grok'], {
+            encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const first = out.split(/\r?\n/).map(s => s.trim()).find(s => s);
+        if (first && fs.existsSync(first))
+            return first;
+    }
+    catch { /* fall through */ }
+    return named;
+}
+function buildGrokSpawnScript(opts) {
+    const cwd = path.resolve(opts.cwd);
+    const title = opts.title || `grok ${path.basename(cwd)}`;
+    const grok = opts.grokExe || resolveGrokExe();
+    const promptArg = opts.prompt ? ` ${winQuote(opts.prompt)}` : '';
+    // Self-relaunch: schtasks runs this hidden; `start cmd /k %~f0 --boot`
+    // opens a visible command-prompt bootloader that then execs grok.exe.
+    // Immediate task-delete used to cancel the launch — caller waits.
+    return [
+        '@echo off',
+        'if /I "%~1"=="--boot" goto boot',
+        `start ${winQuote(title)} cmd /k "%~f0" --boot`,
+        'goto :eof',
+        ':boot',
+        `cd /d ${winQuote(cwd)}`,
+        `echo [greprag] booting Grok TUI in ${cwd}`,
+        `${winQuote(grok)}${promptArg}`,
+        'echo.',
+        'echo [greprag] grok exited. This window is yours.',
+    ].join('\r\n') + '\r\n';
+}
+function grokSpawnHelp() {
+    return `greprag grok spawn — open a fresh Grok Build TUI in a new command prompt.
+
+  greprag grok spawn [--cwd <path>] [--prompt "<text>"|--prompt-file <path>] [--title <name>]
+  greprag grok spawn --dry-run
+
+Windows: schtasks /IT starts a new \`cmd /k\` window (bootloader) that runs
+grok.exe. That escapes the agent tool Job Object. The child is a real TUI
+with its own $GROK_SESSION_ID; it arms its own inbox watch. This session
+keeps one watch. Message it with:
+  greprag send "…" --to <handle>@greprag.com/<child-uuid> --from-session $GROK_SESSION_ID
+`;
+}
+function sleepMs(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* wait for Task Scheduler to start the .cmd */ }
+}
+function runGrokSpawn(args) {
+    if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+        console.log(grokSpawnHelp());
+        return;
+    }
+    const cwd = path.resolve(getArg(args, '--cwd') || process.cwd());
+    const promptFile = getArg(args, '--prompt-file');
+    let prompt = getArg(args, '--prompt') || positionalPrompt(args);
+    if (promptFile) {
+        if (!fs.existsSync(promptFile)) {
+            console.error(`greprag grok spawn: prompt file not found: ${promptFile}`);
+            process.exit(1);
+        }
+        prompt = fs.readFileSync(promptFile, 'utf8').replace(/^\uFEFF/, '').trimEnd();
+    }
+    const title = getArg(args, '--title');
+    const dryRun = args.includes('--dry-run');
+    const grokExe = resolveGrokExe();
+    const opts = { cwd, prompt, title, grokExe, dryRun };
+    if (process.platform !== 'win32') {
+        const cmd = [grokExe, '--cwd', cwd, prompt].filter((p) => !!p);
+        if (dryRun) {
+            console.log(cmd.join(' '));
+            return;
+        }
+        console.error('greprag grok spawn: Windows-only bootloader (Job Object). Run this yourself:');
+        console.error(`  ${cmd.map(a => /\s/.test(a) ? JSON.stringify(a) : a).join(' ')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const script = buildGrokSpawnScript(opts);
+    if (dryRun) {
+        process.stdout.write(script);
+        return;
+    }
+    if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+        console.error(`greprag grok spawn: cwd is not a directory: ${cwd}`);
+        process.exit(1);
+    }
+    const tn = `greprag-grok-${Date.now().toString(36)}`;
+    const file = path.join(os.tmpdir(), `${tn}.cmd`);
+    fs.writeFileSync(file, script, 'utf8');
+    try {
+        (0, child_process_1.execFileSync)('schtasks', [
+            '/Create', '/TN', tn, '/TR', file, '/SC', 'ONCE', '/ST', '23:59',
+            '/F', '/IT',
+        ], { stdio: ['ignore', 'pipe', 'pipe'] });
+        (0, child_process_1.execFileSync)('schtasks', ['/Run', '/TN', tn], { stdio: ['ignore', 'pipe', 'pipe'] });
+        // /Run is async. Deleting immediately cancelled the launch (field 2026-08-21).
+        sleepMs(2500);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`greprag grok spawn: schtasks failed: ${msg}`);
+        process.exit(1);
+    }
+    finally {
+        try {
+            (0, child_process_1.execFileSync)('schtasks', ['/Delete', '/TN', tn, '/F'], { stdio: 'ignore' });
+        }
+        catch { /* leftover task is harmless */ }
+    }
+    console.log(`Spawned Grok TUI (cmd /k bootloader) for ${cwd}${prompt ? ` — prompt: ${prompt}` : ''}`);
+    console.log('The new session arms its own inbox watch. This session keeps one.');
+}
+function runGrok(args) {
+    const sub = args[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        console.log(grokSpawnHelp());
+        return;
+    }
+    if (sub === 'spawn')
+        return runGrokSpawn(args.slice(1));
+    console.error(`Unknown "grok ${sub}". Run \`greprag grok spawn --help\`.`);
+    process.exit(1);
+}
+function getArg(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    const value = args[idx + 1];
+    return value.startsWith('--') ? undefined : value;
+}
+function positionalPrompt(args) {
+    const skip = new Set(['--cwd', '--prompt', '--prompt-file', '--title']);
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        if (skip.has(args[i])) {
+            i += 1;
+            continue;
+        }
+        if (args[i] === '--dry-run' || args[i] === '--help' || args[i] === '-h')
+            continue;
+        if (args[i].startsWith('--'))
+            continue;
+        out.push(args[i]);
+    }
+    return out.length ? out.join(' ') : undefined;
+}

package/dist/commands/inbox-drain.js

@@ -9,7 +9,13 @@
  *  inbox`. This closes it: on every arm (SessionStart startup|resume|compact)
  *  drain THIS session's unread, session-DIRECTED messages into the agent's
  *  context, tagged peer/human, mark them read, and advance the stored cursor so
- *  there is no double-delivery. adr: adr/monitor-resilience.md
+ *  there is no double-delivery.
+ *
+ *  INJECT ONLY WHEN UNARMED. A live watcher already printed the body (Claude
+ *  Monitor / Grok monitor stdout). Grok also wires drain on Stop because
+ *  SessionStart stdout cannot inject — that Stop path is the unarmed floor.
+ *  Passing `armed: true` still marks inbound unread + advances the cursor, but
+ *  does not inject (and never claims "no live watcher"). adr: adr/monitor-resilience.md
  *
  *  SCOPE = session-directed INBOUND only (to_session_id == me). NOT the front
  *  desk (cold opens + email — that's the human-scoped `mail` hook's job) and NOT
@@ -126,7 +132,31 @@ async function runInboxDrain(opts) {
         return none;
     // Chronological (oldest → newest) so a coordination thread reads in order.
     inbound.sort((a, b) => tsOf(a) - tsOf(b));
-    // 3. Cap the injected volume to the NEWEST `cap`. Older inbound-unread stay
+    // 3. Armed watcher already delivered the body (live stdout). Mark every
+    //    inbound-unread read and advance the cursor, but do not inject — the
+    //    unarmed copy would lie, and Grok Stop would duplicate a live interrupt.
+    const cursor = newestId(messages);
+    if (opts.armed) {
+        if (cursor) {
+            try {
+                writeCursor(opts.session, cursor);
+            }
+            catch { /* best-effort */ }
+        }
+        const ids = inbound.map(m => m.id).filter(Boolean);
+        if (ids.length > 0) {
+            try {
+                await doFetch(`${base}/v1/inbox/read`, {
+                    method: 'POST',
+                    headers: { Authorization: `Bearer ${opts.apiKey}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ ids }),
+                });
+            }
+            catch { /* mark-read is best-effort */ }
+        }
+        return { context: null, drained: inbound.length, truncated: 0, cursorAdvancedTo: cursor };
+    }
+    // 4. Cap the injected volume to the NEWEST `cap`. Older inbound-unread stay
     //    unread (NOT marked, NOT silently dropped): they remain in `greprag inbox`
     //    and the next arm re-drains them. The overflow count is stated below.
     let drain = inbound;
@@ -135,20 +165,20 @@ async function runInboxDrain(opts) {
         truncated = inbound.length - cap;
         drain = inbound.slice(inbound.length - cap); // newest `cap`, still chronological
     }
-    // 4. Build the injected context (peer/human tagged).
+    // 5. Build the injected context (peer/human tagged). Unarmed-only — this copy
+    //    is true because we returned above when a live watcher was present.
     const context = buildDrainContext(drain, truncated, opts.session);
-    // 5. Advance the poll cursor to the newest endpoint message id so the just-
+    // 6. Advance the poll cursor to the newest endpoint message id so the just-
     //    armed poll resumes strictly AFTER everything already in the inbox — no
     //    double-delivery. Only when there is something to drain (never disturb a
     //    healthy poll's cursor on an empty arm).
-    const cursor = newestId(messages);
     if (cursor) {
         try {
             writeCursor(opts.session, cursor);
         }
         catch { /* best-effort */ }
     }
-    // 6. Mark the drained (injected) ids read LAST — after inject + cursor — so a
+    // 7. Mark the drained (injected) ids read LAST — after inject + cursor — so a
     //    crash before this point re-drains next arm rather than losing a message.
     //    Inbound ids only, so a peer's view of my outbound is never touched.
     //    Fail-quiet: an unreachable / not-yet-deployed /read route leaves the

package/dist/commands/inbox-primer-reminder.js

@@ -30,7 +30,8 @@ const session_id_1 = require("../session-id");
 function buildInboxPrimer(env) {
     const codex = env.platform === 'codex';
     const opencode = env.platform === 'opencode';
-    const arm = (0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic);
+    const grok = env.platform === 'grok';
+    const arm = (0, session_id_1.armMonitorCommand)(env.short, env.ownerPid, env.assistant, env.mechanic, env.platform);
     return [
         // LEAD — the forcing function (restored 2026-06-22). ARM is an ALARM, not reference:
         // you are unreachable until you do it, and it must be re-done every time the watcher
@@ -39,16 +40,20 @@ function buildInboxPrimer(env) {
         // opencode gets NO alarm: its relay self-arms in the plugin (startSessionRelay) —
         // "ToolSearch select:Monitor" is unactionable there (neither tool exists) and an
         // un-followable alarm decays into banner-blindness for the announces around it.
-        codex
-            ? '[CODEX INBOX — greprag is your agent-to-agent mesh. Codex-to-Codex: discover tasks and their repo/workspace with `codex_app.list_threads`, then coordinate with `codex_app.send_message_to_thread`. Reaching ANY non-Codex peer (Claude Code / opencode / another tenant\'s agent): `greprag send` IS the live primary path — native Codex messaging cannot reach them.]'
-            : opencode
-                ? '[OPENCODE INBOX — greprag is your agent-to-agent mesh. Inbound delivery is AUTOMATIC here: the greprag plugin arms a relay for this session (nothing to arm or re-arm) and inbound peer messages arrive as injected turns.]'
-                : '[⚠ ARM YOUR INBOX WATCHER NOW — you are UNREACHABLE until you do. Peers are live in your mesh trying to coordinate with this session, and the operator can DM you — but they reach you ONLY while armed. Unarmed, you are invisible and their messages silently pile up. The watcher can DROP ANYTIME (crash / reload / OOM) — EVERY turn you are flagged unarmed you MUST re-arm, or coordination breaks.]',
-        codex
-            ? 'CODEX: Native Codex tools are the source of truth: `codex_app.list_threads` discovers tasks plus their repo/workspace, and `codex_app.send_message_to_thread` handles Codex-to-Codex coordination. GrepRAG inbox rows for Codex surface through turn hooks only: SessionStart `drain` and UserPromptSubmit `codex-notify`. There is no Codex startup watcher to install. If hooks do not fire, open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG commands, start a fresh Codex session, then drain what is waiting: `greprag inbox`.'
-            : opencode
-                ? 'DELIVERY: the relay arms itself on this session\'s first turn and injects inbound messages as they land — treat an injected `Message from <handle> (session <8hex>):` turn as async peer mail, not the operator typing. Drain anything already waiting: `greprag inbox`.'
-                : `ARM: Monitor is a deferred tool — \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED — a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
+        grok
+            ? '[GROK INBOX — greprag is your agent-to-agent mesh. Idle wake is Grok `monitor` (NOT Claude Monitor, NOT a bash while-true). Turn-boundary drain also rides Stop additionalContext. Unarmed, idle mail waits until the next Stop or user prompt.]'
+            : codex
+                ? '[CODEX INBOX — greprag is your agent-to-agent mesh. Codex-to-Codex: discover tasks and their repo/workspace with `codex_app.list_threads`, then coordinate with `codex_app.send_message_to_thread`. Reaching ANY non-Codex peer (Claude Code / opencode / Grok / another tenant\'s agent): `greprag send` IS the live primary path — native Codex messaging cannot reach them.]'
+                : opencode
+                    ? '[OPENCODE INBOX — greprag is your agent-to-agent mesh. Inbound delivery is AUTOMATIC here: the greprag plugin arms a relay for this session (nothing to arm or re-arm) and inbound peer messages arrive as injected turns.]'
+                    : '[⚠ ARM YOUR INBOX WATCHER NOW — you are UNREACHABLE until you do. Peers are live in your mesh trying to coordinate with this session, and the operator can DM you — but they reach you ONLY while armed. Unarmed, you are invisible and their messages silently pile up. The watcher can DROP ANYTIME (crash / reload / OOM) — EVERY turn you are flagged unarmed you MUST re-arm, or coordination breaks.]',
+        grok
+            ? `ARM (idle wake): Grok \`monitor\` tool, persistent:true, description:"greprag inbox ${env.short}", command: \`${arm}\`. \`--quiet\` is REQUIRED — Grok treats stderr as wake events; the Claude bash wrapper is PowerShell-invalid. Use full UUID / 16-hex, never 8-hex. A chip → \`greprag load grok-chip-spawn\` then \`greprag grok spawn\` (child arms its own watch; parent keeps ONE). A helper → spawn_subagent. Floor: Stop-hook drain injects unread mail even if you never arm. Then \`greprag inbox\`.`
+            : codex
+                ? 'CODEX: Native Codex tools are the source of truth: `codex_app.list_threads` discovers tasks plus their repo/workspace, and `codex_app.send_message_to_thread` handles Codex-to-Codex coordination. GrepRAG inbox rows for Codex surface through turn hooks only: SessionStart `drain` and UserPromptSubmit `codex-notify`. There is no Codex startup watcher to install. If hooks do not fire, open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG commands, start a fresh Codex session, then drain what is waiting: `greprag inbox`.'
+                : opencode
+                    ? 'DELIVERY: the relay arms itself on this session\'s first turn and injects inbound messages as they land — treat an injected `Message from <handle> (session <8hex>):` turn as async peer mail, not the operator typing. Drain anything already waiting: `greprag inbox`.'
+                    : `ARM: Monitor is a deferred tool — \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED — a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
         '',
         // The facts + directives — a flat list (no MODEL/RULES scaffolding; the labels were
         // human doc-structure, dead weight to an agent). Everything that helps the agent DECIDE

package/dist/commands/inbox-watch-supervisor.js

@@ -36,6 +36,16 @@ const child_process_1 = require("child_process");
 const inbox_watch_1 = require("./inbox-watch");
 const watcher_registry_1 = require("./watcher-registry");
 const LOG_PREFIX = '[greprag inbox watch]';
+function watchQuiet() {
+    return process.env.GREPRAG_WATCH_QUIET === '1'
+        || !!process.env.GROK_SESSION_ID
+        || process.argv.includes('--quiet');
+}
+function slog(msg) {
+    if (watchQuiet())
+        return;
+    console.error(msg);
+}
 // ---- Supervisor-driven watcher liveness (registry freshness) -------------
 // adr: docs/registry-freshness-design.md
 //
@@ -107,12 +117,12 @@ exports.FATAL_EXIT_CODE = 64;
 function installLastResortHandlers() {
     process.on('uncaughtException', (err) => {
         const msg = (err && err.message) || String(err);
-        console.error(`${LOG_PREFIX} uncaughtException: ${msg}`);
+        slog(`${LOG_PREFIX} uncaughtException: ${msg}`);
         process.exit(2);
     });
     process.on('unhandledRejection', (reason) => {
         const msg = (reason && reason.message) || String(reason);
-        console.error(`${LOG_PREFIX} unhandledRejection: ${msg}`);
+        slog(`${LOG_PREFIX} unhandledRejection: ${msg}`);
         process.exit(2);
     });
 }
@@ -263,7 +273,7 @@ async function runSupervisor() {
     // (`armMonitorCommand`) relaunches a fresh supervisor — turn-free recovery, the
     // missing rung for supervisor death. adr: adr/monitor-resilience.md
     const onFatalError = (label) => (err) => {
-        console.error(`${LOG_PREFIX} supervisor ${label}: ${(err && err.message) || String(err)}`);
+        slog(`${LOG_PREFIX} supervisor ${label}: ${(err && err.message) || String(err)}`);
         process.exit(1); // non-zero (not 0/64) → the relauncher relaunches us
     };
     const onUncaught = onFatalError('uncaughtException');
@@ -289,7 +299,7 @@ async function runSupervisor() {
     // genuinely live sibling. adr: adr/monitor-resilience.md
     if (session && (0, watcher_registry_1.isLocallyArmed)(session)) {
         (0, watcher_registry_1.watcherAuditLog)(`arm-skip session=${session} singleton-guard (live sibling pidfile)`);
-        console.error(`${LOG_PREFIX} session ${session} already has a live watcher — not starting a second.`);
+        slog(`${LOG_PREFIX} session ${session} already has a live watcher — not starting a second.`);
         return;
     }
     // Local pidfile (Part 1 of the local-liveness fix): record THIS supervisor's
@@ -333,7 +343,7 @@ async function runSupervisor() {
         }
         if (spawnErr || !currentChild) {
             const reason = spawnErr ? spawnErr.message : 'spawn returned null child';
-            console.error(`${LOG_PREFIX} supervisor: spawn failed (${reason}) — retry in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
+            slog(`${LOG_PREFIX} supervisor: spawn failed (${reason}) — retry in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
             await sleepUntilOrShutdown(backoff, () => shutdownRequested);
             backoff = Math.min(backoff * SUPERVISOR_BACKOFF_FACTOR, SUPERVISOR_BACKOFF_MAX_MS);
             continue;
@@ -402,7 +412,7 @@ async function runSupervisor() {
             const hint = native
                 ? `the child is dying at the OS level (${reason}) before it can run — characteristic of system commit-charge / page-file exhaustion (NOT physical RAM; see docs/session-heap-ceiling.md). Standing down so we stop feeding the exhaustion; the next-turn arm reminder retries once the machine recovers.`
                 : `the child cannot stay up (${reason}). Run \`greprag inbox watch --no-supervise\` to see the underlying error. Standing down to avoid a respawn storm.`;
-            console.error(`${LOG_PREFIX} supervisor: child crash-looped ${consecutiveFastDeaths}× (each < ${(0, inbox_watch_1.fmtDuration)(CRASH_LOOP_LIFETIME_MS)}) — ${hint}`);
+            slog(`${LOG_PREFIX} supervisor: child crash-looped ${consecutiveFastDeaths}× (each < ${(0, inbox_watch_1.fmtDuration)(CRASH_LOOP_LIFETIME_MS)}) — ${hint}`);
             (0, watcher_registry_1.watcherAuditLog)(`crash-loop session=${session ?? 'tenant'} deaths=${consecutiveFastDeaths} last=${reason}`);
             terminalReason = `crash-loop-standdown (${reason})`;
             // Exit FATAL (64) so the bash relauncher BREAKs rather than relaunching us
@@ -411,7 +421,7 @@ async function runSupervisor() {
             process.exitCode = exports.FATAL_EXIT_CODE;
             break;
         }
-        console.error(`${LOG_PREFIX} supervisor: child died (${reason}) after ${(0, inbox_watch_1.fmtDuration)(liveMs)} — respawning in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
+        slog(`${LOG_PREFIX} supervisor: child died (${reason}) after ${(0, inbox_watch_1.fmtDuration)(liveMs)} — respawning in ${(0, inbox_watch_1.fmtDuration)(backoff)}`);
         await sleepUntilOrShutdown(backoff, () => shutdownRequested);
         backoff = Math.min(backoff * SUPERVISOR_BACKOFF_FACTOR, SUPERVISOR_BACKOFF_MAX_MS);
     }