@pellux/goodvibes-tui 2.0.20 → 2.1.0

package/src/core/work-tree-wiring.ts

@@ -0,0 +1,176 @@
+/**
+ * work-tree-wiring.ts, connecting the conversation work tree to the live
+ * runtime: the timing store fed by tool and turn events, agent lanes read
+ * from the agent manager (WRFC chains from the chain controller, cost from
+ * the fleet read model), the call a permission prompt is holding, and the
+ * per-session fold state.
+ *
+ * One call from main.ts; everything the work tree reads at render time goes
+ * through the WorkTreeSources this installs.
+ */
+
+import type { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
+import type { WrfcChain } from '@pellux/goodvibes-sdk/platform/agents';
+import type { ProcessNode } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import type { UiRuntimeEvents } from '@/runtime/index.ts';
+import type { ConversationManager } from './conversation.ts';
+import { WorkTreeTimingStore, userMessageFingerprint, type AgentLaneInfo, type TurnOutcome, type WrfcPhaseInfo } from './work-tree-sources.ts';
+import { loadWorkTreeFolds, loadWorkTreeTurnOutcomes, saveWorkTreeFolds, sweepOrphanWorkTreeFolds } from './work-tree-fold-store.ts';
+import { onSemanticSummaryReady } from '../renderer/lane-graph/semantic-memo.ts';
+import { onSyntaxHighlightReady } from '../renderer/code-block.ts';
+
+type AgentRecord = ReturnType<AgentManager['list']>[number];
+
+export interface WorkTreeWiringDeps {
+  readonly conversation: ConversationManager;
+  readonly events: UiRuntimeEvents;
+  readonly agentManager: Pick<AgentManager, 'getStatus' | 'getConversationSnapshot'>;
+  readonly listChains: () => readonly WrfcChain[];
+  readonly fleetNodes: () => readonly ProcessNode[];
+  /** The call id a permission prompt is holding, if any. */
+  readonly pendingCallId: () => string | undefined;
+  readonly turnActive: () => boolean;
+  readonly sessionsDir: string;
+  readonly sessionId: () => string;
+  /** Repaint (a ◈ summary of an opened edit landed). */
+  readonly requestRender: () => void;
+}
+
+function firstLines(text: string | undefined, n: number): string | undefined {
+  if (!text) return undefined;
+  const lines = text.split('\n').filter((l) => l.trim().length > 0).slice(0, n);
+  return lines.length > 0 ? lines.join('\n') : undefined;
+}
+
+/** A finished agent's transcript never changes: read it once. */
+interface SnapshotMemo { readonly stamp: string; readonly messages: readonly ConversationMessageSnapshot[] }
+
+export function wireWorkTree(deps: WorkTreeWiringDeps): { readonly timings: WorkTreeTimingStore; readonly unsubs: Array<() => void> } {
+  const timings = new WorkTreeTimingStore();
+  const unsubs: Array<() => void> = [];
+  const { conversation, events } = deps;
+
+  unsubs.push(events.tools.on('TOOL_EXECUTING', (ev) => timings.callStarted(ev.callId, ev.startedAt)));
+  unsubs.push(events.tools.on('TOOL_SUCCEEDED', (ev) => timings.callSettled(ev.callId, ev.durationMs, Date.now())));
+  unsubs.push(events.tools.on('TOOL_FAILED', (ev) => timings.callSettled(ev.callId, ev.durationMs, Date.now())));
+  unsubs.push(events.tools.on('TOOL_CANCELLED', (ev) => timings.callSettled(ev.callId, undefined, Date.now())));
+  // Everything the session sidecar keeps: fold decisions and failed/cancelled turn endings.
+  const persistView = (): void => saveWorkTreeFolds(deps.sessionsDir, deps.sessionId(), conversation.workTree.foldState(), conversation.workTree.turnOutcomes());
+
+  unsubs.push(events.turns.on('TURN_SUBMITTED', () => {
+    const snapshot = conversation.getMessageSnapshot();
+    for (let i = snapshot.length - 1; i >= 0; i--) {
+      if (snapshot[i]!.role === 'user') { timings.turnStarted(i, Date.now(), userMessageFingerprint(snapshot[i])); break; }
+    }
+  }));
+  const endTurn = (outcome: TurnOutcome): void => {
+    const ended = timings.turnEnded(Date.now(), outcome);
+    // The header drops "working" and states a failure on the next build.
+    conversation.workTree.invalidate();
+    if (!ended || ended.timing.fingerprint === undefined) return;
+    if (conversation.workTree.recordTurnOutcome({ index: ended.index, fingerprint: ended.timing.fingerprint, outcome })) persistView();
+  };
+  unsubs.push(events.turns.on('TURN_COMPLETED', (ev) => endTurn(ev.stopReason === 'empty_response' ? 'failed' : 'completed')));
+  unsubs.push(events.turns.on('TURN_ERROR', () => endTurn('failed')));
+  unsubs.push(events.turns.on('TURN_CANCEL', () => endTurn('cancelled')));
+  unsubs.push(events.turns.on('PREFLIGHT_FAIL', () => endTurn('failed')));
+  // A new or resumed transcript: turn timings are keyed by message index and belong to the old one.
+  unsubs.push(conversation.workTree.onReset(() => timings.clear()));
+
+  const snapshots = new Map<string, SnapshotMemo>();
+  const messagesOf = (record: AgentRecord): readonly ConversationMessageSnapshot[] => {
+    const finished = record.status !== 'running' && record.status !== 'pending';
+    const stamp = `${record.status}:${record.completedAt ?? ''}:${record.toolCallCount}`;
+    const memo = snapshots.get(record.id);
+    if (finished && memo && memo.stamp === stamp) return memo.messages;
+    const messages = deps.agentManager.getConversationSnapshot(record.id);
+    if (finished) snapshots.set(record.id, { stamp, messages });
+    return messages;
+  };
+
+  const costOf = (agentId: string): number | undefined => {
+    const node = deps.fleetNodes().find((n) => n.id === agentId);
+    // Only a real reading: an unpriced node has no cost to state.
+    return node && node.costState !== 'unpriced' && typeof node.costUsd === 'number' ? node.costUsd : undefined;
+  };
+
+  const wrfcPhases = (record: AgentRecord): { phases: WrfcPhaseInfo[]; passed: boolean | undefined } | undefined => {
+    const chain = deps.listChains().find((c) => c.ownerAgentId === record.id || (c.engineerAgentId === record.id && c.ownerAgentId === c.engineerAgentId));
+    if (!chain) return undefined;
+    const phases: WrfcPhaseInfo[] = [];
+    for (const id of chain.allAgentIds) {
+      if (id === chain.ownerAgentId && id !== chain.engineerAgentId) continue;
+      const phase = deps.agentManager.getStatus(id);
+      if (!phase) continue;
+      const role = (phase.wrfcRole ?? (id === chain.engineerAgentId ? 'engineer' : id === chain.reviewerAgentId ? 'reviewer' : id === chain.fixerAgentId ? 'fixer' : 'engineer')) as WrfcPhaseInfo['role'];
+      const latestReview = role === 'reviewer' && id === chain.reviewerAgentId ? chain.reviewerReport : undefined;
+      phases.push({
+        agentId: id,
+        role,
+        task: phase.task,
+        status: phase.status,
+        startedAt: phase.startedAt,
+        completedAt: phase.completedAt,
+        findings: latestReview?.issues.map((issue) => issue.description),
+        passed: latestReview ? (chain.lastReviewVerdict?.passed ?? latestReview.passed) : undefined,
+        output: firstLines(phase.fullOutput, 6),
+      });
+    }
+    phases.sort((a, b) => (a.startedAt ?? 0) - (b.startedAt ?? 0));
+    const passed = chain.state === 'passed' ? true : chain.state === 'failed' ? false : undefined;
+    return { phases, passed };
+  };
+
+  const agent = (agentId: string): AgentLaneInfo | null => {
+    const record = deps.agentManager.getStatus(agentId);
+    if (!record) return null;
+    const wrfc = wrfcPhases(record);
+    return {
+      id: record.id,
+      name: record.template,
+      task: record.task,
+      status: record.status,
+      startedAt: record.startedAt,
+      completedAt: record.completedAt,
+      toolCallCount: record.toolCallCount,
+      costUsd: costOf(record.id),
+      error: record.error,
+      messages: wrfc ? [] : messagesOf(record),
+      wrfcPhases: wrfc?.phases,
+      wrfcPassed: wrfc?.passed,
+    };
+  };
+
+  conversation.setWorkTreeSources({
+    callTiming: (callId) => timings.callTiming(callId),
+    turnTiming: (index) => timings.turnTiming(index),
+    agent,
+    waitingCallIds: () => {
+      const id = deps.pendingCallId();
+      return id ? new Set([id]) : new Set<string>();
+    },
+    turnActive: deps.turnActive,
+    turnOutcome: (index) => conversation.workTree.turnOutcome(index),
+    now: () => Date.now(),
+  });
+
+  // Fold decisions persist per session, beside the session file.
+  conversation.workTree.onFoldChange(persistView);
+  sweepOrphanWorkTreeFolds(deps.sessionsDir);
+  unsubs.push(onSemanticSummaryReady(() => { conversation.workTree.invalidate(); deps.requestRender(); }));
+  // A tree-sitter parse landed: code drawn with the regex placeholder is redrawn with it.
+  unsubs.push(onSyntaxHighlightReady(() => { conversation.workTree.invalidate(); deps.requestRender(); }));
+  return { timings, unsubs };
+}
+
+/**
+ * Restore a resumed session's fold decisions and failed/cancelled turn
+ * endings (called by the resume routine, after the transcript is restored).
+ */
+export function restoreWorkTreeFolds(conversation: ConversationManager, sessionsDir: string, sessionId: string): number {
+  const entries = loadWorkTreeFolds(sessionsDir, sessionId);
+  conversation.workTree.restoreFoldState(entries);
+  conversation.workTree.restoreTurnOutcomes(loadWorkTreeTurnOutcomes(sessionsDir, sessionId));
+  return entries.length;
+}

package/src/core/workstream-notification.ts

@@ -18,11 +18,17 @@
  * their reasons, which is the same principle the channel renderer follows: in
  * plain words, never by an opaque identifier.
  *
+ * The title names the work (owner ruling 2026-09-29): the workstream's task,
+ * trimmed at a word boundary, and the body adds the last review score when
+ * one was reached. behavior.notificationsMetadataOnly (default off) drops the
+ * task, the reason and the score, leaving what kind of stop it was.
+ *
  * Split out of turn-event-wiring.ts as a pure function so the text is testable
  * on its own, the wiring itself cannot be asserted against without mocking a
  * process-global notifier.
  */
 import { formatTurnBudgetOutcome } from './turn-budget-outcome.ts';
+import { NOTIFICATION_TEXT_LIMITS, trimAtWordBoundary } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 
 /** The fields of WORKFLOW_CHAIN_FAILED this narration reads. */
 export interface WorkstreamFailureNarrationInput {
@@ -32,11 +38,32 @@ export interface WorkstreamFailureNarrationInput {
   readonly turnLimitSource?: 'default' | 'spawn-override' | 'policy-bound' | undefined;
 }
 
+/** What the host remembers about the workstream, and the privacy setting. */
+export interface WorkstreamNotificationContext {
+  /** The workstream's task, from WORKFLOW_CHAIN_CREATED. */
+  readonly task?: string | null | undefined;
+  /** The last review score (out of 10), from WORKFLOW_REVIEW_COMPLETED. */
+  readonly reviewScore?: number | null | undefined;
+  /** behavior.notificationsMetadataOnly */
+  readonly metadataOnly?: boolean | undefined;
+}
+
 export interface WorkstreamNotification {
   readonly title: string;
   readonly body: string;
 }
 
+function titled(outcome: string, context: WorkstreamNotificationContext): string {
+  const prefix = `Workstream ${outcome}: `;
+  const task = context.metadataOnly ? '' : trimAtWordBoundary(context.task ?? '', NOTIFICATION_TEXT_LIMITS.desktopTitle - prefix.length);
+  return task ? `${prefix}${task}` : `GoodVibes: workstream ${outcome}`;
+}
+
+function withScore(body: string, context: WorkstreamNotificationContext): string {
+  if (context.metadataOnly || typeof context.reviewScore !== 'number' || !Number.isFinite(context.reviewScore)) return body;
+  return `${body} (last review ${Math.round(context.reviewScore * 10) / 10}/10)`;
+}
+
 /**
  * Title and body for a workstream that reached a terminal state.
  *
@@ -49,21 +76,24 @@ export interface WorkstreamNotification {
  */
 export function workstreamFailureNotification(
   payload: WorkstreamFailureNarrationInput,
+  context: WorkstreamNotificationContext = {},
 ): WorkstreamNotification {
+  const metadataOnly = context.metadataOnly === true;
   if (payload.failureKind === 'cancelled') {
     return {
-      title: 'GoodVibes: workstream cancelled',
-      body: `Cancelled: ${payload.reason}`,
+      title: titled('cancelled', context),
+      body: metadataOnly ? 'Cancelled' : withScore(`Cancelled: ${payload.reason}`, context),
     };
   }
   if (payload.failureKind === 'max_turns') {
     return {
-      title: 'GoodVibes: workstream hit its turn budget',
-      body: `The workstream ${formatTurnBudgetOutcome({ limit: payload.turnLimit, source: payload.turnLimitSource })}`,
+      title: titled('hit its turn budget', context),
+      body: withScore(`The workstream ${formatTurnBudgetOutcome({ limit: payload.turnLimit, source: payload.turnLimitSource })}`, context),
     };
   }
+  const reason = payload.failureKind === 'transport' ? 'transient transport error' : payload.reason;
   return {
-    title: 'GoodVibes: workstream failed',
-    body: `Failed: ${payload.failureKind === 'transport' ? 'transient transport error' : payload.reason}`,
+    title: titled('failed', context),
+    body: metadataOnly ? (payload.failureKind === 'transport' ? `Failed: ${reason}` : 'Failed') : withScore(`Failed: ${reason}`, context),
   };
 }

package/src/core/wrfc-notice-titles.ts

@@ -0,0 +1,37 @@
+/**
+ * wrfc-notice-titles.ts, the plain title of each review-chain line this
+ * terminal writes itself.
+ *
+ * runtime/bootstrap-core.ts and runtime/wrfc-persistence.ts write a few
+ * "[WRFC] …" lines of their own (the SDK's lines are titled by its
+ * runtimeEventOfNotice). The notification history keeps each such event as
+ * one entry under a plain title, with the line's detail as the body
+ * (core/notices.ts). The test feeds every producer's template through
+ * shellChainNoticeOf so the lines and this table cannot drift apart.
+ */
+
+export interface ShellChainNotice {
+  readonly title: string;
+  readonly level: 'info' | 'warning';
+  /** The line without its bracket tag or status mark. */
+  readonly detail: string;
+}
+
+const SHELL_CHAIN_LINES: ReadonlyArray<{ readonly pattern: RegExp; readonly title: string; readonly level: ShellChainNotice['level'] }> = [
+  { pattern: /^\[WRFC\] Engineer enumerated \d+ constraints? for chain \S+/, title: 'Review chain constraints listed', level: 'info' },
+  { pattern: /^\[WRFC\] Fix #\d+ targeting \d+ constraints? on chain \S+/, title: 'Review chain fix started', level: 'info' },
+  { pattern: /^\[WRFC\] ✗ Chain \S+: \d+ constraint violations? forced failure/, title: 'Review chain failed its constraints', level: 'warning' },
+  { pattern: /^\[WRFC\] Guard: .*\(spawn-forced-wrfc\)$/s, title: 'Agent request sent through a review chain', level: 'info' },
+  { pattern: /^\[WRFC\] Guard: .*\(spawn-suppressed-wrfc\)$/s, title: 'Agent request kept out of a review chain', level: 'info' },
+  { pattern: /^\[WRFC\] Guard: .*\(batch-collapsed-to-wrfc\)$/s, title: 'Agent requests combined into one review chain', level: 'info' },
+  { pattern: /^\[WRFC\] Chain \S+ \(.*\) was interrupted by a restart; /s, title: 'Review chain interrupted by a restart', level: 'warning' },
+  { pattern: /^\[WRFC\] Pre-router buffer overflowed: /, title: 'Early review chain messages dropped', level: 'warning' },
+];
+
+/** The plain title of a review-chain line this terminal writes, or undefined for any other line. */
+export function shellChainNoticeOf(text: string): ShellChainNotice | undefined {
+  const line = text.trim();
+  const match = SHELL_CHAIN_LINES.find((entry) => entry.pattern.test(line));
+  if (!match) return undefined;
+  return { title: match.title, level: match.level, detail: line.replace(/^\[WRFC\]\s*/, '').replace(/^✗\s*/, '') };
+}

package/src/input/agents-modal-text.ts

@@ -0,0 +1,119 @@
+/**
+ * agents-modal-text.ts, the plain-text pieces the Agents modal shows: the
+ * hosted session's header facts and rows, and a compact live tail of an
+ * agent's conversation for the side column.
+ *
+ * Every hosted fact is a field of the daemon's own record; nothing is derived
+ * here. The tail shows what an agent said and did most recently: its words,
+ * the tools it called (→) and the first line of each result (←).
+ */
+
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import { createEmptyLine, type Line } from '@pellux/goodvibes-sdk/platform/types';
+import type { HostedSessionFeedState, HostedSessionRow } from '../views/hosted-session-feed.ts';
+import type { AgentsText } from '../renderer/agents-modal.ts';
+import { activeTokens } from '../renderer/theme.ts';
+import { wrapText, getDisplayWidth } from '../utils/terminal-width.ts';
+
+/** What the hosted session is, what it is doing, and what leaving it would do. */
+export function hostedHeaderTexts(state: HostedSessionFeedState): AgentsText[] {
+  const record = state.record;
+  if (!record) return [];
+  const lines: AgentsText[] = [
+    { text: `${record.status} · ${record.turnCount} turn${record.turnCount === 1 ? '' : 's'} · ${record.messageCount} message${record.messageCount === 1 ? '' : 's'}`, tone: 'text' },
+    { text: `workspace ${record.workspaceRoot}`, tone: 'faint' },
+    {
+      text: `${record.effectiveDetachPolicy === 'survive' ? 'leaving keeps it running (survive)' : 'leaving ends it (kill)'}, ${record.detachPolicy === null ? 'from the setting' : 'set for this session'}`,
+      tone: record.effectiveDetachPolicy === 'survive' ? 'success' : 'warning',
+    },
+    { text: `attached: ${record.attachedClients.length > 0 ? record.attachedClients.join(', ') : 'nobody'}`, tone: 'muted' },
+  ];
+  if (record.status === 'terminated') lines.push({ text: `ended: ${record.terminatedReason ?? 'no reason recorded'}`, tone: 'error' });
+  if (record.restoredFromDisk) lines.push({ text: 'restored from disk after a daemon restart', tone: 'warning' });
+  lines.push(state.streaming
+    ? { text: 'live event stream open', tone: 'success' }
+    : { text: `no live stream: ${state.streamNote ?? 'not subscribed'}`, tone: 'warning' });
+  if (state.runningToolCalls.length > 0) {
+    lines.push({ text: `running: ${state.runningToolCalls.map((call) => call.tool).join(', ')}`, tone: 'brand' });
+  }
+  if (state.droppedRows > 0) lines.push({ text: `${state.droppedRows} earlier row(s) dropped; reattach to backfill`, tone: 'faint' });
+  return lines;
+}
+
+/** The hosted conversation's rows as text. */
+export function hostedRowTexts(rows: readonly HostedSessionRow[]): AgentsText[] {
+  return rows.map((row) => {
+    const prefix = row.kind === 'user' ? 'you: ' : row.kind === 'tool' ? '' : row.kind === 'error' ? 'error: ' : '';
+    const text = `${prefix}${row.text}${row.streaming ? ' …' : ''}`;
+    if (row.kind === 'tool') return { text, tone: 'brand', glyph: '→' };
+    if (row.kind === 'error') return { text, tone: 'error' };
+    if (row.kind === 'user') return { text, tone: 'text', bold: true };
+    if (row.kind === 'system') return { text, tone: 'faint' };
+    return { text, tone: 'text' };
+  });
+}
+
+/** The hosted transcript as lines at a width (text from column 5, like the transcript). */
+export function hostedBody(rows: readonly HostedSessionRow[], width: number, height: number): Line[] {
+  const t = activeTokens();
+  const out: Line[] = [];
+  const textWidth = Math.max(8, width - 9);
+  for (const item of hostedRowTexts(rows)) {
+    const fg = item.tone === 'error' ? t.error : item.tone === 'brand' ? t.brand : item.tone === 'faint' ? t.textFaint : t.text;
+    const text = item.glyph ? `${item.glyph} ${item.text}` : item.text;
+    for (const part of wrapText(text, textWidth)) {
+      const line = createEmptyLine(width);
+      let x = 5;
+      for (const ch of part) {
+        const w = getDisplayWidth(ch);
+        if (w <= 0 || x + w > width - 4) break;
+        line[x] = { ...line[x]!, char: ch, fg, bold: item.bold === true };
+        if (w === 2) line[x + 1] = { ...line[x]!, char: '' };
+        x += w;
+      }
+      out.push(line);
+    }
+  }
+  return out.slice(-Math.max(1, height));
+}
+
+function contentText(content: string | ReadonlyArray<{ type: string; text?: string }>): string {
+  if (typeof content === 'string') return content;
+  return content.map((part) => (part.type === 'text' ? part.text ?? '' : `[${part.type}]`)).join(' ');
+}
+
+/** The one argument that says what a tool call is about (a path, a command, a query). */
+function callSubject(args: Record<string, unknown>): string {
+  for (const key of ['path', 'file_path', 'filePath', 'command', 'cmd', 'pattern', 'query', 'url', 'name']) {
+    const value = args[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return '';
+}
+
+function firstLine(text: string): string {
+  return text.split('\n').find((line) => line.trim().length > 0)?.trim() ?? '';
+}
+
+/** The most recent `limit` entries of an agent's conversation, as tail lines. */
+export function transcriptTail(snapshot: readonly ConversationMessageSnapshot[], limit: number): AgentsText[] {
+  const out: AgentsText[] = [];
+  for (const message of snapshot) {
+    if (message.role === 'user') {
+      const text = firstLine(contentText(message.content as string));
+      if (text) out.push({ text: `you: ${text}`, tone: 'text', bold: true });
+    } else if (message.role === 'assistant') {
+      const text = message.content.trim();
+      if (text) for (const paragraph of text.split(/\n\s*\n/).slice(-2)) out.push({ text: paragraph.replace(/\s+/g, ' ').trim(), tone: 'text' });
+      for (const call of message.toolCalls ?? []) {
+        const subject = callSubject(call.arguments);
+        out.push({ text: subject ? `${call.name} ${subject}` : call.name, tone: 'muted', glyph: '→' });
+      }
+    } else if (message.role === 'tool') {
+      const text = firstLine(message.content);
+      out.push({ text: `${message.toolName ?? 'result'}${text ? `: ${text}` : ''}`, tone: 'faint', glyph: '←' });
+    }
+  }
+  if (out.length === 0) out.push({ text: 'No messages yet.', tone: 'faint' });
+  return out.slice(-limit);
+}