brane 0.0.2 → 0.3.0

package/dist/commands/meld.js

@@ -0,0 +1,332 @@
+import { defineCommand } from "citty";
+import { spawnSync } from "node:child_process";
+import qrcode from "qrcode-terminal";
+import { getDaemonAddress, openDatabase } from "../db/schema.js";
+import { getTailscaleHost } from "../tailscale.js";
+import { connectionFragment } from "../shared/view-url.js";
+import { UNUSED_TOKEN_LAPSE_MS } from "../daemon/token-ring.js";
+import { daemonRequest, resolveDaemonEndpoint, warnIfVersionMismatch, } from "../daemon/client.js";
+/** What the CLI prints before a request the daemon holds for the presence
+ *  check (src/daemon/presence-gate.ts). The daemon is on this machine, so
+ *  this process's platform names its prompt. On stderr, so it never lands in
+ *  output a script captures. */
+export function presenceWaitNote(platform = process.platform) {
+    const prompt = platform === "darwin" ? "Touch ID (or your login password)" : platform === "win32" ? "Windows Hello" : "the system's authentication prompt";
+    return `Confirm with ${prompt} on this machine to continue…`;
+}
+/** Print `presenceWaitNote()` before a gated request, unless this is an
+ *  agent's session: the daemon refuses an agent unasked, so there is nothing
+ *  to wait for. */
+export function announcePresenceWait(env = process.env) {
+    if (!env.BRANE_NARRATIVE_SECRET)
+        console.error(presenceWaitNote());
+}
+/** Ask the daemon for a fresh device token. The daemon keeps only its hash,
+ *  so the QR this goes into is the one and only copy — every scan of every
+ *  meld is its own device, revocable alone. From this machine the daemon
+ *  first asks the operator to confirm at the OS prompt. */
+export async function mintDeviceToken(endpoint, label) {
+    announcePresenceWait();
+    const { token } = await daemonRequest(endpoint, "/api/tokens", {
+        method: "POST",
+        body: label ? { label } : {},
+    });
+    return token;
+}
+/** What `brane meld` and `brane spawn --meld` print under the QR. */
+export function meldLapseNote() {
+    return `This QR is valid for ${UNUSED_TOKEN_LAPSE_MS / 60_000} minutes; once scanned, the device stays signed in until revoked.`;
+}
+/** Build a meld URL pointing at the daemon (optionally targeting a specific
+ *  in-app path). Shared by `brane meld` and `brane spawn --meld`. */
+export function buildMeldUrl(opts) {
+    const { db, daemon } = opts;
+    const { port, token } = daemon;
+    const tailscaleHost = "tailscaleHost" in opts ? opts.tailscaleHost : getTailscaleHost();
+    const host = opts.host ?? tailscaleHost ?? "127.0.0.1";
+    const isLoopbackFallback = !opts.host && !tailscaleHost && host === "127.0.0.1";
+    const tlsRow = db.prepare("SELECT value FROM meta WHERE key = 'daemon_tls'").get();
+    const tls = tlsRow?.value === "true";
+    const useTls = tls && host === tailscaleHost;
+    const useLocal = opts.local === true || !useTls;
+    let effectivePort = port;
+    if (useLocal && tls && !useTls) {
+        const httpPortRow = db.prepare("SELECT value FROM meta WHERE key = 'daemon_http_port'").get();
+        if (httpPortRow)
+            effectivePort = httpPortRow.value;
+    }
+    const scheme = useTls ? "https" : "http";
+    const portSuffix = useTls && effectivePort === "443" ? "" : `:${effectivePort}`;
+    const daemonHost = `${host}${portSuffix}`;
+    // Tailscale is present and we'd advertise its hostname, but there's no cert,
+    // so we're silently emitting plain HTTP instead of the expected HTTPS.
+    const tlsDegraded = !!tailscaleHost && host === tailscaleHost && !tls && opts.local !== true;
+    let path = opts.path ?? "/";
+    if (!path.startsWith("/"))
+        path = "/" + path;
+    const url = meldLink({ daemonHost, scheme, useLocal }, token, path);
+    return { url, daemonHost, scheme, useLocal, isLoopbackFallback, tlsDegraded };
+}
+/** A meld URL for `token`, at the daemon `parts` describes. */
+export function meldLink(parts, token, path = "/") {
+    // The daemon's address and token ride in the URL fragment, which the
+    // browser never sends to any server — so the shared SPA's host (Cloudflare)
+    // does not see the token, a pasted link's unfurler does not fetch it, and
+    // the daemon's own request log does not record it. The app reads it from
+    // `location.hash` and strips it once it has been used.
+    const conn = { host: parts.daemonHost, token };
+    return parts.useLocal
+        ? `${parts.scheme}://${parts.daemonHost}${path}${connectionFragment(conn, false)}`
+        : `https://brane.organelle.dev${path}${connectionFragment(conn, true)}`;
+}
+/** Ask this machine's daemon for a device token for a daemon on another
+ *  machine, and its hash. The daemon stores neither, and first asks the
+ *  operator to confirm at the OS prompt, as it does for `brane meld`. */
+export async function mintRemoteDeviceToken(endpoint) {
+    announcePresenceWait();
+    return daemonRequest(endpoint, "/api/tokens/remote", { method: "POST", body: {} });
+}
+/** What one run of the `--ask` command told us. `output` is its stdout, or
+ *  null when the command itself failed (machine not reachable yet). Pure, so
+ *  the suite pins every case:
+ *
+ *  - `address`: the daemon is up and reachable over Tailscale;
+ *  - `wait`: not yet — no answer, no daemon, or no Tailscale name yet (a QR
+ *    for 127.0.0.1 would be useless, and a wrong QR costs a restart);
+ *  - `old`: the remote answered without the JSON line, so its brane
+ *    predates `--connection` and ran a plain meld instead. */
+export function readMeldReply(output) {
+    if (output === null)
+        return { kind: "wait", reason: "the remote machine is not answering yet" };
+    for (const line of output.split(/\r?\n/).reverse()) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        let r;
+        try {
+            r = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (r.ready === false)
+            return { kind: "wait", reason: typeof r.reason === "string" ? r.reason : "not ready" };
+        if (r.ready !== true)
+            continue;
+        if (typeof r.daemonHost !== "string" || (r.scheme !== "http" && r.scheme !== "https") || typeof r.useLocal !== "boolean")
+            continue;
+        if (r.isLoopbackFallback)
+            return { kind: "wait", reason: "the remote machine has no Tailscale name yet" };
+        const { ready: _ready, ...connection } = r;
+        return { kind: "address", connection: connection };
+    }
+    return { kind: "old" };
+}
+/** The `--send` command with the hash in place of `{hash}`. A hash is 64 hex
+ *  digits, so it needs no quoting in a shell command. */
+const fillHashError = "--send must contain {hash}, where the token's hash goes";
+export function fillHash(template, hash) {
+    if (!template.includes("{hash}"))
+        throw new Error(fillHashError);
+    return template.replaceAll("{hash}", hash);
+}
+/** How long `brane meld --remote` waits for the remote daemon's address. */
+const REMOTE_MELD_WAIT_MS = 3 * 60_000;
+/** `--send` waits for whatever its command waits for (`fly secrets set` waits
+ *  for the machines to restart), which can outlast a couple of minutes. */
+const REMOTE_SEND_TIMEOUT_MS = 10 * 60_000;
+/** One `--ask` try; a slow `fly ssh` connect is retried, not waited out. */
+const REMOTE_ASK_TIMEOUT_MS = 60_000;
+/** Why `brane meld --remote` won't run here, or null if it will. The token is
+ *  printed into the QR and the URL; in an agent's session that output is the
+ *  agent's to read, and a device token is the operator's. This only saves a
+ *  round trip: the gate is the daemon's, which refuses an agent's token and
+ *  asks the shell for presence (`POST /api/tokens/remote`). */
+export function refusesRemoteMeld(env = process.env) {
+    return env.BRANE_NARRATIVE_SECRET
+        ? "brane meld --remote prints a device token; run it from a shell outside an agent session."
+        : null;
+}
+/** `brane meld --remote`: meld a device to a daemon on a machine that can
+ *  show no presence prompt (a Fly machine, a VPS). The token is minted by
+ *  this machine's daemon, behind its presence prompt; `--send` hands the
+ *  remote only its hash, and `--ask` reads back only its address. Nothing
+ *  here knows which host it is. */
+async function meldRemote(args) {
+    const refusal = refusesRemoteMeld();
+    if (refusal) {
+        console.error(refusal);
+        process.exit(1);
+    }
+    if (!args.send || !args.ask) {
+        console.error("brane meld --remote needs --send '<command with {hash}>' and --ask '<command that runs brane meld --connection there>'.");
+        process.exit(1);
+    }
+    // Before the prompt, so a bad --send never asks the operator anything.
+    if (!args.send.includes("{hash}")) {
+        console.error(fillHashError);
+        process.exit(1);
+    }
+    let token;
+    let send;
+    try {
+        const endpoint = await resolveDaemonEndpoint();
+        warnIfVersionMismatch(endpoint);
+        const minted = await mintRemoteDeviceToken(endpoint);
+        token = minted.token;
+        send = fillHash(args.send, minted.hash);
+    }
+    catch (err) {
+        console.error(`Failed to mint a device token: ${err.message}`);
+        process.exit(1);
+    }
+    console.log("Sending the remote daemon the new device token's hash...");
+    const sent = spawnSync("sh", ["-c", send], { stdio: "inherit", timeout: REMOTE_SEND_TIMEOUT_MS });
+    if (sent.status !== 0) {
+        console.error(`--send failed (${sent.error?.message ?? `exit ${sent.status}`}); nothing was shown, so nothing is lost.`);
+        process.exit(1);
+    }
+    console.log("Waiting for the remote daemon...");
+    const deadline = Date.now() + REMOTE_MELD_WAIT_MS;
+    let connection = null;
+    let waitingFor = "the remote daemon";
+    // The last failed try's stderr, shown if we give up: the difference between
+    // a wrong app name, an ssh login and a daemon that never came up.
+    let lastError = "";
+    while (!connection && Date.now() < deadline) {
+        const asked = spawnSync("sh", ["-c", args.ask], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8", timeout: REMOTE_ASK_TIMEOUT_MS });
+        if (asked.status !== 0)
+            lastError = (asked.stderr ?? "").trim() || (asked.error?.message ?? `exit ${asked.status}`);
+        const reply = readMeldReply(asked.status === 0 ? asked.stdout : null);
+        if (reply.kind === "old") {
+            console.error("The remote runs a brane that predates `brane meld --connection`. Update it, then run this again.");
+            process.exit(1);
+        }
+        if (reply.kind === "address")
+            connection = reply.connection;
+        else {
+            waitingFor = reply.reason;
+            await new Promise((r) => setTimeout(r, 5_000));
+        }
+    }
+    if (!connection) {
+        console.error(`Gave up waiting: ${waitingFor}.`);
+        if (lastError)
+            console.error(`The last --ask failed with:\n${lastError.split("\n").slice(-10).join("\n")}`);
+        console.error("Run this again once it's up; the token sent this time was never shown, so nothing is lost.");
+        process.exit(1);
+    }
+    const url = meldLink(connection, token);
+    console.log(`\nScan this QR code to meld:\n`);
+    qrcode.generate(url, { small: args.small ?? true }, (code) => {
+        console.log(code);
+    });
+    console.log(`\n${url}\n`);
+    console.log(`Daemon: ${connection.daemonHost} (${connection.scheme})`);
+    // The clock started with the remote daemon's restart, not now.
+    console.log(`This QR is valid for ${UNUSED_TOKEN_LAPSE_MS / 60_000} minutes from the remote daemon's start; once scanned, the device stays signed in until revoked.`);
+    if (connection.tlsDegraded) {
+        console.log("\nWarning: the remote daemon has no TLS cert, so this QR uses plain HTTP.");
+    }
+}
+export const meldCommand = defineCommand({
+    meta: {
+        name: "meld",
+        description: "Generate a QR code to connect a device to this brane",
+    },
+    args: {
+        host: {
+            type: "string",
+            description: "Override the host (default: Tailscale DNS > 127.0.0.1)",
+        },
+        small: {
+            type: "boolean",
+            description: "Use small QR code (half-block characters)",
+        },
+        local: {
+            type: "boolean",
+            description: "Generate direct daemon URL instead of brane.organelle.dev",
+        },
+        connection: {
+            type: "boolean",
+            description: "Print where a meld URL would point, as JSON, and mint nothing (what `--ask` runs on the remote machine)",
+        },
+        remote: {
+            type: "boolean",
+            description: "Meld to a daemon on another machine: mint the token here, hand it only the hash (--send), read back its address (--ask)",
+        },
+        send: {
+            type: "string",
+            description: "With --remote: a shell command that gives the remote daemon BRANE_DEVICE_TOKEN_SHA256={hash} and restarts it",
+        },
+        ask: {
+            type: "string",
+            description: "With --remote: a shell command that runs `brane meld --connection` on the remote machine",
+        },
+    },
+    async run({ args }) {
+        if (args.remote) {
+            await meldRemote(args);
+            return;
+        }
+        if (args.connection) {
+            // No token, so no presence check: an address is not a secret. Never
+            // starts a daemon — over `fly ssh` it would die with the session. Always
+            // one JSON line on stdout and exit 0, so the caller reads one channel
+            // and depends on nothing about how ssh passes on exit codes.
+            const db = openDatabase();
+            try {
+                const address = getDaemonAddress(db);
+                const reply = address
+                    ? (({ url: _url, ...connection }) => ({ ready: true, ...connection }))(buildMeldUrl({ db, daemon: { port: address.port, token: "" }, host: args.host, local: args.local }))
+                    : { ready: false, reason: "no daemon is running yet" };
+                console.log(JSON.stringify(reply));
+            }
+            finally {
+                db.close();
+            }
+            return;
+        }
+        let endpoint;
+        let token;
+        try {
+            endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            token = await mintDeviceToken(endpoint);
+        }
+        catch (err) {
+            console.error(`Failed to mint a device token: ${err.message}`);
+            process.exit(1);
+        }
+        const daemon = { port: endpoint.port, token };
+        const db = openDatabase();
+        const { url, daemonHost, scheme, useLocal, isLoopbackFallback, tlsDegraded } = buildMeldUrl({
+            db,
+            daemon,
+            host: args.host,
+            local: args.local,
+        });
+        db.close();
+        console.log(`\nScan this QR code to meld:\n`);
+        qrcode.generate(url, { small: args.small ?? true }, (code) => {
+            console.log(code);
+        });
+        console.log(`\n${url}\n`);
+        console.log(`Daemon: ${daemonHost} (${scheme})`);
+        if (!useLocal) {
+            console.log(`App: brane.organelle.dev`);
+        }
+        console.log(meldLapseNote());
+        if (isLoopbackFallback) {
+            console.log("\nNo Tailscale detected. This QR points at 127.0.0.1 and will only work from this machine.");
+            console.log("For cross-device access, install Tailscale and run `brane certify`,");
+            console.log("or pass `--host <address>` to advertise an address you trust.");
+        }
+        else if (tlsDegraded) {
+            console.log("\nWarning: Tailscale is up but the daemon has no TLS cert, so this QR uses plain HTTP.");
+            console.log("Run `brane certify` to provision one — it'll tell you if \"HTTPS for your tailnet\"");
+            console.log("needs enabling at https://login.tailscale.com/admin/dns.");
+        }
+    },
+});
+//# sourceMappingURL=meld.js.map

package/dist/commands/memory.js

@@ -0,0 +1,215 @@
+import { resolve } from "node:path";
+import { defineCommand } from "citty";
+import { resolveDaemonEndpoint, daemonRequest, warnIfVersionMismatch } from "../daemon/client.js";
+/** Parse a duration string like "1h", "2d", "30m", "1w" into milliseconds. */
+export function parseDuration(input) {
+    const match = input.match(/^(\d+)\s*(ms|s|m|h|d|w)$/);
+    if (!match)
+        throw new Error(`Invalid duration: "${input}". Use e.g. 30m, 1h, 2d, 1w`);
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const multipliers = {
+        ms: 1,
+        s: 1000,
+        m: 60 * 1000,
+        h: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+    };
+    return value * multipliers[unit];
+}
+/** Format a timestamp as a relative time string like "3m ago". */
+export function timeSince(timestampMs, now = Date.now()) {
+    const seconds = Math.floor((now - timestampMs) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+export function formatRecentNarratives(rows, since) {
+    if (rows.length === 0)
+        return `No narratives active in the last ${since}.`;
+    const lines = [];
+    for (const row of rows) {
+        const icon = row.status === "active" ? "●" : "○";
+        const title = row.title ? `"${row.title}"` : `(${row.agent_type})`;
+        const events = `${row.event_count} event${row.event_count === 1 ? "" : "s"}`;
+        lines.push(`${icon} ${row.id}  ${title}  ${row.last_activity_ago}  (${events})`);
+        if (row.summary)
+            lines.push(`  Summary: ${row.summary}`);
+    }
+    return lines.join("\n");
+}
+/** Query string for `/api/narratives/recent`. A relative `--fold` is resolved
+ *  against this shell's cwd, since the daemon's cwd means nothing here. */
+export function buildRecentQuery(args, cwd) {
+    const q = new URLSearchParams();
+    q.set("since", args.since);
+    if (args.archived)
+        q.set("archived", "1");
+    if (args.search)
+        q.set("search", args.search);
+    if (args.status)
+        q.set("status", args.status);
+    q.set("limit", String(parseInt(args.limit, 10) || 20));
+    if (args.fold)
+        q.set("fold", args.fold.startsWith("~") ? args.fold : resolve(cwd, args.fold));
+    return q.toString();
+}
+const memoryLog = defineCommand({
+    meta: {
+        name: "log",
+        description: "Show recently active narratives with search/filtering",
+    },
+    args: {
+        since: {
+            type: "string",
+            default: "24h",
+            description: "Time window for recent activity (e.g. 30m, 1h, 2d, 1w)",
+        },
+        search: {
+            type: "string",
+            description: "Filter to narratives containing matching event content",
+        },
+        status: {
+            type: "string",
+            description: "Filter by narrative status (active, ended)",
+        },
+        limit: {
+            type: "string",
+            default: "20",
+            description: "Maximum number of narratives to show",
+        },
+        fold: {
+            type: "string",
+            description: "Filter by fold path (absolute or portable, e.g. ~/dev/brane)",
+        },
+        archived: {
+            type: "boolean",
+            description: "Include archived narratives (absorbed history is archived by construction)",
+            default: false,
+        },
+        json: {
+            type: "boolean",
+            description: "Output as JSON",
+        },
+    },
+    async run({ args }) {
+        try {
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            const { narratives, since } = await daemonRequest(endpoint, `/api/narratives/recent?${buildRecentQuery(args, process.cwd())}`);
+            if (args.json) {
+                console.log(JSON.stringify(narratives, null, 2));
+                return;
+            }
+            console.log(formatRecentNarratives(narratives, since));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+export function formatSearchResults(results) {
+    if (results.length === 0)
+        return "No results found.";
+    const lines = [`Found ${results.length} results:`, ""];
+    results.forEach((r, i) => {
+        const preview = r.content.length > 120 ? r.content.slice(0, 120) + "..." : r.content;
+        lines.push(`${i + 1}. ${r.narrative_id} (seq ${r.seq}) - Score: ${r.score.toFixed(2)}`);
+        lines.push(`   "${preview}"`);
+        lines.push(`   > brane attach ${r.narrative_id}`, "");
+    });
+    return lines.join("\n");
+}
+const memorySearch = defineCommand({
+    meta: {
+        name: "search",
+        description: "Semantic search across narrative history",
+    },
+    args: {
+        query: {
+            type: "positional",
+            required: true,
+            description: "Search query",
+        },
+        limit: {
+            type: "string",
+            default: "10",
+            description: "Maximum number of results",
+        },
+    },
+    async run({ args }) {
+        try {
+            // The daemon's embedding model is already warm; loading a second copy
+            // here cost every search a 30 s cold start. Indexing of new events is
+            // the daemon's background job (and `brane memory index` on demand).
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            console.log(`Searching: "${args.query}"\n`);
+            const { results } = await daemonRequest(endpoint, "/api/search", {
+                method: "POST",
+                body: { query: args.query, limit: parseInt(args.limit, 10) || 10 },
+            });
+            console.log(formatSearchResults(results));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+export function formatIndexResult(stats) {
+    return (`Done. Scanned ${stats.narratives_scanned} narratives, ` +
+        `indexed ${stats.narratives_indexed}, ` +
+        `created ${stats.chunks_created} chunks.`);
+}
+const memoryIndex = defineCommand({
+    meta: {
+        name: "index",
+        description: "Re-index narrative content for semantic search",
+    },
+    args: {
+        rebuild: {
+            type: "boolean",
+            description: "Rebuild entire index from scratch",
+        },
+    },
+    async run({ args }) {
+        try {
+            // Runs through the daemon's indexer, queued behind any background
+            // pass already in flight — two processes indexing the same cursors
+            // was the race the in-process version had.
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            const stats = await daemonRequest(endpoint, "/api/memory/index", {
+                method: "POST",
+                body: { rebuild: args.rebuild ?? false },
+            });
+            console.log(formatIndexResult(stats));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+export const memoryCommand = defineCommand({
+    meta: {
+        name: "memory",
+        description: "Semantic memory search and indexing",
+    },
+    subCommands: {
+        log: memoryLog,
+        search: memorySearch,
+        index: memoryIndex,
+    },
+});
+//# sourceMappingURL=memory.js.map

package/dist/commands/revive.js

@@ -0,0 +1,74 @@
+import { defineCommand } from "citty";
+import { resolveDaemonEndpoint, daemonRequest, warnIfVersionMismatch } from "../daemon/client.js";
+export const reviveCommand = defineCommand({
+    meta: {
+        name: "revive",
+        description: "Restart a dead agent session",
+    },
+    args: {
+        id: {
+            type: "positional",
+            required: true,
+            description: "Session/narrative ID to revive",
+        },
+        prompt: {
+            type: "string",
+            description: "Custom prompt to inject after revival",
+        },
+        "no-prompt": {
+            type: "boolean",
+            description: "Suppress the initial prompt",
+        },
+        agent: {
+            type: "string",
+            description: "Continue under a different agent (spawns a twin of this narrative)",
+        },
+    },
+    async run({ args }) {
+        try {
+            // Reviving goes through the daemon, exactly as the web app's revive menu
+            // item and the `revive` MCP tool do — `POST /api/revive/:nid` is the
+            // single revive path, and the CLI is one of its clients rather than a
+            // second implementation. Everything below this call is printing.
+            const endpoint = await resolveDaemonEndpoint();
+            warnIfVersionMismatch(endpoint);
+            const result = await daemonRequest(endpoint, `/api/revive/${encodeURIComponent(args.id)}`, { method: "POST", body: buildReviveBody(args) });
+            console.log(formatReviveResult(args.id, result));
+            if (result.status === "already_running" && args.prompt && !args["no-prompt"]) {
+                console.log(`Sent prompt to ${result.nid}`);
+            }
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    },
+});
+/** Map CLI flags onto the `POST /api/revive/:nid` payload. Absent flags are
+ *  omitted rather than sent as `undefined`/`false`, so the daemon's own
+ *  defaults stay in charge of anything the operator didn't ask about. */
+export function buildReviveBody(args) {
+    return {
+        ...(args.prompt ? { prompt: args.prompt } : {}),
+        ...(args["no-prompt"] ? { no_prompt: true } : {}),
+        ...(args.agent ? { agent: args.agent } : {}),
+    };
+}
+/** The one line `brane revive` prints for each outcome. Split out so the
+ *  three-way distinction — which the old in-process CLI could not make at all
+ *  — is testable without a daemon. */
+export function formatReviveResult(requestedNid, result) {
+    const suffix = result.agent ? ` (${result.agent})` : "";
+    switch (result.status) {
+        case "already_running":
+            return `Session ${result.nid} is already running.`;
+        case "continued":
+            // A twin: `result.nid` is a *new* narrative that reads the requested
+            // one's history. Printing the requested id here would name a pane that
+            // isn't the one now running.
+            return `Continued ${requestedNid} as ${result.nid}${suffix}`;
+        default:
+            return `Revived ${result.nid}${suffix}`;
+    }
+}
+//# sourceMappingURL=revive.js.map