@murmurv2/cli 2.11.0 → 2.12.0

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

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
-import { realpath, stat } from 'node:fs/promises';
+import { access, realpath, stat } from 'node:fs/promises';
+import { constants } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 const paths = path.win32;
@@ -102,7 +103,10 @@ export function createWindowsAdapter(options = {}) {
             || !(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)
+            || v.restartsPerHourLimit !== 5
+            // Older helpers omit foreignKind; it describes only a Service that is not this installation's.
+            || !(v.foreignKind === undefined || v.foreignKind === null
+                || v.manager === 'foreign' && ['previous-installation', 'not-murmur'].includes(v.foreignKind)))
             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))
@@ -112,7 +116,12 @@ export function createWindowsAdapter(options = {}) {
                 fail('native-response-invalid');
             return { snapshot: { ...empty('service.not-installed'), state: 'stopped' }, installed: false };
         }
-        if (v.manager === 'foreign' || !object(v.profile))
+        // A Service left by another Murmur installation (a pilot or an earlier version) can be replaced
+        // on request; a name taken by another program never is. Anything else stays unverified.
+        if (v.manager === 'foreign')
+            fail(v.foreignKind === 'previous-installation' ? 'previous-installation'
+                : v.foreignKind === 'not-murmur' ? 'foreign-image' : 'profile-unverified');
+        if (!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)) {
@@ -151,8 +160,63 @@ export function createWindowsAdapter(options = {}) {
             || (action === 'stop' ? after.snapshot.state !== 'stopped' : after.snapshot.state !== 'running' || after.snapshot.pid === null))
             fail('action-unconfirmed');
     }
+    /** Removes only a Service that another Murmur installation registered under this name. */
+    async function removePrevious(c) {
+        validate(c);
+        const found = await inspect(c).then(() => null, (error) => error);
+        if (found === null)
+            return; // Absent or already this installation's: nothing to replace.
+        if (!(found instanceof Error && found.message === 'service.previous-installation'))
+            throw found;
+        if (await elevated() === false)
+            fail('elevation-required');
+        await invoke(c, 'remove-previous');
+        const after = await inspect(c).catch(() => null);
+        if (!after || after.installed)
+            fail('action-unconfirmed');
+    }
     return {
         manager: 'windows-service',
+        removePrevious,
+        async logDirectory(c) {
+            validate(c);
+            if (!(await inspect(c)).installed)
+                throw new Error('logs.service-not-installed');
+            const programData = Object.entries(env).find(([key]) => key.toLowerCase() === 'programdata')?.[1];
+            if (!programData || !paths.isAbsolute(programData))
+                throw new Error('logs.windows-native-location-unavailable');
+            // This is the native helper's ProgramData/Murmur/logs/<service> layout.
+            // Verify ownership above and containment after resolving junctions below.
+            try {
+                const root = await canonicalize(paths.join(programData, 'Murmur', 'logs'));
+                const logDir = await canonicalize(paths.join(programData, 'Murmur', 'logs', c.serviceName));
+                if (paths.relative(root, logDir) !== c.serviceName)
+                    throw new Error('logs.path-outside-service');
+                if (!(await stat(logDir)).isDirectory())
+                    throw new Error('logs.not-directory');
+                await access(logDir, constants.R_OK);
+                return logDir;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith('logs.'))
+                    throw error;
+                const code = error.code;
+                throw new Error(code === 'ENOENT' ? 'logs.directory-missing' : code === 'EACCES' || code === 'EPERM' ? 'logs.directory-unreadable' : 'logs.path-unavailable');
+            }
+        },
+        async observeStore(c, pid) {
+            validate(c);
+            if (!natural(pid) || pid === 0)
+                return null;
+            const result = await run(await helper(c), ['observe-store', String(pid)], { env: selectedEnvironment(c), timeout: 8000 });
+            if (result.code !== 0)
+                return null; // Older helpers cannot provide this proof.
+            const v = JSON.parse(result.stdout);
+            if (!object(v) || v.schema !== 'murmur.store-proof/1' || v.pid !== pid || typeof v.observedStorePath !== 'string')
+                return null;
+            absolute(v.observedStorePath);
+            return await same(v.observedStorePath, c.storePath) ? canonicalize(v.observedStorePath) : null;
+        },
         async status(c) {
             try {
                 return (await inspect(c)).snapshot;

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

@@ -6,6 +6,14 @@ export type Measurement = {
 };
 export declare const pairFingerprint: (config: AgentConfig, peerId: string) => string;
 export declare function validPairProof(proof: any, config: AgentConfig, peerId: string, now: number): boolean;
+interface ContactReload {
+    state: "current" | "partial" | "retained";
+    count: number;
+    invalidCount: number;
+    lastSuccessAt: string | null;
+    lastError: string | null;
+    lastErrorAt: string | null;
+}
 export interface StatusOptions {
     context: ServiceContext;
     adapter: PlatformAdapter;
@@ -14,9 +22,10 @@ export interface StatusOptions {
 export declare function readStatus({ context: c, adapter, now }: StatusOptions): Promise<{
     schema: "murmur.status/1";
     generatedAt: string;
-    agentId: string | null;
+    agentId: any;
     serviceName: string;
     service: {
+        managed: boolean | null;
         lastFailureAt: null;
         restartsLastHour: number | null;
         restartFailureThreshold: number;
@@ -25,7 +34,7 @@ export declare function readStatus({ context: c, adapter, now }: StatusOptions):
             manager: Measurement;
             history: Measurement;
         };
-        state: "running" | "stopped" | "failed" | "unknown";
+        state: "running" | "running-unmanaged" | "stopped" | "failed" | "unknown";
         manager: import("./types.js").ServiceManager;
         since: string | null;
         pid: number | null;
@@ -41,6 +50,8 @@ export declare function readStatus({ context: c, adapter, now }: StatusOptions):
         connectedAt: any;
         lastError: any;
         lastErrorAt: any;
+        disconnectedAt: any;
+        reconnectAttempts: any;
         unknownReason: string | null;
         measurements: {
             runtime: Measurement;
@@ -52,7 +63,10 @@ export declare function readStatus({ context: c, adapter, now }: StatusOptions):
             paired: boolean | null;
             lastInboundAt: string | null;
             lastOutboundAt: string | null;
+            lastExchangeAt: string | null;
+            connection: "connected" | "stale" | "unverified";
         }> | null;
+        reload: ContactReload | null;
         unknownReason: string | null;
         measurements: Record<string, Measurement>;
     };
@@ -135,3 +149,4 @@ export declare function readStatus({ context: c, adapter, now }: StatusOptions):
     };
 }>;
 export declare function configuredWakeMode(config: AgentConfig): "hook" | "monitor" | "none";
+export {};

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

@@ -2,8 +2,9 @@ import { DatabaseSync } from "node:sqlite";
 import path from "node:path";
 import { realpath } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { loadConfig, readJson, safeError } from "./config.js";
+import { loadConfig, readJson, safeError, validAgentId } from "./config.js";
 import { readOutboxAttention } from "./outbox-attention.js";
+import { assistantRead, wakeColumns } from "./message-status.js";
 const measured = (at) => ({ measuredAt: at, unknownReason: null });
 const unknown = (reason) => ({ measuredAt: null, unknownReason: reason });
 export const pairFingerprint = (config, peerId) => createHash("sha256").update(JSON.stringify([
@@ -11,10 +12,27 @@ export const pairFingerprint = (config, peerId) => createHash("sha256").update(J
     config.peers[peerId]?.signing.publicKey, config.peers[peerId]?.encryption.publicKey,
 ])).digest("hex");
 export function validPairProof(proof, config, peerId, now) {
-    const at = Date.parse(proof?.verifiedAt);
+    const at = pairProofTime(proof, config, peerId, now);
+    return at !== null && now - Date.parse(at) <= 86400000;
+}
+function pairProofTime(proof, config, peerId, now) {
     return proof?.peerId === peerId && proof?.localAgentId === config.agentId
         && proof?.keyFingerprint === pairFingerprint(config, peerId)
-        && Number.isFinite(at) && now - at >= -5000 && now - at <= 86400000;
+        ? exchangeTime(proof.verifiedAt, now) : null;
+}
+function exchangeTime(value, now) {
+    const timestamp = typeof value === "string" ? Date.parse(value) : NaN;
+    return Number.isFinite(timestamp) && timestamp <= now + 5000 ? new Date(timestamp).toISOString() : null;
+}
+function contactReload(raw, now) {
+    if (!raw || !["current", "partial", "retained"].includes(raw.state)
+        || !Number.isSafeInteger(raw.count) || raw.count < 0
+        || !Number.isSafeInteger(raw.invalidCount) || raw.invalidCount < 0
+        || (raw.lastError !== null && (typeof raw.lastError !== "string" || !/^agent-config-[a-z-]+$/.test(raw.lastError))))
+        return null;
+    return { state: raw.state, count: raw.count, invalidCount: raw.invalidCount,
+        lastSuccessAt: exchangeTime(raw.lastSuccessAt, now), lastError: raw.lastError,
+        lastErrorAt: exchangeTime(raw.lastErrorAt, now) };
 }
 export async function readStatus({ context: c, adapter, now = Date.now }) {
     const started = now();
@@ -46,13 +64,33 @@ export async function readStatus({ context: c, adapter, now = Date.now }) {
         const raw = await readJson(path.join(c.dataDir, "daemon-observation.json"));
         const timestamp = Date.parse(raw.measuredAt);
         const storePath = await realpath(c.storePath);
-        if (raw.schema === "murmur.runtime/1" && service.state === "running" && raw.pid === service.pid
-            && raw.agentId === config?.agentId && raw.storePath === storePath && service.observedStorePath === storePath
+        if (raw.schema === "murmur.runtime/1" && Number.isSafeInteger(raw.pid) && raw.pid > 0
+            // A rejected on-disk config must not hide an already running process's
+            // reload diagnostic. Fresh PID/open-store evidence still gates acceptance.
+            && validAgentId(raw.agentId) && (!config || raw.agentId === config.agentId) && raw.storePath === storePath
             && Number.isFinite(timestamp) && started - timestamp >= -5000 && started - timestamp <= 15000
-            && ["connected", "disconnected", "unauthorized", "unknown"].includes(raw.broker?.state)
+            && ["connected", "disconnected", "unauthorized", "closed", "unknown"].includes(raw.broker?.state)
             && typeof raw.wake?.enabled === "boolean" && ["hook", "monitor", "none"].includes(raw.wake?.mode)) {
-            observation = raw;
-            runtimeMeasurement = measured(raw.measuredAt);
+            const managed = service.state === "running" && raw.pid === service.pid && service.observedStorePath === storePath;
+            // A fresh file alone cannot prove liveness: the OS must observe this PID's
+            // open database. Never use process arguments or the configured service name.
+            const independent = !managed && service.state !== "failed"
+                ? await adapter.observeStore?.(c, raw.pid).catch(() => null) : null;
+            if (managed || independent === storePath) {
+                // A Service of a previous Murmur installation keeps its own label: the live process is
+                // most likely its child, and "running outside this app" would hide the replacement.
+                const previous = service.detail === "service.previous-installation";
+                if (!managed && raw.pid !== service.pid && !previous)
+                    service = { state: "running-unmanaged", manager: "none", pid: raw.pid,
+                        observedStorePath: storePath, since: exchangeTime(raw.startedAt, started), lastExitCode: null,
+                        restartCount: null, restartWindowMs: null, detail: "service.running-unmanaged" };
+                else if (independent === storePath)
+                    service = { ...service, observedStorePath: storePath };
+                observation = raw;
+                runtimeMeasurement = measured(raw.measuredAt);
+            }
+            else
+                runtimeMeasurement = unknown("runtime.process-store-unverified");
         }
         else
             runtimeMeasurement = unknown("runtime.observation-unverified-or-stale");
@@ -70,7 +108,9 @@ export async function readStatus({ context: c, adapter, now = Date.now }) {
         lastFault: null, lastFaultAt: null, unknownReason: null,
         measurements: { store: unknown("store.unavailable"), runtime: runtimeMeasurement } };
     const peers = {
-        list: config ? Object.keys(config.peers).map((agentId) => ({ agentId, paired: null, lastInboundAt: null, lastOutboundAt: null })) : null,
+        list: config ? Object.keys(config.peers).map((agentId) => ({ agentId, paired: null, lastInboundAt: null, lastOutboundAt: null,
+            lastExchangeAt: null, connection: "unverified" })) : null,
+        reload: contactReload(observation?.contacts, started),
         unknownReason: configError, measurements: { config: config ? measured(at) : unknown(configError ?? "config.unavailable"), store: unknown("store.unavailable"), proof: unknown("peers.proof-unavailable") },
     };
     let deliveries = null;
@@ -116,7 +156,9 @@ export async function readStatus({ context: c, adapter, now = Date.now }) {
             wake.storedOnly = rows["stored-only"] ?? 0;
             wake.pendingUndelivered = (rows.pending ?? 0) + (rows.inflight ?? 0) + (rows.failed ?? 0);
             wake.lastDeliveredAt = db.prepare("SELECT MAX(wake_updated_at) AS at FROM local_messages WHERE direction='inbound' AND wake_status='handled'").get().at;
-            const fault = db.prepare("SELECT wake_error,wake_updated_at FROM local_messages WHERE direction='inbound' AND wake_status IN ('failed','dlq') AND wake_error IS NOT NULL ORDER BY wake_updated_at DESC LIMIT 1").get();
+            const fault = db.prepare(`SELECT wake_error,wake_updated_at FROM local_messages WHERE direction='inbound'
+        AND (wake_status IN ('failed','dlq') OR (wake_status='inflight' AND wake_error='accepted-turn-unobservable'))
+        AND wake_error IS NOT NULL ORDER BY wake_updated_at DESC LIMIT 1`).get();
             wake.lastFault = fault ? safeError(fault.wake_error) : null;
             wake.lastFaultAt = fault?.wake_updated_at ?? null;
             wake.measurements.store = measured(at);
@@ -124,14 +166,20 @@ export async function readStatus({ context: c, adapter, now = Date.now }) {
         catch {
             wake.measurements.store = unknown("wake.store-schema-unavailable");
         }
+        const exchangeCutoff = new Date(started + 5000).toISOString();
         for (const peer of peers.list ?? []) {
-            peer.lastInboundAt = db.prepare("SELECT MAX(created_at) AS at FROM local_messages WHERE direction='inbound' AND sender=?").get(peer.agentId).at;
-            peer.lastOutboundAt = db.prepare("SELECT MAX(created_at) AS at FROM outbox WHERE json_extract(envelope_json,'$.recipients[0]')=?").get(peer.agentId).at;
+            peer.lastInboundAt = db.prepare("SELECT created_at AS at FROM local_messages WHERE direction='inbound' AND sender=? AND julianday(created_at)<=julianday(?) ORDER BY julianday(created_at) DESC LIMIT 1").get(peer.agentId, exchangeCutoff)?.at ?? null;
+            peer.lastOutboundAt = db.prepare("SELECT created_at AS at FROM outbox WHERE json_extract(envelope_json,'$.recipients[0]')=? AND julianday(created_at)<=julianday(?) ORDER BY julianday(created_at) DESC LIMIT 1").get(peer.agentId, exchangeCutoff)?.at ?? null;
+            const ackedAt = db.prepare("SELECT updated_at AS at FROM outbox WHERE status='acked' AND json_extract(envelope_json,'$.recipients[0]')=? AND julianday(updated_at)<=julianday(?) ORDER BY julianday(updated_at) DESC LIMIT 1").get(peer.agentId, exchangeCutoff)?.at ?? null;
+            peer.lastExchangeAt = [peer.lastInboundAt, ackedAt].map(value => exchangeTime(value, started)).filter((value) => value !== null).sort().at(-1) ?? null;
         }
         peers.measurements.store = measured(at);
         const outbound = db.prepare("SELECT msg_id AS msgId,json_extract(envelope_json,'$.recipients[0]') AS peer,'outbound' AS direction,CASE status WHEN 'acked' THEN 'delivered' WHEN 'sent' THEN 'inflight' ELSE status END AS state,updated_at AS at,attempts,last_error AS error FROM outbox ORDER BY updated_at DESC LIMIT 20").all();
-        const inbound = db.prepare("SELECT msg_id AS msgId,sender AS peer,'inbound' AS direction,'delivered' AS state,created_at AS at,0 AS attempts,NULL AS error FROM local_messages WHERE direction='inbound' ORDER BY created_at DESC LIMIT 20").all();
-        deliveries = [...outbound, ...inbound].sort((a, b) => String(b.at).localeCompare(String(a.at))).slice(0, 20).map((r) => ({ ...r, error: r.error ? safeError(r.error) : null }));
+        const inbound = db.prepare(`SELECT msg_id AS msgId,sender AS peer,'inbound' AS direction,'delivered' AS state,created_at AS at,0 AS attempts,NULL AS error,${wakeColumns(db)} FROM local_messages WHERE direction='inbound' ORDER BY created_at DESC LIMIT 20`).all();
+        deliveries = [...outbound, ...inbound].sort((a, b) => String(b.at).localeCompare(String(a.at))).slice(0, 20).map((r) => ({ ...r,
+            error: r.error ? safeError(r.error) : null, wake_status: r.wake_status ?? null,
+            wake_error: r.wake_error ? safeError(r.wake_error) : null,
+            wake_updated_at: r.wake_updated_at ?? null, assistantRead: assistantRead(r.wake_status) }));
         db.exec("COMMIT");
     }
     catch {
@@ -143,25 +191,37 @@ export async function readStatus({ context: c, adapter, now = Date.now }) {
     if (config) {
         try {
             const proofs = await readJson(path.join(c.dataDir, "pair-proofs.json"));
-            for (const peer of peers.list ?? [])
+            for (const peer of peers.list ?? []) {
                 peer.paired = validPairProof(proofs[peer.agentId], config, peer.agentId, started) ? true : null;
+                const proofAt = pairProofTime(proofs[peer.agentId], config, peer.agentId, started);
+                peer.lastExchangeAt = [peer.lastExchangeAt, proofAt].filter((value) => value !== null).sort().at(-1) ?? null;
+            }
             peers.measurements.proof = measured(at);
         }
         catch { /* No roundtrip evidence: every pairing stays unknown. */ }
     }
+    for (const peer of peers.list ?? [])
+        peer.connection = peer.lastExchangeAt === null ? "unverified"
+            : started - Date.parse(peer.lastExchangeAt) <= 86400000 ? "connected" : "stale";
     const reason = (sources) => Object.entries(sources).filter(([, v]) => v.unknownReason).map(([name, v]) => `${name}:${v.unknownReason}`).join("; ") || null;
     inbox.unknownReason = reason(inbox.measurements);
     outbox.unknownReason = reason(outbox.measurements);
     wake.unknownReason = reason(wake.measurements);
     peers.unknownReason = reason(peers.measurements);
     return {
-        schema: "murmur.status/1", generatedAt: at, agentId: config?.agentId ?? null, serviceName: c.serviceName,
-        service: { ...service, lastFailureAt: null, restartsLastHour, restartFailureThreshold: 5,
+        schema: "murmur.status/1", generatedAt: at, agentId: config?.agentId ?? observation?.agentId ?? null, serviceName: c.serviceName,
+        service: { ...service, managed: service.state === "running" ? true : service.state === "running-unmanaged" ? false : null, lastFailureAt: null,
+            restartsLastHour: service.state === "running-unmanaged" ? null : restartsLastHour, restartFailureThreshold: 5,
             unknownReason: service.state === "unknown" ? service.detail ?? "service.unavailable" : null,
             measurements: { manager: service.state === "unknown" ? unknown(service.detail ?? "service.unavailable") : measured(at), history: unknown("service.history-unavailable") } },
         broker: { url: config?.natsUrl ?? null, state: observation?.broker?.state ?? "unknown",
             connectedAt: observation?.broker?.connectedAt ?? null, lastError: observation?.broker?.lastError ?? null,
-            lastErrorAt: observation?.broker?.lastErrorAt ?? null, unknownReason: runtimeMeasurement.unknownReason,
+            lastErrorAt: observation?.broker?.lastErrorAt ?? null,
+            // #276 — since when the link is lost and how many reconnect attempts failed meanwhile.
+            disconnectedAt: typeof observation?.broker?.disconnectedAt === "string" ? observation.broker.disconnectedAt : null,
+            reconnectAttempts: Number.isSafeInteger(observation?.broker?.reconnectAttempts) && observation.broker.reconnectAttempts >= 0
+                ? observation.broker.reconnectAttempts : null,
+            unknownReason: runtimeMeasurement.unknownReason,
             measurements: { runtime: runtimeMeasurement } },
         peers, inbox, deliveries,
         outbox: {

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

@@ -10,7 +10,7 @@ export interface ServiceContext {
 }
 export type ServiceManager = "windows-service" | "scheduled-task" | "launchd" | "systemd" | "none";
 export interface ServiceSnapshot {
-    state: "running" | "stopped" | "failed" | "unknown";
+    state: "running" | "running-unmanaged" | "stopped" | "failed" | "unknown";
     manager: ServiceManager;
     since: string | null;
     pid: number | null;
@@ -32,9 +32,19 @@ export interface ClientDetection {
 export interface PlatformAdapter {
     manager: ServiceManager;
     status(context: ServiceContext): Promise<ServiceSnapshot>;
+    /** Read-only proof that this PID currently holds the selected store open. */
+    observeStore?(context: ServiceContext, pid: number): Promise<string | null>;
     install(context: ServiceContext): Promise<void>;
     start(context: ServiceContext): Promise<void>;
     stop(context: ServiceContext): Promise<void>;
     uninstall?(context: ServiceContext): Promise<void>;
+    /**
+     * Removes a Service registered under this name by another installation of Murmur (a pilot or
+     * an earlier version), so that install can follow in the same elevated process. Resolves
+     * without change when there is none; refuses a Service that does not run Murmur.
+     */
+    removePrevious?(context: ServiceContext): Promise<void>;
     detectClients(context: ServiceContext): Promise<ClientDetection[]>;
+    /** Native log location, after verifying the selected service owns this profile. */
+    logDirectory?(context: ServiceContext): Promise<string>;
 }

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

@@ -59,7 +59,7 @@ export function statusVerdict(input, now = Date.now()) {
         return out("grey", invalid);
     if (typeof s.schema !== "string" || !/^murmur\.status\/1(?:\.\d+)?$/.test(s.schema))
         return out("grey", "schema.unknown");
-    unread = count(s.inbox?.unread) && s.inbox.unread > 0;
+    unread = count(s.wake?.delivery?.pendingUndelivered) && s.wake.delivery.pendingUndelivered > 0;
     const stamp = typeof s.generatedAt === "string" && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(s.generatedAt) ? Date.parse(s.generatedAt) : NaN;
     if (!Number.isFinite(stamp) || !Number.isFinite(now))
         return out("grey", "snapshot.unparsable");
@@ -69,7 +69,7 @@ export function statusVerdict(input, now = Date.now()) {
         return out("grey", "snapshot.future");
     if (s.service?.state === "stopped")
         return out("grey", "service.stopped");
-    if (!["running", "failed"].includes(s.service?.state))
+    if (!["running", "running-unmanaged", "failed"].includes(s.service?.state))
         return out("grey", "service.unknown");
     if (s.service.state === "failed")
         return out("red", "service.failed");
@@ -101,6 +101,8 @@ export function statusVerdict(input, now = Date.now()) {
             note(name, "source-unreadable");
     switch (s.broker?.state) {
         case "unauthorized": return out("yellow", "broker.unauthorized");
+        // #276 — the client gave up for good; only a restart brings the link back.
+        case "closed": return out("red", "broker.closed");
         case "connected": break;
         case null:
         case undefined:

package/runtime/packages/setup/dist/src/wake-attention.d.ts

@@ -0,0 +1,11 @@
+import type { ServiceContext } from './types.js';
+/** Acknowledge an unknown accepted outcome; never replay it or claim it was read. */
+export declare function dismissWake(c: ServiceContext, msgId: string, expectedAgent: string): Promise<{
+    schema: string;
+    agentId: string;
+    msgIds: import("node:sqlite").SQLOutputValue[];
+    status: string;
+    reason: string;
+    executed: boolean;
+    historyPreserved: boolean;
+}>;

package/runtime/packages/setup/dist/src/wake-attention.js

@@ -0,0 +1,44 @@
+import { DatabaseSync } from 'node:sqlite';
+import { lstat, mkdir, rmdir } from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig, validAgentId } from './config.js';
+/** Acknowledge an unknown accepted outcome; never replay it or claim it was read. */
+export async function dismissWake(c, msgId, expectedAgent) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,150}$/.test(msgId) || !validAgentId(expectedAgent))
+        throw new Error('wake.selection-invalid');
+    const lock = path.join(c.dataDir, '.setup-write.lock');
+    await mkdir(lock, { mode: 0o700 });
+    try {
+        const config = await loadConfig(c);
+        if (config.agentId !== expectedAgent)
+            throw new Error('wake.identity-changed');
+        const file = await lstat(c.storePath);
+        if (!file.isFile() || file.isSymbolicLink() || (typeof process.getuid === 'function' && file.uid !== process.getuid())) {
+            throw new Error('wake.store-invalid');
+        }
+        const db = new DatabaseSync(c.storePath);
+        try {
+            db.exec('PRAGMA busy_timeout=1000; BEGIN IMMEDIATE');
+            const row = db.prepare("SELECT wake_batch_id FROM local_messages WHERE direction='inbound' AND msg_id=?").get(msgId);
+            if (!row)
+                throw new Error('wake.dismiss-not-eligible');
+            const rows = db.prepare(`SELECT msg_id,wake_status,wake_error FROM local_messages WHERE direction='inbound'
+        AND (msg_id=? OR (wake_batch_id IS NOT NULL AND wake_batch_id=?))`).all(msgId, row.wake_batch_id);
+            if (rows.some(r => !['dlq', 'muted'].includes(String(r.wake_status)) || r.wake_error !== 'accepted-turn-unobservable')) {
+                throw new Error('wake.dismiss-not-eligible');
+            }
+            const update = db.prepare("UPDATE local_messages SET wake_status='muted',wake_next_at=NULL,wake_updated_at=? WHERE direction='inbound' AND msg_id=?");
+            for (const r of rows)
+                update.run(new Date().toISOString(), r.msg_id);
+            db.exec('COMMIT');
+            return { schema: 'murmur.wake-dismiss/1', agentId: config.agentId, msgIds: rows.map(r => r.msg_id),
+                status: 'muted', reason: 'accepted-turn-unobservable', executed: false, historyPreserved: true };
+        }
+        finally {
+            db.close();
+        }
+    }
+    finally {
+        await rmdir(lock);
+    }
+}

package/runtime/packages/setup/package.json

@@ -1 +1 @@
-{"name":"@murmurv2/cli","private":true,"version":"2.11.0","type":"module","main":"dist/src/index.js","types":"dist/src/index.d.ts"}
+{"name":"@murmurv2/cli","private":true,"version":"2.12.0","type":"module","main":"dist/src/index.js","types":"dist/src/index.d.ts"}