@corenel/harness 0.4.1 → 0.5.1

package/dist/sidecar/server.js

@@ -1,4 +1,9 @@
 import { SIDECAR_PROTOCOL, errMessage, isLoopbackHost, } from '@corenel/protocol';
+/** How long the welcome waits on `clientDirName` before going out without it. A
+ * manifest write is a few milliseconds; anything near this is a wedged disk, and
+ * a client left with no handshake at all is worse than one that has to fall back
+ * to deducing its own directory. */
+const DIR_NAME_TIMEOUT_MS = 3000;
 /** True for anything with a callable `.then` -- covers native Promises and any
  * other thenable a caller's `onClient` might return, without assuming it's a
  * real Promise instance (the declared type is `() => void`; an async function
@@ -91,6 +96,14 @@ export class SidecarServer {
             writable: true,
             value: void 0
         });
+        /** The friendly label from the same `hello`, kept beside `clientId` so the
+         * dirName resolver is handed the identity the manifest keys on. */
+        Object.defineProperty(this, "clientName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Detach function for this connection's attendance attachment, set on a
          * successful `hello` when `opts.attendance` is wired. Called once, on channel
          * close, so a dead connection stops receiving/counting toward asks. */
@@ -100,6 +113,23 @@ export class SidecarServer {
             writable: true,
             value: void 0
         });
+        /** The synced directory THIS connection belongs to, once resolved -- the same
+         * value echoed in `welcome.dirName`. Retained so `hosts-list` can stamp
+         * `self` and `hosts-forget` can refuse the caller's own tree from the
+         * daemon's own knowledge rather than from anything the client claimed. */
+        Object.defineProperty(this, "dirName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Detach for this connection's entry in the shared hosts live set. */
+        Object.defineProperty(this, "hostsDetach", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Detach callbacks for runs this connection is watching, so a dropped socket
          * stops the hub fanning out into a dead channel. */
         Object.defineProperty(this, "runDetachers", {
@@ -222,16 +252,42 @@ export class SidecarServer {
         // Every connected server subscribes, which is what makes a root added by one
         // paired client reach ALL of them: two browsers on one daemon must never
         // disagree about what is reachable. The payload is the COMPLETE set.
-        const offRoots = opts.roots?.subscribe((s) => this.ch.send({ t: 'roots', root: s.root, roots: s.roots }));
+        /* Both subscriptions are made HERE, in the constructor, and both therefore
+         * have to check `authed` themselves. Nothing else does it for them: every
+         * `case` in onMessage guards its own handler, but a broadcast is not a
+         * reply to a request -- it arrives on its own, and at construction time
+         * `authed` is necessarily still false. Unguarded, a process that opens the
+         * socket and never sends `hello` is fed the daemon's working directories,
+         * and every room's participant names, spend, parked state and close
+         * reasons. The subscription itself is kept (not deferred to the hello) so
+         * there is exactly one place it is set up and torn down. */
+        const offRoots = opts.roots?.subscribe((s) => {
+            if (!this.authed)
+                return;
+            this.ch.send({ t: 'roots', root: s.root, roots: s.roots });
+        });
+        // Same reasoning as roots: every connected client hears every room move,
+        // not just the one that started it -- ONE room service is shared across
+        // every per-connection SidecarServer.
+        const offRooms = opts.rooms?.subscribe((room) => {
+            if (!this.authed)
+                return;
+            this.ch.send({ t: 'room-progress', room });
+        });
         this.ch.onClose?.(() => {
             this.attendedDetach?.();
             this.attendedDetach = undefined;
+            // Leave the live set, or this directory reads as connected for ever and
+            // could never be reclaimed -- the refusal would outlive the connection.
+            this.hostsDetach?.();
+            this.hostsDetach = undefined;
             // A dropped connection must stop receiving run events, or the hub keeps
             // fanning out into a dead channel for the rest of the run.
             for (const detach of this.runDetachers)
                 detach();
             this.runDetachers.clear();
             offRoots?.();
+            offRooms?.();
             // Stop streaming process output into a dead socket. The PROCESSES keep
             // running - that is the point of the table living on the daemon - but this
             // connection stops hearing about them until something re-attaches.
@@ -417,12 +473,121 @@ export class SidecarServer {
                 }
                 void this.onRunTranscript(m);
                 return;
+            case 'crew-memory':
+                if (!this.authed) {
+                    this.ch.send({ t: 'crew-memory-result', id: m.id, memories: [] });
+                    return;
+                }
+                void this.onCrewMemory(m);
+                return;
             case 'host-sync-put':
                 void this.onHostSyncPut(m);
                 return;
             case 'host-sync-delete':
                 void this.onHostSyncDelete(m);
                 return;
+            case 'agent-pause-list':
+                // `ok: false`, not an empty list: telling an unauthenticated caller
+                // "this daemon is holding no pauses" is a claim it has not earned, the
+                // same reasoning as room-list below.
+                if (!this.authed) {
+                    this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                this.onAgentPauseList(m);
+                return;
+            case 'agent-pause-set':
+                if (!this.authed) {
+                    this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onAgentPauseSet(m);
+                return;
+            case 'hosts-list':
+                // `ok: false`, not an empty estate: telling an unauthenticated caller
+                // "this daemon holds no synced hosts" is a claim it has not earned --
+                // the same reasoning as agent-pause-list above.
+                if (!this.authed) {
+                    this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onHostsList(m);
+                return;
+            case 'hosts-forget':
+                if (!this.authed) {
+                    this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onHostsForget(m);
+                return;
+            case 'room-open':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-open-result', id: m.id, ok: false, problems: ['not authenticated'] });
+                    return;
+                }
+                void this.onRoomOpen(m);
+                return;
+            case 'room-list':
+                // `ok: false`, not an empty list: telling an unauthenticated caller
+                // "this daemon has no rooms" is a lie, and the protocol now has an
+                // arm that says what actually happened.
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-list-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomList(m);
+                return;
+            case 'room-read':
+                // Same as room-list: "no such room" is a considered answer this
+                // caller has not earned. Say it was refused instead.
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-read-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomRead(m);
+                return;
+            case 'room-answer':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-answer-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomAnswer(m);
+                return;
+            case 'room-resume':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-resume-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomResume(m);
+                return;
+            case 'room-interject':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomInterject(m);
+                return;
+            case 'room-findings':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-findings-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomFindings(m);
+                return;
+            case 'room-finding-edit':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomFindingEdit(m);
+                return;
+            case 'room-close':
+                if (!this.authed) {
+                    this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: 'not authenticated' });
+                    return;
+                }
+                void this.onRoomClose(m);
+                return;
             default:
                 // welcome / denied / invoke-result / host-call / event / run-accepted /
                 // run-done / permission-ask / permission-resolved are host-side.
@@ -454,6 +619,7 @@ export class SidecarServer {
             const name = typeof m.clientName === 'string' && m.clientName
                 ? m.clientName.slice(0, MAX_IDENTITY_FIELD_LEN)
                 : clientId;
+            this.clientName = name;
             // Best-effort, fire-and-forget: a throwing/rejecting `onClient` must never
             // deny/break an otherwise valid, authenticated handshake -- identity
             // recording is informational, not part of the auth decision. Covers BOTH
@@ -483,6 +649,52 @@ export class SidecarServer {
             });
         }
         this.opts.log?.(`paired — ${this.tools.size} ${this.tools.size === 1 ? 'tool' : 'tools'} advertised (host dir: ${this.hostStateDir})`);
+        /* THE ONE THING THAT WAITS. The welcome carries the synced directory name
+         * this daemon resolved for this connection, and the client has no other way
+         * to learn it -- it could previously only deduce it, and got null whenever
+         * no workspace was open or two hosts held the same workspace id, leaving a
+         * management surface unable to say which registrations were its own.
+         *
+         * Bounded, and every failure ends the same way as an older daemon: no
+         * `dirName` on the welcome. A handshake that never arrives would be a far
+         * worse trade than a client that falls back to deducing. */
+        const identity = this.clientId === undefined
+            ? undefined
+            : { clientId: this.clientId, name: this.clientName ?? this.clientId };
+        if (this.opts.clientDirName && identity) {
+            void this.resolveDirName(this.opts.clientDirName, identity).then((dirName) => {
+                this.sendWelcome(dirName);
+            });
+            return;
+        }
+        this.sendWelcome(null);
+    }
+    /** Resolve the connection's synced directory name, or null for every failure
+     * mode there is (throw, rejection, non-string, timeout). */
+    async resolveDirName(resolve, identity) {
+        try {
+            const timed = new Promise((res) => setTimeout(() => res(null), DIR_NAME_TIMEOUT_MS));
+            const got = await Promise.race([Promise.resolve(resolve(identity)), timed]);
+            return typeof got === 'string' && got ? got : null;
+        }
+        catch (err) {
+            this.opts.log?.(`clientDirName failed: ${errMessage(err)}`);
+            return null;
+        }
+    }
+    sendWelcome(dirName) {
+        /* Remembered BEFORE the welcome goes out, because `self` and the
+         * forget-your-own-tree refusal are both answered from it. A daemon too old
+         * to resolve one, or a client with no identity, leaves it undefined -- and
+         * then every entry reads `self: false` and nothing is refused on that
+         * ground, which is correct: this connection genuinely has no directory. */
+        if (dirName) {
+            this.dirName = dirName;
+            // Only a resolved directory can be attached: an unidentified connection
+            // is not "connected as" anything, and marking it would pin a tree it
+            // has no claim to.
+            this.hostsDetach = this.opts.hosts?.attach(dirName);
+        }
         const tools = [...this.tools.values()].map(({ run: _run, ...decl }) => decl);
         // Advertise the loopback HTTP proxy so the host can route local-LLM calls
         // through us (server-side fetch, no browser CORS) instead of failing, and
@@ -494,8 +706,14 @@ export class SidecarServer {
         const features = [
             'http-proxy',
             ...(this.opts.runner ? ['runner'] : []),
+            // The daemon can resolve a model for an agent that sets none. Advertised
+            // so a client can warn before deploying an agent left on the workspace
+            // default, whose scheduled runs would otherwise fail one by one with
+            // nothing on screen to say why.
+            ...(this.opts.runner?.hasDefaultModel ? ['default-model'] : []),
             ...(this.opts.acp ? ['acp'] : []),
             ...(this.opts.roots?.areas.length ? ['add-roots'] : []),
+            ...(this.opts.rooms ? ['rooms'] : []),
             ...(this.opts.procs ? ['procs'] : []),
             ...(this.opts.sessions ? ['sessions'] : []),
             // The operator's transcript CEILING, advertised so a client offers the
@@ -508,8 +726,21 @@ export class SidecarServer {
             // operator declared somewhere a checkout may be written, so a client only
             // offers "start from a repository" where it would actually work.
             ...(this.opts.sessions?.canClone ? ['session-clone'] : []),
+            // Whether this daemon HOLDS pauses. Advertised only with a real store
+            // behind it, so a client offers "Pause" only where pausing would actually
+            // stop the agent -- the alternative is a button that reports success on a
+            // daemon that keeps firing.
+            ...(this.opts.pauses ? ['agent-pause'] : []),
+            // Whether this daemon can report and reclaim its synced host directories.
+            // Advertised only with a real manifest behind it, so a client never
+            // offers a destructive control to a daemon that would refuse it.
+            ...(this.opts.hosts ? ['hosts-admin'] : []),
         ];
-        this.ch.send({ t: 'welcome', tools, features, ...(this.opts.info ? { info: this.opts.info } : {}) });
+        this.ch.send({
+            t: 'welcome', tools, features,
+            ...(this.opts.info ? { info: this.opts.info } : {}),
+            ...(dirName ? { dirName } : {}),
+        });
     }
     /** Proxy a host HTTP request server-side. Restricted to LOOPBACK targets — the
      * sidecar must never be usable as an SSRF pivot to internal/metadata hosts. The
@@ -772,7 +1003,28 @@ export class SidecarServer {
             this.ch.send({ t: 'invoke-result', id: m.id, ok: false, error: `unknown tool ${m.name}` });
             return;
         }
-        this.opts.log?.(`invoke ${m.name}`);
+        /* MUTATIONS ARE LOUD, READS ARE NOT.
+         *
+         * A single agent run issues hundreds of `fs_read_file` / `fs_list_dir`
+         * calls, and one line each buries everything else in the daemon's
+         * scrollback -- the pairing line, a policy refusal, a failing write. What
+         * an operator is actually watching for is what the agent CHANGED, so that
+         * is what still prints.
+         *
+         * `=== true`, deliberately, because in this codebase an OMITTED `mutates`
+         * means read-only: writes and shell declare `mutates: true`
+         * (sidecar/src/tools.ts), reads say nothing, and the permission service
+         * reads it the same way (`if (tool.mutates && ...)`). Logging on "not
+         * explicitly false" would therefore have logged every read and changed
+         * nothing. The log must agree with the layer that decides permissions --
+         * a tool that mutates without declaring it is already escaping the policy's
+         * mutating backstop, and that is a policy bug to fix at the declaration,
+         * not something a divergent logging rule should paper over.
+         *
+         * Failures below are logged whatever the kind: a read that throws is
+         * exactly the line someone is scrolling back to find. */
+        if (tool.mutates === true)
+            this.opts.log?.(`invoke ${m.name}`);
         try {
             const result = await tool.run(m.args, this.makeContext());
             this.ch.send({ t: 'invoke-result', id: m.id, ok: true, result });
@@ -935,6 +1187,25 @@ export class SidecarServer {
             this.ch.send({ t: 'run-transcript-result', id: m.id, lines: [] });
         }
     }
+    /** What one of this caller's crew agents has LEARNED, from the daemon's own
+     * copy. Same owner-scoping shape as `onRunHistory`: the identity handed down
+     * is the untrusted `{ clientId }` this connection authenticated with, and
+     * the runner resolves it through the hosts manifest before it ever touches
+     * a path. */
+    async onCrewMemory(m) {
+        try {
+            const memories = this.opts.runner?.memories
+                ? await this.opts.runner.memories({ clientId: this.clientId }, m.agent)
+                : [];
+            this.ch.send({ t: 'crew-memory-result', id: m.id, memories });
+        }
+        catch {
+            // A memory folder that cannot be read is not a reason to break the
+            // caller's page. The client distinguishes "none" from "unreachable" by
+            // whether the call resolved at all.
+            this.ch.send({ t: 'crew-memory-result', id: m.id, memories: [] });
+        }
+    }
     async onRun(m) {
         /* WHERE the run happens, decided once, up front.
          *
@@ -1044,6 +1315,247 @@ export class SidecarServer {
             this.ch.send({ t: 'roots-add-result', id: m.id, ok: false, error: errMessage(e) });
         }
     }
+    /** Every synced host directory, with `self` stamped from THIS connection's
+     * own resolved directory -- never from anything the client sent. */
+    async onHostsList(m) {
+        if (!this.opts.hosts) {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: 'this daemon does not administer synced hosts' });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: true, hosts: this.stampSelf(await this.opts.hosts.list()) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'hosts-list-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    stampSelf(hosts) {
+        return hosts.map((h) => ({ ...h, self: this.dirName !== undefined && h.dirName === this.dirName }));
+    }
+    /**
+     * Delete one synced tree and its manifest entry.
+     *
+     * THE REFUSALS ARE THE FEATURE. A client's UI is not a guard -- this message
+     * carries a `dirName` the client chose, so both rules that make the operation
+     * safe are enforced here: the caller's OWN directory is refused outright, and
+     * the port refuses any directory a client is attached as. The first is
+     * checked here rather than left to the second because it is answerable from
+     * this connection's own identity and yields the more useful sentence.
+     */
+    async onHostsForget(m) {
+        if (!this.opts.hosts) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'this daemon does not administer synced hosts' });
+            return;
+        }
+        if (typeof m.dirName !== 'string' || !m.dirName) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: 'dirName must be a non-empty string' });
+            return;
+        }
+        if (this.dirName !== undefined && m.dirName === this.dirName) {
+            this.ch.send({
+                t: 'hosts-forget-result', id: m.id, ok: false,
+                error: 'That is this connection’s own synced directory. Disconnect this client first, then remove it from another one.',
+            });
+            return;
+        }
+        try {
+            const outcome = await this.opts.hosts.forget(m.dirName);
+            if (!outcome.ok) {
+                this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: outcome.reason });
+                return;
+            }
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: true, hosts: this.stampSelf(await this.opts.hosts.list()) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'hosts-forget-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    onAgentPauseList(m) {
+        if (!this.opts.pauses) {
+            // An honest empty answer for a daemon without the capability: it is
+            // holding no pauses, which is true. The feature gate is what tells a
+            // client whether it may OFFER the control.
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: true, pauses: [] });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: true, pauses: this.opts.pauses.list() });
+        }
+        catch (err) {
+            this.ch.send({ t: 'agent-pause-list-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onAgentPauseSet(m) {
+        if (!this.opts.pauses) {
+            // NOT an empty success. Accepting a pause this daemon cannot hold would
+            // leave the operator believing an agent had been stopped while it kept
+            // firing on the hour -- the exact failure the feature exists to end.
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'this daemon does not hold agent pauses' });
+            return;
+        }
+        // Runtime-validate: the message arrived via `JSON.parse(...) as SidecarMsg`,
+        // so the declared types guarantee nothing. Both fields become part of a
+        // persisted key.
+        if (typeof m.owner !== 'string' || typeof m.agent !== 'string' || !m.agent) {
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: 'owner must be a string and agent a non-empty string' });
+            return;
+        }
+        try {
+            const pauses = await this.opts.pauses.set(m.owner, m.agent, m.paused === true);
+            // Republish before replying: the caller's own row and every other
+            // connected client's must change together, or a second browser keeps
+            // offering "Pause" on an agent already paused.
+            this.opts.pauses.refresh();
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: true, pauses });
+        }
+        catch (err) {
+            this.ch.send({ t: 'agent-pause-set-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomOpen(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-open-result', id: m.id, ok: false, problems: ['this sidecar does not host rooms'] });
+            return;
+        }
+        try {
+            const r = await this.opts.rooms.open(m.req);
+            this.ch.send(r.ok
+                ? { t: 'room-open-result', id: m.id, ok: true, room: r.room }
+                : { t: 'room-open-result', id: m.id, ok: false, problems: r.problems });
+        }
+        catch (err) {
+            // A room failure must never kill the connection; the client gets a
+            // refusal it can render instead of a socket that went quiet.
+            this.ch.send({ t: 'room-open-result', id: m.id, ok: false, problems: [errMessage(err)] });
+        }
+    }
+    async onRoomList(m) {
+        if (!this.opts.rooms) {
+            // Honest empty answer for a daemon without the capability -- it is
+            // running no rooms, same reasoning as proc-list/session-list. Distinct
+            // from the catch below: that is a STORE FAILURE, not "there are none".
+            this.ch.send({ t: 'room-list-result', id: m.id, ok: true, rooms: [] });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'room-list-result', id: m.id, ok: true, rooms: await this.opts.rooms.list() });
+        }
+        catch (err) {
+            // A room failure must never kill the connection, and it must not read
+            // as "this daemon has no rooms" either -- an empty list here would be
+            // exactly the wrong answer to "the store could not be read".
+            this.ch.send({ t: 'room-list-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomRead(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-read-result', id: m.id, ok: true, room: null, messages: [], turnCosts: [] });
+            return;
+        }
+        try {
+            const found = await this.opts.rooms.read(m.roomId);
+            // `found === null` here is Task 5's considered "no such room" -- keep
+            // it a successful `ok: true, room: null`, never conflated with the
+            // catch below's "could not read it" failure.
+            this.ch.send(found
+                ? { t: 'room-read-result', id: m.id, ok: true, room: found.room, messages: found.messages, turnCosts: found.turnCosts }
+                : { t: 'room-read-result', id: m.id, ok: true, room: null, messages: [], turnCosts: [] });
+        }
+        catch (err) {
+            // A thrown read is a STORE FAILURE, not "the room does not exist" --
+            // collapsing it into `room: null` would train a client to stop
+            // retrying on what was really transient.
+            this.ch.send({ t: 'room-read-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomResume(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-resume-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.resume(m.roomId);
+            this.ch.send({ t: 'room-resume-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            // A room failure must never kill the connection; the client gets a
+            // refusal it can show.
+            this.ch.send({ t: 'room-resume-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomAnswer(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-answer-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.answer(m.roomId, m.participantId, m.text, m.addressed);
+            this.ch.send({ t: 'room-answer-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            // A room failure must never kill the connection; the client gets a
+            // refusal it can render instead of a socket that went quiet.
+            this.ch.send({ t: 'room-answer-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomInterject(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.interject(m.roomId, m.participantId, m.text);
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            // A room failure must never kill the connection; the client gets a
+            // refusal it can render instead of a socket that went quiet.
+            this.ch.send({ t: 'room-interject-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomClose(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const room = await this.opts.rooms.close(m.roomId, m.participantId, m.reason);
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: true, room });
+        }
+        catch (err) {
+            this.ch.send({ t: 'room-close-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomFindings(m) {
+        if (!this.opts.rooms) {
+            // A daemon without the capability hosts no rooms, so it holds no
+            // findings -- an honest empty document, the same answer `room-list`
+            // gives. The catch below is the different thing: a real read that failed.
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: true, findings: [] });
+            return;
+        }
+        try {
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: true, findings: await this.opts.rooms.findings(m.roomId) });
+        }
+        catch (err) {
+            this.ch.send({ t: 'room-findings-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
+    async onRoomFindingEdit(m) {
+        if (!this.opts.rooms) {
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: 'this sidecar does not host rooms' });
+            return;
+        }
+        try {
+            const findings = await this.opts.rooms.editFinding(m.roomId, m.participantId, m.edit);
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: true, findings });
+        }
+        catch (err) {
+            // A refused edit must never kill the connection; the person gets the
+            // reason their edit did not land.
+            this.ch.send({ t: 'room-finding-edit-result', id: m.id, ok: false, error: errMessage(err) });
+        }
+    }
     async onHostSyncPut(m) {
         const identity = this.requireHostSyncIdentity();
         if ('error' in identity) {