@mmerterden/multi-agent-pipeline 20.30.0 → 20.33.0

package/pipeline/scripts/office-build.mjs

@@ -8,7 +8,10 @@
  * strings.json) and this script inlines them into
  * pipeline/office/index.html: the list of sprite names in pipeline/office/assets
  * (served by contract-server.mjs at /office/assets/), the strings as a JSON
- * literal, the two code files in order inside one IIFE.
+ * literal, the two code files in order inside one IIFE. It also renders the
+ * pixel grids in pipeline/office-art into PNG sprites in pipeline/office/assets
+ * and writes pipeline/office/toolkit.json, the toolkit version shipped with
+ * the page; --check holds all three to their sources.
  *
  *   node pipeline/scripts/office-build.mjs          write the page
  *   node pipeline/scripts/office-build.mjs --check  exit 1 when the page on
@@ -16,7 +19,9 @@
  *                                                   sources build to
  */
 
+import { createHash } from "node:crypto";
 import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { deflateSync } from "node:zlib";
 import { basename, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
@@ -24,8 +29,94 @@ const ROOT = join(import.meta.dirname, "..");
 const SRC = join(ROOT, "office-src");
 const OUT = join(ROOT, "office", "index.html");
 const ASSETS = join(ROOT, "office", "assets");
+const TOOLKIT = join(ROOT, "office", "toolkit.json");
+const ART = join(ROOT, "office-art");
+const FACTS = join(ROOT, "..", "docs", "facts.json");
 const PNG_SIGNATURE = "89504e470d0a1a0a";
 
+// --- the project's own sprites -----------------------------------------------
+// Each office-art/<NAME>.txt is a "size WxH" line and H rows of W letters, one
+// letter per pixel from office-art/palette.json, "." transparent. They are
+// encoded here into office/assets/<NAME>.png byte for byte the same each time
+// (no timestamp, fixed compression), so --check can hold the PNGs to their
+// text and a review reads the drawing as a diff.
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (const b of buf) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(body));
+  return Buffer.concat([len, body, crc]);
+}
+/** An RGBA PNG, unfiltered rows, zlib level 9. */
+export function encodePng(width, height, rgba) {
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;
+  header[9] = 6;
+  const raw = Buffer.alloc((width * 4 + 1) * height);
+  for (let y = 0; y < height; y++) {
+    rgba.copy(raw, y * (width * 4 + 1) + 1, y * width * 4, (y + 1) * width * 4);
+  }
+  return Buffer.concat([
+    Buffer.from(PNG_SIGNATURE, "hex"),
+    chunk("IHDR", header),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+/** One art file as a PNG; throws on a size line, row length or letter that does not fit. */
+export function renderArt(text, colors, name = "sprite") {
+  const lines = text.replace(/\r/g, "").trimEnd().split("\n");
+  const m = /^size (\d{1,3})x(\d{1,3})$/.exec(lines[0] ?? "");
+  if (!m) throw new Error(`${name}: the first line is "size WxH"`);
+  const [w, h] = [Number(m[1]), Number(m[2])];
+  const rows = lines.slice(1);
+  if (rows.length !== h) throw new Error(`${name}: ${rows.length} rows, expected ${h}`);
+  const rgba = Buffer.alloc(w * h * 4);
+  rows.forEach((row, y) => {
+    if (row.length !== w)
+      throw new Error(`${name}: row ${y + 1} is ${row.length} wide, expected ${w}`);
+    [...row].forEach((ch, x) => {
+      if (ch === ".") return;
+      const hex = colors[ch];
+      if (!hex) throw new Error(`${name}: "${ch}" is not in the palette`);
+      const o = (y * w + x) * 4;
+      rgba[o] = parseInt(hex.slice(0, 2), 16);
+      rgba[o + 1] = parseInt(hex.slice(2, 4), 16);
+      rgba[o + 2] = parseInt(hex.slice(4, 6), 16);
+      rgba[o + 3] = 255;
+    });
+  });
+  return encodePng(w, h, rgba);
+}
+
+/** Every art sprite, name -> PNG bytes. */
+export function artSprites() {
+  const { colors } = JSON.parse(readFileSync(join(ART, "palette.json"), "utf8"));
+  const out = new Map();
+  for (const f of readdirSync(ART).sort()) {
+    if (!f.endsWith(".txt")) continue;
+    const name = basename(f, ".txt");
+    if (!/^[A-Z0-9_]{1,48}$/.test(name)) throw new Error(`${f}: sprite names are A-Z, 0-9 and _`);
+    out.set(name, renderArt(readFileSync(join(ART, f), "utf8"), colors, name));
+  }
+  return out;
+}
+
 // The sprite names the page may load from /office/assets/: every PNG beside
 // the page, checked to be one.
 function atlas() {
@@ -41,6 +132,20 @@ function atlas() {
   return out;
 }
 
+/**
+ * The toolkit version the office's Tools window starts, shipped beside the
+ * page: the version this release was checked against, from docs/facts.json.
+ * The host runs the toolkit as @latest; the panel only runs an exact version,
+ * and every pipeline update brings the newer one with it.
+ */
+export function toolkitDoc() {
+  const v = JSON.parse(readFileSync(FACTS, "utf8")).toolkitVersion;
+  if (typeof v !== "string" || !/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(v)) {
+    throw new Error("docs/facts.json carries no exact toolkitVersion");
+  }
+  return JSON.stringify({ toolkitVersion: v }, null, 2) + "\n";
+}
+
 export function build() {
   const read = (f) => readFileSync(join(SRC, f), "utf8");
   const strings = JSON.parse(read("strings.json"));
@@ -56,6 +161,12 @@ export function build() {
     "})();",
   ].join("\n");
   const style = read("style.css").trim();
+  // The build id the server reads back from the installed page: the page
+  // compares it with its own to tell that a newer one has been installed.
+  const hash = createHash("sha256").update(script).update(style).update(read("shell.html"));
+  // Redrawn sprites change the page too, though no source text did.
+  for (const [name, png] of artSprites()) hash.update(name).update(png);
+  const build = hash.digest("hex").slice(0, 12);
   // Text that would close the inline element early, or open an HTML comment
   // inside it, turns source into markup.
   if (/<\/script|<!--/i.test(script)) throw new Error("the script contains </script or <!--");
@@ -64,26 +175,52 @@ export function build() {
   for (const marker of ["/*STYLE*/", "/*SCRIPT*/"]) {
     if (shell.split(marker).length !== 2) throw new Error(`shell.html needs exactly one ${marker}`);
   }
-  return shell.replace("/*STYLE*/", () => style).replace("/*SCRIPT*/", () => script);
+  const stamped = script.replace('"use strict";', () => `"use strict";\nconst BUILD = "${build}";`);
+  return shell.replace("/*STYLE*/", () => style).replace("/*SCRIPT*/", () => stamped);
 }
 
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
 if (isMain) {
+  const art = artSprites();
+  const check = process.argv.includes("--check");
+  if (!check) for (const [name, png] of art) writeFileSync(join(ASSETS, `${name}.png`), png);
   const html = build();
-  if (process.argv.includes("--check")) {
-    let current = "";
-    try {
-      current = readFileSync(OUT, "utf8");
-    } catch {
-      // A missing page is stale by definition.
+  const toolkit = toolkitDoc();
+  if (check) {
+    for (const [name, png] of art) {
+      let on = null;
+      try {
+        on = readFileSync(join(ASSETS, `${name}.png`));
+      } catch {
+        // Missing is stale.
+      }
+      if (!on || !on.equals(png)) {
+        console.error(
+          `office/assets/${name}.png is stale: run node pipeline/scripts/office-build.mjs`,
+        );
+        process.exit(1);
+      }
     }
-    if (current !== html) {
+    const read = (f) => {
+      try {
+        return readFileSync(f, "utf8");
+      } catch {
+        // A missing file is stale by definition.
+        return "";
+      }
+    };
+    if (read(OUT) !== html) {
       console.error("office/index.html is stale: run node pipeline/scripts/office-build.mjs");
       process.exit(1);
     }
-    console.log("office/index.html matches its sources");
+    if (read(TOOLKIT) !== toolkit) {
+      console.error("office/toolkit.json is stale: run node pipeline/scripts/office-build.mjs");
+      process.exit(1);
+    }
+    console.log("office/index.html and office/toolkit.json match their sources");
   } else {
     writeFileSync(OUT, html);
-    console.log(`wrote ${OUT} (${Buffer.byteLength(html)} bytes)`);
+    writeFileSync(TOOLKIT, toolkit);
+    console.log(`wrote ${OUT} (${Buffer.byteLength(html)} bytes) and ${TOOLKIT}`);
   }
 }

package/pipeline/scripts/office-control.mjs

@@ -6,7 +6,7 @@
  *
  *   on [--no-open]   start contract-server.mjs in the background with the
  *                    installed panel page (../office/index.html, passed as
- *                    MA_OFFICE_PAGE) and an 8 hour lifetime, or reuse the one this script
+ *                    MA_OFFICE_PAGE), running until `off`, or reuse the one this script
  *                    started if it is still alive, then open the browser at
  *                    /office with a one-time code in the URL fragment,
  *                    through a 0600 launcher file so the code is never on a
@@ -30,8 +30,8 @@
  *                    script only reports it; it carries no remote code.
  *
  * State: one 0600 file, ~/.claude/logs/multi-agent/office/office.json, with
- * the pid, port and token file of the server this script started. Nothing runs
- * while the panel is closed: the server exits by itself after its idle time.
+ * the pid, port and token file of the server this script started. The server
+ * runs until office-off stops it; no daemon, hook or watcher runs beside it.
  *
  * Usage:
  *   office-control.mjs on [--no-open] [--json]
@@ -56,11 +56,16 @@ import {
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+
+import { codeDigest } from "../lib/code-digest.mjs";
 import { fileURLToPath } from "node:url";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const IDLE_MINUTES = 15;
-const MAX_HOURS = 8;
+// The panel runs until office-off: no idle stop and no lifetime, because a
+// person keeps it open beside their work. The server still binds 127.0.0.1
+// only, and every office-on that starts one mints a new token.
+const IDLE_MINUTES = 0;
+const MAX_HOURS = 0;
 /** How far a process's start may sit before its token file's startedAt. */
 const START_SKEW_MS = 120 * 1000;
 
@@ -248,10 +253,23 @@ function openBrowser(target, env) {
   return r.status === 0;
 }
 
-/** Start (or reuse) the panel server and open the browser. */
+const digestOf = (server) => (server ? codeDigest(dirname(server)) : null);
+
+/**
+ * Start (or reuse) the panel server and open the browser. A running server
+ * whose code on disk has changed since it started (an update installed a new
+ * pipeline) is stopped and a new one started, so the panel never runs on a
+ * server older than its page.
+ */
 export async function officeOn({ env = process.env, open = true } = {}) {
   let s = current(env);
   let reused = true;
+  let restarted = false;
+  if (s && s.serverDigest && s.serverDigest !== digestOf(serverScript(env))) {
+    officeOff({ env });
+    s = null;
+    restarted = true;
+  }
   if (!s) {
     reused = false;
     const server = serverScript(env);
@@ -289,13 +307,22 @@ export async function officeOn({ env = process.env, open = true } = {}) {
       idleMinutes: info.idleMinutes,
       maxHours: info.maxHours ?? null,
       startedAt: new Date().toISOString(),
+      serverDigest: digestOf(server),
     });
     s = current(env);
     if (!s) throw new Error("the server stopped right after it started");
   }
   const page = `${s.url}/office`;
   const opened = open ? openBrowser(`${page}#code=${await panelCode(s)}`, env) : false;
-  return { running: true, reused, url: page, pid: s.pid, idleMinutes: s.idleMinutes, opened };
+  return {
+    running: true,
+    reused,
+    restarted,
+    url: page,
+    pid: s.pid,
+    idleMinutes: s.idleMinutes,
+    opened,
+  };
 }
 
 /** Stop the server this script started. */

package/pipeline/scripts/office-credentials.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * @file office-credentials.mjs  -  the key cabinet: which services the pipeline
+ * holds a credential for and whether each one works, never a value.
+ *
+ * The answer comes from lib/credential-inventory.sh, the same inventory a run
+ * consults before asking the user for data an external system holds. That
+ * script probes a credential through the credential store with stdout
+ * discarded, so a secret never reaches this process; this file keeps only the
+ * logical name, the state, the probe verdict and what the credential is for,
+ * each checked against a fixed vocabulary.
+ *
+ * Renewing a credential stays in the terminal (`/multi-agent:setup`): the
+ * secret never passes through the browser.
+ *
+ * Usage:
+ *   office-credentials.mjs [--json] [--probe]
+ *
+ * Exit: 0 printed, 2 usage.
+ *
+ * @module pipeline/scripts/office-credentials
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
+import { spawnAsync } from "./_spawn-async.mjs";
+
+export const CONTRACT_VERSION = "1.0.0";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const STATES = new Set(["present", "mapped-but-missing", "unmapped"]);
+const REACH = new Set([
+  "not-probed",
+  "reachable",
+  "auth-rejected",
+  "unreachable",
+  "no-host-configured",
+  "well-formed",
+  "not-probeable",
+  "malformed",
+  "no-credential",
+  "probe-error",
+  "server-error",
+  "tier-1-ready",
+  "tier-2-ready",
+  "tier-1-no-grant",
+]);
+const NAME = /^[a-z][a-z0-9_]{0,60}$/;
+
+function inventoryPath(env) {
+  if (env.MA_CREDENTIAL_INVENTORY) return env.MA_CREDENTIAL_INVENTORY;
+  for (const p of [join(HERE, "..", "lib", "credential-inventory.sh")]) if (existsSync(p)) return p;
+  return null;
+}
+
+export async function officeCredentials({ probe = false, env = process.env } = {}) {
+  const script = inventoryPath(env);
+  const base = {
+    contractVersion: CONTRACT_VERSION,
+    generatedAt: new Date().toISOString(),
+    probed: probe,
+  };
+  if (!script) return { ...base, available: false, credentials: [] };
+  const r = await spawnAsync("bash", [script, "--json", ...(probe ? ["--probe"] : [])], {
+    env,
+    timeoutMs: probe ? 45000 : 10000,
+  });
+  const doc = (() => {
+    try {
+      return JSON.parse(r.stdout || "");
+    } catch {
+      return null;
+    }
+  })();
+  const rows = Array.isArray(doc?.credentials) ? doc.credentials : [];
+  return {
+    ...base,
+    available: Boolean(doc),
+    credentials: rows
+      .filter((c) => typeof c?.logical === "string" && NAME.test(c.logical))
+      .map((c) => ({
+        logical: c.logical,
+        state: STATES.has(c.state) ? c.state : "mapped-but-missing",
+        // A verdict this file does not know is reported as unknown, never as
+        // not checked: a probe that ran said something.
+        reachability: REACH.has(c.reachability) ? c.reachability : probe ? "unknown" : "not-probed",
+        capability: typeof c.capability === "string" ? c.capability.slice(0, 160) : null,
+      })),
+  };
+}
+
+if (invokedDirectly(import.meta.url)) {
+  const args = process.argv.slice(2);
+  if (args.some((a) => a !== "--json" && a !== "--probe")) {
+    console.error("usage: office-credentials.mjs [--json] [--probe]");
+    process.exit(2);
+  }
+  const doc = await officeCredentials({ probe: args.includes("--probe") });
+  process.stdout.write(
+    args.includes("--json")
+      ? JSON.stringify(doc) + "\n"
+      : doc.credentials.map((c) => `${c.logical}: ${c.state}, ${c.reachability}`).join("\n") + "\n",
+  );
+}

package/pipeline/scripts/office-memory.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * @file office-memory.mjs  -  what the pipeline has learned, per repository.
+ *
+ * The learning loop writes four stores, and this reads them without changing
+ * any:
+ *
+ *   code graph      ~/.claude/knowledge/<repo>/code-graph.json (graph-build.mjs)
+ *   learnings       ~/.claude/memory/multi-agent/<repo>/learnings-ledger.jsonl
+ *                   (learnings-ledger.mjs: durable facts, conventions, rejected
+ *                   preferences replayed into later runs)
+ *   past findings   .../triage-corpus.jsonl (triage-memory.mjs: review findings)
+ *   session notes   .../session-notes.jsonl (learn-from-transcripts.mjs)
+ *
+ * For each repository: when the graph was built and how large it is, how many
+ * learnings, findings and session notes there are, the newest learnings'
+ * statements (redacted and cut short) and when anything was last written. An
+ * empty shelf is reported as empty, so a repository the loop never fed shows.
+ *
+ * Usage:
+ *   office-memory.mjs [--json]
+ *
+ * MA_MEMORY_ROOT and MA_KNOWLEDGE_ROOT override the two roots. Each store is
+ * read asynchronously: lines are counted in chunks and only the last
+ * MAX_BYTES are parsed, so a store that keeps growing never blocks the server.
+ *
+ * Exit: 0 printed, 2 usage.
+ *
+ * @module pipeline/scripts/office-memory
+ */
+
+import { constants, createReadStream, existsSync, readdirSync, statSync } from "node:fs";
+import { open } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
+import { createRedactor } from "./transcript-index.mjs";
+
+export const CONTRACT_VERSION = "1.0.0";
+const MAX_REPOS = 60;
+const RECENT = 5;
+const REPO = /^[A-Za-z0-9._-]{1,100}$/;
+const MAX_BYTES = 1024 * 1024;
+
+const roots = (env) => ({
+  memory: env.MA_MEMORY_ROOT || join(homedir(), ".claude", "memory", "multi-agent"),
+  knowledge: env.MA_KNOWLEDGE_ROOT || join(homedir(), ".claude", "knowledge"),
+});
+
+const dirsOf = (root) => {
+  try {
+    return readdirSync(root, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && REPO.test(d.name))
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+};
+
+// A line that is not a JSON object is skipped like an unreadable one.
+const parse = (line) => {
+  try {
+    const v = JSON.parse(line);
+    return v && typeof v === "object" && !Array.isArray(v) ? [v] : [];
+  } catch {
+    return [];
+  }
+};
+
+// A store's lines, the same way for a small file read whole and a large one
+// counted in chunks: every newline, and a last line that has none.
+function linesIn(buf) {
+  let n = 0;
+  for (let i = buf.indexOf(10); i !== -1; i = buf.indexOf(10, i + 1)) n++;
+  return n + (buf.length && buf[buf.length - 1] !== 10 ? 1 : 0);
+}
+
+// Counted through the handle already open, so the count is of the same file.
+async function countLines(fh, size) {
+  let n = 0;
+  let last = 10;
+  const stream = createReadStream(null, { fd: fh.fd, start: 0, end: size - 1, autoClose: false });
+  for await (const chunk of stream) {
+    for (let i = chunk.indexOf(10); i !== -1; i = chunk.indexOf(10, i + 1)) n++;
+    if (chunk.length) last = chunk[chunk.length - 1];
+  }
+  return n + (size > 0 && last !== 10 ? 1 : 0);
+}
+
+/**
+ * A store's line count and its last lines parsed (unreadable lines skipped);
+ * { count: 0, tail: [] } for no file. Only the last `maxBytes` are parsed.
+ */
+async function store(path, maxBytes) {
+  let fh;
+  try {
+    // Non-blocking and not through a link: a FIFO or a symlink planted in a
+    // store's place is skipped instead of holding a worker thread.
+    fh = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+    const st = await fh.stat();
+    if (!st.isFile()) return { count: 0, tail: [] };
+    const { size } = st;
+    const start = Math.max(0, size - maxBytes);
+    const buf = Buffer.alloc(size - start);
+    await fh.read(buf, 0, buf.length, start);
+    let text = buf.toString("utf8");
+    if (start > 0) text = text.slice(text.indexOf("\n") + 1);
+    const lines = text.split("\n").filter(Boolean);
+    const count = start > 0 ? await countLines(fh, size) : linesIn(buf);
+    return { count, tail: lines.flatMap(parse) };
+  } catch {
+    return { count: 0, tail: [] };
+  } finally {
+    await fh?.close();
+  }
+}
+
+const ms = (v) => {
+  const t = Date.parse(v ?? "");
+  return Number.isFinite(t) ? t : null;
+};
+const iso = (t) => (t === null ? null : new Date(t).toISOString());
+
+async function shelf(name, r, now, R, maxBytes) {
+  const dir = join(r.memory, name);
+  const graphPath = join(r.knowledge, name, "code-graph.json");
+  let graph = null;
+  if (existsSync(graphPath)) {
+    const st = statSync(graphPath);
+    graph = {
+      builtAt: iso(st.mtimeMs),
+      ageDays: Math.max(0, Math.floor((now - st.mtimeMs) / 86_400_000)),
+      sizeKb: Math.round(st.size / 1024),
+    };
+  }
+  const [learnings, findings, notes] = await Promise.all(
+    ["learnings-ledger.jsonl", "triage-corpus.jsonl", "session-notes.jsonl"].map((f) =>
+      store(join(dir, f), maxBytes),
+    ),
+  );
+  const times = [...learnings.tail, ...findings.tail, ...notes.tail]
+    .map((x) => ms(x.ts))
+    .filter((t) => t !== null);
+  if (graph) times.push(ms(graph.builtAt));
+  return {
+    repo: name,
+    graph,
+    learnings: learnings.count,
+    findings: findings.count,
+    sessionNotes: notes.count,
+    recent: learnings.tail
+      .slice(-RECENT)
+      .reverse()
+      .map((x) => ({
+        kind: typeof x.kind === "string" ? x.kind.slice(0, 30) : null,
+        statement: R.excerpt(String(x.statement ?? ""), 120) ?? "",
+        at: iso(ms(x.ts)),
+      })),
+    lastWrite: times.length ? iso(Math.max(...times)) : null,
+  };
+}
+
+export async function officeMemory({
+  env = process.env,
+  now = Date.now(),
+  maxBytes = MAX_BYTES,
+} = {}) {
+  const r = roots(env);
+  // The transcript redactor: credentials by provider rule as well as paths
+  // and addresses, the same pass the activity view uses.
+  const R = createRedactor();
+  const names = [...new Set([...dirsOf(r.memory), ...dirsOf(r.knowledge)])];
+  // One shelf that cannot be read is left out; the others still answer.
+  const read = await Promise.all(names.map((n) => shelf(n, r, now, R, maxBytes).catch(() => null)));
+  const shelves = read
+    .filter(Boolean)
+    .sort((a, b) => (b.lastWrite ?? "").localeCompare(a.lastWrite ?? ""))
+    .slice(0, MAX_REPOS);
+  return { contractVersion: CONTRACT_VERSION, generatedAt: new Date(now).toISOString(), shelves };
+}
+
+if (invokedDirectly(import.meta.url)) {
+  const args = process.argv.slice(2);
+  if (args.some((a) => a !== "--json")) {
+    console.error("usage: office-memory.mjs [--json]");
+    process.exit(2);
+  }
+  const doc = await officeMemory();
+  process.stdout.write(
+    args.includes("--json")
+      ? JSON.stringify(doc) + "\n"
+      : doc.shelves
+          .map(
+            (s) =>
+              `${s.repo}: graph ${s.graph ? s.graph.ageDays + "d old" : "none"}, ${s.learnings} learnings, ${s.findings} findings, ${s.sessionNotes} notes`,
+          )
+          .join("\n") + "\n",
+  );
+}