pi-weave 0.1.7 → 0.1.8

package/src/core/view/links.ts

@@ -0,0 +1,105 @@
+/**
+ * Link and tag derivations over vault/graph data (weave-workspace §3, §4.3).
+ */
+
+import type { GraphEdge } from "../graph/model";
+import type { NoteMeta } from "../types";
+
+/** Map each node id → its incoming `links-to` sources (backlinks). */
+export function deriveBacklinks(edges: readonly GraphEdge[]): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  for (const e of edges) {
+    if (e.kind !== "links-to") continue;
+    const list = out.get(e.target);
+    if (list) list.push(e.source);
+    else out.set(e.target, [e.source]);
+  }
+  return out;
+}
+
+/**
+ * One tag and every note carrying it (weave-workspace §4.3).
+ *
+ * `slugs` rather than node ids: `note:` is a graph-internal prefix, and every
+ * consumer of this index — the note column's tag chips, `GraphPayload.tags` —
+ * addresses notes by slug.
+ */
+export interface TagIndex {
+  tag: string;
+  slugs: string[];
+}
+
+/**
+ * The minimum a note has to expose to be tag-indexed: its identity and its
+ * tags.
+ *
+ * Declared structurally instead of taking `NoteSummary` outright so the
+ * function accepts a `Note` (which has a `body` and no `bodyLength`) just as
+ * happily as a `NoteSummary`. §4.3 specifies `NoteSummary[]`; this is that
+ * signature widened to its actual requirement rather than narrowed past it,
+ * and `NoteSummary` still satisfies it exactly.
+ */
+export type TaggedNote = Pick<NoteMeta, "tags"> & { slug: string };
+
+/**
+ * Invert `note → tags` into `tag → notes` (weave-workspace §4.3).
+ *
+ * ## Why this takes notes and not a `GraphModel`
+ *
+ * The obvious alternative is deriving from the graph, since every other
+ * function in this directory does. It is the wrong source here, and the
+ * reason is worth stating because "derive everything from the graph" is
+ * otherwise a good rule.
+ *
+ * `buildGraph` flattens tags into `detail.tags`, a comma-joined **display**
+ * string (`build.ts`: `note.tags.join(", ")`). Recovering an array from it
+ * means splitting on `", "` — which is re-parsing a display string into
+ * structure, precisely what §4.2/§4.3 forbid `detail` from being used for,
+ * and it is lossy besides: a tag containing a comma round-trips wrong, and
+ * the tag is simply absent when a note has none. The alternative is to make
+ * `GraphNode` carry a real `tags: string[]` alongside the display string,
+ * which puts the same fact on the node twice and grows the wire model for
+ * every note whether or not anything reads it.
+ *
+ * Notes are the upstream source of truth. Both callers already hold them —
+ * `buildCurrentGraph` and `WorkspaceCache` each read the vault before they
+ * build a graph — so deriving here costs no extra I/O and keeps one
+ * representation of a tag: the array on the note. The graph's display string
+ * stays a projection of that, never an input to it.
+ *
+ * ## Ordering
+ *
+ * Count descending, then tag ascending, per §4.3 — the popular tags surface
+ * first and ties are alphabetical rather than insertion-ordered. Each `slugs`
+ * list is sorted ascending too, so the whole structure is a pure function of
+ * the tag/slug *set*: two vaults with the same tags in a different note order
+ * produce byte-identical JSON, which is what lets this ride the ETag.
+ *
+ * The tiebreak is **codepoint** order, not `localeCompare`, which is the one
+ * place this file departs from the habit elsewhere in core. `localeCompare`
+ * reads the host's default locale and the runtime's ICU build — a Node
+ * compiled with small-icu can order `"Arch"` against `"arch"` differently
+ * from one with full-icu. Everywhere else that is a cosmetic difference in a
+ * list a human is about to read; here the output is hashed into a cache key
+ * (§5.3), so an ordering that varies by machine is a correctness bug rather
+ * than a preference. Codepoint order is total, locale-free and matches the
+ * bare `.sort()` used for `slugs` just below.
+ *
+ * Duplicate tags within one note collapse (front matter is hand-editable and
+ * `tags: [a, a]` is a typo, not two memberships).
+ */
+export function deriveTagIndex(notes: readonly TaggedNote[]): TagIndex[] {
+  const bySlug = new Map<string, Set<string>>();
+  for (const note of notes) {
+    for (const tag of note.tags) {
+      const slugs = bySlug.get(tag);
+      if (slugs) slugs.add(note.slug);
+      else bySlug.set(tag, new Set([note.slug]));
+    }
+  }
+  return [...bySlug]
+    .map(([tag, slugs]): TagIndex => ({ tag, slugs: [...slugs].sort() }))
+    // Tags come from a Map's keys, so no two are equal and the comparator
+    // never needs to return 0 for the tiebreak — `< ? -1 : 1` is total here.
+    .sort((a, b) => b.slugs.length - a.slugs.length || (a.tag < b.tag ? -1 : 1));
+}

package/src/core/view/time.ts

@@ -0,0 +1,47 @@
+/**
+ * Time formatting for the portable view-models (weave-workspace §3).
+ */
+
+import type { TreeMeta } from "./types";
+
+/** Relative human time, mirroring the page's `relTime`. `now` is epoch ms. */
+export function relTime(iso: string | undefined, now: number): string {
+  if (!iso) return "";
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return "";
+  const s = Math.max(0, Math.floor((now - t) / 1000));
+  if (s < 60) return "just now";
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  if (d < 30) return `${d}d ago`;
+  const mo = Math.floor(d / 30);
+  if (mo < 12) return `${mo}mo ago`;
+  return `${Math.floor(mo / 12)}y ago`;
+}
+
+/** Short-sha length used when abbreviating a commit for display. */
+const SHORT_SHA_LEN = 7;
+
+/**
+ * Render a `TreeMeta` as a single plain-text annotation.
+ *
+ * This reproduces the strings the TUI printed when `TreeRow.meta` was itself a
+ * string, so terminal output is unchanged by the structuring. Richer renderers
+ * (the browser workspace) should switch on the union instead of calling this.
+ */
+export function formatTreeMeta(meta: TreeMeta, now: number): string {
+  if (meta === null) return "";
+  switch (meta.kind) {
+    case "relTime":
+      return relTime(meta.iso, now);
+    case "count":
+      return meta.phrasing === "attribute" ? `${meta.unit}=${meta.n}` : `${meta.n} ${meta.unit}`;
+    case "commit":
+      return meta.sha.slice(0, SHORT_SHA_LEN);
+    case "text":
+      return meta.text;
+  }
+}

package/src/core/view/tree.ts

@@ -0,0 +1,269 @@
+/**
+ * treeRows — the portable Explore/tree view-model (weave-workspace §3).
+ *
+ * Ported 1:1 from the retired browser page's `listTree`. Pure: it takes a
+ * `GraphModel` plus a `TreeState` and returns rows. No renderer concepts —
+ * no widths, no truncation, no escape codes. Both the TUI and the browser
+ * workspace build their tree column from this.
+ */
+
+import type { GraphModel, GraphNode, NodeKind } from "../graph/model";
+import type { NoteSource } from "../types";
+import type { SelectableRow, TreeMeta } from "./types";
+
+/** One row in the Explore tree. */
+export interface TreeRow extends SelectableRow {
+  depth: number;
+  hasKids: boolean;
+  expanded: boolean;
+  label: string;
+  kind: NodeKind;
+  provenance: NoteSource | null;
+  /** Structured trailing annotation; renderers format it (see formatTreeMeta). */
+  meta: TreeMeta;
+}
+
+export interface TreeState {
+  /** Expanded node ids (when no filter is active). */
+  expanded: ReadonlySet<string>;
+  /** Reveal repo plumbing (gitState/external/package/entryPoint). */
+  showInternals: boolean;
+  /** Provenance filter (null = all). */
+  provFilter: NoteSource | null;
+  /** Substring filter on node labels (case-insensitive). */
+  query: string;
+}
+
+/** Disambiguate labels that would otherwise read as the same entry twice
+ *  (a remote URL whose tail matches the repo name, an npm package named
+ *  after the repo). Mirrors the page's `listLabel`. */
+export function listLabel(node: GraphNode): string {
+  if (node.kind === "external" && node.detail.url) {
+    const u = node.detail.url
+      .replace(/^[a-z]+:\/\//, "")
+      .replace(/^[^@\/]+@/, "")
+      .replace(/\.git$/, "")
+      .replace(/\/+$/, "");
+    if (u) return u;
+  }
+  if (node.kind === "package" && node.detail.manifest) {
+    return `${node.label} (${node.detail.manifest})`;
+  }
+  return node.label;
+}
+
+/** Build the contains/anchored-at nesting + entry-point-to-module map. */
+interface TreeIndex {
+  byId: Map<string, GraphNode>;
+  /** strict contains (used for entry-point → module placement). */
+  contains: Map<string, string[]>;
+  /** contains + anchored-at (the nesting hierarchy). */
+  tree: Map<string, string[]>;
+  /** node id → true when it has an incoming contains/anchored-at edge. */
+  incoming: Set<string>;
+  /** module id → entry-point ids nested under it (by path prefix). */
+  moduleEntries: Map<string, string[]>;
+  /** roots (nodes with no incoming edge), in node-input order. */
+  roots: string[];
+}
+
+function indexTree(model: GraphModel): TreeIndex {
+  const byId = new Map<string, GraphNode>();
+  for (const n of model.nodes) byId.set(n.id, n);
+
+  const contains = new Map<string, string[]>();
+  const tree = new Map<string, string[]>();
+  const incoming = new Set<string>();
+  for (const e of model.edges) {
+    if (e.kind === "contains") {
+      const list = contains.get(e.source);
+      if (list) list.push(e.target);
+      else contains.set(e.source, [e.target]);
+    }
+    if (e.kind === "contains" || e.kind === "anchored-at") {
+      const list = tree.get(e.source);
+      if (list) list.push(e.target);
+      else tree.set(e.source, [e.target]);
+      incoming.add(e.target);
+    }
+  }
+
+  // Entry points nest under the module whose path is the entry's directory prefix.
+  // The caller only invokes this for entryPoint nodes, so the path guard suffices.
+  const moduleFor = (entry: GraphNode): string | null => {
+    if (!entry.detail.path) return null;
+    const p = entry.detail.path;
+    let best: string | null = null;
+    let bestLen = 0;
+    const repoKids = contains.get("repository") ?? [];
+    for (const cid of repoKids) {
+      const c = byId.get(cid);
+      if (c && c.kind === "module" && c.detail.path) {
+        const mp = c.detail.path;
+        if (p.startsWith(mp + "/") && mp.length > bestLen) {
+          best = cid;
+          bestLen = mp.length;
+        }
+      }
+    }
+    return best;
+  };
+
+  const moduleEntries = new Map<string, string[]>();
+  for (const n of model.nodes) {
+    if (n.kind !== "entryPoint") continue;
+    const m = moduleFor(n);
+    if (m) {
+      const list = moduleEntries.get(m);
+      if (list) list.push(n.id);
+      else moduleEntries.set(m, [n.id]);
+    }
+  }
+
+  const roots = model.nodes.filter((n) => !incoming.has(n.id)).map((n) => n.id);
+  return { byId, contains, tree, incoming, moduleEntries, roots };
+}
+
+/** The roots of a graph (nodes with no incoming contains/anchored-at edge). */
+export function graphRoots(model: GraphModel): string[] {
+  const incoming = new Set<string>();
+  for (const e of model.edges) {
+    if (e.kind === "contains" || e.kind === "anchored-at") incoming.add(e.target);
+  }
+  return model.nodes.filter((n) => !incoming.has(n.id)).map((n) => n.id);
+}
+
+/** Knowledge-first default: hide repo plumbing unless showInternals. */
+function hiddenInternalKind(kind: NodeKind): boolean {
+  return kind === "gitState" || kind === "external" || kind === "package" || kind === "entryPoint";
+}
+
+function sortKids(ids: string[], byId: Map<string, GraphNode>): string[] {
+  return ids
+    .slice()
+    .sort((a, b) => {
+      const la = listLabel(byId.get(a)!);
+      const lb = listLabel(byId.get(b)!);
+      return la.localeCompare(lb);
+    });
+}
+
+/** A `count` meta when the detail value is numeric, else a verbatim `text`
+ *  meta — so a hand-built or corrupt graph still displays what it holds. */
+function countMeta(raw: string, unit: string, phrasing: "attribute" | "prose"): TreeMeta {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    return { kind: "text", text: phrasing === "attribute" ? `${unit}=${raw}` : `${raw} ${unit}` };
+  }
+  return { kind: "count", n, unit, phrasing };
+}
+
+function metaFor(node: GraphNode): TreeMeta {
+  switch (node.kind) {
+    case "note":
+      return node.detail.updated ? { kind: "relTime", iso: node.detail.updated } : null;
+    case "module":
+      return node.detail.files ? countMeta(node.detail.files, "files", "attribute") : null;
+    case "gitState":
+      return node.detail.commit ? { kind: "commit", sha: node.detail.commit } : null;
+    case "repository":
+      return node.detail.files ? countMeta(node.detail.files, "files", "prose") : null;
+    case "package":
+      return node.detail.kind ? { kind: "text", text: node.detail.kind } : null;
+    case "entryPoint":
+      return node.detail.summary ? { kind: "text", text: "summary" } : null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Build the Explore tree rows (port of the page's `listTree`).
+ *
+ * - Roots: `vault`, `repository` (nodes with no incoming containment edge).
+ * - Entry points nest under their prefix module.
+ * - Internals hidden by default; the caller toggles `showInternals`.
+ * - Filter (query and/or provenance): prune to matches + ancestors, auto-expanding ancestors.
+ * - Default expansion (no filter): controlled by `state.expanded`.
+ */
+export function treeRows(model: GraphModel, state: TreeState): TreeRow[] {
+  const idx = indexTree(model);
+  const { byId, tree, moduleEntries, roots } = idx;
+
+  const children = (id: string): string[] => {
+    const kids = tree.get(id) ?? [];
+    // Drop entry points that have a claiming module (they re-nest under it).
+    const filtered = kids.filter((kid) => {
+      const n = byId.get(kid);
+      if (!n || n.kind !== "entryPoint") return true;
+      for (const [, entries] of moduleEntries) {
+        if (entries.includes(kid)) return false;
+      }
+      return true;
+    });
+    let all = filtered.concat(moduleEntries.get(id) ?? []);
+    // Skip kids absent from the node set (corrupt/hand-built graphs): the page
+    // never produces these, but a defensive filter keeps the tree robust.
+    all = all.filter((k) => byId.has(k));
+    if (!state.showInternals) {
+      all = all.filter((k) => {
+        const n = byId.get(k);
+        return !(n && hiddenInternalKind(n.kind));
+      });
+    }
+    return sortKids(all, byId);
+  };
+
+  const filtering = state.provFilter !== null || state.query.length > 0;
+
+  const matches = (node: GraphNode): boolean => {
+    if (state.provFilter !== null && node.provenance !== state.provFilter) return false;
+    if (state.query.length > 0 && !listLabel(node).toLowerCase().includes(state.query.toLowerCase())) return false;
+    return true;
+  };
+
+  // Pass 1: mark visible nodes (self-match or a visible descendant).
+  const visible = new Set<string>();
+  const mark = (id: string): boolean => {
+    const node = byId.get(id)!;
+    let any = false;
+    for (const k of children(id)) if (mark(k)) any = true;
+    const show = matches(node) || any;
+    if (show) visible.add(id);
+    return show;
+  };
+  for (const r of roots) mark(r);
+
+  const rows: TreeRow[] = [];
+  const walk = (id: string, depth: number): void => {
+    if (!visible.has(id)) return;
+    const node = byId.get(id)!;
+    const kids = children(id);
+    const visibleKids = kids.filter((k) => visible.has(k));
+    const expanded = filtering ? visibleKids.length > 0 : state.expanded.has(id);
+    rows.push({
+      id,
+      depth,
+      hasKids: kids.length > 0,
+      expanded,
+      label: listLabel(node),
+      kind: node.kind,
+      provenance: node.provenance,
+      meta: metaFor(node),
+    });
+    if (expanded) for (const k of visibleKids) walk(k, depth + 1);
+  };
+  for (const r of roots) walk(r, 0);
+  return rows;
+}
+
+/** Empty-state hint for the tree surface (weave-view-tui-design §5.1). */
+export function treeEmptyHint(model: GraphModel): string | null {
+  const vault = model.nodes.find((n) => n.kind === "vault");
+  if (!vault) return null;
+  // no notes and no repository
+  const hasNotes = model.nodes.some((n) => n.kind === "note");
+  const hasRepo = model.nodes.some((n) => n.kind === "repository");
+  if (!hasNotes && !hasRepo) return "no notes yet — add one with the weave_note tool";
+  return null;
+}

package/src/core/view/types.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared row/meta types for the portable view-models (weave-workspace §3).
+ *
+ * These are *renderer-agnostic*: no terminal widths, no pre-truncation, no
+ * DOM. The TUI and the browser workspace both consume them and each applies
+ * its own formatting.
+ */
+
+/** A selectable row in any surface. `target` (when set) is the node id a row
+ *  jumps to on activation (a link / neighbor). */
+export interface SelectableRow {
+  id: string;
+  /** Node id this row jumps to on activation (links/backlinks/neighbors). */
+  target?: string;
+}
+
+/**
+ * The dim trailing annotation on a tree row, as structured data.
+ *
+ * Deliberately *not* a formatted string: a terminal column, an HTML `<span>`,
+ * and a `<time>` element each want something different, and a relative time
+ * has to be re-derived as the clock moves. `formatTreeMeta` (view/time.ts)
+ * reproduces the terminal phrasing; other renderers are free to ignore it.
+ */
+export type TreeMeta =
+  /** Relative timestamp, e.g. a note's `updated`. Rendered against a clock. */
+  | { kind: "relTime"; iso: string }
+  /**
+   * A counted quantity. `phrasing` is a display hint, not a hard rule:
+   * `"attribute"` reads as `unit=n` (a property of the row), `"prose"` reads
+   * as `n unit` (a description of it).
+   */
+  | { kind: "count"; n: number; unit: string; phrasing: "attribute" | "prose" }
+  /** A full commit sha; renderers abbreviate to taste. */
+  | { kind: "commit"; sha: string }
+  /** An opaque, already-human string (a package kind, a marker word). */
+  | { kind: "text"; text: string }
+  /** No annotation. */
+  | null;

package/src/pi/index.ts

@@ -13,6 +13,7 @@ import { registerNoteTool } from "./tools/noteTool";
 import { registerRepoTool } from "./tools/repoTool";
 import { deepScanRepository, formatDeepScanResult } from "./summarize";
 import { runWeaveViewTui } from "./viewer/tui/run";
+import { WebWorkspaceController } from "./viewer/web/run";
 
 /**
  * pi-weave — an agent-native knowledge workspace (docs/design.md):
@@ -27,13 +28,21 @@ export default function piWeave(pi: ExtensionAPI): void {
   registerNoteTool(pi);
   registerRepoTool(pi);
 
-  // /weave-view is the in-terminal explorer (the old browser viewer was
-  // retired for a pixi.js rewrite); it holds no session resources, so there
-  // is no per-session lifecycle to tear down.
+  // /weave-view opens the browser workspace by default (weave-workspace §13);
+  // `tui` selects the in-terminal explorer. The browser workspace owns a
+  // server, a file watcher and live SSE streams for the rest of the session,
+  // so unlike the TUI it has a real teardown — see `session_shutdown` below.
   let lastCtx: ExtensionContext | ExtensionCommandContext | null = null;
   let lastStatusText: string | undefined = undefined;
   let isActive = false;
 
+  const web = new WebWorkspaceController({
+    exec: (command, args) => pi.exec(command, args),
+    // A boot or an idle shutdown changes what the status line should say, and
+    // neither happens inside a command handler that could refresh it itself.
+    onStateChange: () => updateStatus(),
+  });
+
   function updateStatus(ctx?: ExtensionContext | ExtensionCommandContext, text?: string): void {
     if (ctx) lastCtx = ctx;
     const c = ctx || lastCtx;
@@ -41,10 +50,28 @@ export default function piWeave(pi: ExtensionAPI): void {
     if (text !== undefined) {
       lastStatusText = text;
     }
-    if (!lastStatusText) {
+
+    // A running browser workspace is a background process the user cannot
+    // otherwise see — an open port on their machine — so it always gets a
+    // marker. Resolved *before* the "nothing to show" test, because the port
+    // is itself something to show.
+    //
+    // This ordering is the fix for a real bug: the early return used to sit
+    // above this lookup, so a workspace started in a session that never
+    // emitted `session_start` (no seeded `lastStatusText`) did not merely
+    // fail to gain the marker — it actively cleared the status line while a
+    // server was listening. The browser-launch-failure path is exactly that
+    // shape, which is why it was the case that caught it.
+    const port = web.port();
+    const suffix = port === null ? "" : ` · web:${port}`;
+
+    // Clear only when there is genuinely nothing to say: no base text *and*
+    // no server.
+    if (!lastStatusText && port === null) {
       c.ui.setStatus("weave", undefined);
       return;
     }
+
     let theme: { fg?: (slot: string, text: string) => string } | undefined;
     try {
       theme = (c.ui as unknown as { theme?: { fg?: (slot: string, text: string) => string } })?.theme;
@@ -54,11 +81,19 @@ export default function piWeave(pi: ExtensionAPI): void {
     const indicator = (isActive || inFlightDeepScans.size > 0)
       ? (theme?.fg ? theme.fg("accent", "●") : "●")
       : (theme?.fg ? theme.fg("dim", "○") : "○");
-    c.ui.setStatus("weave", `${indicator} ${lastStatusText}`);
+    // With no base text the marker stands alone (`○ web:51234`) rather than
+    // rendering a leading ` · ` separator against nothing.
+    const body = lastStatusText ? `${lastStatusText}${suffix}` : `web:${port}`;
+    c.ui.setStatus("weave", `${indicator} ${body}`);
   }
 
   pi.on("session_shutdown", async () => {
-    // The TUI explorer owns no session-scoped resources; nothing to stop.
+    // The TUI explorer owns nothing session-scoped, but the browser workspace
+    // owns an HTTP server, a recursive file watcher and any number of open SSE
+    // streams. `close()` releases all three (server.ts closes the hub and
+    // awaits the watcher); a leaked listener outliving the pi session is a
+    // real bug, not a tidiness concern.
+    await web.close();
   });
 
   pi.on("agent_start", async (_event, ctx) => {
@@ -97,14 +132,26 @@ export default function piWeave(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("weave-view", {
-    description: "Open the in-terminal knowledge-graph explorer (vault + repository); reads from disk live",
+    description: "Open the knowledge workspace in your browser ('tui' for the in-terminal explorer, '--no-open' to just print the URL)",
     handler: async (args, ctx) => {
-      const arg = args.trim().toLowerCase();
-      if (arg !== "" && arg !== "tui") {
-        ctx.ui.notify("usage: /weave-view [tui]", "warning");
+      const parsed = parseWeaveViewArgs(args);
+      if (parsed === null) {
+        ctx.ui.notify(WEAVE_VIEW_USAGE, "warning");
         return;
       }
-      await runWeaveViewTui(ctx);
+      if (parsed.surface === "tui") {
+        await runWeaveViewTui(ctx);
+        return;
+      }
+      const outcome = await web.run(ctx, { open: parsed.open });
+      // A browser that would not launch on a machine that has a terminal
+      // still leaves the user somewhere to go. The server stays up — the URL
+      // in the notification remains valid — and the TUI opens on top of it.
+      if (outcome.fallbackToTui && ctx.mode === "tui") await runWeaveViewTui(ctx);
+      // Unconditionally, and last: the TUI writes its own status line on
+      // close, which would otherwise drop the `· web:PORT` marker for a
+      // server that is still running.
+      updateStatus(ctx);
     },
   });
 
@@ -156,6 +203,52 @@ export default function piWeave(pi: ExtensionAPI): void {
   });
 }
 
+/* ------------------------------------------------------------------ */
+/* /weave-view argument parsing                                        */
+/* ------------------------------------------------------------------ */
+
+export const WEAVE_VIEW_USAGE = "usage: /weave-view [tui|web] [--no-open]";
+
+/** Which explorer `/weave-view` was asked for. */
+export interface WeaveViewArgs {
+  surface: "tui" | "web";
+  /** `false` for `--no-open`. Meaningless for `tui`, which never opens one. */
+  open: boolean;
+}
+
+/**
+ * Parse `/weave-view`'s argument string, or `null` for "print the usage".
+ *
+ * Bare `/weave-view` is the **browser** workspace (weave-workspace §13):
+ * the default is the thing most people want most of the time, and `tui` is
+ * one word away for the SSH case. `--no-open` is accepted on the web
+ * surface only — silently ignoring it after `tui` would be a lie about what
+ * happened.
+ *
+ * Exported because a parser is exactly the kind of thing that should be
+ * tested as a table rather than through eight command invocations.
+ */
+export function parseWeaveViewArgs(args: string): WeaveViewArgs | null {
+  const tokens = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  let surface: "tui" | "web" = "web";
+  let open = true;
+  let sawSurface = false;
+  for (const token of tokens) {
+    if (token === "--no-open") {
+      // Rejecting the repeat costs nothing and keeps "did I typo?" honest.
+      if (!open) return null;
+      open = false;
+      continue;
+    }
+    if (sawSurface) return null;
+    if (token !== "tui" && token !== "web") return null;
+    surface = token;
+    sawSurface = true;
+  }
+  if (surface === "tui" && !open) return null;
+  return { surface, open };
+}
+
 /* ------------------------------------------------------------------ */
 /* In-flight deep scans (background, cancellable)                      */
 /* ------------------------------------------------------------------ */

package/src/pi/viewer/tui/explorer.ts

@@ -21,6 +21,7 @@ import type { ViewNote } from "../../../core/graph/current";
 import {
   detailModel,
   focusModel,
+  formatTreeMeta,
   graphRoots,
   healthModel,
   initialState,
@@ -359,8 +360,8 @@ export class WeaveExplorer implements Component {
       showInternals: this.state.showInternals,
       provFilter: this.state.provFilter,
       query: this.state.query,
-      now: this.nowFn(),
     });
+    const now = this.nowFn();
     const hint = treeEmptyHint(this.model);
     if (rows.length === 0 && hint) {
       return { lines: [{ text: t.fg("dim", hint) }], rows: [] };
@@ -369,7 +370,8 @@ export class WeaveExplorer implements Component {
       const chev = chevron(r.expanded, r.hasKids);
       const marker = this.rowMarker(r.kind, r.provenance);
       const label = sanitizeTerminalText(r.label);
-      const meta = r.meta ? t.fg("dim", `  ${sanitizeTerminalText(r.meta)}`) : "";
+      const metaText = formatTreeMeta(r.meta, now);
+      const meta = metaText ? t.fg("dim", `  ${sanitizeTerminalText(metaText)}`) : "";
       const indent = "  ".repeat(r.depth);
       const body = `${indent}${chev} ${marker}${label}`;
       const text = meta ? `${body}${meta}` : body;