beatrina 0.8.7 → 0.9.43

package/kernel/mcp/{carmar-mcp.mjs → beatrina-mcp.mjs}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-// carmar-mcp.mjs — the MCP stdio server that connects an agent CLI (Claude
-// Code, Codex, anything speaking MCP) to the user's running CarmaR notebook.
+// beatrina-mcp.mjs — the MCP stdio server that connects an agent CLI (Claude
+// Code, Codex, anything speaking MCP) to the user's running Beatrina notebook.
 //
-//   claude mcp add carmar -- node /abs/path/tools/mcp/carmar-mcp.mjs
-//   codex  mcp add carmar -- node /abs/path/tools/mcp/carmar-mcp.mjs
+//   claude mcp add beatrina -- node /abs/path/tools/mcp/beatrina-mcp.mjs
+//   codex  mcp add beatrina -- node /abs/path/tools/mcp/beatrina-mcp.mjs
 //
 // The CLI spawns this process and speaks JSON-RPC over stdio; this process
 // joins the kernel's WebSocket — the SAME loopback socket a notebook page uses —
@@ -14,13 +14,15 @@
 // Boundary, by design: this file never reads CLI credentials, never talks to
 // Anthropic or OpenAI, never proxies a subscription. Authentication stays
 // inside the official CLI. Kernel discovery uses the same-user runtime file
-// (~/.carmar/run, mode 0600); no credential is placed in a URL.
+// (~/.beatrina/run and, still read, the older ~/.carmar/run; mode 0600 —   (beatrina-names: keep)
+// host/runtime-dir.mjs); no credential is placed in a URL.
 //
 // Zero dependencies: Node >= 22 (built-in WebSocket and fetch).
 
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { createRequire } from "node:module";
 import process from "node:process";
 // `../../lib/` resolves to the repo's lib/ from tools/mcp/, and to inst/app/lib/
 // from the R package's inst/app/kernel/mcp/ — build-r-pkg.sh stages the module
@@ -30,8 +32,29 @@ import { authoringInstructions } from "../../lib/agent-authoring-contract.js";
 // agent sees and the engines the notebook accepts cannot drift. Import-free,
 // staged beside the contract by every builder for the same reason.
 import { AUTHORING_ENGINES } from "../../lib/engine-labels.js";
+import { readEnv } from "../../host/env-names.mjs";
+import { runtimeReadDirs } from "../../host/runtime-dir.mjs";
+// The product's version, from the single source of truth every other
+// distribution reads (notebook.version.cjs). Hard-coded as "0.1.0" until
+// 2026-09-18, while the product shipped 0.9.0 — the suite pins only the name,
+// so it could not say so.
+const SERVER_VERSION = (() => {
+  const req = createRequire(import.meta.url);
+  // In a checkout this file is tools/mcp/, and the version lives in
+  // notebook.version.cjs at the root. Staged, it is kernel/mcp/ and that file
+  // does NOT travel — but the generated package.json does, carrying the same
+  // number. Two layouts, one answer, and never a literal.
+  for (const from of ["../../notebook.version.cjs", "../../package.json"]) {
+    try {
+      const v = req(from).version;
+      if (v && v !== "0.1.0") return v;
+    } catch { /* the other layout */ }
+  }
+  return "0.0.0";
+})();
+
 
-const log = (...parts) => console.error("[carmar-mcp]", ...parts);
+const log = (...parts) => console.error("[beatrina-mcp]", ...parts);
 
 // MCP initialization instructions are the durable contract shared by Codex,
 // Claude Code, and any other compliant client. Keep the one-block authoring
@@ -46,8 +69,9 @@ const SERVER_INSTRUCTIONS = authoringInstructions();
 
 // ── kernel discovery ─────────────────────────────────────────────────────────
 
-const RUNTIME_DIR = process.env.CARMAR_RUNTIME_DIR
-  || path.join(os.homedir(), ".carmar", "run");
+// Current directory first, then the legacy one; an explicit
+// BEATRINA_RUNTIME_DIR (or its older spelling) is read alone.
+const RUNTIME_DIRS = runtimeReadDirs(process.env);
 
 const argUrl = (() => {
   const at = process.argv.indexOf("--url");
@@ -70,57 +94,102 @@ function wsUrlFrom(pageUrl) {
   }
 }
 
-async function healthy(host) {
+/**
+ * Ask one candidate's `/health`. THREE answers, not two: a kernel four
+ * minutes into a `check()` does not answer a socket in two seconds, and
+ * "did not answer" is not "is not there".
+ * @returns {Promise<"live"|"refused"|"unknown">}
+ *   live    — it answered `{"ok":true}`
+ *   refused — the connection was REFUSED: nothing is listening on that port
+ *   unknown — a timeout, a reset, or an answer that was not ours
+ */
+async function probeHealth(host) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 2000);
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 2000);
     const reply = await fetch(`http://${host}/health`, { signal: controller.signal });
-    clearTimeout(timer);
-    if (!reply.ok) return false;
+    if (!reply.ok) return "unknown";
     const body = await reply.json();
-    return body && body.ok === true;
-  } catch {
-    return false;
+    return body && body.ok === true ? "live" : "unknown";
+  } catch (e) {
+    // Node wraps the socket error: fetch rejects with a TypeError whose
+    // `cause` carries the errno. ECONNREFUSED is the one proof that the port
+    // is empty; an abort (the timeout) proves only that we grew impatient.
+    const code = e && e.cause && e.cause.code;
+    return code === "ECONNREFUSED" ? "refused" : "unknown";
+  } finally {
+    clearTimeout(timer);
   }
 }
 
+const healthy = async (host) => (await probeHealth(host)) === "live";
+
 /**
  * Find a live kernel: explicit env/arg first, then the runtime files newest
- * first. Files that fail the health check are STALE LITTER from a killed
- * kernel (a SIGKILL skips serve.R's cleanup) and are removed here — this
- * process owns the same user account that wrote them.
+ * first.
+ *
+ * Discovery is read-only. A failed probe never unlinks a record: the path
+ * may already hold a newer supervisor's replacement. The owning supervisor
+ * and explicit session cleanup own record removal.
+ *
+ *  · **The probes go out together.** They ran one after another, so twenty
+ *    left-behind records cost forty seconds before the first answer and the
+ *    CLI gave up first — a hang, in every way that matters to the person
+ *    waiting. The whole sweep now costs one timeout, and the newest live
+ *    kernel still wins, because the ORDER is decided before the probes are.
  */
 async function discoverKernel() {
-  const explicit = process.env.CARMAR_MCP_URL || argUrl;
+  const explicit = readEnv(process.env, "MCP_URL") || argUrl;
   if (explicit) {
     const candidate = wsUrlFrom(explicit);
     if (candidate && await healthy(candidate.host)) return candidate;
-    throw new Error(`No healthy CarmaR kernel at ${explicit}.`);
+    throw new Error(`No healthy Beatrina kernel at ${explicit}.`);
   }
-  let names = [];
-  try {
-    names = fs.readdirSync(RUNTIME_DIR).filter((name) => /^kernel-\d+\.json$/.test(name));
-  } catch {
-    names = [];
-  }
-  const files = names
-    .map((name) => {
-      const file = path.join(RUNTIME_DIR, name);
-      try { return { file, mtime: fs.statSync(file).mtimeMs }; }
-      catch { return null; }
+  const records = RUNTIME_DIRS
+    .flatMap((dir) => {
+      let names = [];
+      try { names = fs.readdirSync(dir).filter((name) => /^kernel-\d+\.json$/.test(name)); } catch { names = []; }
+      return names.map((name) => path.join(dir, name));
+    })
+    .map((file) => {
+      try {
+        const mtime = fs.statSync(file).mtimeMs;
+        const record = JSON.parse(fs.readFileSync(file, "utf8"));
+        // `JSON.parse` answers `null` for the four bytes `null`, and a number
+        // for a truncated one — neither is a record, and both reached a
+        // `record.pid` below until this line existed.
+        if (!record || typeof record !== "object") return null;
+        return { file, mtime, record, candidate: record.url ? wsUrlFrom(record.url) : null };
+      } catch {
+        // Unreadable or not JSON: a torn write, or a file that is not ours.
+        // It names no process, so nothing here can prove it dead — leave it.
+        return null;
+      }
     })
     .filter(Boolean)
     .sort((a, b) => b.mtime - a.mtime);
-  for (const { file } of files) {
-    let record = null;
-    try { record = JSON.parse(fs.readFileSync(file, "utf8")); } catch { record = null; }
-    const candidate = record && record.url ? wsUrlFrom(record.url) : null;
-    if (candidate && await healthy(candidate.host)) return candidate;
-    try { fs.unlinkSync(file); log("removed stale runtime file", file); } catch { /* not ours to force */ }
-  }
+
+  const probed = await Promise.all(records.map(async (rec) => ({
+    ...rec, state: rec.candidate ? await probeHealth(rec.candidate.host) : "unusable",
+  })));
+
+  const live = probed.find((rec) => rec.state === "live");
+  // Discovery is read-only: a record can be replaced by a newly started
+  // supervisor while /health is pending. The old PID cannot authorize
+  // deleting the new record. Record cleanup belongs to the session owner.
+
+  if (live) return live.candidate;
+
+  // The refusal NAMES the directories it read, because the one failure this
+  // sentence has actually had is a bridge looking in the wrong one: a copy
+  // built before the 2026-09-16 rename searched `~/.carmar/run` while every   (beatrina-names: keep)
+  // running session wrote `~/.beatrina/run`, reported "no kernel" with four
+  // supervisors up, and gave the person nothing to go on. A path in the
+  // refusal makes that mismatch a one-line diagnosis instead of a bug report.
   throw new Error(
-    "No running CarmaR kernel found. Start one (CarmaR.app, carmar::run(), or "
-    + "`npm run kernel`) and open the notebook it prints, then try again.");
+    `No running Beatrina kernel found (looked in ${RUNTIME_DIRS.join(", ")}). `
+    + "Start one (the `beatrina` command, the desktop app, or `npm run kernel`) "
+    + "and open the notebook it prints, then try again.");
 }
 
 // ── the kernel connection ────────────────────────────────────────────────────
@@ -233,11 +302,31 @@ async function askWorker(type, payload, timeoutMs = 30000) {
 
 // ── the tools ────────────────────────────────────────────────────────────────
 
+/**
+ * The tools this server is PERMITTED to offer, when it was told.
+ *
+ * `BEATRINA_MCP_TOOLS` is set only by the supervisor when IT spawned this
+ * server for a subscription chat turn (host/planes/mcp.mjs), and it carries
+ * the host's decision — the tool names themselves, not a level to re-derive,
+ * so the contract has one owner. An Ask turn gets the reading tools; the
+ * explicit Code grant gets the authoring ones (fix.md P1.5, where the same Ask
+ * request could insert, revise and run a chunk purely because a CLI provider
+ * was selected).
+ *
+ * UNSET means unrestricted, and that is deliberate rather than an oversight:
+ * an agent the user installed themselves (`npm run mcp:install`) is their own
+ * CLI, running as them, with the whole vocabulary — the kernel's page-only and
+ * agent-refused rules are what bound it, exactly as before.
+ */
+const PERMITTED = readEnv(process.env, "MCP_TOOLS")
+  .split(",").map((name) => name.trim()).filter(Boolean);
+const permitted = (name) => PERMITTED.length === 0 || PERMITTED.includes(String(name));
+
 const TOOLS = [
   {
-    name: "carmar_status",
+    name: "beatrina_status",
     description:
-      "Check the CarmaR connection: whether a local R kernel is running and "
+      "Check the Beatrina connection: whether a local R kernel is running and "
       + "whether a notebook window is open. Call this first when other tools fail.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     async run() {
@@ -251,7 +340,7 @@ const TOOLS = [
           summary: pages > 0
             ? `Connected: kernel at ${conn.host}, ${pages} notebook page(s) open.`
             : `The kernel at ${conn.host} is running, but NO notebook window is open — `
-              + "notebook tools will fail until the user opens CarmaR in a browser.",
+              + "notebook tools will fail until the user opens Beatrina in a browser.",
           data: { kernel: conn.host, pages },
         };
       } catch (e) {
@@ -265,15 +354,23 @@ const TOOLS = [
   {
     name: "notebook_read",
     description:
-      "Read the open CarmaR notebook: every chunk in order (address, name, "
-      + "source, latest output summary) plus which chunk is active. Chunk "
-      + "addresses like \"3\" or \"7A\" are the handles other tools accept. Each code "
-      + "chunk carries its `engine` (\"r\", \"python\", …) and `engines` lists what the "
-      + "attached session runs.",
+      "Read the open Beatrina notebook: every chunk IN DOCUMENT ORDER (address, name, "
+      + "source, latest output summary) plus which chunk is active. `number` is the "
+      + "chunk's position in the document (1 is first) — reason about execution order "
+      + "with it. An `address` like \"3\" or \"7A\" is a stable handle other tools accept; "
+      + "it survives insertion and deletion and is therefore NOT in order. `document` "
+      + "carries the notebook's own file `path` and R's `workingDirectory`, which is what "
+      + "every relative path in the code resolves against. Each chunk carries `stale` "
+      + "(its result no longer matches its source), and each code chunk its `engine`; "
+      + "`engines` lists what the attached session runs.",
     inputSchema: {
       type: "object",
       properties: {
         include_output: { type: "boolean", description: "Include each chunk's latest output summary (default true)." },
+        outline: { type: "boolean", description: "Only address, name, kind, engine, review state and output status per chunk — no source, no output text. Read a large document this way first, then fetch the chunks you need with `chunks` or chunk_read." },
+        chunks: { type: "array", items: { type: "string" }, description: "Only these chunks, by address (\"3\", \"7A\") or name; the reply lists any that do not exist under `missing`." },
+        from: { type: "string", description: "Start at this chunk (address or name), inclusive." },
+        limit: { type: "integer", minimum: 1, description: "At most this many chunks; when more remain, `next` names the address to continue from." },
       },
       additionalProperties: false,
     },
@@ -281,7 +378,7 @@ const TOOLS = [
   },
   {
     name: "chunk_read",
-    description: "Read one chunk of the notebook — its source, its engine and its latest output — by address (\"3\", \"7A\") or name.",
+    description: "Read one chunk of the notebook — its source, its engine and its latest output, INCLUDING the first rows of any table it produced — by address (\"3\", \"7A\") or name.",
     inputSchema: {
       type: "object",
       properties: { chunk: { type: "string", description: "Chunk address or name." } },
@@ -316,6 +413,12 @@ const TOOLS = [
           description: "Placement (default \"auto\": after the active chunk, else beginning).",
         },
         after: { type: "string", description: "Optional chunk address or name to place this block after." },
+        name: {
+          type: "string",
+          description: "A short name for the chunk (letters, digits, hyphens — \"load-data\"); other tools "
+            + "accept it in place of the address. Refused when another chunk already has it. Without it "
+            + "the notebook derives a name from the code's first assignment.",
+        },
         base_revision: {
           type: "string",
           description: "The `document.revisionId` from your most recent notebook_read (or the "
@@ -338,19 +441,36 @@ const TOOLS = [
       + "document is in Writing mode — R is quiet there and nothing runs, not "
       + "even for an agent; the error says so. Do not retry: ask the user to "
       + "switch the document to Develop. Reading (notebook_read, chunk_read) and "
-      + "authoring (chunk_insert, chunk_update) still work in Writing mode.",
+      + "authoring (chunk_insert, chunk_update) still work in Writing mode. "
+      + "A chunk with cache=TRUE and an unchanged source is RESTORED from knitr's "
+      + "cache, not executed — the reply says so (`cached: true`) and none of the "
+      + "chunk's side effects (setwd(), files written, seeds) happen; pass `force` "
+      + "to run it anyway. The reply also carries R's working directory (`cwd`) and, for a "
+      + "table, its first rows — not only column names and types. Give `through` to run a "
+      + "CONTIGUOUS RANGE in document order in one call, and `only_stale` to skip chunks "
+      + "whose result still matches their source. A failing chunk stops the range, because "
+      + "the chunks below it would run against a session that is not in the state they "
+      + "assume; the reply says where it stopped and how many did not run.",
     inputSchema: {
       type: "object",
       properties: {
-        chunk: { type: "string", description: "Chunk address (\"3\", \"7A\") or name." },
-        timeout_s: { type: "number", description: "Seconds to wait (default 300)." },
+        chunk: { type: "string", description: "Chunk address (\"3\", \"7A\") or name. With `through`, the FIRST chunk of the range." },
+        through: { type: "string", description: "Last chunk of a contiguous document-order range (inclusive). Omit to run one chunk. Resolved on document position, not on the addresses' spelling." },
+        only_stale: { type: "boolean", description: "Run only chunks whose result no longer matches their source (notebook_read's `stale`). Without `through`, applies from `chunk` to the end of the document." },
+        timeout_s: { type: "number", description: "Seconds to wait (default 300). For a range this is the budget for the WHOLE range." },
+        force: { type: "boolean", description: "Evaluate even when knitr holds a cached result for this chunk, and rebuild that cache (default false)." },
       },
       required: ["chunk"],
       additionalProperties: false,
     },
     run: (args) => {
       const seconds = Math.min(3600, Math.max(5, Number(args.timeout_s) || 300));
-      return askPage("chunk_run", { chunk: args.chunk }, seconds * 1000);
+      return askPage("chunk_run", {
+        chunk: args.chunk,
+        ...(args.through ? { through: args.through } : {}),
+        ...(args.only_stale === true ? { only_stale: true } : {}),
+        ...(args.force === true ? { force: true } : {}),
+      }, seconds * 1000);
     },
   },
   {
@@ -376,6 +496,61 @@ const TOOLS = [
     },
     run: (args) => askPage("chunk_update", args, 30000),
   },
+  {
+    name: "chunk_delete",
+    description:
+      "PROPOSE removing one chunk. Nothing is deleted by this call. The block stays in the "
+      + "document, struck through, and the user decides: \"Delete it\" removes it, \"Keep the "
+      + "block\" cancels the proposal. Because nothing is taken, a proposal you are unsure of "
+      + "costs the user nothing — say what it is a duplicate of in your message rather than "
+      + "replacing the chunk's code with a comment asking for a deletion. Revision-guarded: "
+      + "send `base_revision` from the most recent notebook_read.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chunk: { type: "string", description: "Chunk address (\"3\", \"7A\") or name to propose deleting." },
+        base_revision: {
+          type: "string",
+          description: "Required `document.revisionId` from the most recent notebook_read. Proposing against a stale picture of the document is refused.",
+        },
+      },
+      required: ["chunk", "base_revision"],
+      additionalProperties: false,
+    },
+    run: (args) => askPage("chunk_delete", args, 30000),
+  },
+  {
+    name: "notebook_render",
+    description:
+      "Render the notebook to a self-contained HTML file — the same report the user's own "
+      + "Knit produces, from the same builder. Use it to SEE your own output instead of "
+      + "asking the user to knit and describe it. It renders what is on screen: a chunk "
+      + "edited since it last ran is published with an out-of-date banner on its result, "
+      + "not silently as current, so pass `run: \"stale\"` (or run what you changed with chunk_run) "
+      + "when you want the report to be true. Any size: a report past the socket's limit is "
+      + "written over HTTP. Needs a connected R session, which is what writes the file.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Where to write the file, as R sees it; must end in .html. A relative path resolves against R's working directory, which notebook_read reports." },
+        format: { type: "string", enum: ["html"], description: "Output format (default \"html\"). For PDF, open the HTML and print it — the report carries its own A4 page setup." },
+        echo: { type: "boolean", description: "Include the code (default true). False renders results only. `code` supersedes it." },
+        run: { type: "string", enum: ["none", "stale", "all"], description: "What to run first, visibly in the notebook: \"none\" (default — render what is on screen), \"stale\" (chunks edited since they ran, or never run), \"all\" (every chunk; cache: true chunks are restored). The reply counts ran / cached / failed." },
+        code: { type: "string", enum: ["chunk", "show", "fold", "hide"], description: "How code appears: \"chunk\" (each chunk's echo decides — the default), \"show\", \"fold\" (collapsed, click to show), \"hide\"." },
+        toc: { type: "boolean", description: "A table of contents under the title (default: the document's own `toc:`)." },
+        number_sections: { type: "boolean", description: "Number the headings 1, 1.1 … (default: the document's own `number-sections:`)." },
+        table_rows: { type: "integer", minimum: 0, description: "Rows per table in the report (default 50); 0 = every row the notebook holds." },
+        page_width: {
+          type: "string",
+          description: "Page width: \"standard\" (1040px, a reading measure — the default), \"wide\" (1280px), \"full\" (1600px), or a CSS length such as \"1400px\". Printing scales the whole page to A4 at whichever width you choose.",
+        },
+      },
+      required: ["path"],
+      additionalProperties: false,
+    },
+    // Running every chunk first can take as long as the analysis does.
+    run: (args) => askPage("notebook_render", args, args && args.run && args.run !== "none" ? 3600000 : 120000),
+  },
   {
     name: "file_list",
     description:
@@ -422,11 +597,17 @@ const TOOLS = [
   {
     name: "file_open",
     description:
-      "Open a notebook document (.qmd, .Rmd, .md) in the CarmaR window as "
-      + "chunks. For plain reading use file_read instead.",
+      "Open a notebook document (.qmd, .Rmd, .md) in the Beatrina window as "
+      + "chunks. For plain reading use file_read instead. A document that is "
+      + "already open is only brought to the front — the window does not watch "
+      + "the file; pass `reload` after changing it on disk so the window shows "
+      + "the file as it is now.",
     inputSchema: {
       type: "object",
-      properties: { path: { type: "string", description: "Document to open in the notebook." } },
+      properties: {
+        path: { type: "string", description: "Document to open in the notebook." },
+        reload: { type: "boolean", description: "The document is already open: replace its content with the file as it is on disk now (one edit the user can Undo; the tab and its history stay). Refused while the document has unsaved changes — ask the user to save, or to use View ▸ Reload from disk themselves." },
+      },
       required: ["path"],
       additionalProperties: false,
     },
@@ -461,7 +642,7 @@ async function onRequest(msg) {
       protocolVersion: typeof params?.protocolVersion === "string"
         ? params.protocolVersion : PROTOCOL_FALLBACK,
       capabilities: { tools: {} },
-      serverInfo: { name: "carmar", version: "0.1.0" },
+      serverInfo: { name: "beatrina", version: SERVER_VERSION },
       instructions: SERVER_INSTRUCTIONS,
     });
     return;
@@ -469,13 +650,22 @@ async function onRequest(msg) {
   if (method === "ping") { reply(id, {}); return; }
   if (method === "tools/list") {
     reply(id, {
-      tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
+      tools: TOOLS.filter(({ name }) => permitted(name))
+        .map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
     });
     return;
   }
   if (method === "tools/call") {
     const tool = TOOLS.find((candidate) => candidate.name === params?.name);
     if (!tool) { replyError(id, -32602, `Unknown tool: ${params?.name}`); return; }
+    // Listing is not the gate. A client may call a name it was never offered —
+    // from its own memory of an earlier turn, or because it was told to.
+    if (!permitted(tool.name)) {
+      replyError(id, -32601, `${tool.name} is not available in this lane. This request may read the `
+        + "notebook but not change or run it; ask the user to switch to Code mode, which is where "
+        + "permission to author is given.");
+      return;
+    }
     try {
       const out = await tool.run(params?.arguments || {});
       // Page replies arrive as {ok, summary, data}; local tools return the

package/kernel/notebook-page.R

@@ -1,11 +1,11 @@
 # notebook-page.R — the ONE page a kernel of a given build serves and opens.
 #
 # The answer is a pin, never a search: a kernel stamped `<build>` belongs to
-# exactly `carmar_V<build>.html`, looked for in the two product-owned places a
+# exactly `beatrina_V<build>.html`, looked for in the two product-owned places a
 # built notebook can be (the repo's ../dist, then the folder beside kernel/ in
 # a distribution). Nothing else is eligible — not a higher version that
 # happens to sit in the same folder, not a `.beta.min` twin, not an unsigned
-# per-user download (historical releases accepted CARMAR_DIST and let one
+# per-user download (historical releases accepted BEATRINA_DIST and let one
 # replace the page executed beside a trusted kernel; a full-product update
 # replaces the installation instead, so that override is gone).
 #
@@ -20,19 +20,19 @@
 #'
 #' @param here  the directory holding serve.R (the repo's spike/, or a
 #'   distribution's kernel/ folder).
-#' @param build The kernel's stamped release identity (`CARMAR_KERNEL_BUILD`).
+#' @param build The kernel's stamped release identity (`BEATRINA_KERNEL_BUILD`).
 #'   Required and non-empty; a source checkout with no stamp at all passes
 #'   "unknown", which pins nothing and is answered with "".
-#' @return Path to `carmar_V<build>.html`, or "" when that exact file is
+#' @return Path to `beatrina_V<build>.html`, or "" when that exact file is
 #'   present in neither location.
-carmar_notebook_page <- function(here, build) {
+beatrina_notebook_page <- function(here, build) {
   stopifnot(
     "`here` must be a single directory path" =
       is.character(here) && length(here) == 1L && !is.na(here) && nzchar(here),
     "`build` must be a single non-empty string (the kernel's stamped build)" =
       is.character(build) && length(build) == 1L && !is.na(build) && nzchar(build)
   )
-  wanted <- paste0("carmar_V", build, ".html")
+  wanted <- paste0("beatrina_V", build, ".html")
   candidates <- c(file.path(here, "..", "dist", wanted), file.path(here, "..", wanted))
   present <- candidates[file.exists(candidates)]
   if (length(present) == 0L) return("")
@@ -44,7 +44,7 @@ carmar_notebook_page <- function(here, build) {
 #' Windows paths carry backslashes and a drive letter; a URL carries neither.
 #' Until 7.60 serve.R announced `paste0("file://", URLencode(normalizePath(page)))`,
 #' which on Windows is `file://C:%5CUsers%5C…` — a name no file has — and
-#' `carmar::run()` opens the kernel's announcement in preference to its own
+#' `beatrina::run()` opens the kernel's announcement in preference to its own
 #' `notebook_launch_url()`, so every Windows student saw an empty tab (issue
 #' #45, 2026-09-09, a student's pasted link). One rule for every OS: forward
 #' slashes, and `file:///` (three) when the path does not itself start with

package/kernel/project.R

@@ -2,15 +2,15 @@
 # requiring terminal commands. Pure status logic is separate from worker.R so
 # lockfile edge cases and organisation-mirror policy can be tested directly.
 
-carmar_project_or <- function(value, fallback) if (is.null(value)) fallback else value
+beatrina_project_or <- function(value, fallback) if (is.null(value)) fallback else value
 
-carmar_repository_display <- function(value) {
-  value <- as.character(carmar_project_or(value, ""))[[1L]]
+beatrina_repository_display <- function(value) {
+  value <- as.character(beatrina_project_or(value, ""))[[1L]]
   value <- sub("^([A-Za-z]+://)[^/@]+@", "\\1", value)
   sub("[?#].*$", "", value)
 }
 
-carmar_project_status <- function(path = getwd(), env = Sys.getenv,
+beatrina_project_status <- function(path = getwd(), env = Sys.getenv,
                                   installed = NULL, repos = getOption("repos"),
                                   renv_available = NULL, libraries = .libPaths()) {
   root <- normalizePath(path, winslash = "/", mustWork = FALSE)
@@ -18,12 +18,12 @@ carmar_project_status <- function(path = getwd(), env = Sys.getenv,
   has_lock <- file.exists(lockfile)
   project_files <- list.files(root, pattern = "[.]Rproj$", ignore.case = TRUE)
   has_quarto <- any(file.exists(file.path(root, c("_quarto.yml", "_quarto.yaml"))))
-  managed_raw <- trimws(env("CARMAR_CRAN_MIRROR", ""))
+  managed_raw <- trimws(env("BEATRINA_CRAN_MIRROR", ""))
   mirror_error <- if (nzchar(managed_raw) && !grepl("^https://", managed_raw))
     "The administrator's package mirror must use HTTPS." else ""
   cran <- if (length(repos) && "CRAN" %in% names(repos)) unname(repos[["CRAN"]]) else ""
   repository <- if (nzchar(managed_raw)) managed_raw else cran
-  repository <- carmar_repository_display(repository)
+  repository <- beatrina_repository_display(repository)
   if (is.null(renv_available)) renv_available <- requireNamespace("renv", quietly = TRUE)
   active_project <- trimws(env("RENV_PROJECT", ""))
   active <- nzchar(active_project) && identical(
@@ -48,7 +48,7 @@ carmar_project_status <- function(path = getwd(), env = Sys.getenv,
       } else {
         locked <- names(parsed$Packages)
         wanted <- vapply(parsed$Packages, function(record) {
-          value <- carmar_project_or(record$Version, "")
+          value <- beatrina_project_or(record$Version, "")
           if (is.character(value) && length(value) == 1L) value else ""
         }, character(1))
       }
@@ -84,15 +84,15 @@ carmar_project_status <- function(path = getwd(), env = Sys.getenv,
   )
 }
 
-carmar_project_action <- function(action, path = getwd(), env = Sys.getenv,
+beatrina_project_action <- function(action, path = getwd(), env = Sys.getenv,
                                   install = NULL, restore = NULL,
                                   available = function() requireNamespace("renv", quietly = TRUE)) {
   action <- if (is.character(action) && length(action) == 1L) action else ""
   if (!action %in% c("bootstrap", "restore")) stop("unknown project environment action")
-  state <- carmar_project_status(path = path, env = env,
+  state <- beatrina_project_status(path = path, env = env,
                                  renv_available = isTRUE(available()))
   if (nzchar(state$mirror_error)) stop(state$mirror_error)
-  managed <- trimws(env("CARMAR_CRAN_MIRROR", ""))
+  managed <- trimws(env("BEATRINA_CRAN_MIRROR", ""))
   repos <- getOption("repos")
   if (nzchar(managed)) repos <- c(CRAN = managed)