@murmurv2/cli 2.11.0

package/runtime/packages/setup/dist/src/platform/windows.js

@@ -0,0 +1,189 @@
+import { execFile } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const paths = path.win32;
+const fail = (reason) => { throw new Error(`service.${reason}`); };
+/**
+ * murmur-svc ends a failure with exactly one footer line `murmur-svc: reason=<key>` (LF). Only that
+ * strict last line is trusted and only its key is kept, case preserved; the rest of stderr may carry
+ * paths or OS text and is never read. Anything else keeps the old generic code.
+ */
+export function helperReason(stderr) {
+    const key = /(?:^|\n)murmur-svc: reason=([A-Za-z][A-Za-z0-9.]{0,80})\n?$/.exec(stderr)?.[1];
+    return key && !key.endsWith('.') && !key.includes('..') ? `helper.${key}` : 'helper-command-failed';
+}
+const object = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const natural = (v) => Number.isSafeInteger(v) && Number(v) >= 0;
+const textOrNull = (v) => v === null || typeof v === 'string';
+function absolute(value) {
+    if (typeof value !== 'string' || !paths.isAbsolute(value) || paths.normalize(value) !== value || /[\x00-\x1f\x7f]/.test(value))
+        fail('invalid-path');
+}
+function validate(c) {
+    for (const key of ['dataDir', 'configPath', 'storePath', 'repoRoot', 'nodePath', 'logDir'])
+        absolute(c[key]);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,100}$/.test(c.serviceName))
+        fail('invalid-name');
+    if (c.configPath !== paths.join(c.dataDir, 'agent-config.json') || c.storePath !== paths.join(c.dataDir, 'murmur.db') || c.logDir !== paths.join(c.dataDir, 'logs'))
+        fail('conflicting-store-path');
+}
+const empty = (detail) => ({ state: 'unknown', manager: 'windows-service', since: null, pid: null,
+    lastExitCode: null, observedStorePath: null, restartCount: null, restartWindowMs: null, ...(detail ? { detail } : {}) });
+const defaultRun = (file, args, options) => new Promise(resolve => {
+    execFile(file, args, { ...options, windowsHide: true, maxBuffer: 256 * 1024, encoding: 'utf8' }, (error, stdout, stderr) => {
+        resolve({ code: error ? typeof error.code === 'number' ? error.code : -1 : 0, stdout, stderr });
+    });
+});
+// SCM mutations need a High (elevated administrator) or System integrity token. Without it the helper
+// fails with a bare exit code, so a new user must be told to reopen the terminal as administrator.
+const defaultElevated = () => new Promise(resolve => {
+    // By absolute path: a whoami.exe planted earlier in PATH must not decide this.
+    execFile(paths.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'whoami.exe'), ['/groups', '/fo', 'csv', '/nh'], { windowsHide: true, encoding: 'utf8', timeout: 8000 }, (error, stdout) => {
+        resolve(error ? null : /"S-1-16-(12288|16384)"/.test(stdout));
+    });
+});
+/** Native SCM helper is the only service observer and mutator. No shell, PID guessing or registry fallback. */
+export function createWindowsAdapter(options = {}) {
+    const env = options.env ?? process.env, home = options.homeDir ?? homedir();
+    const run = options.run ?? defaultRun, canonicalize = options.canonicalize ?? realpath, elevated = options.elevated ?? defaultElevated;
+    const same = async (a, b) => (await canonicalize(a)) === (await canonicalize(b));
+    async function helper(c) {
+        const explicit = options.helperPath ?? env.MURMUR_SERVICE_BIN;
+        if (explicit !== undefined) {
+            absolute(explicit);
+            return explicit;
+        }
+        for (const file of [paths.join(c.repoRoot, 'bin', 'murmur-svc.exe'), paths.join(c.repoRoot, 'spikes', 'windows-service-go', 'murmur-svc.exe')]) {
+            try {
+                if ((await stat(file)).isFile())
+                    return file;
+            }
+            catch { }
+        }
+        return fail('helper-not-installed');
+    }
+    function selectedEnvironment(c) {
+        const selected = {};
+        for (const name of ['SystemRoot', 'WINDIR', 'ProgramData', 'TEMP', 'TMP', 'USERPROFILE', 'LOCALAPPDATA', 'APPDATA', 'PATH']) {
+            const found = Object.keys(env).find(k => k.toLowerCase() === name.toLowerCase());
+            if (found && env[found] !== undefined)
+                selected[name] = env[found];
+        }
+        return { ...selected, DATA_DIR: c.dataDir, MURMUR_DATA_DIR: c.dataDir, MURMUR_NODE: c.nodePath,
+            MURMUR_ENTRY: paths.join(c.repoRoot, 'scripts', 'murmur-daemon.mjs'), MURMUR_WORKDIR: c.repoRoot,
+            MURMUR_SERVICE_NAME: c.serviceName, MURMUR_RESTARTS_PER_HOUR_LIMIT: '5' };
+    }
+    async function invoke(c, action) {
+        validate(c);
+        const result = await run(await helper(c), [action], { env: selectedEnvironment(c), timeout: action === 'status' ? 8000 : 55000 });
+        if (result.code !== 0)
+            fail(helperReason(result.stderr));
+        return result.stdout;
+    }
+    async function inspect(c) {
+        let v;
+        try {
+            const parsed = JSON.parse(await invoke(c, 'status'));
+            if (!object(parsed))
+                fail('native-response-invalid');
+            v = parsed;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                fail('native-response-invalid');
+            throw error;
+        }
+        const keys = ['schema', 'serviceName', 'profile', 'state', 'manager', 'pid', 'daemonPid', 'since', 'lastExitCode', 'lastFailureAt',
+            'observedStorePath', 'observedStoreUnknownReason', 'restartCount', 'restartWindowMs', 'restartsLastHour', 'restartsUnknownReason', 'restartsPerHourLimit'];
+        if (keys.some(k => !Object.hasOwn(v, k)) || v.schema !== 'murmur.windows-service/1' || v.serviceName !== c.serviceName
+            || !['running', 'stopped', 'failed', 'unknown'].includes(v.state) || !['windows-service', 'none', 'foreign'].includes(v.manager)
+            || !natural(v.pid) || !(v.daemonPid === null || natural(v.daemonPid) && v.daemonPid > 0)
+            || !(v.lastExitCode === null || Number.isSafeInteger(v.lastExitCode))
+            || !['since', 'lastFailureAt', 'observedStorePath', 'observedStoreUnknownReason', 'restartsUnknownReason'].every(k => textOrNull(v[k]))
+            || !['since', 'lastFailureAt'].every(k => v[k] === null || Number.isFinite(Date.parse(v[k])))
+            || v.restartsPerHourLimit !== 5)
+            fail('native-response-invalid');
+        if (!(v.restartCount === null && v.restartWindowMs === null || natural(v.restartCount) && natural(v.restartWindowMs) && v.restartWindowMs <= 3600000)
+            || (v.restartWindowMs === 3600000 ? v.restartsLastHour !== v.restartCount : v.restartsLastHour !== null))
+            fail('native-response-invalid');
+        if (v.manager === 'none') {
+            if (v.state !== 'stopped' || v.profile !== null || v.pid !== 0 || v.daemonPid !== null || v.observedStorePath !== null || v.restartCount !== null)
+                fail('native-response-invalid');
+            return { snapshot: { ...empty('service.not-installed'), state: 'stopped' }, installed: false };
+        }
+        if (v.manager === 'foreign' || !object(v.profile))
+            fail('profile-unverified');
+        const expected = { dataDir: c.dataDir, node: c.nodePath, workDir: c.repoRoot, entry: paths.join(c.repoRoot, 'scripts', 'murmur-daemon.mjs') };
+        for (const [key, value] of Object.entries(expected)) {
+            absolute(v.profile[key]);
+            if (!await same(v.profile[key], value))
+                fail('profile-mismatch');
+        }
+        if (v.profile.restartsPerHourLimit !== 5 || v.state === 'running' && v.pid === 0)
+            fail('native-response-invalid');
+        let observed = null;
+        if (v.observedStorePath !== null) {
+            absolute(v.observedStorePath);
+            if (v.daemonPid === null || !await same(v.observedStorePath, c.storePath))
+                fail('observed-store-mismatch');
+            observed = await canonicalize(v.observedStorePath);
+        }
+        return { installed: true, snapshot: { ...empty(), state: v.state, since: v.since, pid: v.daemonPid,
+                lastExitCode: v.lastExitCode, observedStorePath: observed, restartCount: v.restartCount, restartWindowMs: v.restartWindowMs } };
+    }
+    async function mutate(c, action) {
+        validate(c);
+        const before = await inspect(c);
+        if (action === 'install' && before.installed)
+            fail('already-installed');
+        if (action !== 'install' && !before.installed) {
+            if (action === 'stop' || action === 'uninstall')
+                return;
+            fail('not-installed');
+        }
+        // An unmeasurable level leaves the decision to SCM rather than refusing a real administrator.
+        if (await elevated() === false)
+            fail('elevation-required');
+        await invoke(c, action);
+        const after = await inspect(c);
+        if (action === 'uninstall' ? after.installed : !after.installed
+            || (action === 'stop' ? after.snapshot.state !== 'stopped' : after.snapshot.state !== 'running' || after.snapshot.pid === null))
+            fail('action-unconfirmed');
+    }
+    return {
+        manager: 'windows-service',
+        async status(c) {
+            try {
+                return (await inspect(c)).snapshot;
+            }
+            catch (e) {
+                const reason = e instanceof Error && /^service\.(?:[a-z-]+|helper\.[A-Za-z][A-Za-z0-9.]*)$/.test(e.message) ? e.message : 'service.measurement-failed';
+                return empty(reason);
+            }
+        },
+        install: c => mutate(c, 'install'), start: c => mutate(c, 'start'), stop: c => mutate(c, 'stop'), uninstall: c => mutate(c, 'uninstall'),
+        async detectClients() {
+            const rows = [];
+            for (const [id, command, configPath, format] of [
+                ['claude-code', 'claude', env.CLAUDE_CONFIG_DIR ? null : paths.join(home, '.claude.json'), 'json'],
+                ['codex-cli', 'codex', paths.join(env.CODEX_HOME || paths.join(home, '.codex'), 'config.toml'), 'toml'],
+            ]) {
+                let installed = false;
+                for (const dir of (env.PATH ?? env.Path ?? '').split(';')) {
+                    if (!paths.isAbsolute(dir))
+                        continue;
+                    for (const suffix of ['.exe', '.cmd', '.bat']) {
+                        try {
+                            if ((await stat(paths.join(dir, command + suffix))).isFile())
+                                installed = true;
+                        }
+                        catch { }
+                    }
+                }
+                rows.push({ id, installed, configPath: configPath && paths.isAbsolute(configPath) ? configPath : null, format });
+            }
+            return rows;
+        },
+    };
+}

package/runtime/packages/setup/dist/src/private-file.d.ts

@@ -0,0 +1,5 @@
+import { type FileHandle } from 'node:fs/promises';
+/** Protect a newly created, still-empty setup output before writing credentials. */
+export declare function protectPrivateFile(file: string, handle: FileHandle): Promise<void>;
+/** Existing Windows files keep their access policy, including intentional sandbox readers. */
+export declare function preparePrivateReplacement(file: string, handle: FileHandle, previous: string): Promise<void>;

package/runtime/packages/setup/dist/src/private-file.js

@@ -0,0 +1,101 @@
+import { execFile } from 'node:child_process';
+import { lstat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { sameClientFileIdentity } from './file-identity.js';
+const exec = promisify(execFile);
+const protect = `
+$ErrorActionPreference = 'Stop'
+# Node can inherit PowerShell 7's module paths when launched by a CI runner or
+# terminal. Only load modules belonging to this Windows PowerShell 5.1 process.
+$env:PSModulePath = [System.IO.Path]::Combine($PSHOME, 'Modules')
+$file = $env:MURMUR_SETUP_PRIVATE_FILE
+$source = $env:MURMUR_SETUP_ACCESS_SOURCE
+$section = [System.Security.AccessControl.AccessControlSections]::Access
+function AccessPolicy($acl) {
+  $sddl = $acl.GetSecurityDescriptorSddlForm($section)
+  # Windows marks a copied DACL as auto-inherited even when its ACEs are unchanged.
+  # Ignore only that bookkeeping flag, retaining protection, order and every ACE.
+  return [regex]::Replace($sddl, '^D:(?:P|AI|AR)*', { param($match) $match.Value.Replace('AI', '') })
+}
+$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+# Match onboarding's new-profile policy: creator and the LocalSystem service.
+# Existing replacements use their saved DACL below, including intentional readers.
+$allowed = @($user, 'S-1-5-18') | Select-Object -Unique
+$security = New-Object System.Security.AccessControl.FileSecurity
+if ($source) {
+  $original = Get-Acl -LiteralPath $source
+  $expected = $original.GetSecurityDescriptorSddlForm($section)
+  $security.SetSecurityDescriptorSddlForm($expected, $section)
+  $expectedPolicy = AccessPolicy $original
+} else {
+  $security.SetAccessRuleProtection($true, $false)
+  foreach ($id in $allowed) {
+    $sid = New-Object System.Security.Principal.SecurityIdentifier($id)
+    $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'Allow')
+    $security.AddAccessRule($rule)
+  }
+}
+Set-Acl -LiteralPath $file -AclObject $security
+$actual = Get-Acl -LiteralPath $file
+if ($source) {
+  if ((AccessPolicy $actual) -cne $expectedPolicy -or
+      (AccessPolicy (Get-Acl -LiteralPath $source)) -cne $expectedPolicy) { throw 'changed access policy' }
+  exit 0
+}
+if (!$actual.AreAccessRulesProtected) { throw 'unprotected ACL' }
+$rules = @($actual.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier]))
+if ($rules.Count -ne $allowed.Count) { throw 'unexpected ACL entries' }
+foreach ($rule in $rules) {
+  if ($allowed -notcontains $rule.IdentityReference.Value -or $rule.AccessControlType -ne 'Allow' -or
+      $rule.FileSystemRights -ne [System.Security.AccessControl.FileSystemRights]::FullControl) { throw 'unexpected ACL' }
+}
+`;
+async function prepareFile(file, handle, accessSource) {
+    if (process.platform !== 'win32')
+        return;
+    const opened = await handle.stat({ bigint: true });
+    const before = await lstat(file, { bigint: true });
+    if (!opened.isFile() || opened.size !== 0n || !before.isFile() || !sameClientFileIdentity(before, opened)) {
+        throw new Error('private-file.target-invalid');
+    }
+    const sourceBefore = accessSource ? await lstat(accessSource, { bigint: true }).catch(error => {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }) : null;
+    if (sourceBefore && (!sourceBefore.isFile() || sameClientFileIdentity(sourceBefore, opened))) {
+        throw new Error('private-file.access-source-invalid');
+    }
+    try {
+        // Cold Windows PowerShell 5.1 startup (including antivirus checks) can exceed
+        // ten seconds. This ceiling bounds a hung ACL command, not its normal path.
+        await exec(path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'), ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(protect, 'utf16le').toString('base64')], { env: { ...process.env, MURMUR_SETUP_PRIVATE_FILE: file, MURMUR_SETUP_ACCESS_SOURCE: sourceBefore ? accessSource : '' },
+            windowsHide: true, timeout: 60_000, maxBuffer: 64 * 1024 });
+    }
+    catch (error) {
+        // Keep paths, command text and arbitrary PowerShell stderr out of diagnostics.
+        const failure = error;
+        const rejection = ['changed access policy', 'unprotected ACL', 'unexpected ACL entries', 'unexpected ACL']
+            .find(reason => failure.stderr?.includes(reason));
+        const reason = failure.killed ? 'timeout' : failure.code === 'ENOENT' ? 'powershell-unavailable'
+            : rejection?.replaceAll(' ', '-') ?? 'command-failed';
+        throw new Error(`private-file.windows-acl-failed:${reason}`);
+    }
+    const after = await lstat(file, { bigint: true });
+    if (!after.isFile() || !sameClientFileIdentity(after, opened))
+        throw new Error('private-file.target-changed');
+    if (sourceBefore) {
+        const sourceAfter = await lstat(accessSource, { bigint: true });
+        if (!sourceAfter.isFile() || !sameClientFileIdentity(sourceBefore, sourceAfter))
+            throw new Error('private-file.access-source-changed');
+    }
+}
+/** Protect a newly created, still-empty setup output before writing credentials. */
+export async function protectPrivateFile(file, handle) {
+    return prepareFile(file, handle);
+}
+/** Existing Windows files keep their access policy, including intentional sandbox readers. */
+export async function preparePrivateReplacement(file, handle, previous) {
+    return prepareFile(file, handle, previous);
+}

package/runtime/packages/setup/dist/src/reply-test.d.ts

@@ -0,0 +1,25 @@
+import type { ServiceContext } from './types.js';
+/** Preparing instructions never sends a message or writes any profile state. */
+export declare function prepareReplyTest(context: ServiceContext, peerId: string): Promise<{
+    schema: string;
+    agentId: string;
+    peerId: string;
+    conversationId: string;
+    token: string;
+    createdAt: string;
+    expiresAt: string;
+    requestText: string;
+    expectedReply: string;
+}>;
+/** Inspect only this test's durable rows; do not consume inbox state or poll NATS. */
+export declare function checkReplyTest(context: ServiceContext, token: string): Promise<{
+    schema: string;
+    generatedAt: string;
+    agentId: string;
+    peerId: string;
+    conversationId: string;
+    state: string;
+    requestMsgId: any;
+    replyMsgId: any;
+    receivedAt: any;
+}>;

package/runtime/packages/setup/dist/src/reply-test.js

@@ -0,0 +1,75 @@
+import { randomBytes } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import { loadConfig, validAgentId } from './config.js';
+import { pairFingerprint } from './status.js';
+const duration = 15 * 60 * 1000;
+const conversation = (c) => `murmur:setup:${c.nonce}`;
+const reply = (c) => `MURMUR-SETUP-REPLY ${c.nonce}`;
+const request = (c) => `Murmur connection test from ${c.agentId}. Use murmur_send to reply to ${c.agentId} in this same conversation with exactly this line: ${reply(c)}`;
+// Agent identities/signatures may surround the protocol line, but a substring
+// inside an explanation or blockquote is not a completed request/reply.
+const hasProtocolLine = (text, expected) => text.split(/\r?\n/).some(line => line.trim() === expected);
+/** Preparing instructions never sends a message or writes any profile state. */
+export async function prepareReplyTest(context, peerId) {
+    const config = await loadConfig(context);
+    if (!validAgentId(peerId) || !config.peers[peerId] || peerId === config.agentId)
+        throw new Error('reply-test.peer-invalid');
+    const challenge = { version: 1, agentId: config.agentId, peerId, fingerprint: pairFingerprint(config, peerId),
+        nonce: randomBytes(24).toString('hex'), createdAt: new Date().toISOString() };
+    return { schema: 'murmur.reply-test-plan/1', agentId: config.agentId, peerId, conversationId: conversation(challenge),
+        token: Buffer.from(JSON.stringify(challenge)).toString('base64url'), createdAt: challenge.createdAt,
+        expiresAt: new Date(Date.parse(challenge.createdAt) + duration).toISOString(),
+        requestText: request(challenge), expectedReply: reply(challenge) };
+}
+/** Inspect only this test's durable rows; do not consume inbox state or poll NATS. */
+export async function checkReplyTest(context, token) {
+    if (token.length > 2048 || !/^[A-Za-z0-9_-]+$/.test(token))
+        throw new Error('reply-test.token-invalid');
+    let test;
+    try {
+        test = JSON.parse(Buffer.from(token, 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new Error('reply-test.token-invalid');
+    }
+    const now = Date.now(), start = Date.parse(test?.createdAt), end = start + duration;
+    if (test?.version !== 1 || !validAgentId(test.agentId) || !validAgentId(test.peerId)
+        || typeof test.nonce !== 'string' || !/^[a-f0-9]{48}$/.test(test.nonce)
+        || typeof test.fingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(test.fingerprint)
+        || !Number.isFinite(start) || start > now + 5000)
+        throw new Error('reply-test.token-invalid');
+    const config = await loadConfig(context), peer = config.peers[test.peerId];
+    if (config.agentId !== test.agentId || !peer || pairFingerprint(config, test.peerId) !== test.fingerprint)
+        throw new Error('reply-test.profile-changed');
+    const db = new DatabaseSync(context.storePath, { readOnly: true });
+    try {
+        db.exec('PRAGMA busy_timeout=1000; BEGIN');
+        const sent = db.prepare(`SELECT msg_id AS msgId, created_at AS createdAt, text, channel_id AS channelId,
+      sender_member_id AS senderMemberId, addressee_member_id AS addresseeMemberId FROM local_messages
+      WHERE direction='outbound' AND sender=? AND conversation_id=? ORDER BY rowid DESC LIMIT 100`)
+            .all(test.agentId, conversation(test));
+        const received = db.prepare(`SELECT msg_id AS msgId, created_at AS createdAt, text, channel_id AS channelId,
+      sender_member_id AS senderMemberId, addressee_member_id AS addresseeMemberId FROM local_messages
+      WHERE direction='inbound' AND sender=? AND conversation_id=?
+      ORDER BY rowid DESC LIMIT 100`).all(test.peerId, conversation(test));
+        db.exec('COMMIT');
+        const inWindow = (row) => {
+            const at = Date.parse(row.createdAt);
+            return Number.isFinite(at) && at >= start - 5000 && at <= Math.min(end, now + 5000);
+        };
+        const routing = (row, inbound) => (row.channelId ?? null) === (peer.channelId ?? null)
+            && (row.senderMemberId ?? null) === ((inbound ? peer.memberId : config.memberId) ?? null)
+            && (row.addresseeMemberId ?? null) === ((inbound ? config.memberId : peer.memberId) ?? null);
+        const outbound = sent.find(row => hasProtocolLine(row.text, request(test)) && inWindow(row) && routing(row, false));
+        const inbound = outbound && received.find(row => inWindow(row) && routing(row, true)
+            && hasProtocolLine(row.text, reply(test))
+            && Date.parse(row.createdAt) >= Date.parse(outbound.createdAt) - 5000);
+        return { schema: 'murmur.reply-test/1', generatedAt: new Date(now).toISOString(), agentId: config.agentId,
+            peerId: test.peerId, conversationId: conversation(test),
+            state: inbound ? 'replied' : now > end ? 'expired' : outbound ? 'waiting' : 'not-sent',
+            requestMsgId: outbound?.msgId ?? null, replyMsgId: inbound?.msgId ?? null, receivedAt: inbound?.createdAt ?? null };
+    }
+    finally {
+        db.close();
+    }
+}

package/runtime/packages/setup/dist/src/state.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceContext } from "./types.js";
+/** Reuse the runtime's existing private-state writer; setup ships with that runtime. */
+export declare function writeState(c: ServiceContext, file: string, value: unknown): Promise<void>;

package/runtime/packages/setup/dist/src/state.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { preparePrivateReplacement } from "./private-file.js";
+/** Reuse the runtime's existing private-state writer; setup ships with that runtime. */
+export async function writeState(c, file, value) {
+    if (path.dirname(file) !== c.dataDir)
+        throw new Error("state.outside-data-dir");
+    const helpers = await import(pathToFileURL(path.join(c.repoRoot, "scripts", "secure-state.mjs")).href);
+    await helpers.writePrivateJson(file, value, {
+        beforeWrite: (temporary, handle) => preparePrivateReplacement(temporary, handle, file),
+    });
+}

package/runtime/packages/setup/dist/src/status-line.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Render one untrusted-data-free segment for prompts, tmux and Claude Code.
+ * Message bodies, peer IDs and runtime errors are deliberately never copied.
+ */
+export declare function renderStatusLine(status: unknown, now?: number): string;

package/runtime/packages/setup/dist/src/status-line.js

@@ -0,0 +1,19 @@
+import { statusVerdict } from './verdict.js';
+const natural = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const safeCode = (value) => /^[a-z][a-z0-9.-]{0,80}$/.test(value) ? value : 'status.invalid';
+/**
+ * Render one untrusted-data-free segment for prompts, tmux and Claude Code.
+ * Message bodies, peer IDs and runtime errors are deliberately never copied.
+ */
+export function renderStatusLine(status, now = Date.now()) {
+    const verdict = statusVerdict(status, now);
+    const unreadValue = status && typeof status === 'object'
+        ? status.inbox?.unread
+        : null;
+    const unread = natural(unreadValue) && unreadValue > 0 ? `Murmur: ${unreadValue} unread` : '';
+    if (verdict.level === 'green')
+        return unread;
+    const label = verdict.level === 'red' ? 'error' : verdict.level === 'yellow' ? 'warning' : 'unknown';
+    const health = `Murmur: ${label} (${safeCode(verdict.code)})`;
+    return unread ? `${unread} | ${health}` : health;
+}

package/runtime/packages/setup/dist/src/status.d.ts

@@ -0,0 +1,137 @@
+import { type AgentConfig } from "./config.js";
+import type { PlatformAdapter, ServiceContext } from "./types.js";
+export type Measurement = {
+    measuredAt: string | null;
+    unknownReason: string | null;
+};
+export declare const pairFingerprint: (config: AgentConfig, peerId: string) => string;
+export declare function validPairProof(proof: any, config: AgentConfig, peerId: string, now: number): boolean;
+export interface StatusOptions {
+    context: ServiceContext;
+    adapter: PlatformAdapter;
+    now?: () => number;
+}
+export declare function readStatus({ context: c, adapter, now }: StatusOptions): Promise<{
+    schema: "murmur.status/1";
+    generatedAt: string;
+    agentId: string | null;
+    serviceName: string;
+    service: {
+        lastFailureAt: null;
+        restartsLastHour: number | null;
+        restartFailureThreshold: number;
+        unknownReason: string | null;
+        measurements: {
+            manager: Measurement;
+            history: Measurement;
+        };
+        state: "running" | "stopped" | "failed" | "unknown";
+        manager: import("./types.js").ServiceManager;
+        since: string | null;
+        pid: number | null;
+        lastExitCode: number | null;
+        observedStorePath: string | null;
+        restartCount: number | null;
+        restartWindowMs: number | null;
+        detail?: string;
+    };
+    broker: {
+        url: string | null;
+        state: any;
+        connectedAt: any;
+        lastError: any;
+        lastErrorAt: any;
+        unknownReason: string | null;
+        measurements: {
+            runtime: Measurement;
+        };
+    };
+    peers: {
+        list: Array<{
+            agentId: string;
+            paired: boolean | null;
+            lastInboundAt: string | null;
+            lastOutboundAt: string | null;
+        }> | null;
+        unknownReason: string | null;
+        measurements: Record<string, Measurement>;
+    };
+    inbox: {
+        unread: number | null;
+        total: number | null;
+        lastAt: string | null;
+        unknownReason: string | null;
+        measurements: {
+            store: Measurement;
+            cursor: Measurement;
+        };
+    };
+    deliveries: Record<string, unknown>[] | null;
+    outbox: {
+        attention: {
+            schema: "murmur.outbox-attention/1";
+            total: number;
+            pending: number;
+            dismissed: number;
+            items: {
+                msgId: string;
+                peer: string | null;
+                createdAt: string;
+                failedAt: string;
+                reason: string;
+                attempts: number;
+                token: string;
+                dismissed: boolean;
+            }[];
+            truncated: boolean;
+            unknownReason: null;
+        } | {
+            unknownReason: string;
+        };
+        queue: {
+            pending: number | null;
+            inflight: number | null;
+            delivered: number | null;
+            failed: number | null;
+            dlq: number | null;
+            oldestPendingAt: string | null;
+            unknownReason: string | null;
+        };
+        faults: {
+            lastError: string | null;
+            lastErrorAt: string | null;
+            unknownReason: string | null;
+            source: string;
+        };
+    };
+    wake: {
+        config: {
+            enabled: boolean | null;
+            mode: "none" | "hook" | "monitor" | null;
+            responder: string | null;
+            unknownReason: string | null;
+        };
+        effective: {
+            enabled: any;
+            needsRestart: boolean | null;
+            observedAt: string | null;
+            unknownReason: string | null;
+        };
+        delivery: {
+            pendingUndelivered: number | null;
+            storedOnly: number | null;
+            lastDeliveredAt: string | null;
+            unknownReason: string | null;
+        };
+        faults: {
+            lastFault: string | null;
+            lastFaultAt: any;
+            unknownReason: string | null;
+            measurements: {
+                store: Measurement;
+                runtime: Measurement;
+            };
+        };
+    };
+}>;
+export declare function configuredWakeMode(config: AgentConfig): "hook" | "monitor" | "none";