@pellux/goodvibes-tui 0.22.0 → 0.24.0

package/src/renderer/settings-modal-helpers.ts

@@ -4,8 +4,8 @@
  * architecture cap. No layout logic lives here.
  */
 
-import type { SettingEntry, McpEntry, SubscriptionEntry } from '../input/settings-modal.ts';
-import { SETTINGS_CATEGORIES } from '../input/settings-modal.ts';
+import type { SettingEntry, McpEntry, SubscriptionEntry } from '../input/settings-modal-types.ts';
+import { SETTINGS_CATEGORIES } from '../input/settings-modal-types.ts';
 import { isSecretConfigKey, isSecretReferenceValue } from '../config/secret-config.ts';
 
 function maskSecretValue(value: string): string {

package/src/renderer/settings-modal.ts

@@ -150,7 +150,7 @@ function buildSettingContext(modal: SettingsModal, entry: SettingEntry): string[
   ];
 
   if (entry.locked) lines.push(`Locked: ${entry.lockReason ?? 'This setting is locked by a higher-priority layer.'}`);
-  if (entry.conflict) lines.push(`Conflict: resolve with /settingssync resolve ${entry.setting.key} local|synced.`);
+  if (entry.conflict) lines.push(`Conflict: resolve with /settings-sync resolve ${entry.setting.key} local|synced.`);
 
   lines.push('', entry.setting.description);
 

package/src/renderer/ui-factory.ts

@@ -243,6 +243,17 @@ export class UIFactory {
     });
     const bottomLine = createBaseLine();
     for (let x = 0; x < boxWidth; x++) bottomLine[boxStartX + x] = { char: GLYPHS.surface.bottom, fg: BORDER_COLOR, bg: '', bold: false, dim: false, underline: false, italic: false, strikethrough: false };
+    // Multi-line indicator lives inside the bottom border (right-aligned) so
+    // the footer height stays invariant while the user adds prompt lines.
+    if (promptLines.length > 1) {
+      const lineCountTag = ` ${promptLines.length}L `;
+      let tx = boxStartX + boxWidth - lineCountTag.length - 2;
+      for (const ch of lineCountTag) {
+        if (tx >= boxStartX + boxWidth - 1) break;
+        bottomLine[tx] = { char: ch, fg: '244', bg: '', bold: false, dim: true, underline: false, italic: false, strikethrough: false };
+        tx += 1;
+      }
+    }
     lines.push(bottomLine);
     lines.push(createBaseLine());
     const composerTokens: Array<{ text: string; fg: string; bold?: boolean; dim?: boolean }> = [];

package/src/runtime/bootstrap-core.ts

@@ -123,6 +123,88 @@ export interface BootstrapCoreState {
 
 export type CompanionMessagePayload = Extract<SessionEvent, { type: 'COMPANION_MESSAGE_RECEIVED' }>;
 
+// ---------------------------------------------------------------------------
+// Operator narration of inbound channel events
+// ---------------------------------------------------------------------------
+
+/**
+ * Narrate an inbound channel event to the operator via the SystemMessageRouter.
+ *
+ * When an external surface (GitHub, Slack, ntfy, etc.) triggers an agent turn,
+ * this function produces a human-readable system message so the operator can
+ * observe which event caused the turn. Returns null for internal/companion
+ * sources that do not need operator narration.
+ *
+ * @param event - The normalized inbound event descriptor.
+ * @returns A narration string, or null if no narration is appropriate.
+ */
+export function narrateInboundEvent(event: {
+  source: string;
+  metadata: Readonly<Record<string, unknown>> | undefined;
+}): string | null {
+  const { source, metadata } = event;
+  if (!source) return null;
+
+  // Derive the effective surface — prefer metadata.surface, fall back to source.
+  const surface = typeof metadata?.surface === 'string' ? metadata.surface : source;
+
+  // Internal / companion sources do not need operator narration.
+  if (surface === 'companion' || source === 'companion') return null;
+  if (surface === 'internal' || source === 'internal') return null;
+
+  // Build a surface label for the log prefix.
+  const label = ((): string => {
+    switch (surface) {
+      case 'github':        return '[GitHub]';
+      case 'slack':         return '[Slack]';
+      case 'discord':       return '[Discord]';
+      case 'ntfy':          return '[ntfy]';
+      case 'homeassistant': return '[HomeAssistant]';
+      case 'telegram':      return '[Telegram]';
+      case 'google-chat':   return '[Google Chat]';
+      case 'signal':        return '[Signal]';
+      case 'whatsapp':      return '[WhatsApp]';
+      case 'msteams':       return '[Teams]';
+      case 'imessage':      return '[iMessage]';
+      case 'bluebubbles':   return '[BlueBubbles]';
+      case 'mattermost':    return '[Mattermost]';
+      case 'matrix':        return '[Matrix]';
+      case 'webhook':       return '[Webhook]';
+      default:              return `[${surface[0]!.toUpperCase()}${surface.slice(1)}]`;
+    }
+  })();
+
+  const eventType   = typeof metadata?.eventType   === 'string' ? metadata.eventType   : null;
+  const eventAction = typeof metadata?.eventAction  === 'string' ? metadata.eventAction : null;
+  const topic       = typeof metadata?.topic        === 'string' ? metadata.topic       : null;
+  const prNumber    = typeof metadata?.prNumber     === 'number' ? metadata.prNumber    : null;
+  const issueNumber = typeof metadata?.issueNumber  === 'number' ? metadata.issueNumber : null;
+  const repo        = typeof metadata?.repo         === 'string' ? metadata.repo        : null;
+
+  // Build event-specific detail for GitHub events.
+  if (surface === 'github' && eventType) {
+    const actionPart = eventAction ? ` ${eventAction}` : '';
+    let detail = `${eventType}${actionPart} → agent triggered`;
+    if (prNumber !== null) {
+      detail = `PR #${prNumber}${repo ? ` (${repo})` : ''} ${eventAction ?? eventType} → agent triggered`;
+    } else if (issueNumber !== null) {
+      detail = `Issue #${issueNumber}${repo ? ` (${repo})` : ''} ${eventAction ?? eventType} → agent triggered`;
+    } else if (repo) {
+      detail = `${eventType}${actionPart} in ${repo} → agent triggered`;
+    }
+    return `${label} ${detail}`;
+  }
+
+  // ntfy: include topic when available.
+  if (surface === 'ntfy' && topic) {
+    return `${label} inbound message on topic '${topic}' → agent triggered`;
+  }
+
+  // Generic narration for all other surfaces.
+  const eventDetail = eventType ? ` ${eventType}${eventAction ? ` ${eventAction}` : ''}` : '';
+  return `${label}${eventDetail} inbound event → agent triggered`;
+}
+
 export function companionMessageToOrchestratorInputOptions(
   payload: CompanionMessagePayload,
 ): OrchestratorUserInputOptions {
@@ -525,6 +607,16 @@ export async function initializeBootstrapCore(
   runtimeUnsubs.push(runtimeBus.on<Extract<SessionEvent, { type: 'COMPANION_MESSAGE_RECEIVED' }>>(
     'COMPANION_MESSAGE_RECEIVED',
     ({ payload }) => {
+      // Narrate inbound external events to the operator so they can observe
+      // which channel event triggered the agent turn.
+      const narration = narrateInboundEvent({
+        source: payload.source,
+        metadata: payload.metadata,
+      });
+      if (narration) {
+        routeOrBuffer(narration, 'low');
+      }
+
       if (orchestratorHandleUserInputRef.value) {
         // Delegate to the orchestrator: adds user message + fires a real LLM turn.
         // Preserve surface origin metadata so the SDK can correlate replies back

package/src/runtime/bootstrap-hook-bridge.ts

@@ -13,6 +13,7 @@ import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { replayJournalForSession } from '../core/session-recovery.ts';
 
 export interface ResumeSessionOptions {
   readonly runtimeBus: RuntimeEventBus;
@@ -27,6 +28,7 @@ export interface ResumeSessionOptions {
   readonly panelManager: PanelManager;
   readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
   readonly providerRegistry: Pick<ProviderRegistry, 'get' | 'getCurrentModel' | 'getForModel' | 'require'>;
+  readonly homeDirectory: string;
 }
 
 export function createResumeSessionHandler(options: ResumeSessionOptions): (sessionId: string) => void {
@@ -47,6 +49,22 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
         titleSource: meta.titleSource,
       });
       options.runtime.sessionId = sessionId;
+      replayJournalForSession({
+        homeDirectory: options.homeDirectory,
+        sessionId,
+        snapshotTimestamp: meta.timestamp ?? 0,
+        conversation: options.conversation,
+        persistSnapshot: (replayedMessages) => {
+          options.sessionManager.save(sessionId, replayedMessages as never[], {
+            title: options.conversation.title || meta.title,
+            model: meta.model,
+            provider: meta.provider,
+            timestamp: Date.now(),
+            titleSource: meta.titleSource,
+            returnContext: meta.returnContext,
+          });
+        },
+      });
       options.onSessionIdChanged?.(sessionId);
       if (meta?.model) options.runtime.model = meta.model;
       if (meta?.provider) options.runtime.provider = meta.provider;

package/src/runtime/bootstrap-shell.ts

@@ -106,6 +106,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     panelManager: services.panelManager,
     configManager,
     providerRegistry: services.providerRegistry,
+    homeDirectory: services.homeDirectory,
   });
 
   const openAgentDetailRef: { fn: (agentId: string) => void } = { fn: (_agentId: string) => {} };

package/src/shell/blocking-input.ts

@@ -2,6 +2,8 @@ import type { ConversationManager } from '../core/conversation';
 import type { PermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SessionSnapshot } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import { replayJournalForSession } from '../core/session-recovery.ts';
 
 export type PendingPermissionState = PermissionRequest & {
   resolve: (approved: boolean, remember?: boolean) => void;
@@ -17,6 +19,22 @@ export type BlockingInputHandlerOptions = {
   render: () => void;
   loadRecoveryConversation: () => SessionSnapshot | null;
   deleteRecoveryFile: () => void;
+  /**
+   * Absolute home directory used to locate the transcript journal for this
+   * recovery session. Required for journal replay on Ctrl+R restore.
+   */
+  homeDirectory: string;
+  /**
+   * The session ID that the recovery file belongs to. Required for journal
+   * replay so the correct journal path can be resolved.
+   */
+  sessionId: string;
+  /**
+   * Persist the post-replay snapshot so the WAL gap is durably closed.
+   * Called with the replayed message list. Best-effort — failures are swallowed
+   * inside replayJournalForSession.
+   */
+  persistSnapshot: (messages: ConversationMessageSnapshot[]) => void;
   /**
    * Optional callback invoked after Ctrl+R restore to reopen panels captured in
    * the recovery snapshot's returnContext. When provided (as wired in main.ts),
@@ -47,6 +65,9 @@ export function handleBlockingShellInput(
     render,
     loadRecoveryConversation,
     deleteRecoveryFile,
+    homeDirectory,
+    sessionId,
+    persistSnapshot,
     reopenPanels,
   } = options;
 
@@ -86,6 +107,17 @@ export function handleBlockingShellInput(
           title: recovery.title,
           titleSource: recovery.titleSource,
         });
+        // Replay journal records that post-date the recovery snapshot so turns
+        // written after the last recovery-file write (but before SIGKILL) are
+        // not silently dropped. snapshotTimestamp=0 when timestamp is absent so
+        // all journal records are replayed — safer than dropping.
+        replayJournalForSession({
+          homeDirectory,
+          sessionId,
+          snapshotTimestamp: recovery.timestamp ?? 0,
+          conversation,
+          persistSnapshot,
+        });
         reopenPanels?.(recovery);
         systemMessageRouter.high('[Recovery] Session restored.');
         deleteRecoveryFile();

package/src/shell/recovery-input-helpers.ts

@@ -0,0 +1,71 @@
+/**
+ * Helper factories for main()'s stdin fast-path: the Ctrl+R recovery
+ * persistence/panel-reopen callbacks and the one-key error-retry
+ * affordance. Extracted from main.ts so the entrypoint stays under the
+ * architecture line ceiling; main() wires these with its live services.
+ */
+
+import type { ConversationMessageSnapshot } from '../core/conversation.ts';
+import type { SessionSnapshot } from '@/runtime/index.ts';
+
+export interface PersistRecoveryDeps {
+  readonly sessionManager: {
+    save(id: string, msgs: never[], meta: { title: string; model: string; provider: string; timestamp: number }): unknown;
+  };
+  readonly runtime: { readonly sessionId: string; readonly model: string; readonly provider: string };
+  readonly conversation: { readonly title?: string | null };
+}
+
+/** Persist a replayed/restored snapshot through the session manager. */
+export function createPersistRecoverySnapshot(deps: PersistRecoveryDeps): (msgs: ConversationMessageSnapshot[]) => void {
+  return (msgs) => void deps.sessionManager.save(deps.runtime.sessionId, msgs as never[], {
+    title: deps.conversation.title ?? '',
+    model: deps.runtime.model,
+    provider: deps.runtime.provider,
+    timestamp: Date.now(),
+  });
+}
+
+export interface ReopenPanelsDeps {
+  readonly panelManager: { open(id: string): void; show(): void };
+  readonly render: () => void;
+}
+
+/** Reopen the panels recorded in a restored session's return context (capped at 4). */
+export function createReopenRecoveryPanels(deps: ReopenPanelsDeps): (snapshot: SessionSnapshot) => void {
+  return (snapshot) => {
+    for (const panelId of (snapshot.returnContext?.openPanels ?? []).slice(0, 4)) {
+      try { deps.panelManager.open(panelId); } catch { /* unknown panel id */ }
+    }
+    if ((snapshot.returnContext?.openPanels?.length ?? 0) > 0) { deps.panelManager.show(); deps.render(); }
+  };
+}
+
+export interface ErrorAffordanceDeps {
+  /** True when the failover retry context is armed (a retry is actually possible). */
+  readonly retryArmed: boolean;
+  /** Re-submit the failed turn via the shared failover retry path (no duplicate user messages). */
+  readonly retry: () => void;
+  readonly openModelPicker: () => void;
+  readonly render: () => void;
+}
+
+/**
+ * Handle one keypress while the error-retry affordance is active.
+ * 'r' retries on the current provider when armed; 'm' opens the model
+ * picker. Returns true when the key was consumed; any other key returns
+ * false so the caller routes it as normal input.
+ */
+export function handleErrorAffordanceKey(data: string, deps: ErrorAffordanceDeps): boolean {
+  if (data === 'r' && deps.retryArmed) {
+    deps.retry();
+    deps.render();
+    return true;
+  }
+  if (data === 'm') {
+    deps.openModelPicker();
+    deps.render();
+    return true;
+  }
+  return false;
+}

package/src/utils/browser.ts

@@ -0,0 +1,29 @@
+/**
+ * browser.ts — cross-platform browser launcher utility.
+ *
+ * Extracted from cli/management.ts so it can be used by input-layer commands
+ * without creating an upward cli→input dependency. Lives in utils (Layer 0)
+ * and has no imports from shell-UI or entrypoint layers.
+ */
+
+import { spawn } from 'node:child_process';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+/**
+ * Open the given URL in the user's default browser.
+ * Returns a status string (success or error description).
+ * Does not throw — errors are returned as a descriptive string.
+ */
+export function openBrowser(url: string): string {
+  const platform = process.platform;
+  const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.once('error', () => {});
+    child.unref();
+    return 'browser open requested';
+  } catch (error) {
+    return `browser open failed: ${summarizeError(error)}`;
+  }
+}

package/src/utils/terminal-width.ts

@@ -43,9 +43,16 @@ function stripAnsi(text: string): string {
 
 /**
  * Calculates the visual width of a string in the terminal.
- * Handles CJK characters, emoji (including ZWJ sequences), and
- * variation selectors correctly as double-width.
- * ANSI escape sequences (SGR/CSI/OSC-8) are stripped before measurement.
+ * Handles CJK characters, emoji, and variation selectors correctly as
+ * double-width. ANSI escape sequences (SGR/CSI/OSC-8) are stripped before
+ * measurement.
+ *
+ * NOTE: Width is measured per Unicode scalar value (code point), not per
+ * grapheme cluster. ZWJ sequences (e.g. 👨‍👩‍👧‍👦) are handled component-by-component:
+ * each component's width is summed and ZWJ/VS chars contribute zero width,
+ * so the total is accurate. However, truncation (truncateDisplay) may split
+ * a ZWJ family mid-sequence, leaving dangling ZWJ/VS characters. This is a
+ * cosmetic degradation only — line widths remain correct.
  */
 export function getDisplayWidth(text: string): number {
   text = stripAnsi(text);

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.22.0';
+let _version = '0.24.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;