@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/dashboard-rpc/events-tail.js

@@ -0,0 +1,257 @@
+import { existsSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { logLiveFile } from '@openagt/agent-driver';
+import { JsonlTailer, followFile } from '../jsonl-tail.js';
+/** How often the poll backstop re-reads the log when `fs.watch` says nothing. */
+const POLL_MS = 1000;
+/**
+ * Tail a JSONL log: read what is already in it, then follow appends. Each complete line is
+ * parsed and handed to `onEvent`; malformed lines are skipped. Returns a stop function that
+ * removes the watcher and the poll.
+ *
+ * The reading is {@link JsonlTailer} and the following is {@link followFile}. This used to be
+ * its own copy of both, which is how it ended up missing the tailer's same-length-rewrite
+ * detection (#567).
+ *
+ * `onReplayed` is told once the first pull — the replay of everything already logged — has
+ * been delivered (#1383). That boundary is what lets a reconnecting client buffer the replay
+ * and swap its feed atomically instead of blanking while history re-streams. The follower
+ * only starts after it, so no appended line can slip in ahead of the marker. Best-effort on
+ * a failed first read: the marker still fires (the poll retries the read), because a client
+ * waiting on it forever would freeze its feed.
+ *
+ * Kept transport-agnostic (a plain `onEvent` callback, not a stream) so the file
+ * side can be driven on its own; `events.ts` wires it to the SSE endpoint.
+ */
+export function tailEvents(path, onEvent, onReplayed) {
+    const tailer = new JsonlTailer(path, onEvent);
+    let stopped = false;
+    let stopFollow;
+    const follow = () => {
+        if (stopped)
+            return;
+        onReplayed?.();
+        stopFollow = followFile(dirname(path), () => tailer.pull(), { pollMs: POLL_MS });
+    };
+    void tailer.pull().then(follow, follow);
+    return () => {
+        stopped = true;
+        stopFollow?.();
+    };
+}
+/**
+ * Reads the message a run is writing, from the live file beside its diary, for
+ * {@link tailAgentEvents}' `afterPull`: the file changes in the diary's directory, so the diary's
+ * watch reads it too. `send` gets the text when it changed, and `''` once the file is gone.
+ */
+export function partialReader(send) {
+    let sent = '';
+    return async (diary) => {
+        const text = await readFile(join(dirname(diary), logLiveFile(basename(diary, '.jsonl'))), 'utf8').catch(() => '');
+        if (text === sent)
+            return;
+        sent = text;
+        send(text);
+    };
+}
+/** Whether the file at `path` holds at least one byte; a file that cannot be read holds nothing. */
+function holdsSomething(path) {
+    try {
+        return statSync(path).size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Tail a run's diary across its relocations: the same read-then-follow as {@link tailEvents},
+ * but where the diary is is asked again whenever the tailed file is not there.
+ *
+ * A run's diary does not sit still. While the run works it is a file in the run's checkout; when
+ * the run ends its tool records it and reclaims the checkout, and from then on the diary is the
+ * finished run's, read whole from the project's runs provider. A fixed-path tail whose file was
+ * retired went silent *without the final lines* whenever the last `fs.watch` signal was lost —
+ * the 1s poll then found the file gone and had nothing to read, so the feed never learned the run
+ * ended. This tail treats a missing file as the question it is: it asks `resolve` where the diary
+ * is now (`resolveAgentDiary` answers the finished run once the checkout is gone, #1472). A new
+ * file retargets the same tailer and follows it. A finished run's lines are the same lines the
+ * file had, in the same order, so the ones past the count already delivered are sent and the tail
+ * ends: a finished diary does not grow. The same file, or no answer, means the diary has not
+ * moved, and the tail keeps waiting where it is. A diary that is nowhere yet (`pending`: the run
+ * was started a moment ago and its tool has not made the checkout, or it is being continued and
+ * its checkout is on its way back) is asked for again on the same cadence until it has a home,
+ * and only then followed; the replay boundary is reported once what that home holds has been
+ * delivered, not before: a feed that reconnects swaps what it shows for the replay at the
+ * boundary, and a boundary reported with nothing delivered emptied a chat that was full, for as
+ * long as the diary took to have a home. Asking even when the file was never seen matters for a
+ * short run (#1774): started, ended and reclaimed between two polls, its diary was only ever
+ * visible as a finished run.
+ *
+ * `onReplayed` keeps {@link tailEvents}' once-per-subscription contract: a relocation is not a
+ * new replay boundary, so it never fires twice.
+ *
+ * `afterPull` is told the diary's path after each read of it: the files beside the diary change
+ * with it, and a caller reads them there, on the same watch.
+ */
+export function tailAgentEvents(resolve, onEvent, onReplayed, afterPull) {
+    let stopped = false;
+    let stopFollow;
+    let path;
+    let tailer;
+    let relocating = false;
+    let waiting;
+    let delivered = 0;
+    /** The replay boundary still to report: the followed file was not there when it was first read. */
+    let owed;
+    const deliver = (event) => {
+        delivered++;
+        onEvent(event);
+    };
+    /** The finished run's lines the feed has not had yet; then wait for the run to be resumed. */
+    const finish = (lines) => {
+        stopFollow?.();
+        stopFollow = undefined;
+        for (const line of lines.slice(delivered))
+            deliver(line);
+        // A boundary owed for a file that never came: the finished run's lines are the replay.
+        const boundary = owed;
+        owed = undefined;
+        boundary?.();
+        awaitDiary(true);
+    };
+    const follow = () => {
+        if (stopped || path === undefined)
+            return;
+        stopFollow = followFile(dirname(path), pullOrRelocate, { pollMs: POLL_MS });
+    };
+    const relocate = async () => {
+        const next = await resolve();
+        // No answer, nowhere yet, or the same file: not moved (or not visible yet) — keep polling the current home.
+        if (stopped || !tailer || next === undefined || 'pending' in next)
+            return;
+        if ('finished' in next)
+            return finish(next.finished);
+        if (next.file === path)
+            return;
+        stopFollow?.();
+        path = next.file;
+        tailer.retarget(next.file);
+        await tailer.pull();
+        follow();
+    };
+    const pullOrRelocate = async () => {
+        if (stopped || !tailer || path === undefined)
+            return;
+        if (existsSync(path)) {
+            // A file that is there and still holds nothing is a diary about to be written: the owed
+            // boundary waits for the pull that had lines to deliver, or it would say an empty replay.
+            const written = owed !== undefined && holdsSomething(path);
+            await tailer.pull();
+            if (written) {
+                const boundary = owed;
+                owed = undefined;
+                boundary?.();
+            }
+            await afterPull?.(path);
+            return;
+        }
+        if (relocating)
+            return;
+        relocating = true;
+        try {
+            await relocate();
+        }
+        finally {
+            relocating = false;
+        }
+    };
+    /**
+     * Follow `file` from its start: what is there is the replay, and appends follow. A resumed run's
+     * diary starts with the lines the feed already had, so as many lines as were delivered are skipped.
+     * The same holds when the file is rewritten in place: a run continued in the checkout it kept
+     * has its diary written again, whole, before the new lines, and the tailer reads a rewritten
+     * file from its top. It is one run's diary either way, so what was delivered is skipped again.
+     */
+    const begin = (file, onReplayedOnce) => {
+        path = file;
+        let skip = delivered;
+        tailer = new JsonlTailer(file, line => {
+            if (skip > 0)
+                skip--;
+            else
+                deliver(line);
+        }, () => {
+            skip = delivered;
+        });
+        // The boundary is reported once the file has been read. A checkout is there a moment before
+        // the diary is written into it, and the diary is there a moment before its first lines:
+        // reported then, the boundary would say an empty replay. So it is reported only when the
+        // file held something before the read, and owed until a later read finds it written.
+        const written = holdsSomething(file);
+        const replayed = () => {
+            if (stopped)
+                return;
+            if (written)
+                onReplayedOnce();
+            else
+                owed = onReplayedOnce;
+            follow();
+        };
+        void tailer.pull().then(replayed, replayed);
+    };
+    /**
+     * The diary is nowhere yet, or is a finished run's: ask again after a poll, until it has a home.
+     * A finished run is asked about for as long as the feed is open, since it may be resumed: its diary
+     * is then a file in a checkout again, or, for a resumed run that already ended again, more
+     * finished lines. `replayed` is the boundary still owed, when the diary had no home at first:
+     * it is reported once the home's lines are delivered.
+     */
+    const awaitDiary = (finished, replayed = () => { }) => {
+        if (stopped)
+            return;
+        waiting = setTimeout(() => {
+            waiting = undefined;
+            // A finished run is asked about from the shared, cached reads: the question may stay open for hours.
+            void resolve({ cached: finished }).then(next => {
+                if (stopped)
+                    return;
+                if (next === undefined || 'pending' in next)
+                    return awaitDiary(finished, replayed);
+                if ('finished' in next) {
+                    finish(next.finished);
+                    replayed();
+                    return;
+                }
+                begin(next.file, replayed);
+            }, () => awaitDiary(finished, replayed));
+        }, POLL_MS);
+        waiting.unref?.();
+    };
+    void resolve().then(initial => {
+        if (stopped)
+            return;
+        // No journal to speak of (unknown project): honor the replay contract and stay silent.
+        if (initial === undefined) {
+            onReplayed?.();
+            return;
+        }
+        if ('finished' in initial) {
+            finish(initial.finished);
+            onReplayed?.();
+            return;
+        }
+        if ('pending' in initial) {
+            awaitDiary(false, () => onReplayed?.());
+            return;
+        }
+        begin(initial.file, () => onReplayed?.());
+    }, () => onReplayed?.());
+    return () => {
+        stopped = true;
+        if (waiting)
+            clearTimeout(waiting);
+        stopFollow?.();
+    };
+}
+//# sourceMappingURL=events-tail.js.map

package/dist/dashboard-rpc/events-tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-tail.js","sourceRoot":"","sources":["../../src/dashboard-rpc/events-tail.ts"],"names":[],"mappings":"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"}

package/dist/dashboard-rpc/events.d.ts

@@ -0,0 +1,39 @@
+import type { FrameworkEvent } from '../events.js';
+/**
+ * The end-of-replay marker (#1383). A subscribe replays the whole log before following live,
+ * and without a boundary a reconnecting client cannot tell "replay still streaming" from "the
+ * log is genuinely this short" — so it blanked a populated feed and refilled it line by line.
+ * Sent once per subscription, after the on-disk replay is delivered. Wire-only: it is not a
+ * {@link FrameworkEvent}, is never written to any journal, and the client swallows it.
+ */
+export type StreamSync = {
+    kind: 'stream-sync';
+};
+/**
+ * The message the agent is writing, as far as it has got (the run's live file, beside its diary);
+ * empty once there is none. Wire-only like {@link StreamSync}: the pieces are never in the diary,
+ * and the page shows them until the whole message's line arrives.
+ */
+export type PartialMessage = {
+    kind: 'partial';
+    text: string;
+};
+/** What `onEvents` streams: the agent's events, plus the wire-only end-of-replay marker and partial message. */
+export type LiveFeedEvent = FrameworkEvent | StreamSync | PartialMessage;
+/**
+ * Follow one agent's events: `send` is called per event until the returned stop function runs.
+ * Returns undefined when there is nothing to stream (an unknown project), which the mount ends as
+ * a clean close — mirroring the read model's empty results rather than throwing at the client.
+ *
+ * The `agentId` names the run whose diary is followed; without one there is nothing to stream.
+ *
+ * Two sources, chosen by what is wired. An in-memory stream wins: an agent the daemon is relaying
+ * from a device (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
+ * runs, so an ordinary local agent falls through to tailing the log.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no replay
+ * boundary to report, so a reconnecting client falls back to a grace deadline before swapping its
+ * feed (see use-live-events in the dashboard).
+ */
+export declare function streamAgentEvents(projectId: string, agentId: string | undefined, send: (value: LiveFeedEvent) => void, onDone?: () => void): Promise<(() => void) | undefined>;
+//# sourceMappingURL=events.d.ts.map

package/dist/dashboard-rpc/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAclD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAA;AAEhD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9D,gHAAgH;AAChH,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,UAAU,GAAG,cAAc,CAAA;AAExE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,IAAI,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EACpC,MAAM,CAAC,EAAE,MAAM,IAAI,GAClB,OAAO,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAqBnC"}

package/dist/dashboard-rpc/events.js

@@ -0,0 +1,47 @@
+import { fromDiaryLine, resolveAgentDiary } from '../store/index.js';
+import { contextEventsSource, resolveProjectPath } from './context.js';
+import { partialReader, tailAgentEvents } from './events-tail.js';
+import { forwardStream } from './stream-forward.js';
+// The live event stream behind the dashboard (#405): the selected run's diary, the file the run's
+// tool writes as the agent works. Each new line becomes one `send(event)`, which the mount writes
+// out as one SSE frame. Runs, docs, and the project log come over the read-model RPCs (reads.ts).
+/** The diary to follow, or undefined when the project or the run is unknown. */
+async function resolveEventsDiary(projectId, agentId, opts = {}) {
+    const cwd = await resolveProjectPath(projectId);
+    return cwd ? resolveAgentDiary(cwd, agentId, undefined, undefined, opts) : undefined;
+}
+/**
+ * Follow one agent's events: `send` is called per event until the returned stop function runs.
+ * Returns undefined when there is nothing to stream (an unknown project), which the mount ends as
+ * a clean close — mirroring the read model's empty results rather than throwing at the client.
+ *
+ * The `agentId` names the run whose diary is followed; without one there is nothing to stream.
+ *
+ * Two sources, chosen by what is wired. An in-memory stream wins: an agent the daemon is relaying
+ * from a device (#1067). Otherwise the on-disk log. The daemon's source answers only for relayed
+ * runs, so an ordinary local agent falls through to tailing the log.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no replay
+ * boundary to report, so a reconnecting client falls back to a grace deadline before swapping its
+ * feed (see use-live-events in the dashboard).
+ */
+export async function streamAgentEvents(projectId, agentId, send, onDone) {
+    const stream = contextEventsSource()(projectId, agentId);
+    // An in-memory agent: replay + follow it, and end when it ends — a relayed agent that finished has
+    // nothing more to say, and leaving the response open would read as a live feed gone quiet.
+    if (stream)
+        return forwardStream(stream, send, onDone);
+    // Everywhere else: tail the run's diary. The relocating tail, because the diary moves
+    // mid-subscription: when the run ends its tool records it and reclaims the checkout, and a
+    // fixed-path tail whose fs.watch missed the final appends went silent without the run's `end`.
+    // On the move it asks again and sends the finished run's lines it had not sent, so the feed
+    // gets exactly the lines the move would have swallowed.
+    if ((await resolveEventsDiary(projectId, agentId)) === undefined)
+        return undefined;
+    return tailAgentEvents(opts => resolveEventsDiary(projectId, agentId, opts), line => {
+        const event = fromDiaryLine(line);
+        if (event)
+            send(event);
+    }, () => send({ kind: 'stream-sync' }), partialReader(text => send({ kind: 'partial', text })));
+}
+//# sourceMappingURL=events.js.map

package/dist/dashboard-rpc/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/dashboard-rpc/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAA4C,MAAM,mBAAmB,CAAA;AAC9G,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEnD,kGAAkG;AAClG,kGAAkG;AAClG,kGAAkG;AAElG,gFAAgF;AAChF,KAAK,UAAU,kBAAkB,CAAC,SAAiB,EAAE,OAAgB,EAAE,IAAI,GAAyB,EAAE;IACpG,MAAM,GAAG,GAAG,MAAM,kBAAkB,CAAC,SAAS,CAAC,CAAA;IAC/C,OAAO,GAAG,CAAC,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AACtF,CAAC;AAqBD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAiB,EACjB,OAA2B,EAC3B,IAAoC,EACpC,MAAmB;IAEnB,MAAM,MAAM,GAAG,mBAAmB,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACxD,mGAAmG;IACnG,2FAA2F;IAC3F,IAAI,MAAM;QAAE,OAAO,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAA;IAEtD,sFAAsF;IACtF,2FAA2F;IAC3F,+FAA+F;IAC/F,4FAA4F;IAC5F,wDAAwD;IACxD,IAAI,CAAC,MAAM,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IAClF,OAAO,eAAe,CACpB,IAAI,CAAC,EAAE,CAAC,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,EACpD,IAAI,CAAC,EAAE;QACL,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;QACjC,IAAI,KAAK;YAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IACxB,CAAC,EACD,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EACnC,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CACvD,CAAA;AACH,CAAC"}

package/dist/dashboard-rpc/events.telefunc.d.ts

@@ -0,0 +1,36 @@
+import type { ClientChannel } from 'telefunc';
+import type { FrameworkEvent } from '../events.js';
+/**
+ * The end-of-replay marker (#1383). A subscribe replays the whole log before following live,
+ * and without a boundary a reconnecting client cannot tell "replay still streaming" from "the
+ * log is genuinely this short" — so it blanked a populated feed and refilled it line by line.
+ * Sent once per subscription, after the on-disk replay is delivered. Wire-only: it is not a
+ * {@link FrameworkEvent}, is never written to any journal, and the client swallows it.
+ */
+export type StreamSync = {
+    kind: 'stream-sync';
+};
+/** What `onEvents` streams: the run's events, plus the wire-only end-of-replay marker. */
+export type LiveFeedEvent = FrameworkEvent | StreamSync;
+/**
+ * `onEvents(projectId, runId?)` returns a Channel that streams one live run: the client
+ * `.listen()`s for `FrameworkEvent`s and `.close()`s to unsubscribe, which stops the tail.
+ * An unknown project yields a channel that closes immediately (mirrors the read model's
+ * empty results rather than throwing at the client).
+ *
+ * Pass the `runId` to follow that run's own log (#749). A project has several concurrent
+ * runs since #736, each writing inside its worktree, so the run id is what makes the feed
+ * that run's rather than a mix — and without it the feed for a worktree run is empty.
+ * Omitting it keeps the pre-#736 behavior of tailing the project root.
+ *
+ * Two sources, chosen by the mount. An in-memory stream on the context wins: the relay's own run
+ * (#426), or a run the daemon is relaying from a device (#1067). Otherwise the on-disk log. The
+ * daemon sets a source that answers only for relayed runs, so an ordinary local run yields undefined
+ * here and falls through to tailing the log, exactly as before.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no
+ * replay boundary to report, so a reconnecting client falls back to a grace deadline before
+ * swapping its feed (see use-live-events in the dashboard).
+ */
+export declare function onEvents(projectId: string, runId?: string): Promise<ClientChannel<never, LiveFeedEvent>>;
+//# sourceMappingURL=events.telefunc.d.ts.map

package/dist/dashboard-rpc/events.telefunc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.telefunc.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/events.telefunc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAG7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAsBlD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAA;AAEhD,0FAA0F;AAC1F,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,UAAU,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAkC9G"}

package/dist/dashboard-rpc/events.telefunc.js

@@ -0,0 +1,70 @@
+import { resolveRunEventsPath } from '../store/index.js';
+import { contextEventsSource, resolveProjectPath } from './context.js';
+import { tailRunEvents } from './events-tail.js';
+import { forwardStream, streamChannel } from './stream-channel.js';
+// The live event stream behind the new dashboard (#405): the selected project's run,
+// read straight from the same `.the-framework/events.jsonl` the daemon writes. Each new
+// JSONL line becomes one `channel.send(event)`, so the file watcher maps 1:1 onto a
+// Telefunc Channel — serialization, type validation, and reconnect come for free. Runs,
+// docs, and the project log come over the read-model RPCs (reads.telefunc.ts).
+/**
+ * The events file to tail, or undefined when the project is unknown. With a `runId` this is
+ * that run's own log inside its worktree (#749): since #736 a run appends there, not to the
+ * project root, so streaming the project path would follow a file nothing writes to. Once the
+ * run has ended and its worktree is gone, the run's archived `<id>.jsonl` is that log (#1472) —
+ * tailing the project root there would stream a foreign run's journal.
+ */
+async function resolveEventsPath(projectId, runId) {
+    const cwd = await resolveProjectPath(projectId);
+    return cwd ? resolveRunEventsPath(cwd, runId) : undefined;
+}
+/**
+ * `onEvents(projectId, runId?)` returns a Channel that streams one live run: the client
+ * `.listen()`s for `FrameworkEvent`s and `.close()`s to unsubscribe, which stops the tail.
+ * An unknown project yields a channel that closes immediately (mirrors the read model's
+ * empty results rather than throwing at the client).
+ *
+ * Pass the `runId` to follow that run's own log (#749). A project has several concurrent
+ * runs since #736, each writing inside its worktree, so the run id is what makes the feed
+ * that run's rather than a mix — and without it the feed for a worktree run is empty.
+ * Omitting it keeps the pre-#736 behavior of tailing the project root.
+ *
+ * Two sources, chosen by the mount. An in-memory stream on the context wins: the relay's own run
+ * (#426), or a run the daemon is relaying from a device (#1067). Otherwise the on-disk log. The
+ * daemon sets a source that answers only for relayed runs, so an ordinary local run yields undefined
+ * here and falls through to tailing the log, exactly as before.
+ *
+ * Only the on-disk tail sends the {@link StreamSync} marker: the in-memory sources have no
+ * replay boundary to report, so a reconnecting client falls back to a grace deadline before
+ * swapping its feed (see use-live-events in the dashboard).
+ */
+export async function onEvents(projectId, runId) {
+    const stream = contextEventsSource()?.(projectId, runId);
+    if (stream) {
+        // An in-memory run: replay + follow it, mirroring how serveSSE consumes it.
+        return streamChannel(send => forwardStream(stream, send));
+    }
+    // Everywhere else: tail the run's on-disk events.jsonl (undefined path -> closed channel).
+    // The relocating tail, because the journal moves mid-subscription: teardown copies it into the
+    // archive and removes the worktree, and a fixed-path tail whose fs.watch missed the final
+    // appends went silent without the run's `end`. On the move it re-resolves (the archive, #1472)
+    // and carries its offset, so the feed gets exactly the lines the move would have swallowed.
+    const path = await resolveEventsPath(projectId, runId);
+    // The one place a run-scoped feed must NOT relocate to: the project-root journal, which is
+    // resolveRunEventsPath's last-resort fallback once a Delete has removed worktree and archive
+    // alike — it is another run's feed (#1472). A deleted session's tab goes quiet instead. The
+    // initial attach stays permissive: a fallback run (non-git project) legitimately lives there.
+    const rootJournal = runId === undefined ? undefined : await resolveEventsPath(projectId, undefined);
+    let initial = true;
+    return streamChannel(send => path
+        ? tailRunEvents(async () => {
+            const next = await resolveEventsPath(projectId, runId);
+            if (initial) {
+                initial = false;
+                return next;
+            }
+            return rootJournal !== undefined && next === rootJournal ? undefined : next;
+        }, send, () => send({ kind: 'stream-sync' }))
+        : undefined);
+}
+//# sourceMappingURL=events.telefunc.js.map

package/dist/dashboard-rpc/events.telefunc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.telefunc.js","sourceRoot":"","sources":["../../src/dashboard-rpc/events.telefunc.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAElE,qFAAqF;AACrF,wFAAwF;AACxF,oFAAoF;AACpF,wFAAwF;AACxF,+EAA+E;AAE/E;;;;;;GAMG;AACH,KAAK,UAAU,iBAAiB,CAAC,SAAiB,EAAE,KAAc;IAChE,MAAM,GAAG,GAAG,MAAM,kBAAkB,CAAC,SAAS,CAAC,CAAA;IAC/C,OAAO,GAAG,CAAC,CAAC,CAAC,oBAAoB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC3D,CAAC;AAcD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,SAAiB,EAAE,KAAc;IAC9D,MAAM,MAAM,GAAG,mBAAmB,EAAE,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACxD,IAAI,MAAM,EAAE,CAAC;QACX,4EAA4E;QAC5E,OAAO,aAAa,CAAgB,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;IAC1E,CAAC;IACD,2FAA2F;IAC3F,+FAA+F;IAC/F,0FAA0F;IAC1F,+FAA+F;IAC/F,4FAA4F;IAC5F,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACtD,2FAA2F;IAC3F,6FAA6F;IAC7F,4FAA4F;IAC5F,8FAA8F;IAC9F,MAAM,WAAW,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,iBAAiB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACnG,IAAI,OAAO,GAAG,IAAI,CAAA;IAClB,OAAO,aAAa,CAAgB,IAAI,CAAC,EAAE,CACzC,IAAI;QACF,CAAC,CAAC,aAAa,CACX,KAAK,IAAI,EAAE;YACT,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;YACtD,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,GAAG,KAAK,CAAA;gBACf,OAAO,IAAI,CAAA;YACb,CAAC;YACD,OAAO,WAAW,KAAK,SAAS,IAAI,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7E,CAAC,EACD,IAAI,EACJ,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CACpC;QACH,CAAC,CAAC,SAAS,CACd,CAAA;AACH,CAAC"}

package/dist/dashboard-rpc/index.d.ts

@@ -0,0 +1,29 @@
+export { onAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onOpenQuestions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
+export { sendStop, sendChoice, sendBridgeAnswer, sendBridgeAnswerCancel, sendBridgeBrowser, sendMessage, sendStart, sendOpenInApp, sendRemoveWorktree, sendDeleteAgent, sendOpenPullRequest, sendPush, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
+export { streamAgentEvents, type LiveFeedEvent, type PartialMessage, type StreamSync } from './events.js';
+export { onProjects, sendAddProject, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck, type ProjectLauncher } from './projects.js';
+export { onPreferences, savePreferences, patchPreferences, onProjectPresets, saveProjectPresets, onEditors, type SavePreferencesResult, type PatchPreferencesResult, } from './preferences.js';
+export { type EditorInfo } from '../dashboard/open-in-app.js';
+export { onQuota } from './quota.js';
+export { onModels } from './models.js';
+export { checkDevices, type DeviceCheck } from './devices.js';
+export { onModules, runModuleCommand, readModule, type DashboardModule, type ModuleCommandResult, type ModuleReadResult } from './modules.js';
+import { streamAgentEvents } from './events.js';
+/** One RPC: called with whatever the browser sent, answering with whatever JSON.stringify keeps. */
+export type RpcHandler = (...args: never[]) => unknown;
+/**
+ * Every RPC the mount will answer, by name.
+ *
+ * Built from the modules' own exports rather than listed by hand, so a function that is exported
+ * and simply never registered — the failure that shipped per-project preferences broken (#866),
+ * a 400 and nothing else — cannot happen: the name IS the export name.
+ *
+ * Null-prototype, because the name is a path segment off an unauthenticated request and this table
+ * is indexed by it directly. With `Object.prototype` behind it, `POST /_rpc/constructor` found
+ * `Object` and answered 200 with whatever it was handed, and `__proto__` / `toString` / `valueOf`
+ * were reachable too — 500s rather than the 404 a name that is not an RPC has to get.
+ */
+export declare const RPC_HANDLERS: Record<string, RpcHandler>;
+/** The live event stream, which is a subscription rather than a call — see `rpc-serve.ts`. */
+export declare const RPC_EVENT_STREAM: typeof streamAgentEvents;
+//# sourceMappingURL=index.d.ts.map

package/dist/dashboard-rpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,WAAW,EAAE,cAAc,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5X,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAE,mBAAmB,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAC7Q,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,wBAAwB,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAClJ,OAAO,EACL,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,EACT,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAU7I,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAE/C,oGAAoG;AACpG,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAA;AAEtD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAOnD,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,gBAAgB,0BAAoB,CAAA"}

package/dist/dashboard-rpc/index.js

@@ -0,0 +1,40 @@
+// The dashboard's RPC surface (#405), served in-process by the daemon so `sendStart` can reach
+// the daemon's own `startAgent`. The browser calls these by name over `POST /_rpc/<name>`; the
+// dashboard's `rpc/` modules are typed stubs against these signatures, so a rename that misses
+// one is a type error rather than a 404 at runtime.
+export { onAgents, onAgent, onAgentsDoing, onDocs, onQueue, onOverview, onRecentAgents, onInterventions, onOpenQuestions, onActivity, onDashboard, onGitHostHome, onRepositoryOffer, onGitStatus, onProjectFiles, onRetainedWorktrees, onAgentWorktree, onAgentHandoff, onBridgeQuestion, onBridgeStatus, onBridgeToken, onBridgeEvents, onBridgeAnswer, onBridgeBrowser } from './reads.js';
+export { sendStop, sendChoice, sendBridgeAnswer, sendBridgeAnswerCancel, sendBridgeBrowser, sendMessage, sendStart, sendOpenInApp, sendRemoveWorktree, sendDeleteAgent, sendOpenPullRequest, sendPush, sendMergeBranch, sendMerge, sendCreateRepository } from './control.js';
+export { streamAgentEvents } from './events.js';
+export { onProjects, sendAddProject, sendPickProjectDirectory, onOnboarding, onCommands, onStartCheck } from './projects.js';
+export { onPreferences, savePreferences, patchPreferences, onProjectPresets, saveProjectPresets, onEditors, } from './preferences.js';
+export { onQuota } from './quota.js';
+export { onModels } from './models.js';
+export { checkDevices } from './devices.js';
+export { onModules, runModuleCommand, readModule } from './modules.js';
+import * as reads from './reads.js';
+import * as control from './control.js';
+import * as projects from './projects.js';
+import * as preferences from './preferences.js';
+import * as quota from './quota.js';
+import * as models from './models.js';
+import * as devices from './devices.js';
+import * as modules from './modules.js';
+import { streamAgentEvents } from './events.js';
+/**
+ * Every RPC the mount will answer, by name.
+ *
+ * Built from the modules' own exports rather than listed by hand, so a function that is exported
+ * and simply never registered — the failure that shipped per-project preferences broken (#866),
+ * a 400 and nothing else — cannot happen: the name IS the export name.
+ *
+ * Null-prototype, because the name is a path segment off an unauthenticated request and this table
+ * is indexed by it directly. With `Object.prototype` behind it, `POST /_rpc/constructor` found
+ * `Object` and answered 200 with whatever it was handed, and `__proto__` / `toString` / `valueOf`
+ * were reachable too — 500s rather than the 404 a name that is not an RPC has to get.
+ */
+export const RPC_HANDLERS = Object.assign(Object.create(null), Object.fromEntries([reads, control, projects, preferences, quota, models, devices, modules]
+    .flatMap(module => Object.entries(module))
+    .filter((entry) => typeof entry[1] === 'function')));
+/** The live event stream, which is a subscription rather than a call — see `rpc-serve.ts`. */
+export const RPC_EVENT_STREAM = streamAgentEvents;
+//# sourceMappingURL=index.js.map

package/dist/dashboard-rpc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/dashboard-rpc/index.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,+FAA+F;AAC/F,+FAA+F;AAC/F,oDAAoD;AACpD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,WAAW,EAAE,cAAc,EAAE,mBAAmB,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5X,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAE,mBAAmB,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAC7Q,OAAO,EAAE,iBAAiB,EAA4D,MAAM,aAAa,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,wBAAwB,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAwB,MAAM,eAAe,CAAA;AAClJ,OAAO,EACL,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,GAGV,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,YAAY,EAAoB,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAyE,MAAM,cAAc,CAAA;AAE7I,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAK/C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,YAAY,GAA+B,MAAM,CAAC,MAAM,CACnE,MAAM,CAAC,MAAM,CAAC,IAAI,CAA+B,EACjD,MAAM,CAAC,WAAW,CAChB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;KACrE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;KACzC,MAAM,CAAC,CAAC,KAAK,EAAiC,EAAE,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CACpF,CACF,CAAA;AAED,8FAA8F;AAC9F,MAAM,CAAC,MAAM,gBAAgB,GAAG,iBAAiB,CAAA"}

package/dist/dashboard-rpc/models.d.ts

@@ -0,0 +1,4 @@
+import type { ModelsView } from '../dashboard/models.js';
+/** Which models each coding agent offers, or why one could not say. */
+export declare function onModels(): Promise<ModelsView>;
+//# sourceMappingURL=models.d.ts.map

package/dist/dashboard-rpc/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/models.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAKxD,uEAAuE;AACvE,wBAAgB,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,CAE9C"}

package/dist/dashboard-rpc/models.js

@@ -0,0 +1,8 @@
+import { contextModels } from './context.js';
+// The agent and model menu's surface: which models each coding agent offers, as the daemon asked
+// them. The source is wired into the dashboard context by the daemon.
+/** Which models each coding agent offers, or why one could not say. */
+export function onModels() {
+    return contextModels().read();
+}
+//# sourceMappingURL=models.js.map

package/dist/dashboard-rpc/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/dashboard-rpc/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAG5C,iGAAiG;AACjG,sEAAsE;AAEtE,uEAAuE;AACvE,MAAM,UAAU,QAAQ;IACtB,OAAO,aAAa,EAAE,CAAC,IAAI,EAAE,CAAA;AAC/B,CAAC"}

package/dist/dashboard-rpc/modules.d.ts

@@ -0,0 +1,43 @@
+import { type ModuleCommandResult } from '../project-modules.js';
+import { type ModuleReadResult } from '../dashboard/module-host.js';
+export type { ModuleCommandResult } from '../project-modules.js';
+export type { ModuleReadResult } from '../dashboard/module-host.js';
+/** One module as the dashboard loads it: where its module is, and which projects have it. */
+export interface DashboardModule {
+    /** The package that brings it. */
+    package: string;
+    /** The URL of its browser module, served from the first project that has it. */
+    url: string;
+    /** The registered projects whose packages include it, in the registry's order. */
+    projects: string[];
+}
+/**
+ * Every module any registered project brings (#1774), one per package: the sidebar and the pages
+ * are cross-project, like the Overview. A package several projects install is loaded once, from
+ * the first of them in the registry's order; its page then reads each project through that
+ * project's own command. A project that cannot be read contributes nothing.
+ */
+export declare function onModules(): Promise<DashboardModule[]>;
+/**
+ * Run one of a module package's commands in one project and answer its JSON output: how a module
+ * reads (and changes) its own data. Refused for an unknown project and for a package that is not a
+ * module of that project, so a page can run only its own package's commands, never an arbitrary
+ * program. Once the command has run, the framework forgets what it had read of that project's
+ * provided data (its queue, its runs): the command may have written it, and the next read sees
+ * that at once instead of a cached copy.
+ *
+ * `acts` says the command is a module's action on the project (a link action), not a page's read:
+ * the framework then also converges the project's data branch with origin, as its clock does
+ * every minute, before forgetting — a package's command writes as a remote writer, straight to
+ * origin, and this machine's copy would otherwise show the write only at the next sync.
+ */
+export declare function runModuleCommand(projectId: string, pkg: string, args: string[], command?: string, acts?: boolean): Promise<ModuleCommandResult>;
+/**
+ * Call read `name` of a module's server part in one project: how a module's browser part reads
+ * what a command cannot answer fast enough. Refused for an unknown project, a package that is not
+ * a module of that project, and a module with no server part. A read whose input names a run this
+ * daemon relays to a connected device (`input.agentId`) is read over there, by that device's own
+ * copy of the module, since the run's checkout is there.
+ */
+export declare function readModule(projectId: string, pkg: string, name: string, input: unknown): Promise<ModuleReadResult>;
+//# sourceMappingURL=modules.d.ts.map