@skill-map/cli 0.14.0 → 0.14.1

package/dist/cli/guide/sm-guide.md

@@ -80,15 +80,17 @@ ls -A
 ```
 
 **Items que ignorás** del listado al evaluar "vacío" (no cuentan
-como contenido del usuario):
+como contenido del usuario, son infraestructura del propio skill):
 
-- `.claude` — infraestructura de skills/agents; puede contener este
-  mismo skill.
-- `SKILL.md` — si el tester tiene una copia del skill suelta acá.
-- `sm-guide.md` — copia del skill materializada por `sm guide`
-  (suelta en la raíz del cwd).
+- `.claude` — infraestructura de skills/agents.
+- `SKILL.md` — copia del skill suelta acá.
+- `sm-guide.md` — copia del skill materializada por `sm guide`.
 - `guide-state.yml` — modo resume (ver §Resume / restart).
 
+La whitelist es **interna** — no se la enumerás al tester. Si todo
+está OK le decís simplemente "Listo, el directorio está limpio.
+Sigamos." sin paréntesis ni aclaraciones de qué items se ignoraron.
+
 Reglas (después de filtrar los items ignorados):
 
 - Listado vacío → el dir está vacío. **Seguís.**
@@ -167,51 +169,117 @@ Sugerí `node --version` y guialo.
 
 ### 3. Crear el fixture en el cwd
 
+Cuatro nodos, uno por cada *kind* que skill-map reconoce — un skill,
+un agente, un hook y una nota — todos linkeados entre sí para que el
+grafo tenga forma. Más un `.skill-map-ignore` para que el escaneo no
+levante archivos propios de la guía.
+
 ```
 <cwd>/
-├── docs/
-│   ├── overview.md
-│   └── architecture.md
+├── .claude/
+│   ├── skills/
+│   │   └── demo-skill/
+│   │       └── SKILL.md      # kind: skill
+│   ├── agents/
+│   │   └── demo-agent.md     # kind: agent
+│   └── hooks/
+│       └── demo-hook.md      # kind: hook
 ├── notes/
-│   └── todo.md          # link roto a propósito (sirve en el largo)
+│   └── todo.md               # kind: note (con link roto a propósito)
+├── .skill-map-ignore
 ├── guide-state.yml
 └── findings.md
 ```
 
-`docs/overview.md`:
+`.claude/skills/demo-skill/SKILL.md`:
 ```markdown
 ---
-title: Overview
-tags: [docs, intro]
+name: demo-skill
+description: |
+  Skill de ejemplo que muestra cómo skill-map detecta el frontmatter
+  y los links internos. Útil para inspeccionar el grafo en la UI.
+inputs:
+  - name: target
+    type: path
+    description: Archivo a procesar.
+    required: true
+outputs:
+  - name: report
+    type: string
+    description: Resumen en Markdown.
 ---
 
-# Overview
+# demo-skill
+
+Este skill recorre un archivo y devuelve un reporte. Cuando necesita
+delegar trabajo pesado se apoya en el
+[demo-agent](../../agents/demo-agent.md).
 
-Welcome. See [architecture](./architecture.md).
+## Pasos
+1. Leer el `target`.
+2. Validar el frontmatter contra los schemas.
+3. Generar el reporte.
 ```
 
-`docs/architecture.md`:
+`.claude/agents/demo-agent.md`:
 ```markdown
 ---
-title: Architecture
-tags: [docs, architecture]
+name: demo-agent
+description: |
+  Agente de ejemplo que el demo-skill puede invocar para tareas de
+  lectura y ejecución de comandos.
+tools: Read, Bash
+model: sonnet
 ---
 
-# Architecture
+# demo-agent
+
+Procesa entradas y, al cerrar la sesión, dispara el
+[demo-hook](../hooks/demo-hook.md).
 
-Layers: kernel → CLI → UI. Back to [overview](./overview.md).
+Reglas:
+- Nunca correr comandos destructivos sin confirmación.
+- Loggear cada acción a stderr.
 ```
 
-`notes/todo.md` (con link **roto a propósito**):
+`.claude/hooks/demo-hook.md`:
 ```markdown
 ---
-title: TODO
-tags: [notes]
+event: SubagentStop
+blocking: false
+idempotent: true
 ---
 
-# TODO
+# demo-hook
+
+Hook que se dispara cuando un subagente termina. Marca el cierre y
+deja una entrada en la lista de pendientes.
+
+Ver [pendientes](../../notes/todo.md) para el contexto operativo.
+```
+
+`notes/todo.md` (con link **roto a propósito** — sirve en la etapa
+L4 del camino largo):
+```markdown
+---
+title: Pendientes del demo
+tags: [notes, demo]
+---
+
+# Pendientes
+
+- [ ] Documentar el [diagrama de flujo](./missing-page.md) — link
+      roto a propósito, no toques.
+- [ ] Pulir el prompt de [demo-skill](../.claude/skills/demo-skill/SKILL.md).
+- [ ] Confirmar el `event` del [demo-hook](../.claude/hooks/demo-hook.md).
+```
 
-- Write [missing-page](./missing-page.md) — broken link on purpose.
+`.skill-map-ignore` (formato gitignore-like — evita que `sm scan`
+levante archivos internos de la guía como nodos del grafo):
+```
+sm-guide.md
+findings.md
+guide-state.yml
 ```
 
 `findings.md`:
@@ -366,11 +434,12 @@ sm
 > El server queda corriendo. Abrí en el navegador la URL que muestra
 > la salida (típicamente **http://127.0.0.1:4242**).
 >
-> Recorré las 4 vistas:
-> 1. **Grafo** — los nodos del fixture conectados por links
-> 2. **Lista** — tabla con paths y metadata
-> 3. **Inspector** — clickeá un nodo para ver detalles
-> 4. **Event log** — panel lateral con eventos en vivo
+> Recorré las 3 vistas:
+> 1. **Grafo** — los 4 nodos del fixture (skill, agente, hook, nota)
+>    conectados por sus links internos.
+> 2. **Lista** — tabla con paths, kind y metadata.
+> 3. **Inspector** — clickeá un nodo para ver detalles (frontmatter,
+>    links in/out, issues).
 >
 > ¿Cargó todo bien? Si algo no se ve, registralo en findings.
 
@@ -382,25 +451,34 @@ la UI redibujarse sola.
 
 Cambios que aplicás vos (con `Edit` y `Write`):
 
-1. Editar `docs/architecture.md` — agregar al final:
+1. Editar `.claude/skills/demo-skill/SKILL.md` — agregar al final:
    ```markdown
-   See also [examples](./examples.md).
+   Ver también [ejemplos](../../notes/examples.md).
    ```
-2. Crear `docs/examples.md`:
+2. Crear `notes/examples.md`:
    ```markdown
    ---
-   title: Examples
-   tags: [docs, examples]
+   title: Ejemplos del demo-skill
+   tags: [notes, examples, demo]
    ---
-   # Examples
-   Real-world usages.
+
+   # Ejemplos
+
+   Casos típicos de uso del [demo-skill](../.claude/skills/demo-skill/SKILL.md):
+
+   - Procesar un único archivo `.md`.
+   - Validar frontmatter contra `note.schema.json`.
+   - Reportar links rotos detectados al pasar.
    ```
 
 > Mirá el navegador. En 1-2 segundos deberías ver:
-> - Un nodo nuevo (`examples.md`) en el grafo
-> - Una arista nueva: `architecture.md → examples.md`
-> - Eventos en el panel "Event log" tipo `scan.started` /
->   `scan.completed`
+> - Un nodo nuevo (`examples.md`, kind `note`) en el grafo.
+>   **Si no lo ves, hacé zoom con la rueda del mouse o el control de
+>   zoom de la UI** — los nodos nuevos a veces aparecen en un
+>   extremo del canvas.
+> - Un conector nuevo: `demo-skill → examples.md`.
+> - Eventos en el panel lateral tipo `scan.started` /
+>   `scan.completed`.
 >
 > ¿Lo viste moverse? Si no se actualizó, refrescá el navegador y
 > decime.
@@ -464,35 +542,39 @@ que él puede hacer lo mismo desde su editor.
 Pedile que vuelva a arrancar el server (`sm` desde el cwd de la guía)
 y abra el navegador.
 
-> Tu turno. Editá `docs/overview.md` con tu editor favorito y borrá
-> la línea que linkea a `architecture.md`. Guardá. Mirá la UI.
+> Tu turno. Editá `.claude/skills/demo-skill/SKILL.md` con tu editor
+> favorito y borrá la línea que linkea a `demo-agent.md`. Guardá.
+> Mirá la UI.
 >
-> Esperado: la arista `overview → architecture` desaparece. Si
-> `architecture.md` queda sin nadie linkeándolo, aparece como
-> huérfano (lo vamos a explotar en la etapa L4).
+> Esperado: el conector `demo-skill → demo-agent` desaparece. Si
+> `demo-agent.md` queda sin nadie linkeándolo, aparece como huérfano
+> (lo vamos a explotar en la etapa L4).
 
-Verificás leyendo `docs/overview.md` para confirmar que el cambio se
-aplicó. Cuando confirme, pedile **Ctrl+C** para apagar el server.
+Verificás leyendo `.claude/skills/demo-skill/SKILL.md` para confirmar
+que el cambio se aplicó. Cuando confirme, pedile **Ctrl+C** para
+apagar el server.
 
 ### Etapa L2 — Browse CLI: list / show / check (~3 min)
 
 ```bash
 sm list
-sm list --kind doc --limit 10
-sm show docs/overview.md
+sm list --kind skill
+sm list --kind agent
+sm show .claude/skills/demo-skill/SKILL.md
 sm check
 ```
 
-Esperado: ves los nodos del fixture listados; `check` reporta el
-issue del link roto en `notes/todo.md` apuntando a `missing-page.md`.
+Esperado: ves los 4 nodos del fixture listados con su kind; `check`
+reporta el issue del link roto en `notes/todo.md` apuntando a
+`missing-page.md`.
 
 ### Etapa L3 — ASCII: graph + export (~3 min)
 
 ```bash
 sm graph
-sm graph --root docs/overview.md
+sm graph --root .claude/skills/demo-skill/SKILL.md
 sm export --format md > export.md
-sm export --format json --kind doc > export.json
+sm export --format json --kind note > export-notes.json
 ls -la export.*
 ```
 
@@ -516,16 +598,16 @@ sm orphans undo-rename --from <path-renombrado>
 ```
 
 Para no romper nada, sugerí al tester apuntar el link roto de
-`notes/todo.md` a un archivo existente (ej. `docs/architecture.md`).
+`notes/todo.md` a un archivo existente (ej. `notes/examples.md`).
 Es un test, no importa que la semántica sea fea.
 
 ### Etapa L5 — Delta + historia (~4 min)
 
 ```bash
 sm export --format json > .skill-map/baseline.json
-# editá algún .md (ej. agregá una línea en docs/overview.md)
+# editá algún .md (ej. agregá una línea en notes/todo.md)
 sm scan compare-with .skill-map/baseline.json
-sm refresh -n docs/overview.md
+sm refresh -n notes/todo.md
 sm refresh --stale
 sm history
 sm history --action scan
@@ -616,31 +698,58 @@ sm db reset --hard
 
 ## Cierre final
 
-Cuando todo terminó (corto solo, o corto + largo):
+Cuando todo terminó (corto solo, o corto + largo), **ofrecé generar
+un archivo de reporte para enviarle a Pusher**:
 
-```markdown
-# Guía completada 🎉
+> ¡Gracias! Llegamos al final. Antes de cerrar:
+>
+> ¿Querés que genere un **archivo de resultados** consolidado (resumen
+> del recorrido + findings + entorno) listo para mandarle a
+> **Pusher**? Lo guardo como `<cwd>/sm-guide-report.md`.
+>
+> 1. **Sí, generámelo**
+> 2. **No, ya está**
 
-- Ruta: <corto solo | corto + largo>
-- Tester: nivel <N> (si aplica)
-- Directorio de la guía: <cwd>
-- Pasos del corto: 4 / 4
-- Etapas del largo: X / 9 (Y skipped) — si aplica
-- Findings reportados: Z
-- Tiempo total: ~<calculado de timestamps>
+Si dice **1**, escribís `<cwd>/sm-guide-report.md` con esta plantilla:
 
-## Para borrar todo lo que dejó la guía
-Si el cwd era un dir dedicado (ej. `~/sm-guide`), salí y borralo
-entero:
+```markdown
+# sm-guide — reporte para Pusher
+
+- **Fecha**: <ISO-8601>
+- **Ruta**: <corto solo | corto + largo>
+- **Tester**: nivel <N> (si aplica)
+- **Directorio de la guía**: <cwd>
+- **Pasos del corto**: 4 / 4
+- **Etapas del largo**: X / 9 (Y skipped) — si aplica
+- **Tiempo total**: ~<calculado de timestamps>
+
+## Entorno
+- `sm version`: <versión>
+- Node: <versión>
+- OS: <plataforma>
+
+## Findings registrados
+<volcar el contenido relevante de findings.md, sin el header genérico>
+
+## Notas adicionales del tester
+<si dejó comentarios libres>
+```
 
-    cd ~ && rm -rf <cwd>
+Después le mostrás:
 
-## Para mandar tus findings al equipo
-Mandame por <canal-acordado-por-fuera>:
-<cwd>/findings.md
-```
+> Listo. Te dejé el reporte en:
+>
+>     <cwd>/sm-guide-report.md
+>
+> Mandámelo a Pusher cuando quieras (por el canal acordado).
+>
+> Para borrar todo lo que dejó la guía, si el cwd era un dir
+> dedicado:
+>
+>     cd ~ && rm -rf <cwd>
 
-Si quedaron findings, listalos también y agradecé.
+Si dice **2**, le mostrás solo las instrucciones de borrado y
+agradecés.
 
 ## Resume / restart
 
@@ -659,8 +768,9 @@ arrancás así (NO repetís pre-flight desde cero):
 
 Si elige "empezar de cero", confirmás explícitamente. Solo después
 borrás los archivos de la guía del cwd (`guide-state.yml`,
-`findings.md`, `docs/`, `notes/`, `.skill-map/`, y cualquier
-`export.*` o `dump.sql` que haya quedado) y arrancás todo desde el
+`findings.md`, `.skill-map-ignore`, `.claude/`, `notes/`,
+`.skill-map/`, y cualquier `export.*`, `dump.sql` o
+`sm-guide-report.md` que haya quedado) y arrancás todo desde el
 pre-flight.
 
 ## Edge cases

package/dist/cli.js

@@ -7363,7 +7363,7 @@ import { Command as Command8, Option as Option8 } from "clipanion";
 // cli/i18n/guide.texts.ts
 var GUIDE_TEXTS = {
   // Success — written to stdout after `<cwd>/sm-guide.md` is created.
-  written: 'Listo. sm-guide.md creado en {{cwd}}. Abr\xED Claude Code ac\xE1 y decile "gu\xEDame" para arrancar la gu\xEDa interactiva.\n',
+  written: 'Listo. sm-guide.md creado en {{cwd}}. Abr\xED Claude Code ac\xE1 y decile "ejecut\xE1 @sm-guide.md" para arrancar la gu\xEDa interactiva.\n',
   // Refusal — `sm-guide.md` already exists and `--force` was not set.
   // Goes to stderr, exit code 2 (operational error per spec § Exit codes).
   alreadyExists: "sm guide: sm-guide.md ya existe en {{cwd}}. Us\xE1 `--force` para sobrescribir.\n",
@@ -7381,8 +7381,9 @@ var GuideCommand = class extends SmCommand {
     description: "Materialize the interactive tester guide (sm-guide.md) in the current directory.",
     details: `
       Drops the canonical SKILL.md content as ./sm-guide.md so a tester
-      can open Claude Code in the cwd and trigger the sm-guide skill
-      ("gu\xEDame"). Top-level only \u2014 no subdirectory is created.
+      can open Claude Code in the cwd and load the file as a skill by
+      typing "ejecut\xE1 @sm-guide.md". Top-level only \u2014 no subdirectory
+      is created.
 
       Does NOT require an initialized .skill-map/ project. Refuses to
       overwrite an existing sm-guide.md unless --force is passed.
@@ -7454,7 +7455,7 @@ import { Command as Command9, Option as Option9 } from "clipanion";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.14.0",
+  version: "0.14.1",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -9324,13 +9325,13 @@ async function writeDryRunGitignorePlan(stdout, scopeRoot) {
     );
   }
 }
-async function runFirstScan(scopeRoot, homedir2, dbPath, strict, stdout, stderr) {
+async function runFirstScan(scopeRoot, homedir3, dbPath, strict, stdout, stderr) {
   stdout.write(INIT_TEXTS.runningFirstScan);
   const kernel = createKernel();
   for (const manifest of listBuiltIns()) kernel.registry.register(manifest);
   let cfg;
   try {
-    cfg = loadConfig({ scope: "project", cwd: scopeRoot, homedir: homedir2, strict }).effective;
+    cfg = loadConfig({ scope: "project", cwd: scopeRoot, homedir: homedir3, strict }).effective;
   } catch (err) {
     const message = formatErrorMessage(err);
     stderr.write(tx(INIT_TEXTS.configLoadFailure, { message }));
@@ -10582,9 +10583,9 @@ var PLUGINS_TEXTS = {
 };
 
 // cli/commands/plugins.ts
-function resolveSearchPaths2(opts, cwd, homedir2) {
+function resolveSearchPaths2(opts, cwd, homedir3) {
   if (opts.pluginDir) return [resolve17(opts.pluginDir)];
-  const ctx = { cwd, homedir: homedir2 };
+  const ctx = { cwd, homedir: homedir3 };
   const project = defaultProjectPluginsDir(ctx);
   const user = defaultUserPluginsDir(ctx);
   return opts.global ? [user] : [project, user];
@@ -10899,17 +10900,17 @@ function appendUnknownKindWarnings(out, extractorQualifiedId, applicableKinds, k
     if (!knownKinds.has(k)) out.push({ extractorQualifiedId, unknownKind: k });
   }
 }
-function expandHome(p, homedir2) {
-  if (p === "~") return homedir2;
-  if (p.startsWith("~/")) return join13(homedir2, p.slice(2));
+function expandHome(p, homedir3) {
+  if (p === "~") return homedir3;
+  if (p.startsWith("~/")) return join13(homedir3, p.slice(2));
   return p;
 }
-function collectExplorationDirWarnings(plugins, homedir2) {
+function collectExplorationDirWarnings(plugins, homedir3) {
   const out = [];
   forEachProviderInstance(plugins, ({ id, pluginId, instance }) => {
     const dir = instance["explorationDir"];
     if (typeof dir !== "string" || dir.length === 0) return;
-    const resolved = expandHome(dir, homedir2);
+    const resolved = expandHome(dir, homedir3);
     if (!existsSync14(resolved)) {
       out.push({
         providerQualifiedId: qualifiedExtensionId(pluginId, id),
@@ -13706,17 +13707,13 @@ function normalizeAddress(addr, fallbackHost, fallbackPort) {
 
 // cli/i18n/serve.texts.ts
 var SERVE_TEXTS = {
-  // Banner emitted to stderr after the listener binds. Mirrors `sm watch`
-  // by writing operational status to stderr (stdout is reserved for
-  // future `--json` boot payloads).
-  boot: "sm serve: listening on http://{{host}}:{{port}} (scope={{scope}}, db={{db}})\n",
-  // Hint shown after the boot line. Branches on --open: when auto-open
-  // is on (default), the message states intent ("opening …"); when
-  // --no-open, it instructs the user to visit the URL manually.
-  // Both end with the Ctrl+C reminder so the operational tail is
-  // identical regardless of branch.
-  bootOpening: "sm serve: opening http://{{host}}:{{port}}/ in your browser. Press Ctrl+C to stop.\n",
-  bootVisitHint: "sm serve: visit http://{{host}}:{{port}}/ in your browser. Press Ctrl+C to stop.\n",
+  // The boot banner (TTY box / flat-line fallback) is rendered by
+  // `cli/util/serve-banner.ts` rather than templated through `tx` —
+  // ANSI escapes + box-drawing aren't a good fit for the flat
+  // `{{name}}` interpolation surface. The flat-mode strings live in
+  // that helper and stay byte-equivalent to the pre-banner format so
+  // existing pipes / redirects ('listening on <url>' scrapers) don't
+  // break.
   // Browser-open failure. Non-fatal — the URL is already printed; the
   // user can open it manually.
   openFailed: "sm serve: could not auto-open browser ({{message}}). Visit {{url}} manually.\n",
@@ -13740,6 +13737,146 @@ var SERVE_TEXTS = {
   shutdown: "sm serve: shutdown complete.\n"
 };
 
+// cli/util/serve-banner.ts
+import { homedir as homedir2 } from "os";
+import { relative as relative5, isAbsolute as isAbsolute6 } from "path";
+var ESC = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  underline: "\x1B[4m",
+  /** 256-color violet (xterm 141). */
+  violet: "\x1B[38;5;141m",
+  /** 256-color green (xterm 42). */
+  green: "\x1B[38;5;42m"
+};
+var LOGO_LINES = [
+  "  ____  _    _ _ _   __  __             ",
+  " / ___|| | _(_) | | |  \\/  | __ _ _ __  ",
+  " \\___ \\| |/ / | | | | |\\/| |/ _` | '_ \\ ",
+  "  ___) |   <| | | | | |  | | (_| | |_) |",
+  " |____/|_|\\_\\_|_|_| |_|  |_|\\__,_| .__/ ",
+  "                                 |_|    "
+];
+var LOGO_WIDTH = 40;
+function renderBanner(input) {
+  const url = `http://${input.host}:${input.port}`;
+  const dbDisplay = formatDbPath(input.dbPath, input.cwd);
+  const browserLine = input.openBrowser ? "Opening browser\u2026  Press Ctrl+C to stop." : `Visit ${url}/ in your browser.  Press Ctrl+C to stop.`;
+  if (!input.isTTY) {
+    return renderFlat({
+      host: input.host,
+      port: input.port,
+      scope: input.scope,
+      dbPath: input.dbPath,
+      openBrowser: input.openBrowser
+    });
+  }
+  return renderFiglet({
+    version: input.version,
+    url,
+    scope: input.scope,
+    dbDisplay,
+    pathDisplay: formatCwdPath(input.cwd),
+    browserLine,
+    colorEnabled: input.colorEnabled
+  });
+}
+function resolveColorEnabled(opts) {
+  if (opts.noColorFlag) return false;
+  const noColor = opts.env["NO_COLOR"];
+  if (noColor !== void 0 && noColor !== "") return false;
+  const forceColor = opts.env["FORCE_COLOR"];
+  if (forceColor !== void 0 && forceColor !== "") return true;
+  return opts.isTTY;
+}
+function renderFlat(input) {
+  const safeHost = sanitizeForTerminal(input.host);
+  const safeDb = sanitizeForTerminal(input.dbPath);
+  const url = `http://${safeHost}:${input.port}`;
+  const linesOut = [];
+  linesOut.push(`sm serve: listening on ${url} (scope=${input.scope}, db=${safeDb})`);
+  if (input.openBrowser) {
+    linesOut.push(`sm serve: opening ${url}/ in your browser. Press Ctrl+C to stop.`);
+  } else {
+    linesOut.push(`sm serve: visit ${url}/ in your browser. Press Ctrl+C to stop.`);
+  }
+  return linesOut.join("\n") + "\n";
+}
+function renderFiglet(input) {
+  const {
+    dimOpen,
+    dimClose,
+    greenUnderline,
+    greenUnderlineClose,
+    violetOpen,
+    violetClose,
+    greenOpen,
+    greenClose
+  } = resolveAnsi(input.colorEnabled);
+  const logoLines = LOGO_LINES.map((line, i) => {
+    const open = i < 3 ? violetOpen : greenOpen;
+    const close = i < 3 ? violetClose : greenClose;
+    return `${open}${line}${close}`;
+  });
+  const versionText = `v${input.version}`;
+  const versionPad = Math.max(0, LOGO_WIDTH - versionText.length);
+  const versionLine = `${" ".repeat(versionPad)}${dimOpen}${versionText}${dimClose}`;
+  const lines = [];
+  lines.push(...logoLines);
+  lines.push("");
+  lines.push(versionLine);
+  lines.push("");
+  lines.push(`  ${dimOpen}Server${dimClose}   ${greenUnderline}${input.url}${greenUnderlineClose}`);
+  lines.push(`  ${dimOpen}Scope${dimClose}    ${input.scope}`);
+  lines.push(`  ${dimOpen}Path${dimClose}     ${input.pathDisplay}`);
+  lines.push(`  ${dimOpen}DB${dimClose}       ${input.dbDisplay}`);
+  lines.push("");
+  lines.push(`  ${dimOpen}${input.browserLine}${dimClose}`);
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+var EMPTY_ANSI = {
+  dimOpen: "",
+  dimClose: "",
+  greenUnderline: "",
+  greenUnderlineClose: "",
+  violetOpen: "",
+  violetClose: "",
+  greenOpen: "",
+  greenClose: ""
+};
+var ENABLED_ANSI = {
+  dimOpen: ESC.dim,
+  dimClose: ESC.reset,
+  greenUnderline: `${ESC.green}${ESC.underline}`,
+  greenUnderlineClose: ESC.reset,
+  violetOpen: ESC.violet,
+  violetClose: ESC.reset,
+  greenOpen: ESC.green,
+  greenClose: ESC.reset
+};
+function resolveAnsi(colorEnabled) {
+  return colorEnabled ? ENABLED_ANSI : EMPTY_ANSI;
+}
+function formatDbPath(dbPath, cwd) {
+  const safe = sanitizeForTerminal(dbPath);
+  if (!isAbsolute6(safe)) return safe;
+  const rel = relative5(cwd, safe);
+  if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) {
+    return safe;
+  }
+  return rel;
+}
+function formatCwdPath(cwd) {
+  const safe = sanitizeForTerminal(cwd);
+  const home = homedir2();
+  if (home && (safe === home || safe.startsWith(`${home}/`))) {
+    return `~${safe.slice(home.length)}`;
+  }
+  return safe;
+}
+
 // cli/commands/serve.ts
 var ServeCommand = class extends SmCommand {
   static paths = [["serve"]];
@@ -13892,18 +14029,24 @@ var ServeCommand = class extends SmCommand {
       );
       return ExitCode.Error;
     }
+    const stderr = this.context.stderr;
+    const isTTY = stderr.isTTY === true;
+    const colorEnabled = resolveColorEnabled({
+      isTTY,
+      noColorFlag: this.noColor,
+      env: process.env
+    });
     this.context.stderr.write(
-      tx(SERVE_TEXTS.boot, {
+      renderBanner({
+        version: VERSION,
         host: sanitizeForTerminal(handle.address.host),
         port: handle.address.port,
         scope,
-        db: sanitizeForTerminal(dbPath)
-      })
-    );
-    this.context.stderr.write(
-      tx(validation.options.open ? SERVE_TEXTS.bootOpening : SERVE_TEXTS.bootVisitHint, {
-        host: sanitizeForTerminal(handle.address.host),
-        port: handle.address.port
+        dbPath,
+        cwd: runtimeCtx.cwd,
+        openBrowser: validation.options.open,
+        isTTY,
+        colorEnabled
       })
     );
     if (validation.options.open) {