brane 0.3.1 → 0.3.3

package/AGENTS.md

@@ -116,8 +116,8 @@ published GitHub release, and only by it. **Agents never run `npm publish`.**
 The shared web app ships with it: a release deploys its tarball's
 `expo/dist`, and a merge to `main` deploys nothing (staging is Isolate on a
 daemon running `main`). The version bump, tag rule, dist-tag choice, app
-deploy and rollback, and why 0.3.0 has no provenance attestation are in
-[docs/releasing.md](docs/releasing.md).
+deploy and rollback, and why 0.3.0 and 0.3.1 have no provenance
+attestation are in [docs/releasing.md](docs/releasing.md).
 
 ## CLI Commands
 

package/CHANGELOG.md

@@ -6,6 +6,43 @@ page, which is also what triggers its publish (see
 [docs/releasing.md](docs/releasing.md)). This file is the summary that
 travels in the npm tarball.
 
+## 0.3.3 - 2026-10-14
+
+- A fresh `npm install brane` audits clean. The math syntax extension
+  is now vendored (`src/math-syntax.ts`) instead of depending on
+  `micromark-extension-math`, which pinned a second, older katex into
+  every install (GHSA-238p-pmpm-9mq7) and led `npm audit fix --force` to
+  propose brane@0.1.1 ([#608](https://github.com/benjamn/brane/pull/608)).
+- In the web app, "All narratives" opens the list in a new tab, and a
+  link opened in a new tab lands on the daemon it came from rather than
+  the browser's default one ([#607](https://github.com/benjamn/brane/pull/607)).
+- The 膜 glyph carries a caption — a quip or a tip about brane — that
+  changes on each tap and nothing else; the empty state's words move
+  above it, and it no longer says "No narratives yet" when they are all
+  archived ([#606](https://github.com/benjamn/brane/pull/606)).
+- The README, which is also the npm page, opens with a new
+  introduction: what brane is for, the LIVE loop, and terminal
+  mirroring ([#610](https://github.com/benjamn/brane/pull/610)).
+
+Published while the repository is private, so like 0.3.0–0.3.2 it
+carries no npm provenance attestation.
+
+## 0.3.2 - 2026-10-13
+
+- Archive is offered only once a narrative has ended, and the daemon
+  enforces it: `PATCH /api/narratives/:id/archive` answers 409 while the
+  narrative's status isn't `ended`, its agent is still connected, or its
+  tmux session is up. Unarchiving is never refused
+  ([#604](https://github.com/benjamn/brane/pull/604)).
+- Archiving from a narrative's own 🦠 menu goes to the narrative list,
+  and Back returns to the archived narrative
+  ([#603](https://github.com/benjamn/brane/pull/603)).
+- Swiping the narrative's header card down dismisses it to the list;
+  Back returns ([#604](https://github.com/benjamn/brane/pull/604)).
+
+Published while the repository is private, so like 0.3.0 and 0.3.1 it
+carries no npm provenance attestation.
+
 ## 0.3.1 - 2026-10-12
 
 - The shared web app ships with the release. It serves the `latest`
@@ -34,9 +71,12 @@ travels in the npm tarball.
   repoints the fold's hook config at the running daemon
   ([#594](https://github.com/benjamn/brane/pull/594)).
 - Vulnerabilities are reported through GitHub's private vulnerability
-  reporting (see `SECURITY.md`). This is the first release published
-  from the public repository, so it carries npm provenance; 0.3.0 has
-  none ([#597](https://github.com/benjamn/brane/pull/597)).
+  reporting (see `SECURITY.md`)
+  ([#597](https://github.com/benjamn/brane/pull/597)).
+
+Like 0.3.0, published while the repository was private, so it carries
+no npm provenance attestation. The copy of this entry in the 0.3.1
+tarball says otherwise; it is wrong.
 
 ## 0.3.0 - 2026-10-11
 

package/README.md

@@ -1,6 +1,12 @@
 # brane
 
-A TypeScript CLI and userspace daemon for managing narrative agent sessions.
+Brane provides a [web-based remote management interface](https://brane.organelle.dev/) for running long-lived Terminal UI (TUI) applications on any remote machine, securely and directly, without a central server, supporting not only full shells like `zsh` and `fish` and utilities like `lazygit` or `htop`, but also most of the popular _agentic_ TUI commands: `claude`, `codex`, `gemini`, `crush`, `copilot`, `goose`, and so on.
+
+The "intelligent" TUI applications demonstrate their intelligence by using brane's local MCP tools: `whoami`, `narrate`, `listen` and the rest, to implement a protocol for ongoing, purposeful conversation (the "LIVE loop") recorded automatically to a permanent, fully agent-searchable record that remains completely private to the host machine.
+
+Unlike a lot of other remote-coding tools, which let you chat with your agents and accept/deny permissions prompts, brane also _mirrors the terminal of the running agent_, so you can effortlessly observe your agents working from any mobile device, with the full power of a software keyboard and touch inputs for interacting with the terminal from afar, whenever you need that level of control.
+
+## Etymology and economics
 
 "Brane" is short for **membrane**, evoking a [_eukaryotic_](https://en.wikipedia.org/wiki/Eukaryote) metaphor for agent management, inherited from [organelle](https://github.com/benjamn/organelle): the daemon is the nucleus (which has a membrane), agents are organelles (which in turn have their own membranes), and narrative event logs trace everything each organelle has encountered and done (biologically implausible, but very useful).
 
@@ -12,24 +18,6 @@ If you find brane useful, perhaps because your tastes align with mine and I have
 
 [![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-ea4aaa?logo=githubsponsors)](https://github.com/sponsors/benjamn)
 
-## What it does
-
-Brane runs long-lived coding agents (Claude Code, Codex, Gemini, Goose and
-others, or any command) in tmux on your own machine, keeps everything they
-say and hear in one SQLite database, and lets you read, steer and search
-them from a phone or any browser on your tailnet.
-
-Four ideas cover most of it:
-
-- **Fold**: a directory you've registered as a place agents may be spawned.
-- **Narrative**: one agent session's append-only log of everything it said
-  and everything said to it. Every message has a stable address
-  (`claude-4c7289d1:42`) you can link to from anywhere.
-- **The LIVE loop**: the protocol agents follow to talk to you through an
-  MCP server brane injects into each session: listen, interpret, vocalize,
-  execute.
-- **Meld**: a QR code that signs a phone or browser into your daemon.
-
 ## Quick start
 
 0. **Install [Tailscale](https://tailscale.com/download)** and join your

package/dist/daemon/archive-gate.js

@@ -0,0 +1,11 @@
+/** Why the narrative can't be archived yet, or null when it can. */
+export function archiveRefusal({ status, mcpConnected, tmuxLive }) {
+    if (mcpConnected)
+        return "its agent is still connected";
+    if (tmuxLive)
+        return "its session is still running";
+    if (status !== "ended")
+        return `its status is ${status ?? "unset"}, not ended`;
+    return null;
+}
+//# sourceMappingURL=archive-gate.js.map

package/dist/daemon/server.js

@@ -22,6 +22,7 @@ import { getBraneId, getPayloadsDir, getTokenFilePath, fromPortablePath, toPorta
 import { TokenRing } from "./token-ring.js";
 import { signalEventFields, signalStanding } from "./signal-source.js";
 import { AGENT_LOOPBACK_REFUSAL, AGENT_REVIVE_REFUSAL, agentRefusal, agentReviveRefusal } from "./agent-scope.js";
+import { archiveRefusal } from "./archive-gate.js";
 import { DbTokenStore, bootstrapTokens, legacyTokenWarning, parseTokenHashes, liveAgentTokenId, mintAgentToken, recordLauncher, settleAgentLaunch, verifyAgentToken } from "../db/tokens.js";
 import { closeSocketsOf, listTokensRoute, socketOwners, retireTokens } from "./token-routes.js";
 import { getConfig, resolveAppHost } from "../commands/config.js";
@@ -1381,16 +1382,34 @@ export async function startServer(config) {
             const narrativeId = archiveMatch[1];
             parseBody(req).then((body) => {
                 const { archived } = JSON.parse(body);
+                // A running narrative can't be archived: hiding a live agent from the
+                // list is exactly what a rogue one would want. See archive-gate.ts.
+                if (archived) {
+                    const row = db.prepare("SELECT status FROM narratives WHERE id = ?").get(narrativeId);
+                    if (!row) {
+                        sendJson(res, 404, { error: `No narrative ${narrativeId}` });
+                        return;
+                    }
+                    const refusal = archiveRefusal({
+                        status: row.status,
+                        mcpConnected: mcpConnectedNids(mcpClients).has(narrativeId),
+                        tmuxLive: liveTmuxSessions().has(narrativeId),
+                    });
+                    if (refusal) {
+                        sendJson(res, 409, { error: `Can't archive ${narrativeId}: ${refusal}. End it first.` });
+                        return;
+                    }
+                }
                 db.prepare("UPDATE narratives SET archived = ? WHERE id = ?").run(archived ? 1 : 0, narrativeId);
                 // An archived narrative's agent token is a credential nobody needs:
-                // revoke it, unless its session is still running (archiving is not a
-                // way to cut off a live agent; revoking from the Devices list is).
-                // Unarchiving brings nothing back; a revive mints a fresh token.
-                if (archived && !liveTmuxSessions().has(narrativeId)) {
+                // revoke it. Its session is over, or the gate above would have
+                // refused. Unarchiving brings nothing back; a revive mints a fresh
+                // token.
+                if (archived) {
                     const agentRow = liveAgentTokenId(db, narrativeId);
                     if (agentRow) {
                         db.prepare("UPDATE tokens SET revoked_at = ? WHERE kind = 'agent' AND owner_nid = ? AND revoked_at IS NULL").run(Date.now(), narrativeId);
-                        // A connected external's bridge goes now, not at its next redial.
+                        // Any socket still holding it goes now, not at its next redial.
                         closeSocketsOf(viewerSockets, [agentRow]);
                     }
                 }

package/dist/export.js

@@ -4,7 +4,7 @@ import { micromark } from "micromark";
 import { gfmTable, gfmTableHtml } from "micromark-extension-gfm-table";
 import { gfmAutolinkLiteral, gfmAutolinkLiteralHtml } from "micromark-extension-gfm-autolink-literal";
 import { gfmTaskListItem, gfmTaskListItemHtml } from "micromark-extension-gfm-task-list-item";
-import { math } from "micromark-extension-math";
+import { math } from "./math-syntax.js";
 import { NID_PATTERN, NID_REF_PATTERN } from "./shared/markdown-nids.js";
 import { isInlinePayload, INLINE_PAYLOAD_MIME } from "./shared/payload-inline.js";
 import { readEvents, readEventsBySeqs } from "./db/events.js";

package/dist/markdown-diagnostics.js

@@ -32,7 +32,7 @@ import { micromark } from "micromark";
 import { gfmTable, gfmTableHtml } from "micromark-extension-gfm-table";
 import { gfmAutolinkLiteral, gfmAutolinkLiteralHtml } from "micromark-extension-gfm-autolink-literal";
 import { gfmTaskListItem, gfmTaskListItemHtml } from "micromark-extension-gfm-task-list-item";
-import { math } from "micromark-extension-math";
+import { math } from "./math-syntax.js";
 import { mathHtmlExtension } from "./math.js";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { inspectDiagram } from "./diagram/index.js";

package/dist/math-syntax.js

@@ -0,0 +1,354 @@
+/** micromark syntax extension for math: `$…$` (text) and `$$` fences (flow).
+ *
+ *  Vendored from `micromark-extension-math` 3.1.0 (`dev/lib/syntax.js`,
+ *  `math-flow.js`, `math-text.js`), the syntax half only, so the published
+ *  package no longer depends on it. That package's index also loads its
+ *  `mathHtml()`, which imports `katex` at the range it pins (`^0.16.0`). Our
+ *  root `overrides` dedupe that onto our own katex in this checkout, but npm
+ *  ignores a dependency's `overrides`, so every `npm install brane` got a
+ *  second, older katex: loaded, never called (`src/math.ts` is our `mathHtml`),
+ *  and flagged by `npm audit` (GHSA-238p-pmpm-9mq7). The tokenizers are
+ *  unchanged apart from TypeScript annotations and dropping the `devlop`
+ *  assertions, which upstream's production build drops too. The web app still
+ *  imports the package itself: it ships prebuilt, under `expo/`'s overrides.
+ *
+ *  Upstream: https://github.com/micromark/micromark-extension-math
+ *
+ *  (The MIT License)
+ *
+ *  Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  'Software'), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ *  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ *  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ *  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { factorySpace } from "micromark-factory-space";
+import { markdownLineEnding } from "micromark-util-character";
+import { codes, constants, types } from "micromark-util-symbol";
+/** Create an extension for `micromark` to enable math syntax. */
+export function math(options) {
+    return {
+        flow: { [codes.dollarSign]: mathFlow },
+        text: { [codes.dollarSign]: mathText(options) },
+    };
+}
+// --- math (flow) ------------------------------------------------------------
+const mathFlow = {
+    tokenize: tokenizeMathFenced,
+    concrete: true,
+    name: "mathFlow",
+};
+const nonLazyContinuation = {
+    tokenize: tokenizeNonLazyContinuation,
+    partial: true,
+};
+function tokenizeMathFenced(effects, ok, nok) {
+    const self = this;
+    const tail = self.events[self.events.length - 1];
+    const initialSize = tail && tail[1].type === types.linePrefix
+        ? tail[2].sliceSerialize(tail[1], true).length
+        : 0;
+    let sizeOpen = 0;
+    return start;
+    /** Start of math: `$$`, at the first `$`. */
+    function start(code) {
+        effects.enter("mathFlow");
+        effects.enter("mathFlowFence");
+        effects.enter("mathFlowFenceSequence");
+        return sequenceOpen(code);
+    }
+    /** In opening fence sequence. */
+    function sequenceOpen(code) {
+        if (code === codes.dollarSign) {
+            effects.consume(code);
+            sizeOpen++;
+            return sequenceOpen;
+        }
+        if (sizeOpen < 2) {
+            return nok(code);
+        }
+        effects.exit("mathFlowFenceSequence");
+        return factorySpace(effects, metaBefore, types.whitespace)(code);
+    }
+    /** In opening fence, before meta: `$$asciimath`, at `a`. */
+    function metaBefore(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            return metaAfter(code);
+        }
+        effects.enter("mathFlowFenceMeta");
+        effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+        return meta(code);
+    }
+    /** In meta. */
+    function meta(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            effects.exit(types.chunkString);
+            effects.exit("mathFlowFenceMeta");
+            return metaAfter(code);
+        }
+        if (code === codes.dollarSign) {
+            return nok(code);
+        }
+        effects.consume(code);
+        return meta;
+    }
+    /** After meta. */
+    function metaAfter(code) {
+        // Guaranteed to be eol/eof.
+        effects.exit("mathFlowFence");
+        if (self.interrupt) {
+            return ok(code);
+        }
+        return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    /** After eol/eof in math, at a non-lazy closing fence or content. */
+    function beforeNonLazyContinuation(code) {
+        return effects.attempt({ tokenize: tokenizeClosingFence, partial: true }, after, contentStart)(code);
+    }
+    /** Before math content, definitely not before a closing fence. */
+    function contentStart(code) {
+        return (initialSize
+            ? factorySpace(effects, beforeContentChunk, types.linePrefix, initialSize + 1)
+            : beforeContentChunk)(code);
+    }
+    /** Before math content, after optional prefix. */
+    function beforeContentChunk(code) {
+        if (code === codes.eof) {
+            return after(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+        }
+        effects.enter("mathFlowValue");
+        return contentChunk(code);
+    }
+    /** In math content. */
+    function contentChunk(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            effects.exit("mathFlowValue");
+            return beforeContentChunk(code);
+        }
+        effects.consume(code);
+        return contentChunk;
+    }
+    /** After math (ha!). */
+    function after(code) {
+        effects.exit("mathFlow");
+        return ok(code);
+    }
+    function tokenizeClosingFence(effects, ok, nok) {
+        let size = 0;
+        // Before closing fence, at optional whitespace.
+        return factorySpace(effects, beforeSequenceClose, types.linePrefix, self.parser.constructs.disable.null.includes("codeIndented")
+            ? undefined
+            : constants.tabSize);
+        /** In closing fence, after optional whitespace, at sequence. */
+        function beforeSequenceClose(code) {
+            effects.enter("mathFlowFence");
+            effects.enter("mathFlowFenceSequence");
+            return sequenceClose(code);
+        }
+        /** In closing fence sequence. */
+        function sequenceClose(code) {
+            if (code === codes.dollarSign) {
+                size++;
+                effects.consume(code);
+                return sequenceClose;
+            }
+            if (size < sizeOpen) {
+                return nok(code);
+            }
+            effects.exit("mathFlowFenceSequence");
+            return factorySpace(effects, afterSequenceClose, types.whitespace)(code);
+        }
+        /** After closing fence sequence, after optional whitespace. */
+        function afterSequenceClose(code) {
+            if (code === codes.eof || markdownLineEnding(code)) {
+                effects.exit("mathFlowFence");
+                return ok(code);
+            }
+            return nok(code);
+        }
+    }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+    const self = this;
+    return start;
+    function start(code) {
+        if (code === null) {
+            return ok(code);
+        }
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return lineStart;
+    }
+    function lineStart(code) {
+        return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+    }
+}
+// --- math (text) ------------------------------------------------------------
+// To do (upstream): next major: clean spaces in HTML compiler.
+// This has to be coordinated together with `mdast-util-math`.
+function mathText(options) {
+    const options_ = options || {};
+    let single = options_.singleDollarTextMath;
+    if (single === null || single === undefined) {
+        single = true;
+    }
+    return {
+        tokenize: tokenizeMathText,
+        resolve: resolveMathText,
+        previous,
+        name: "mathText",
+    };
+    function tokenizeMathText(effects, ok, nok) {
+        let sizeOpen = 0;
+        let size;
+        let token;
+        return start;
+        /** Start of math (text): `$a$` at the first `$`, or `\$a$` at the second. */
+        function start(code) {
+            effects.enter("mathText");
+            effects.enter("mathTextSequence");
+            return sequenceOpen(code);
+        }
+        /** In opening sequence. */
+        function sequenceOpen(code) {
+            if (code === codes.dollarSign) {
+                effects.consume(code);
+                sizeOpen++;
+                return sequenceOpen;
+            }
+            // Not enough markers in the sequence.
+            if (sizeOpen < 2 && !single) {
+                return nok(code);
+            }
+            effects.exit("mathTextSequence");
+            return between(code);
+        }
+        /** Between something and something else. */
+        function between(code) {
+            if (code === codes.eof) {
+                return nok(code);
+            }
+            if (code === codes.dollarSign) {
+                token = effects.enter("mathTextSequence");
+                size = 0;
+                return sequenceClose(code);
+            }
+            // Tabs don’t work, and virtual spaces don’t make sense.
+            if (code === codes.space) {
+                effects.enter("space");
+                effects.consume(code);
+                effects.exit("space");
+                return between;
+            }
+            if (markdownLineEnding(code)) {
+                effects.enter(types.lineEnding);
+                effects.consume(code);
+                effects.exit(types.lineEnding);
+                return between;
+            }
+            // Data.
+            effects.enter("mathTextData");
+            return data(code);
+        }
+        /** In data. */
+        function data(code) {
+            if (code === codes.eof ||
+                code === codes.space ||
+                code === codes.dollarSign ||
+                markdownLineEnding(code)) {
+                effects.exit("mathTextData");
+                return between(code);
+            }
+            effects.consume(code);
+            return data;
+        }
+        /** In closing sequence. */
+        function sequenceClose(code) {
+            // More.
+            if (code === codes.dollarSign) {
+                effects.consume(code);
+                size++;
+                return sequenceClose;
+            }
+            // Done!
+            if (size === sizeOpen) {
+                effects.exit("mathTextSequence");
+                effects.exit("mathText");
+                return ok(code);
+            }
+            // More or less accents: mark as data.
+            token.type = "mathTextData";
+            return data(code);
+        }
+    }
+}
+const resolveMathText = function (events) {
+    let tailExitIndex = events.length - 4;
+    let headEnterIndex = 3;
+    let index;
+    let enter;
+    // If we start and end with an EOL or a space.
+    if ((events[headEnterIndex][1].type === types.lineEnding ||
+        events[headEnterIndex][1].type === "space") &&
+        (events[tailExitIndex][1].type === types.lineEnding ||
+            events[tailExitIndex][1].type === "space")) {
+        index = headEnterIndex;
+        // And we have data.
+        while (++index < tailExitIndex) {
+            if (events[index][1].type === "mathTextData") {
+                // Then we have padding.
+                events[tailExitIndex][1].type = "mathTextPadding";
+                events[headEnterIndex][1].type = "mathTextPadding";
+                headEnterIndex += 2;
+                tailExitIndex -= 2;
+                break;
+            }
+        }
+    }
+    // Merge adjacent spaces and data.
+    index = headEnterIndex - 1;
+    tailExitIndex++;
+    while (++index <= tailExitIndex) {
+        if (enter === undefined) {
+            if (index !== tailExitIndex && events[index][1].type !== types.lineEnding) {
+                enter = index;
+            }
+        }
+        else if (index === tailExitIndex || events[index][1].type === types.lineEnding) {
+            events[enter][1].type = "mathTextData";
+            if (index !== enter + 2) {
+                events[enter][1].end = events[index - 1][1].end;
+                events.splice(enter + 2, index - enter - 2);
+                tailExitIndex -= index - enter - 2;
+                index = enter + 2;
+            }
+            enter = undefined;
+        }
+    }
+    return events;
+};
+const previous = function (code) {
+    // If there is a previous code, there will always be a tail.
+    return (code !== codes.dollarSign ||
+        this.events[this.events.length - 1][1].type === types.characterEscape);
+};
+//# sourceMappingURL=math-syntax.js.map

package/dist/shared/membrane-quips.js

@@ -0,0 +1,77 @@
+/**
+ * What the 膜 says, in the caption under it.
+ *
+ * `expo/components/MembraneEmpty.web.tsx` shows one of these under the glyph
+ * whenever the glyph is shown — under an empty list and under a full one —
+ * and a tap on the glyph swaps it for another. Nothing else changes it, so
+ * it can be read at leisure, links and all. Each line is markdown, rendered
+ * by the app's own renderer. Two kinds, mixed and worn alike: a quip is a
+ * joke at the glyph's own expense (it is, after all, a fragment shader
+ * running full-time under an empty list), and a tip is the loading-screen
+ * filler of a video game — one true thing about brane the operator may not
+ * have found yet. Every tip states something the app or CLI actually does;
+ * a tip that stops being true should be removed rather than left to
+ * mislead. Brevity is the operator's rule: aim
+ * for one sentence, with no terminal period (claude-nusb6rnr:7).
+ *
+ * The order is one shuffle per page load, then a fixed loop through it
+ * (`QuipLoop`): every line once before any line twice, and the same order
+ * every time round. Randomness is passed in so a test can pin it.
+ */
+export const MEMBRANE_QUIPS = [
+    // ── quips ──────────────────────────────────────────────────────────────
+    "I noticed you were not using your GPU",
+    "I am the opposite of load-bearing",
+    "膜 is pronounced mó",
+    "My Kolmogorov complexity is actually quite low",
+    "Covert side-channel? Takes one to know one",
+    "Abstract impressionism? Here's my abstract impression of _you_",
+    "Drag me around a little",
+    "Do you know where your children are running shader programs?",
+    "No human art was digested in the making of whatever this is",
+    "Too many taps and the paradigm could shift",
+    "Bet you wish your phosphenes were lit like me",
+    "If this be a prisoner's cinema, then who be the prisoners?",
+    "Do not fall in love with any particular color scheme",
+    "All these colors will be lost in time, like tears in rain",
+    // ── tips ───────────────────────────────────────────────────────────────
+    "Agent stop working? Feed it something from the 🥫 menu",
+    "What was that terminal shortcut? Maybe it's in the 🦾 menu",
+    "Agents glow whenever they are awaiting chat input",
+    "@-mention any agent by NID (narrative ID) to summon them",
+    "Ask your agent about rendering mermaid diagrams",
+    "Go ahead and install [Tailscale](https://tailscale.com/) (it's free)",
+    "Command your own daemon: `npm install -g brane`",
+    "Wonder what this does? `brane absorb survey`",
+    "Have YOU read the /LIVE_loop protocol?",
+    "Your daemon from any device: `brane meld` and prosper 🖖",
+    "Fork tangential narratives with 🧬 Twin in the 🦠 menu",
+];
+/** A uniformly random permutation of `list` (Fisher–Yates); `list` is left alone. */
+export function shuffled(list, rand = Math.random) {
+    const out = [...list];
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.min(i, Math.floor(rand() * (i + 1)));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+/** One shuffle of the lines, walked in a loop: `current` is the line showing,
+ *  `next` steps to the one after it, back to the first after the last. */
+export class QuipLoop {
+    order;
+    at = 0;
+    constructor(list = MEMBRANE_QUIPS, rand = Math.random) {
+        if (list.length === 0)
+            throw new Error("no quips");
+        this.order = shuffled(list, rand);
+    }
+    current() {
+        return this.order[this.at];
+    }
+    next() {
+        this.at = (this.at + 1) % this.order.length;
+        return this.current();
+    }
+}
+//# sourceMappingURL=membrane-quips.js.map

package/dist/shared/mo-glyph.js

@@ -17,6 +17,10 @@
  */
 /** Side of the square the path is laid out in, in path units. */
 export const MO_GLYPH_BOX = 1000;
+/** The empty band between the ink and the box's top or bottom edge, in path
+ *  units: the glyph is centered, so it is the same above and below. Whatever
+ *  sits under the glyph is that much farther from the ink than from the box. */
+export const MO_GLYPH_MARGIN = 92.79;
 /** SVG path data for 膜, y down, inside `[0, MO_GLYPH_BOX]²`. */
 export const MO_GLYPH_PATH = "M493.98 449.69L493.98 425.61L791.54 425.61L791.54 449.69L493.98 449.69ZM493.98 557.19L493.98 533.11" +
     "L791.54 533.11L791.54 557.19L493.98 557.19ZM431.20 606.21L431.20 319.83L431.20 275.11L431.20 275.11" +

package/dist/shared/narrative-menu.js

@@ -74,11 +74,14 @@ export function narrativeMenuItems({ role, status, mcpConnected, archived = fals
                     ? { icon: "🐦‍🔥", label: "Revive", onPress: onRevive }
                     : { icon: "🫠", label: "End", onPress: onEnd },
             ]),
-        {
-            icon: archived ? "📂" : "🗄️",
-            label: archived ? "Unarchive" : "Archive",
-            onPress: onArchiveToggle,
-        },
+        // Archive puts away a narrative that is over, so it waits for the session
+        // to end, by the same test that offers Revive. Unarchive is offered on any
+        // archived narrative, whatever its state.
+        ...(archived
+            ? [{ icon: "📂", label: "Unarchive", onPress: onArchiveToggle }]
+            : isEnded
+                ? [{ icon: "🗄️", label: "Archive", onPress: onArchiveToggle }]
+                : []),
     ];
 }
 //# sourceMappingURL=narrative-menu.js.map