omegon 0.6.0

package/extensions/dashboard/overlay.ts

@@ -0,0 +1,365 @@
+/**
+ * Dashboard interactive overlay (Layer 2).
+ *
+ * Right-anchored sidepanel with three tabs:
+ *   [1] Design Tree — node list with status icons, expand to show questions
+ *   [2] Implementation — change list with stage/progress
+ *   [3] Cleave      — dispatch children with status/elapsed
+ *
+ * Keyboard:
+ *   Tab / 1-3    — switch tabs
+ *   ↑/↓          — navigate items
+ *   Enter/→      — expand/collapse item
+ *   ←            — collapse expanded item
+ *   Esc / ctrl+c — close overlay
+ *
+ * Reads sharedState for all data. Subscribes to dashboard:update for live refresh.
+ */
+
+import { spawn } from "node:child_process";
+import type { ExtensionContext } from "@cwilson613/pi-coding-agent";
+import type { Theme } from "@cwilson613/pi-coding-agent";
+import type { TUI } from "@cwilson613/pi-tui";
+import { matchesKey, truncateToWidth, visibleWidth } from "@cwilson613/pi-tui";
+import { DASHBOARD_UPDATE_EVENT, sharedState } from "../shared-state.ts";
+import {
+  TABS,
+  MAX_CONTENT_LINES,
+  rebuildItems,
+  clampIndex,
+  type TabId,
+  type ListItem,
+} from "./overlay-data.ts";
+
+/**
+ * Full-screen blocking overlay options for the /dashboard operator panel.
+ * No width/height restrictions — consumes the entire terminal.
+ */
+export const INSPECTION_OVERLAY_OPTIONS = {
+  anchor: "center",
+  width: "100%",
+  minWidth: 60,
+  maxHeight: "100%",
+  margin: 0,
+  visible: (_termWidth: number) => true,
+} as const;
+
+// ── Overlay Component ───────────────────────────────────────────
+
+export class DashboardOverlay {
+  private tui: TUI;
+  private theme: Theme;
+  private done: (result: void) => void;
+
+  private activeTab: TabId = "design";
+  private selectedIndex = 0;
+  private flatItems: ListItem[] = [];
+  private expandedKeys = new Set<string>();
+  private statusMessage: string | null = null;
+
+  /** Event unsubscribe handle for live refresh. */
+  private unsubscribe: (() => void) | null = null;
+  /** Interval handle for the 1-second elapsed ticker while children are running. */
+  private tickerInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(tui: TUI, theme: Theme, done: (result: void) => void) {
+    this.tui = tui;
+    this.theme = theme;
+    this.done = done;
+    this.rebuild();
+  }
+
+  /** Attach to the pi event bus for live data refresh while overlay is open. */
+  setEventBus(events: { on(event: string, handler: (data: unknown) => void): () => void }): void {
+    this.unsubscribe = events.on(DASHBOARD_UPDATE_EVENT, () => {
+      this.rebuild();
+      this.syncTicker();
+      this.tui.requestRender();
+    });
+  }
+
+  /**
+   * Start or stop the 1-second ticker based on whether any children are running.
+   * The ticker drives the live elapsed counter without needing a shared-state event.
+   */
+  private syncTicker(): void {
+    const cl = sharedState.cleave;
+    const anyRunning = cl?.children?.some((c: { status: string }) => c.status === "running") ?? false;
+
+    if (anyRunning && !this.tickerInterval) {
+      this.tickerInterval = setInterval(() => {
+        // Only re-render if still have running children
+        const cl2 = sharedState.cleave;
+        if (cl2?.children?.some((c: { status: string }) => c.status === "running")) {
+          this.tui.requestRender();
+        } else {
+          this.stopTicker();
+        }
+      }, 1_000);
+    } else if (!anyRunning) {
+      this.stopTicker();
+    }
+  }
+
+  private stopTicker(): void {
+    if (this.tickerInterval !== null) {
+      clearInterval(this.tickerInterval);
+      this.tickerInterval = null;
+    }
+  }
+
+  private selectFirstOpenableItem(): void {
+    const firstOpenable = this.flatItems.findIndex((item) => !!item.openUri);
+    if (firstOpenable >= 0) {
+      this.selectedIndex = firstOpenable;
+    }
+  }
+
+  private openSelectedItem(): void {
+    const item = this.flatItems[this.selectedIndex];
+    if (!item?.openUri) {
+      this.statusMessage = "Selected row has nothing to open";
+      this.tui.requestRender();
+      return;
+    }
+
+    this.statusMessage = "Opening selected item…";
+    this.tui.requestRender();
+
+    try {
+      if (process.platform === "darwin") {
+        spawn("open", [item.openUri], { stdio: "ignore", detached: true }).unref();
+      } else if (process.platform === "win32") {
+        spawn("cmd", ["/c", "start", "", item.openUri], { stdio: "ignore", detached: true }).unref();
+      } else {
+        spawn("xdg-open", [item.openUri], { stdio: "ignore", detached: true }).unref();
+      }
+    } catch {
+      this.statusMessage = "Open failed";
+      this.tui.requestRender();
+      // Best effort only; clickable OSC 8 links remain the primary path.
+    }
+  }
+
+  // ── Keyboard handling ───────────────────────────────────────────
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+      this.done();
+      return;
+    }
+
+    // Tab switching
+    if (matchesKey(data, "tab")) {
+      const idx = TABS.findIndex((t) => t.id === this.activeTab);
+      this.activeTab = TABS[(idx + 1) % TABS.length]!.id;
+      this.selectedIndex = 0;
+      this.statusMessage = null;
+      this.rebuild();
+      this.selectFirstOpenableItem();
+      this.tui.requestRender();
+      return;
+    }
+
+    for (const tab of TABS) {
+      if (data === tab.shortcut) {
+        this.activeTab = tab.id;
+        this.selectedIndex = 0;
+        this.statusMessage = null;
+        this.rebuild();
+        this.selectFirstOpenableItem();
+        this.tui.requestRender();
+        return;
+      }
+    }
+
+    // Navigation — guard empty list
+    if (this.flatItems.length === 0) return;
+
+    if (matchesKey(data, "up")) {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.statusMessage = null;
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "down")) {
+      this.selectedIndex = Math.min(this.flatItems.length - 1, this.selectedIndex + 1);
+      this.statusMessage = null;
+      this.tui.requestRender();
+      return;
+    }
+
+    // Expand/collapse
+    if (matchesKey(data, "return") || matchesKey(data, "right")) {
+      const item = this.flatItems[this.selectedIndex];
+      if (item?.expandable) {
+        if (this.expandedKeys.has(item.key)) {
+          this.expandedKeys.delete(item.key);
+        } else {
+          this.expandedKeys.add(item.key);
+        }
+        this.statusMessage = null;
+        this.rebuild();
+        this.tui.requestRender();
+      } else if (item?.openUri) {
+        this.openSelectedItem();
+      }
+      return;
+    }
+
+    if (matchesKey(data, "left")) {
+      const item = this.flatItems[this.selectedIndex];
+      if (item && this.expandedKeys.has(item.key)) {
+        this.expandedKeys.delete(item.key);
+        this.statusMessage = null;
+        this.rebuild();
+        this.tui.requestRender();
+      }
+      return;
+    }
+
+    if (data === "o" || data === "O") {
+      this.openSelectedItem();
+      return;
+    }
+  }
+
+  // ── Rendering ─────────────────────────────────────────────────
+
+  render(width: number): string[] {
+    const th = this.theme;
+    const innerW = Math.max(1, width - 2);
+    const border = (c: string) => th.fg("border", c);
+    const pad = (s: string) => truncateToWidth(s, innerW, "…", true);
+
+    // Fixed chrome: top border (1) + tab bar (1) + separator (1) + footer separator (1) + 2 footer lines + bottom border (1) = 7
+
+    const lines: string[] = [];
+
+    // Top border with title
+    const title = " Dashboard ";
+    const titleW = visibleWidth(title);
+    const topLeft = "─".repeat(Math.floor((innerW - titleW) / 2));
+    const topRight = "─".repeat(Math.max(0, innerW - titleW - topLeft.length));
+    lines.push(border("╭" + topLeft) + th.fg("accent", title) + border(topRight + "╮"));
+
+    // Tab bar
+    const tabParts: string[] = [];
+    for (const tab of TABS) {
+      if (tab.id === this.activeTab) {
+        tabParts.push(th.fg("accent", `[${tab.shortcut}] ${tab.label}`));
+      } else {
+        tabParts.push(th.fg("dim", `[${tab.shortcut}] ${tab.label}`));
+      }
+    }
+    lines.push(border("│") + pad(" " + tabParts.join("  ")) + border("│"));
+    lines.push(border("├" + "─".repeat(innerW) + "┤"));
+
+    // Content area — always fill MAX_CONTENT_LINES and rely on maxHeight:"100%"
+    // in the overlay options to clip to actual terminal height. This avoids
+    // stale process.stdout.rows readings that cause a short overlay.
+    const contentLines = this.renderContent(innerW).slice(0, MAX_CONTENT_LINES);
+    if (contentLines.length === 0) {
+      lines.push(border("│") + pad(th.fg("dim", " (no data)")) + border("│"));
+      for (let i = 1; i < MAX_CONTENT_LINES; i++) {
+        lines.push(border("│") + pad("") + border("│"));
+      }
+    } else {
+      for (const cl of contentLines) {
+        lines.push(border("│") + pad(cl) + border("│"));
+      }
+      // Pad to fill MAX_CONTENT_LINES; maxHeight:"100%" clips to terminal height
+      for (let i = contentLines.length; i < MAX_CONTENT_LINES; i++) {
+        lines.push(border("│") + pad("") + border("│"));
+      }
+    }
+
+    // Footer with key hints
+    lines.push(border("├" + "─".repeat(innerW) + "┤"));
+    const footerPrimary = this.statusMessage
+      ? th.fg("warning", ` ${this.statusMessage}`)
+      : th.fg("dim", " ↵/o open selected item  ↑↓ navigate  ←→ expand/collapse");
+    lines.push(border("│") + pad(footerPrimary) + border("│"));
+    lines.push(border("│") + pad(th.fg("dim", " Tab switch  Esc close  items with ↗ are openable")) + border("│"));
+    lines.push(border("╰" + "─".repeat(innerW) + "╯"));
+
+    return lines;
+  }
+
+  private renderContent(innerW: number): string[] {
+    const th = this.theme;
+    const thFn = (color: string, text: string) => th.fg(color as any, text);
+    const lines: string[] = [];
+
+    for (let i = 0; i < this.flatItems.length; i++) {
+      const item = this.flatItems[i]!;
+      const isSelected = i === this.selectedIndex;
+      const indent = "  ".repeat(item.depth);
+      const cursor = isSelected ? th.fg("accent", "→ ") : "  ";
+
+      // Expand indicator
+      let expandIcon = "  ";
+      if (item.expandable) {
+        expandIcon = this.expandedKeys.has(item.key)
+          ? th.fg("dim", "▾ ")
+          : th.fg("dim", "▸ ");
+      }
+
+      const contentWidth = Math.max(1, innerW - 4 - item.depth * 2);
+      const itemLines = item.lines(thFn, contentWidth);
+      const openMarker = item.openUri ? th.fg("accent", "↗ ") : "";
+      if (itemLines.length > 0) {
+        lines.push(`${cursor}${indent}${expandIcon}${openMarker}${truncateToWidth(itemLines[0], contentWidth, "…")}`);
+        for (let j = 1; j < itemLines.length; j++) {
+          lines.push(`  ${indent}  ${truncateToWidth(itemLines[j], contentWidth, "…")}`);
+        }
+      }
+    }
+
+    return lines;
+  }
+
+  // ── State ─────────────────────────────────────────────────────
+
+  private rebuild(): void {
+    this.flatItems = rebuildItems(this.activeTab, this.expandedKeys);
+    this.selectedIndex = clampIndex(this.selectedIndex, this.flatItems.length);
+    if (this.flatItems.length > 0 && !this.flatItems[this.selectedIndex]?.openUri && this.selectedIndex === 0) {
+      this.selectFirstOpenableItem();
+    }
+  }
+
+  // ── Component lifecycle ───────────────────────────────────────
+
+  invalidate(): void {}
+
+  dispose(): void {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    this.stopTicker();
+  }
+}
+
+// ── Public API ──────────────────────────────────────────────────
+
+/**
+ * Show the dashboard overlay as a right-anchored sidepanel.
+ * Blocks until the user presses Esc.
+ */
+export async function showDashboardOverlay(ctx: ExtensionContext, pi?: { events: { on(e: string, h: (data: unknown) => void): () => void } }): Promise<void> {
+  await ctx.ui.custom<void>(
+    (tui, theme, _kb, done) => {
+      const overlay = new DashboardOverlay(tui, theme, done);
+      if (pi?.events) {
+        overlay.setEventBus(pi.events);
+      }
+      return overlay;
+    },
+    {
+      overlay: true,
+      overlayOptions: INSPECTION_OVERLAY_OPTIONS,
+    },
+  );
+}

package/extensions/dashboard/render-utils.ts

@@ -0,0 +1,54 @@
+import { truncateToWidth, visibleWidth } from "@cwilson613/pi-tui";
+
+/**
+ * Pad string `s` to exactly `width` visible columns using visibleWidth().
+ * If `s` is already at or wider than `width`, returns `s` unchanged.
+ */
+export function padRight(s: string, width: number): string {
+  const vw = visibleWidth(s);
+  if (vw >= width) return s;
+  return s + " ".repeat(width - vw);
+}
+
+/**
+ * Render a line with `left` flush-left and `right` flush-right within `width`.
+ * Falls back to truncating `left` to fit if both sides don't fit together.
+ */
+export function leftRight(left: string, right: string, width: number): string {
+  const lw = visibleWidth(left);
+  const rw = visibleWidth(right);
+  const gap = width - lw - rw;
+  if (gap >= 0) {
+    return left + " ".repeat(gap) + right;
+  }
+  // Not enough space — truncate left to fit right
+  const leftWidth = Math.max(0, width - rw);
+  if (leftWidth === 0) return right;
+  return truncateToWidth(left, leftWidth, "…") + right;
+}
+
+/**
+ * Merge two column arrays side-by-side using padRight + truncateToWidth.
+ * Row count = Math.max(leftLines.length, rightLines.length).
+ * Each output row has visibleWidth === leftWidth + divider.length + rightWidth.
+ */
+export function mergeColumns(
+  leftLines: string[],
+  rightLines: string[],
+  leftWidth: number,
+  rightWidth: number,
+  divider = "│"
+): string[] {
+  const rows = Math.max(leftLines.length, rightLines.length);
+  const result: string[] = [];
+  for (let i = 0; i < rows; i++) {
+    const left = i < leftLines.length
+      ? padRight(truncateToWidth(leftLines[i], leftWidth, "…"), leftWidth)
+      : " ".repeat(leftWidth);
+    const right = i < rightLines.length
+      ? truncateToWidth(rightLines[i], rightWidth, "…")
+      : "";
+    result.push(left + divider + padRight(right, rightWidth));
+  }
+  return result;
+}

package/extensions/dashboard/types.ts

@@ -0,0 +1,191 @@
+/**
+ * Dashboard type definitions.
+ *
+ * These interfaces define the shape of dashboard state
+ * written by producer extensions (design-tree, openspec, cleave)
+ * and read by the dashboard extension for rendering.
+ *
+ * Re-exported from shared-state.ts for convenience.
+ */
+
+// ── Design Tree ──────────────────────────────────────────────
+
+/** Mirrors DesignSpecBinding from openspec/archive-gate.ts for dashboard consumers. */
+export interface DesignSpecBindingState {
+  active: boolean;
+  archived: boolean;
+  missing: boolean;
+}
+
+/** Acceptance-criteria counts derived from a design node's AC section. */
+export interface AcSummary {
+  scenarios: number;
+  falsifiability: number;
+  constraints: number;
+}
+
+/** Outcome of an /assess spec run persisted in openspec/design/<id>/assessment.json. */
+export interface DesignAssessmentResult {
+  outcome: "pass" | "reopen" | "ambiguous";
+  timestamp: string;
+  summary?: string;
+}
+
+/** Per-status counts across the design pipeline for funnel rendering. */
+export interface DesignPipelineCounts {
+  /** seed/exploring nodes without a spec binding */
+  needsSpec: number;
+  /** seed/exploring nodes with an active or archived spec binding */
+  designing: number;
+  /** nodes in 'decided' status */
+  decided: number;
+  /** nodes in 'implementing' status */
+  implementing: number;
+  /** nodes in 'implemented' status */
+  done: number;
+}
+
+export interface DesignTreeFocusedNode {
+  id: string;
+  title: string;
+  status: string;
+  questions: string[];
+  branch?: string;
+  branchCount?: number;
+  filePath?: string;
+}
+
+export interface DesignTreeDashboardState {
+  nodeCount: number;
+  decidedCount: number;
+  exploringCount: number;
+  implementingCount: number;
+  implementedCount: number;
+  blockedCount: number;
+  deferredCount: number;
+  openQuestionCount: number;
+  focusedNode: DesignTreeFocusedNode | null;
+  /** All nodes for overlay list view */
+  nodes?: Array<{
+    id: string;
+    title: string;
+    status: string;
+    questionCount: number;
+    filePath?: string;
+    branches?: string[];
+    /** OpenSpec design-phase binding state (undefined for seed nodes) */
+    designSpec?: DesignSpecBindingState;
+    /** Acceptance-criteria counts (undefined if no AC section) */
+    acSummary?: AcSummary | null;
+    /** Last /assess spec result (undefined if no assessment.json) */
+    assessmentResult?: DesignAssessmentResult | null;
+    /** Name of linked openspec implementation change (set by design-tree on emit) */
+    openspecChange?: string | null;
+  }>;
+  /** Implementing nodes shown in raised mode with branch associations */
+  implementingNodes?: Array<{ id: string; title: string; branch?: string; filePath?: string }>;
+  /** Design pipeline funnel counts */
+  designPipeline?: DesignPipelineCounts;
+}
+
+// ── OpenSpec ─────────────────────────────────────────────────
+
+export interface OpenSpecChangeEntry {
+  name: string;
+  stage: string;
+  tasksDone: number;
+  tasksTotal: number;
+  /** Which lifecycle artifacts exist */
+  artifacts?: ("proposal" | "design" | "specs" | "tasks")[];
+  /** Spec domain names (e.g. ["auth", "api/tokens"]) */
+  specDomains?: string[];
+  /** Absolute path to the change directory */
+  path?: string;
+}
+
+export interface OpenSpecDashboardState {
+  changes: OpenSpecChangeEntry[];
+}
+
+// ── Cleave ───────────────────────────────────────────────────
+
+export type CleaveStatus =
+  | "idle"
+  | "assessing"
+  | "planning"
+  | "dispatching"
+  | "merging"
+  | "done"
+  | "failed";
+
+export interface CleaveChildState {
+  label: string;
+  status: "pending" | "running" | "done" | "failed";
+  elapsed?: number;
+  /** Epoch ms when the child transitioned to "running". Used for live elapsed calculation. */
+  startedAt?: number;
+  /** Ring buffer of the last 30 meaningful stdout lines from the child process (filtered). */
+  recentLines?: string[];
+  /** Worktree path for this child — used to run git diff on demand. */
+  worktreePath?: string;
+  /** Last meaningful stdout line — kept in sync with recentLines tail for backward compat. */
+  lastLine?: string;
+}
+
+export interface CleaveState {
+  status: CleaveStatus;
+  runId?: string;
+  children?: CleaveChildState[];
+  /** Unix epoch ms of the last cleave dashboard update */
+  updatedAt?: number;
+}
+
+// ── Harness Recovery ─────────────────────────────────────────
+
+export type RecoveryAction =
+  | "retry"
+  | "switch_candidate"
+  | "switch_offline"
+  | "cooldown"
+  | "escalate"
+  | "observe";
+
+export interface RecoveryTarget {
+  provider: string;
+  modelId?: string;
+  label?: string;
+}
+
+export interface RecoveryCooldownSummary {
+  scope: "provider" | "candidate";
+  key: string;
+  provider?: string;
+  modelId?: string;
+  until: number;
+  reason?: string;
+}
+
+export interface RecoveryDashboardState {
+  provider: string;
+  modelId: string;
+  classification: string;
+  summary: string;
+  action: RecoveryAction;
+  retryCount?: number;
+  maxRetries?: number;
+  attemptId?: string;
+  timestamp: number;
+  escalated?: boolean;
+  target?: RecoveryTarget;
+  cooldowns?: RecoveryCooldownSummary[];
+}
+
+// ── Dashboard UI ─────────────────────────────────────────────
+
+export type DashboardMode = "compact" | "raised" | "panel" | "focused";
+
+/** Mutable state held by the dashboard extension, read by the footer component. */
+export interface DashboardState {
+  mode: DashboardMode;
+  turns: number;
+}

package/extensions/dashboard/uri-helper.ts

@@ -0,0 +1,45 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import { getMdservePort } from "../vault/index.ts";
+import { loadConfig, osc8Link, resolveUri } from "../view/uri-resolver.ts";
+
+export type OpenSpecArtifact = "proposal" | "design" | "tasks";
+
+function resolveDashboardUri(absPath?: string): string | undefined {
+  if (!absPath) return undefined;
+  return resolveUri(absPath, {
+    mdservePort: getMdservePort() ?? undefined,
+    config: loadConfig(),
+    projectRoot: process.cwd(),
+  });
+}
+
+function linkText(text: string, absPath?: string): string {
+  const uri = resolveDashboardUri(absPath);
+  return uri ? osc8Link(uri, text) : text;
+}
+
+export function getDashboardFileUri(absPath?: string): string | undefined {
+  return resolveDashboardUri(absPath);
+}
+
+export function linkDashboardFile(text: string, absPath?: string): string {
+  return linkText(text, absPath);
+}
+
+export function getOpenSpecArtifactUri(changePath: string | undefined, artifact: OpenSpecArtifact): string | undefined {
+  if (!changePath) return undefined;
+  const artifactPath = join(changePath, `${artifact}.md`);
+  if (!existsSync(artifactPath)) return undefined;
+  return resolveDashboardUri(artifactPath);
+}
+
+export function linkOpenSpecArtifact(text: string, changePath: string | undefined, artifact: OpenSpecArtifact): string {
+  const uri = getOpenSpecArtifactUri(changePath, artifact);
+  return uri ? osc8Link(uri, text) : text;
+}
+
+export function linkOpenSpecChange(text: string, changePath?: string): string {
+  return linkOpenSpecArtifact(text, changePath, "proposal");
+}