@mrclrchtr/supi-code-intelligence 4.1.0 → 4.3.0

package/src/session/orientation-types.ts

@@ -16,11 +16,16 @@ export interface OrientationWorkflowInput {
   readonly maxResults?: number;
 }
 
-/** Presentation-neutral block collected for an Orientation result. */
-export type OrientationBlock =
-  | { readonly kind: "heading"; readonly level: 1 | 2 | 3; readonly text: string }
+/**
+ * Presentation-neutral content atom a collector emits for one Orientation
+ * section. Collectors never build headings, section notes, or document
+ * framing — the markdown adapter owns all of that. `subheading` renders as an
+ * h3 within a section (only instruction-file paths use it).
+ */
+export type OrientationItem =
   | { readonly kind: "paragraph"; readonly text: string }
   | { readonly kind: "list-item"; readonly text: string }
+  | { readonly kind: "subheading"; readonly text: string }
   | {
       readonly kind: "code";
       readonly language: string | null;
@@ -51,6 +56,8 @@ export interface OrientationSectionData {
   readonly confidence: ConfidenceMode;
   readonly provenance: readonly OrientationProvenance[];
   readonly evidenceLists: readonly EvidenceListMetadata[];
+  /** Content atoms for this section; the adapter frames them under the title + note. */
+  readonly items: readonly OrientationItem[];
 }
 
 export interface OrientationCandidate {
@@ -67,7 +74,10 @@ export interface OrientationCandidate {
 
 /** Immutable facts returned by the session before markdown or TUI rendering. */
 export interface OrientationResultData {
-  readonly blocks: readonly OrientationBlock[];
+  /** Document title rendered as the leading h1 (e.g. "Workspace Orientation", "Code Orientation"). */
+  readonly title: string;
+  /** Leading paragraphs rendered before the title (target summary / resolution notes). */
+  readonly notes: readonly string[];
   readonly sections: readonly OrientationSectionData[];
   readonly confidence: ConfidenceMode;
   readonly focusTarget: string | null;

package/src/session/orientation-workflow.ts

@@ -14,10 +14,9 @@ import { loadCodeIntelligenceConfig } from "../config.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
 import { parseOrientationWorkflowInput } from "./input/workflows.ts";
 import { executeOrientation } from "./orientation/collect.ts";
-import { formatSectionNote } from "./orientation/context-sections.ts";
 import type {
-  OrientationBlock,
   OrientationFocusInput,
+  OrientationItem,
   OrientationResultData,
   OrientationSectionData,
   OrientationWorkflowInput,
@@ -217,6 +216,20 @@ function addInstructionFiles(
   const collected = collectInstructionFiles(matches);
   if (!collected) return result;
   deps.markInstructionDirsSurfaced(collected.metadata.files.map((file) => file.directory));
+  const items: OrientationItem[] = [];
+  for (const file of collected.files) {
+    items.push(
+      { kind: "subheading", text: file.path },
+      { kind: "code", language: null, lines: file.content.split("\n") },
+    );
+    if (file.truncated) {
+      items.push({
+        kind: "paragraph",
+        text: `Instruction file truncated to ${file.shownLines} of ${file.totalLines} lines. Read ${file.path} for the full file.`,
+      });
+    }
+    items.push({ kind: "blank" });
+  }
   const section: OrientationSectionData = {
     key: "instructions",
     title: "Instructions",
@@ -233,10 +246,10 @@ function addInstructionFiles(
         partialReason: null,
       },
     ],
+    items,
   };
   return {
     ...result,
-    blocks: insertInstructionBlocks(result.blocks, collected.files, section),
     sections: [section, ...result.sections],
     renderedSections: ["instructions", ...result.renderedSections],
     instructions: collected.metadata,
@@ -258,50 +271,9 @@ function addTargetSummary(
   cwd: string,
 ): OrientationResultData {
   const name = entry.name ? ` ${entry.name}` : "";
-  const summary: OrientationBlock[] = [
-    ...notes.map((note): OrientationBlock => ({ kind: "paragraph", text: `Note: ${note}` })),
-    {
-      kind: "paragraph",
-      text: `Resolved target${name}: ${relative(cwd, entry.file) || entry.file}:${entry.displayLine}:${entry.displayCharacter} — Target ID: ${entry.targetId}`,
-    },
-    { kind: "blank" },
+  const summaryNotes = [
+    ...notes.map((note) => `Note: ${note}`),
+    `Resolved target${name}: ${relative(cwd, entry.file) || entry.file}:${entry.displayLine}:${entry.displayCharacter} — Target ID: ${entry.targetId}`,
   ];
-  return { ...result, blocks: [...summary, ...result.blocks], target: { ...entry } };
-}
-
-function insertInstructionBlocks(
-  existing: readonly OrientationBlock[],
-  files: readonly {
-    path: string;
-    content: string;
-    truncated: boolean;
-    shownLines: number;
-    totalLines: number;
-  }[],
-  section: OrientationSectionData,
-): OrientationBlock[] {
-  const blocks: OrientationBlock[] = [
-    { kind: "heading", level: 2, text: "Instructions" },
-    { kind: "paragraph", text: formatSectionNote(section) },
-    { kind: "blank" },
-  ];
-  for (const file of files) {
-    blocks.push(
-      { kind: "heading", level: 3, text: file.path },
-      { kind: "code", language: null, lines: file.content.split("\n") },
-    );
-    if (file.truncated) {
-      blocks.push({
-        kind: "paragraph",
-        text: `Instruction file truncated to ${file.shownLines} of ${file.totalLines} lines. Read ${file.path} for the full file.`,
-      });
-    }
-    blocks.push({ kind: "blank" });
-  }
-
-  const insertion = existing.findIndex(
-    (block, index) => index > 0 && block.kind === "heading" && block.level === 2,
-  );
-  if (insertion < 0) return [...existing, ...blocks];
-  return [...existing.slice(0, insertion), ...blocks, ...existing.slice(insertion)];
+  return { ...result, notes: [...summaryNotes, ...result.notes], target: { ...entry } };
 }

package/src/substrate/lsp/lifecycle.ts

@@ -1,9 +1,13 @@
 // LSP lifecycle backed by the process-shared Workspace provider host.
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { unregisterLspFooterContribution } from "../../ui/footer.ts";
 import { acquireWorkspaceProviderHost } from "../workspace-provider-host.ts";
-import type { LspAdapterState } from "./state.ts";
+import { LSP_STATE_CHANGE_EVENT, type LspAdapterState } from "./state.ts";
+
+const STATE_CHANGE_EVENT = new Event(LSP_STATE_CHANGE_EVENT);
+
+/** Poll interval (ms) for detecting server readiness transitions in the footer. */
+const READINESS_POLL_MS = 2_000;
 
 /** Acquire providers once per workspace and release them after the final Pi session ends. */
 export function registerLspSessionLifecycle(
@@ -11,12 +15,55 @@ export function registerLspSessionLifecycle(
   state: LspAdapterState,
   onStarted?: (ctx: ExtensionContext) => void | Promise<void>,
 ): void {
+  let readinessTimer: ReturnType<typeof setInterval> | null = null;
+  let lastFingerprint = "";
+
+  function fingerprint(): string {
+    const servers = state.controller?.workspaceRuntime?.getProjectServers();
+    if (!servers) return "";
+    let ready = 0;
+    let starting = 0;
+    let error = 0;
+    let unavailable = 0;
+    let openFiles = 0;
+    for (const s of servers) {
+      openFiles += s.openFiles.length;
+      if (s.status === "running" && s.ready) ready++;
+      else if (s.status === "running") starting++;
+      else if (s.status === "error") error++;
+      else unavailable++;
+    }
+    return `${ready}:${starting}:${error}:${unavailable}:${openFiles}`;
+  }
+
+  function startReadinessPolling(): void {
+    stopReadinessPolling();
+    lastFingerprint = fingerprint();
+    readinessTimer = setInterval(() => {
+      if (state.controller?.kind !== "ready") return;
+      const current = fingerprint();
+      if (current === lastFingerprint) return;
+      lastFingerprint = current;
+      state.stateChanges.dispatchEvent(STATE_CHANGE_EVENT);
+    }, READINESS_POLL_MS);
+    readinessTimer.unref?.();
+  }
+
+  function stopReadinessPolling(): void {
+    if (readinessTimer) {
+      clearInterval(readinessTimer);
+      readinessTimer = null;
+    }
+    lastFingerprint = "";
+  }
+
   pi.on("session_start", async (_event, ctx: ExtensionContext) => {
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
     state.lspActive = false;
     state.sentinelSnapshot = new Map();
+    stopReadinessPolling();
 
     const lease = await acquireWorkspaceProviderHost(ctx.cwd, {
       projectTrusted: ctx.isProjectTrusted(),
@@ -26,14 +73,19 @@ export function registerLspSessionLifecycle(
     state.lspActive = lease.lspController?.kind === "ready";
     state.sentinelSnapshot = lease.sentinelSnapshot;
     await onStarted?.(ctx);
+
+    // Dispatch initial server list so the footer shows starting servers immediately.
+    state.stateChanges.dispatchEvent(STATE_CHANGE_EVENT);
+    // Poll for readiness transitions (running → ready, errors, etc.).
+    startReadinessPolling();
   });
 
   pi.on("session_shutdown", async () => {
+    stopReadinessPolling();
     await state.providerLease?.release();
     state.providerLease = null;
     state.controller = null;
     state.lspActive = false;
     state.sentinelSnapshot = new Map();
-    unregisterLspFooterContribution();
   });
 }

package/src/substrate/lsp/state.ts

@@ -25,6 +25,8 @@ export interface LspAdapterState {
   lspActive: boolean;
   /** Snapshot of workspace sentinel files (package.json, tsconfig, lockfiles) for change detection. */
   sentinelSnapshot: Map<string, number>;
+  /** Fired when server statuses or readiness change — footer listens for re-renders. */
+  stateChanges: EventTarget;
 }
 
 export function createLspAdapterState(): LspAdapterState {
@@ -34,5 +36,9 @@ export function createLspAdapterState(): LspAdapterState {
     inspector: { handle: null, close: null },
     lspActive: false,
     sentinelSnapshot: new Map(),
+    stateChanges: new EventTarget(),
   };
 }
+
+/** Event type dispatched on {@link LspAdapterState.stateChanges} when server statuses change. */
+export const LSP_STATE_CHANGE_EVENT = "server-status-changed" as const;

package/src/tool/graph/execute.ts

@@ -6,7 +6,7 @@ import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts
 import { searchErrorResult } from "../infra/error-results.ts";
 import { toWorkflowControl } from "../infra/workflow-control.ts";
 import { assembleGraphResult } from "../result/graph.ts";
-import { renderGraphResult } from "./markdown-base.ts";
+import { renderGraphResult } from "./markdown.ts";
 
 export type GraphRelation = RequestedGraphRelation;
 

package/src/tool/graph/markdown.ts

@@ -0,0 +1,222 @@
+/** Markdown adapter for assembled code_graph evidence. */
+
+import {
+  type EvidenceList,
+  type EvidenceListMetadata,
+  renderEvidenceListMetadataDisclosure,
+} from "../../analysis/evidence.ts";
+import { renderReadNextSection } from "../../analysis/read-next.ts";
+import {
+  compactLineRanges,
+  formatAssembledReferenceList,
+} from "../../analysis/references/semantic-refs.ts";
+import type {
+  CallEntry,
+  CalleeScope,
+  ImplementationEntry,
+  ReferenceEntry,
+} from "../../analysis/relations/types.ts";
+import { toDisplayPath } from "../../analysis/search/paths.ts";
+import type { GraphResultAssembly } from "../result/graph.ts";
+
+/** Render an assembled graph result. */
+export function renderGraphResult(assembly: GraphResultAssembly): string {
+  const lines = [
+    `# Graph of \`${assembly.displayName}\``,
+    "",
+    `_File: \`${assembly.resolvedDisplayFile}\`_`,
+    "",
+  ];
+
+  const available = assembly.sections.filter((section) => section.kind === "ok");
+  if (available.length > 0) {
+    lines.push(
+      available
+        .map(
+          (section) =>
+            `**${section.rel}**: ${sectionCount(section)} result${sectionCount(section) === 1 ? "" : "s"}`,
+        )
+        .join(" | "),
+      "",
+    );
+  }
+
+  const unavailable = assembly.sections.filter((section) => section.kind === "unavailable");
+  if (unavailable.length > 0) {
+    lines.push(
+      `_Unavailable: ${unavailable.map((section) => `\`${section.rel}\``).join(", ")}_`,
+      "",
+    );
+  }
+
+  for (const section of assembly.sections) {
+    if (section.kind === "unavailable") {
+      lines.push(`**${section.rel}**: ${section.message}`, "");
+      continue;
+    }
+
+    switch (section.rel) {
+      case "references": {
+        const rendered = renderReferencesResult({
+          symbolName: assembly.displayName,
+          references: section.evidence,
+          externalCount: section.data.externalCount,
+          confidence: section.data.confidence,
+          cwd: assembly.cwd,
+        });
+        lines.push(rendered.content, "");
+        break;
+      }
+      case "callees": {
+        const rendered = renderCallsResult(
+          section.data.enclosingScope,
+          section.evidence,
+          assembly.resolvedDisplayFile,
+          section.data.depth,
+        );
+        lines.push(rendered.content, "");
+        break;
+      }
+      case "implements": {
+        const rendered = renderImplementationsResult({
+          implementations: section.evidence,
+          externalCount: section.data.externalCount,
+          cwd: assembly.cwd,
+          targetName: assembly.displayName,
+        });
+        lines.push(rendered.content, "");
+        break;
+      }
+    }
+  }
+
+  lines.push(...renderReadNextSection(available.flatMap((section) => section.readNext)));
+  return lines.join("\n");
+}
+
+function sectionCount(
+  section: Extract<GraphResultAssembly["sections"][number], { kind: "ok" }>,
+): number {
+  return section.evidence.metadata.totalCount ?? section.evidence.metadata.shownCount;
+}
+
+function renderReferencesResult(options: {
+  symbolName: string;
+  references: EvidenceList<ReferenceEntry>;
+  externalCount: number;
+  confidence: string;
+  cwd: string;
+}): { content: string; evidenceList: EvidenceListMetadata | null } {
+  const total = options.references.metadata.totalCount ?? options.references.metadata.shownCount;
+  const lines = [
+    `# References of \`${options.symbolName}\``,
+    "",
+    `**${total} reference${total === 1 ? "" : "s"}** (${options.confidence})`,
+  ];
+  if (options.externalCount > 0) {
+    lines.push(
+      `_+${options.externalCount} external reference${options.externalCount === 1 ? "" : "s"}_`,
+    );
+  }
+  const invalidDisclosure = renderInvalidProviderLocations(options.references.metadata);
+  if (invalidDisclosure) lines.push(invalidDisclosure);
+  lines.push("");
+
+  const displayEvidence = {
+    key: options.references.key,
+    items: options.references.items.map((reference) => ({
+      file: toDisplayPath(options.cwd, reference.file),
+      line: reference.line,
+    })),
+    metadata: options.references.metadata,
+  };
+  const evidenceList = formatAssembledReferenceList(lines, displayEvidence);
+  return { content: lines.join("\n"), evidenceList };
+}
+
+function renderCallsResult(
+  enclosingScope: CalleeScope,
+  calls: EvidenceList<CallEntry>,
+  relPath: string,
+  depth: "direct" | "deep" = "direct",
+): { content: string; evidenceList: EvidenceListMetadata } {
+  const lines: string[] = [];
+  const depthLabel = depth === "deep" ? "Deep structural calls" : "Direct structural calls";
+  const depthNote =
+    depth === "deep"
+      ? "_Deep: includes calls from nested function/method/callback scopes within the enclosing scope._"
+      : "_Structural only: call expressions are reported by source shape, not symbol identity; calls inside nested function/method/callback scopes are excluded from this enclosing scope._";
+  const total = calls.metadata.totalCount ?? calls.metadata.shownCount;
+
+  lines.push(`# ${depthLabel} from \`${enclosingScope.name}\``, "");
+  lines.push(
+    `**${total} ${depth === "deep" ? "" : "direct "}structural call${total === 1 ? "" : "s"}** from enclosing scope \`${enclosingScope.name}\` (${formatScopeRange(enclosingScope)}) in \`${relPath}\``,
+    "",
+    depthNote,
+    "",
+  );
+
+  for (const call of calls.items) lines.push(`- \`${call.name}\` (L${call.line})`);
+  const disclosure = renderEvidenceListMetadataDisclosure(calls.metadata);
+  if (disclosure) lines.push(disclosure);
+  return { content: lines.join("\n"), evidenceList: calls.metadata };
+}
+
+function renderImplementationsResult(options: {
+  implementations: EvidenceList<ImplementationEntry>;
+  externalCount: number;
+  cwd: string;
+  targetName?: string;
+}): { content: string; evidenceList: EvidenceListMetadata } {
+  const lines: string[] = [
+    options.targetName
+      ? `# Implementations of \`${options.targetName}\` (semantic)`
+      : "# Implementations (semantic)",
+    "",
+  ];
+  const total =
+    options.implementations.metadata.totalCount ?? options.implementations.metadata.shownCount;
+  if (total > 0) {
+    lines.push(`**${total} implementation${total === 1 ? "" : "s"}** in the project`, "");
+    for (const [file, locations] of groupByFile(options.implementations.items, options.cwd)) {
+      lines.push(`### ${file}`, `- ${compactLineRanges(locations)}`, "");
+    }
+    const disclosure = renderEvidenceListMetadataDisclosure(options.implementations.metadata);
+    if (disclosure) lines.push(disclosure);
+  }
+
+  if (options.externalCount > 0) {
+    lines.push(
+      `_+${options.externalCount} external location${options.externalCount === 1 ? "" : "s"} (outside this project)_`,
+      "",
+    );
+  }
+  const invalidDisclosure = renderInvalidProviderLocations(options.implementations.metadata);
+  if (invalidDisclosure) lines.push(invalidDisclosure, "");
+
+  return { content: lines.join("\n"), evidenceList: options.implementations.metadata };
+}
+
+function formatScopeRange(scope: CalleeScope): string {
+  if (scope.startLine === scope.endLine) return `L${scope.startLine}`;
+  return `L${scope.startLine}–L${scope.endLine}`;
+}
+
+function groupByFile(impls: readonly ImplementationEntry[], cwd: string): Map<string, number[]> {
+  const byFile = new Map<string, number[]>();
+  for (const impl of impls) {
+    const displayPath = toDisplayPath(cwd, impl.file);
+    const group = byFile.get(displayPath) ?? [];
+    group.push(impl.line);
+    byFile.set(displayPath, group);
+  }
+  return byFile;
+}
+
+/** Render an explicit disclosure for unusable semantic-provider locations. */
+function renderInvalidProviderLocations(metadata: EvidenceListMetadata): string | null {
+  const count = metadata.invalidLocationCount ?? 0;
+  if (count <= 0 || metadata.partialReason === null) return null;
+  const noun = count === 1 ? "location" : "locations";
+  return `_${count} invalid provider ${noun} omitted (${metadata.partialReason})_`;
+}

package/src/tool/orientation/markdown.ts

@@ -1,30 +1,85 @@
+import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
 import { renderReadNextSection } from "../../analysis/read-next.ts";
+import type {
+  OrientationItem,
+  OrientationProvenance,
+  OrientationSectionData,
+} from "../../session/orientation-types.ts";
 import { assembledReadNext } from "../result/assembly.ts";
 import type { OrientationResultAssembly } from "../result/orientation.ts";
 
-/** Render assembled Orientation blocks into the model-facing markdown adapter. */
+/**
+ * Sole model-facing markdown adapter for Orientation.
+ *
+ * Collectors emit presentation-neutral facts (title, notes, and per-section
+ * {@link OrientationItem}s); this adapter owns all document framing — the
+ * leading notes, the h1 title, the optional Focus section, and each section's
+ * h2 heading + status note.
+ */
 export function renderOrientationResult(assembly: OrientationResultAssembly): string {
   const data = assembly.assembled.data;
   const lines: string[] = [];
-  for (const block of data.blocks) {
-    switch (block.kind) {
-      case "heading":
-        lines.push(`${"#".repeat(block.level)} ${block.text}`);
-        break;
+
+  for (const note of data.notes) lines.push(note);
+  if (data.notes.length > 0) lines.push("");
+
+  lines.push(`# ${data.title}`, "");
+
+  if (data.target && data.focusTarget) {
+    lines.push("## Focus", `- \`${data.focusTarget}\``, "");
+  }
+
+  for (const section of data.sections) {
+    lines.push(`## ${section.title}`, formatSectionNote(section));
+    renderItems(lines, section.items);
+    lines.push("");
+  }
+
+  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
+  return lines.join("\n").trimEnd();
+}
+
+function renderItems(lines: string[], items: readonly OrientationItem[]): void {
+  for (const item of items) {
+    switch (item.kind) {
       case "paragraph":
-        lines.push(block.text);
+        lines.push(item.text);
         break;
       case "list-item":
-        lines.push(`- ${block.text}`);
+        lines.push(`- ${item.text}`);
+        break;
+      case "subheading":
+        lines.push(`### ${item.text}`);
         break;
       case "code":
-        lines.push(`\`\`\`${block.language ?? ""}`, ...block.lines, "```");
+        lines.push(`\`\`\`${item.language ?? ""}`, ...item.lines, "```");
         break;
       case "blank":
         lines.push("");
         break;
     }
   }
-  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
-  return lines.join("\n").trimEnd();
+}
+
+/** Render the same section status/provenance metadata stored in result details. */
+function formatSectionNote(section: OrientationSectionData): string {
+  const facts = section.evidenceLists.map(evidenceSummary).join("; ");
+  const provenance = section.provenance.map(formatProvenance).join(", ");
+  return `_(status: ${section.status}; provenance: ${provenance || "none"}${section.reason ? `; ${section.reason}` : ""}${facts ? `; ${facts}` : ""})_`;
+}
+
+function evidenceSummary(metadata: EvidenceListMetadata): string {
+  if (metadata.totalCount === null) {
+    const omitted = metadata.omittedCount ? `; ${metadata.omittedCount} collected omitted` : "";
+    return `showing ${metadata.shownCount}${omitted}; more may exist — ${metadata.partialReason ?? "partial"}`;
+  }
+  if ((metadata.omittedCount ?? 0) > 0) {
+    return `showing ${metadata.shownCount} of ${metadata.totalCount}; ${metadata.omittedCount} omitted`;
+  }
+  return `${metadata.totalCount} observed`;
+}
+
+function formatProvenance(provenance: OrientationProvenance): string {
+  const detail = provenance.detail ? ` \`${provenance.detail}\`` : "";
+  return `${provenance.source}${provenance.capability ? ` (${provenance.capability})` : ""}${detail}`;
 }

package/src/tool/register.ts

@@ -74,12 +74,22 @@ function getToolRenderer(name: string): ToolRenderer {
  * @param getOrCreateSession — session factory; production passes the app-managed
  *   sessions, tests pass a `createSessionCache`-backed factory.
  */
+const registeredPis = new WeakSet<object>();
+
 export function registerCodeIntelligenceTools(
   pi: ExtensionAPI,
   getOrCreateSession: (cwd: string) => WorkspaceCodeIntelligenceSession,
   promptSurfaces: CodeIntelligenceToolPromptSurfaceMap = CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES,
   specs: readonly CodeIntelligenceToolDefinitionSpec[] = CODE_INTELLIGENCE_TOOL_SPECS,
 ): void {
+  // Skip when another copy is already loaded (e.g. standalone install + bundled
+  // copy inside supi-review). Pi loads packages with separate module roots, so
+  // module-level state is not shared. Key on the pi object: both copies receive
+  // the same ExtensionAPI in one process, while tests get fresh mocks.
+  // ponytail: WeakSet on pi identity; getAllTools() is not callable during load.
+  if (registeredPis.has(pi)) return;
+  registeredPis.add(pi);
+
   for (const spec of specs) {
     const surface = promptSurfaces[spec.name];
     pi.registerTool({

package/src/ui/footer.ts

@@ -1,29 +1,38 @@
 /**
  * LSP footer stats-end contribution for code-intelligence.
  *
- * Provides the persistent "| λ lsp • N servers • M open files" suffix on the
+ * Provides the persistent "| λ lsp • N ✓ • M open files" suffix on the
  * footer stats line, after cost and context info. This was removed during the
  * supi-lsp → supi-code-intelligence migration.
  */
 
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { footerContributions } from "@mrclrchtr/supi-core/footer-registry";
-import type { LspAdapterState } from "../substrate/lsp/state.ts";
+import { LSP_STATE_CHANGE_EVENT, type LspAdapterState } from "../substrate/lsp/state.ts";
 
-/** Build the LSP status text: "λ lsp • 2 servers • 5 open files" */
+/** Build the LSP status text: "λ lsp • 3 ✓ • 1 ⟳ • 1 ✗ • 2 open files" */
 export function buildLspStatusText(lspState: LspAdapterState): string | undefined {
   const controller = lspState.controller;
   const runtime = controller?.workspaceRuntime;
   if (!runtime) return undefined;
 
   const servers = runtime.getProjectServers();
-  const runningServers = servers.filter((s) => s.status === "running").length;
   const openFiles = servers.reduce((sum, s) => sum + s.openFiles.length, 0);
 
-  if (runningServers === 0 && openFiles === 0) return undefined;
+  // Aggregate server states
+  const ready = servers.filter((s) => s.status === "running" && s.ready).length;
+  const starting = servers.filter((s) => s.status === "running" && !s.ready).length;
+  const error = servers.filter((s) => s.status === "error").length;
+  const unavailable = servers.filter((s) => s.status === "unavailable").length;
+
+  const hasServers = ready + starting + error + unavailable > 0;
+  if (!hasServers && openFiles === 0) return undefined;
 
   const parts = ["λ lsp"];
-  if (runningServers > 0)
-    parts.push(`${runningServers} ${runningServers === 1 ? "server" : "servers"}`);
+  if (ready > 0) parts.push(`${ready} ✓`);
+  if (starting > 0) parts.push(`${starting} ⟳`);
+  if (error > 0) parts.push(`${error} ✗`);
+  if (unavailable > 0) parts.push(`${unavailable} ⊘`);
   if (openFiles > 0) parts.push(`${openFiles} ${openFiles === 1 ? "open file" : "open files"}`);
   return parts.join(" • ");
 }
@@ -33,7 +42,12 @@ export function buildLspStatusText(lspState: LspAdapterState): string | undefine
 const FOOTER_KEY = "lsp-status";
 
 /** Register the LSP stats-end footer contribution for the given adapter state. */
-export function registerLspFooterContribution(lspState: LspAdapterState): void {
+export function registerLspFooterContribution(
+  pi: ExtensionAPI,
+  lspState: LspAdapterState,
+): {
+  dispose: () => void;
+} {
   footerContributions.register({
     key: FOOTER_KEY,
     placement: "stats-end",
@@ -44,6 +58,17 @@ export function registerLspFooterContribution(lspState: LspAdapterState): void {
       return `| ${text}`;
     },
   });
+
+  // Trigger TUI re-render when server states change.
+  const handler = () => pi.events.emit("supi:lsp:invalidate", {});
+  lspState.stateChanges.addEventListener(LSP_STATE_CHANGE_EVENT, handler);
+
+  return {
+    dispose() {
+      lspState.stateChanges.removeEventListener(LSP_STATE_CHANGE_EVENT, handler);
+      unregisterLspFooterContribution();
+    },
+  };
 }
 
 /** Remove the LSP stats footer contribution. */