@signalridge/pi-welcome 0.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 1.3.0
+### Minor Changes
+
+- 8488246: Put the inventory back, and take the wordmark off.
+  
+  With `quietStartup` on, Pi's `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/
+  `[Extensions]` sections are gone and nothing brings them back — `/reload` re-runs
+  the same suppressed listing. The card had replaced all of that with three
+  counts, which is strictly less than what the session used to show. It now names
+  them instead, eight per row with a `+N` tail: context files, skills, prompts,
+  extensions, themes, and the tool count.
+  
+  Skills and prompts now come from `getCommands()` rather than `loadSkills()`. An
+  extension may contribute skill paths through `resources_discover`, which is
+  where most of them come from in practice, and the standalone loader cannot see
+  those — measured on a real session it returned zero skills while Pi was showing
+  dozens. Extensions and themes are read from the same settings files and
+  directories Pi reads.
+  
+  The ridgeline mark, the `SIGNALRIDGE / PI` wordmark, and the tagline are gone.
+  The card exists to say what this session is, and a brand line says nothing a
+  returning user does not already know; the key hints lead instead, since with
+  `quietStartup` on they appear nowhere else. The Pi version returns to a row of
+  its own.
+
+## 1.0.0
+### Major Changes
+
+- Adopt a unified 1.0.0 across every published package.
+  
+  The version numbers no longer track their upstream forks individually; from this release each package
+  is versioned on its own merit against the Signalridge line, and 1.0.0 is the shared starting point.
+  Packages whose behavior changed in this release document that change in their own changeset entries;
+  the remainder are re-released unchanged so the whole set shares one baseline.
+
+### Patch Changes
+
+- Neutralize terminal control sequences and bidirectional overrides in the last three surfaces that rendered untrusted text raw: the recap the model writes from tool output, the workspace facts on the startup card, and the directory name written into the terminal title as an OSC escape sequence. The recap also sanitizes transcript text before it truncates it, so a cut can never hand the model half of an escape sequence.
+
 ## Unreleased
 
 - Moved the Pi startup card into the independently publishable Signalridge package.

package/README.md

@@ -1,6 +1,80 @@
 # pi-welcome
 
-TUI-only Signalridge startup card showing Pi's current repository, model, budget, and tools. It uses the active Pi theme, keeps the native resource listing intact, and persists a bounded custom entry. The rounded card collapses to a width-safe compact summary on narrow terminals.
+TUI-only Signalridge startup card: one rounded panel with the current
+repository, model, context budget, key hints, and the inventory of what Pi loaded. It
+uses the active Pi theme, persists a bounded custom entry so a resumed session
+redraws it, and collapses to a width-safe compact summary on narrow terminals.
+
+```
+╭─────────────────────────────────────────────────────────────────────────╮
+│                                                                         │
+│  Ctrl+C interrupt · / commands · ! bash · Ctrl+L clear                  │
+│                                                                         │
+│  Directory:  ~/ghq/github.com/signalridge/pi-extensions                 │
+│  Branch:     main [+392 -202]                                           │
+│  Session:    (new)                                                      │
+│  Model:      openai-codex / gpt-5.6-luna · thinking max                 │
+│  Budget:     400K · compacts at 270K                                    │
+│  Version:    0.84.1                                                     │
+│                                                                         │
+│  Context:    AGENTS.md                                                  │
+│  Skills:     commit, dev-preferences, toolbelt, write-tui +12           │
+│  Prompts:    /plan, /review, /ship +4                                   │
+│  Extensions: btw, code-actions, goal, gpt-fast, statusline +18          │
+│  Themes:     catppuccin-mocha, signalridge-ridgeline +2                 │
+│  Tools:      18 active of 42                                            │
+│                                                                         │
+╰─────────────────────────────────────────────────────────────────────────╯
+```
+
+No logo and no wordmark: the card exists to say what this session is, and a
+brand line says nothing a returning user does not already know.
+
+## Turn on `quietStartup`
+
+The card is designed to be the whole opening screen. Pi's own startup is a
+separate header, key-hint block, and one `[Section]` per resource kind with a
+blank line between each; leaving both on shows two unrelated designs and about
+forty-five lines of them. Set:
+
+```json
+{ "quietStartup": true }
+```
+
+in `~/.pi/agent/settings.json` (or `/settings` → Quiet startup). Pi then prints
+nothing at startup and this card stands alone. Diagnostics — resource
+collisions, extension load errors — are still shown when quiet, so nothing
+actionable is hidden.
+
+Leaving `quietStartup: false` is supported and changes nothing about the card;
+Pi simply prints its own block above it again.
+
+## Where the inventory comes from
+
+With `quietStartup` on, Pi's `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/
+`[Extensions]` sections are gone and nothing brings them back — `/reload` re-runs
+the same suppressed listing — so this card is the only place they appear. It
+names them rather than counting them, capped at eight per row with a `+N` tail.
+
+Skills and prompts come from `getCommands()`, **not** from `loadSkills()`. An
+extension may contribute skill paths through `resources_discover`, which is
+where most of them come from in practice, and the standalone loader cannot see
+those: on a session showing dozens of skills it returns zero. `getCommands()`
+reports what Pi actually registered.
+
+Extensions and themes are read from the same settings files and directories Pi
+reads. Context files come from `loadProjectContextFiles`, and tool counts from
+`getAllTools()` / `getActiveTools()`. Nothing here constructs a second resource
+loader: its `reload()` re-executes every extension factory and would duplicate
+tools, listeners, timers, and child processes.
+
+## Untrusted text
+
+A directory name, a git branch name, and a session name are all
+attacker-controlled in a cloned repository, and the card is a persisted entry
+replayed on every resume. Control characters and bidirectional overrides are
+neutralized at render time, so an entry stored before that landed is cleaned up
+on the way out too.
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalridge/pi-welcome",
-  "version": "0.1.0",
+  "version": "1.3.0",
   "description": "Startup resource and repository summary card for Pi.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -5,9 +5,13 @@
  * active Pi theme and semantic labels instead of a second palette or a bundled
  * font, so it stays legible in both dark and light terminals.
  *
- * It adds to Pi's native startup rather than replacing it. `quietStartup` must
- * stay false: Pi owns the key hints and loaded-resource listing, while this
- * card carries only workspace facts that are useful at a glance.
+ * It is meant to be the ONLY thing a session opens with. Pi's own startup is a
+ * header, a key-hint block, and one `[Section]` per resource kind with a blank
+ * line between each; stacking this card underneath produced two unrelated
+ * designs and about forty-five lines of them. So the card carries the pieces
+ * worth keeping — the key hints and a count of what loaded — and `quietStartup`
+ * is turned on in settings to silence the rest. With `quietStartup: false` Pi
+ * still prints its own block and the two appear together again.
  *
  * The card is a custom entry, not a widget: it lands in the transcript, scrolls
  * away as the conversation grows, and survives a reload. Facts are captured at
@@ -16,14 +20,16 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 
 import {
   type ExtensionAPI,
   type ExtensionContext,
   getAgentDir,
+  keyText,
+  loadProjectContextFiles,
   type Theme,
   VERSION,
 } from "@earendil-works/pi-coding-agent";
@@ -31,22 +37,35 @@ import { type Component, truncateToWidth, visibleWidth, wrapTextWithAnsi } from
 
 const ENTRY_TYPE = "welcome-card";
 
-/** A small original ridgeline mark; no private-use or font-specific glyphs. */
-const LOGO = ["╭─╮", "╰─╯"] as const;
-const BRAND = "SIGNALRIDGE / PI";
-const SUBTITLE = "A focused coding workspace";
-
 /** Columns of padding inside the card. */
 const PAD = 2;
 
 /** Below this width, use a compact no-border layout rather than overflow. */
 const MIN_WIDTH = 20;
 
-/** Sentinel row rendered as a blank line, separating the card's two groups. */
+/** Sentinel row rendered as a blank line, separating the card's groups. */
 const GAP: [string, string] = ["", ""];
 
+/**
+ * Names to spell out in a resource row before collapsing the rest into `+N`.
+ *
+ * Pi's own listing prints every name and lets it wrap; with `quietStartup` on
+ * that listing is gone and this card is the only place the inventory appears,
+ * so it errs toward showing names rather than a bare count. Eight is what fits
+ * on one line at a normal width without turning the card into the wall of text
+ * the merge was meant to remove.
+ */
+const MAX_NAMES = 8;
+
 interface WelcomeData {
   rows: [string, string][];
+  /**
+   * Key hints, most useful first. Kept as separate items rather than one joined
+   * string so a narrow card can drop the trailing ones instead of wrapping a
+   * separator onto a line of its own. Optional because an entry written before
+   * this field existed replays without any.
+   */
+  hints?: string[];
 }
 
 // ─── Fact Collection ───────────────────────────────────────────────────────────
@@ -111,6 +130,154 @@ function formatTokens(n: number): string {
   return String(n);
 }
 
+/** `a, b, c +58` — the first few names, then how many were left out. */
+function nameList(names: readonly string[], max = MAX_NAMES): string | undefined {
+  if (names.length === 0) return undefined;
+  const shown = names.slice(0, max).join(", ");
+  const rest = names.length - max;
+  return rest > 0 ? `${shown} +${rest}` : shown;
+}
+
+/** Sorted, de-duplicated, and free of empties — every row is built from this. */
+function tidy(names: Iterable<string>): string[] {
+  return [...new Set([...names].map((name) => name.trim()).filter((name) => name.length > 0))].sort((a, b) =>
+    a.localeCompare(b),
+  );
+}
+
+/**
+ * `ctrl+c` as `Ctrl+C`: key names read as proper nouns, the words after them
+ * stay lowercase. Pi capitalizes the same way internally but does not export
+ * the helper, so this repeats the one rule rather than reaching past the
+ * package's public surface.
+ */
+function capitalizeKey(key: string): string {
+  return key.replace(/[^+/]+/gu, (part) => part.charAt(0).toUpperCase() + part.slice(1));
+}
+
+/**
+ * The key hints Pi's own header would have shown, as plain text.
+ *
+ * Read from the live keybindings rather than hard-coded, so a rebound key is
+ * still described correctly. Deliberately not built with pi's `keyHint()`: that
+ * colors through pi's own theme singleton, while this card renders with the
+ * theme handed to its entry renderer, and the two would disagree after a theme
+ * change. The whole line is dimmed by the renderer instead of highlighting
+ * individual keys.
+ */
+export function collectHints(): string[] {
+  try {
+    // Ordered most useful first: a narrow card keeps the head of this list.
+    return [
+      [capitalizeKey(keyText("app.interrupt")), "interrupt"],
+      ["/", "commands"],
+      ["!", "bash"],
+      [capitalizeKey(keyText("app.clear")), "clear"],
+      [capitalizeKey(keyText("app.tools.expand")), "expand tools"],
+    ]
+      .filter(([key]) => key && key.length > 0)
+      .map(([key, description]) => `${key} ${description}`);
+  } catch {
+    // Keybindings are a TUI singleton; if it is not up yet, a card without a
+    // hint line is better than no card.
+    return [];
+  }
+}
+
+/**
+ * Extension names, as Pi's own `[Extensions]` section lists them.
+ *
+ * Read from the same two settings files Pi reads, plus the extension
+ * directories it scans. Pi labels a package-sourced extension by its package
+ * name and a file-sourced one by its path, so the scope and the `pi-` prefix
+ * come off to leave the part that identifies it.
+ */
+function collectExtensionNames(cwd: string): string[] {
+  const names: string[] = [];
+  for (const settingsFile of [join(getAgentDir(), "settings.json"), join(cwd, ".pi", "settings.json")]) {
+    try {
+      const packages = JSON.parse(readFileSync(settingsFile, "utf8"))?.packages;
+      if (!Array.isArray(packages)) continue;
+      for (const entry of packages) {
+        const source = typeof entry === "string" ? entry : entry?.source;
+        if (typeof source !== "string") continue;
+        const spec = source.replace(/^npm:/u, "");
+        // `@scope/pi-name@1.2.3` and `./local/path` both reduce to a bare name.
+        const bare = (spec.startsWith("@") ? (spec.split("/")[1] ?? spec) : basename(spec)).replace(/@.*$/u, "");
+        names.push(bare.replace(/^pi-/u, ""));
+      }
+    } catch {}
+  }
+  for (const directory of [join(getAgentDir(), "extensions"), join(cwd, ".pi", "extensions")]) {
+    try {
+      for (const entry of readdirSync(directory)) {
+        names.push(entry.replace(/\.[cm]?[jt]s$/u, "").replace(/^pi-/u, ""));
+      }
+    } catch {}
+  }
+  return tidy(names);
+}
+
+/** Custom theme names, as Pi's own `[Themes]` section lists them. */
+function collectThemeNames(): string[] {
+  try {
+    return tidy(
+      readdirSync(join(getAgentDir(), "themes"))
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => entry.replace(/\.json$/u, "")),
+    );
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * What pi loaded for this session, by name — the inventory its own
+ * `[Context]`/`[Skills]`/`[Prompts]`/`[Themes]`/`[Extensions]` sections print.
+ *
+ * With `quietStartup` on those sections are gone and nothing brings them back
+ * (`/reload` re-runs the same suppressed listing), so this card is the only
+ * place the inventory appears and it names things rather than counting them.
+ *
+ * Skills and prompts come from `getCommands()`, not from `loadSkills()`: an
+ * extension may contribute skill paths through `resources_discover`, which is
+ * where most of them come from here, and the standalone loader cannot see those
+ * — it reports zero on a session showing dozens. `getCommands()` reports what
+ * Pi actually registered, which is the honest answer to "what loaded".
+ */
+export function collectResources(pi: ExtensionAPI, cwd: string): [string, string][] {
+  const rows: [string, string][] = [];
+  const push = (label: string, value: string | undefined) => {
+    if (value) rows.push([label, value]);
+  };
+
+  try {
+    const files = loadProjectContextFiles({ cwd, agentDir: getAgentDir() });
+    // Several scopes can contribute the same filename (a project AGENTS.md and
+    // a global one); the card names kinds of context, not paths.
+    push("Context", nameList(tidy(files.map((file) => basename(file.path)))));
+  } catch {}
+
+  try {
+    const commands = pi.getCommands?.() ?? [];
+    const named = (source: string, prefix = "") =>
+      tidy(commands.filter((command) => command.source === source).map((command) => `${prefix}${command.name}`));
+    push("Skills", nameList(named("skill")));
+    push("Prompts", nameList(named("prompt", "/")));
+  } catch {}
+
+  push("Extensions", nameList(collectExtensionNames(cwd)));
+  push("Themes", nameList(collectThemeNames()));
+
+  try {
+    const all = pi.getAllTools?.() ?? [];
+    const active = pi.getActiveTools?.() ?? [];
+    if (all.length) push("Tools", `${active.length} active of ${all.length}`);
+  } catch {}
+
+  return rows;
+}
+
 function collect(pi: ExtensionAPI, ctx: ExtensionContext): WelcomeData {
   const rows: [string, string][] = [];
   const push = (label: string, value: string | undefined) => {
@@ -127,9 +294,9 @@ function collect(pi: ExtensionAPI, ctx: ExtensionContext): WelcomeData {
   push("Directory", tildify(ctx.cwd) + trusted);
   push("Branch", gitSummary(ctx.cwd));
 
-  // Only a NAME is worth a row. The raw session id is a timestamp glued to a
-  // uuid; it is unreadable, identical in shape every time, and pushes the
-  // Keep the fresh-session label short; raw session ids add noise without helping orientation.
+  // Keep the fresh-session label short; raw session ids add noise without
+  // helping orientation — they are a timestamp glued to a uuid, identical in
+  // shape every time.
   push("Session", pi.getSessionName?.() || "(new)");
 
   const model = ctx.model;
@@ -152,36 +319,81 @@ function collect(pi: ExtensionAPI, ctx: ExtensionContext): WelcomeData {
     }
   }
 
-  try {
-    const all = pi.getAllTools?.() ?? [];
-    const active = pi.getActiveTools?.() ?? [];
-    if (all.length) {
-      push("Tools", `${active.length} active of ${all.length}`);
-    }
-  } catch {}
-
   push("Version", VERSION);
-  return { rows };
+
+  // GAP is the sentinel for a blank row: session facts above, what pi loaded
+  // below, so the card reads as two groups rather than one wall.
+  const resources = collectResources(pi, ctx.cwd);
+  if (resources.length > 0) rows.push(GAP, ...resources);
+
+  const hints = collectHints();
+  return hints.length > 0 ? { rows, hints } : { rows };
 }
 
+// ─── Card Component ────────────────────────────────────────────────────────────
+
 /**
- * Pi 0.84.1 does not expose the already-active resource loader through the
- * public ExtensionContext/ExtensionAPI types. Do not construct a second
- * DefaultResourceLoader here: reload() executes arbitrary extension factories
- * and can duplicate tools, listeners, timers, and external processes. Pi owns
- * the startup resource listing, so this extension intentionally omits it until
- * a public non-executing API exists.
+ * Card facts come from a directory name, a git branch name and a session name.
+ * All three are attacker-controlled in a cloned repository, and the card is a
+ * persisted entry, so a poisoned fact is replayed on every resume. Neutralize
+ * C0/C1 controls and bidi overrides here, at the terminal boundary, so a stored
+ * entry written before this landed is cleaned up on the way out too.
+ *
+ * Duplicated rather than shared, per the package boundary rule; `pi-stamp`'s
+ * metadata sanitizer is the reference shape.
  */
-export function collectResources(_cwd: string): Promise<[string, string][]> {
-  return Promise.resolve([]);
+export function sanitizeCardText(value: string): string {
+  let safe = "";
+  for (const character of value) {
+    safe += isUnsafeTerminalCodePoint(character.codePointAt(0) ?? 0) ? " " : character;
+  }
+  return safe.replace(/\s+/gu, " ").trim();
+}
+
+function isUnsafeTerminalCodePoint(codePoint: number): boolean {
+  return (
+    codePoint <= 0x1f ||
+    (codePoint >= 0x7f && codePoint <= 0x9f) ||
+    codePoint === 0x061c ||
+    codePoint === 0x200e ||
+    codePoint === 0x200f ||
+    (codePoint >= 0x202a && codePoint <= 0x202e) ||
+    (codePoint >= 0x2066 && codePoint <= 0x2069)
+  );
+}
+
+/**
+ * Join as many hints as fit on one line, dropping from the end.
+ *
+ * Wrapping would put a leading `·` at the start of the continuation, which
+ * reads as a bullet for the line below it rather than a separator. Losing the
+ * last hint costs less than that, and the list is ordered so the ones worth
+ * keeping come first.
+ */
+export function fitHints(hints: readonly string[], width: number): string | undefined {
+  for (let count = hints.length; count > 0; count--) {
+    const line = hints.slice(0, count).join(" · ");
+    if (visibleWidth(line) <= width) return line;
+  }
+  return undefined;
 }
-// ─── Card Component ────────────────────────────────────────────────────────────
 
 export class WelcomeCard implements Component {
+  private readonly rows: [string, string][];
+  private readonly hints: string[];
+
   constructor(
-    private readonly data: WelcomeData,
+    data: WelcomeData,
     private readonly theme: Theme,
-  ) {}
+  ) {
+    this.rows = data.rows.map(([label, value]) => [sanitizeCardText(label), sanitizeCardText(value)]);
+    // The entry is replayed from a session file on disk, which an older build
+    // (or a hand edit) may have written with a different shape for this field.
+    this.hints = (Array.isArray(data.hints) ? data.hints : [])
+      .filter((hint): hint is string => typeof hint === "string")
+      .map(sanitizeCardText)
+      .filter((hint) => hint.length > 0);
+  }
 
   /** Pad or truncate a (possibly styled) string to exactly `width` columns. */
   private fit(text: string, width: number): string {
@@ -194,9 +406,8 @@ export class WelcomeCard implements Component {
   private renderCompact(width: number): string[] {
     const t = this.theme;
     const lines = [
-      t.bold(t.fg("accent", "sr / pi")),
-      t.fg("muted", "ready"),
-      ...this.data.rows.map(([label, value]) =>
+      t.fg("muted", this.hints.length > 0 ? (this.hints[0] ?? "ready") : "ready"),
+      ...this.rows.map(([label, value]) =>
         label === GAP[0] && value === GAP[1] ? "" : `${t.fg("dim", `${label}:`)} ${t.fg("text", value)}`,
       ),
     ];
@@ -214,18 +425,20 @@ export class WelcomeCard implements Component {
     const blank = () => line("");
     const pad = " ".repeat(PAD);
     const body: string[] = [blank()];
-    const logoWidth = Math.max(...LOGO.map(visibleWidth));
 
-    body.push(
-      line(pad + t.fg("accent", LOGO[0].padEnd(logoWidth)) + pad + t.bold(t.fg("text", BRAND))),
-      line(pad + t.fg("accent", LOGO[1].padEnd(logoWidth)) + pad + t.fg("muted", SUBTITLE)),
-      blank(),
-    );
+    // No mark and no wordmark. The card exists to say what this session is, and
+    // a brand line says nothing a returning user does not already know. The
+    // hints lead instead: with `quietStartup` on this is the only place they
+    // appear, and they are what a new session actually needs.
+    const hintLine = fitHints(this.hints, Math.max(1, inner - PAD * 2));
+    if (hintLine) {
+      // The whole line is dimmed rather than highlighting each key: this is
+      // orientation, not a control the user is meant to look at.
+      body.push(line(pad + t.fg("dim", hintLine)), blank());
+    }
 
-    const labelWidth = this.data.rows.length
-      ? Math.max(...this.data.rows.map(([label]) => visibleWidth(label))) + 2
-      : 0;
-    for (const [label, value] of this.data.rows) {
+    const labelWidth = this.rows.length ? Math.max(...this.rows.map(([label]) => visibleWidth(label))) + 2 : 0;
+    for (const [label, value] of this.rows) {
       if (label === GAP[0] && value === GAP[1]) {
         body.push(blank());
         continue;
@@ -271,14 +484,7 @@ export default function (pi: ExtensionAPI) {
     } catch {}
 
     try {
-      const data = collect(pi, ctx);
-      const resources = await collectResources(ctx.cwd);
-      if (resources.length) {
-        // GAP is the sentinel for a blank row: session facts above, what pi
-        // loaded below, so the card reads as two groups rather than one wall.
-        data.rows.push(GAP, ...resources);
-      }
-      pi.appendEntry<WelcomeData>(ENTRY_TYPE, data);
+      pi.appendEntry<WelcomeData>(ENTRY_TYPE, collect(pi, ctx));
     } catch {
       // A missing card is not worth failing a session start over.
     }