@pellux/goodvibes-tui 0.18.4

package/src/core/plan-command-handler.ts

@@ -0,0 +1,169 @@
+/**
+ * /plan command handler.
+ *
+ * Handles the subcommands of the /plan slash command:
+ *   /plan mode auto|single|cohort|background|remote
+ *   /plan explain
+ *   /plan override <strategy>
+ *   /plan clear
+ *
+ * Returns a human-readable result string to display in the conversation.
+ */
+
+import { AdaptivePlanner, VALID_STRATEGIES } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+import type { ExecutionStrategy } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import type { RuntimeEventBus } from '../runtime/events/index.ts';
+import { emitPlanStrategyOverridden } from '../runtime/emitters/index.ts';
+import type { AdaptivePlanner as AdaptivePlannerType } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+
+export interface PlanCommandResult {
+  /** Human-readable output to show the user. */
+  output: string;
+  /** Whether the command succeeded. */
+  ok: boolean;
+}
+
+export interface PlanCommandDeps {
+  adaptivePlanner: Pick<
+    AdaptivePlannerType,
+    'getMode' | 'setMode' | 'explain' | 'override' | 'clearOverride' | 'getOverride' | 'getLatest'
+  >;
+  runtimeBus?: RuntimeEventBus | null;
+}
+
+function emitStrategyOverride(
+  runtimeBus: RuntimeEventBus | null | undefined,
+  data: { strategy: ExecutionStrategy | null; clearedBy?: string },
+): void {
+  if (!runtimeBus) return;
+  emitPlanStrategyOverridden(runtimeBus, {
+    sessionId: 'system',
+    traceId: `planner:override:${data.strategy ?? 'none'}`,
+    source: 'plan-command-handler',
+  }, data);
+}
+
+/**
+ * Dispatch a parsed /plan subcommand.
+ *
+ * @param subcommand - The first word after /plan (e.g. 'mode', 'explain', 'override').
+ * @param args       - Remaining tokens.
+ */
+export function handlePlanCommand(
+  deps: PlanCommandDeps,
+  subcommand: string,
+  args: string[],
+): PlanCommandResult {
+  switch (subcommand.toLowerCase()) {
+    case 'mode': {
+      const value = args[0];
+      if (!value) {
+        const current = deps.adaptivePlanner.getMode();
+        return {
+          ok: true,
+          output: `Current mode: **${current}**\n\nAvailable modes: auto | single | cohort | background | remote`,
+        };
+      }
+      if (!VALID_STRATEGIES.includes(value as ExecutionStrategy)) {
+        return {
+          ok: false,
+          output: `Unknown mode '${value}'. Valid: auto | single | cohort | background | remote`,
+        };
+      }
+      deps.adaptivePlanner.setMode(value as ExecutionStrategy);
+      logger.info('[PlanCommandHandler] mode changed', { mode: value });
+      return {
+        ok: true,
+        output: `Execution mode set to **${value}**.`,
+      };
+    }
+
+    case 'explain': {
+      const explanation = deps.adaptivePlanner.explain();
+      return { ok: true, output: explanation };
+    }
+
+    case 'override': {
+      const strategy = args[0];
+      if (!strategy) {
+        return {
+          ok: false,
+          output: 'Usage: /plan override <strategy>\n'
+            + 'Strategies: auto | single | cohort | background | remote\n'
+            + 'Use /plan override auto to clear the override.',
+        };
+      }
+      const result = deps.adaptivePlanner.override(strategy);
+      if (!result.ok) {
+        const explanation = AdaptivePlanner.explainReasonCode(result.reasonCode);
+        logger.warn('[PlanCommandHandler] override rejected', { strategy, reasonCode: result.reasonCode });
+        return {
+          ok: false,
+          output: `Override rejected: ${explanation}`,
+        };
+      }
+      if (result.strategy === 'auto') {
+        // override('auto') already cleared the override internally
+        logger.info('[PlanCommandHandler] override cleared via auto');
+        emitStrategyOverride(deps.runtimeBus, { strategy: 'auto', clearedBy: 'override(auto)' });
+        return {
+          ok: true,
+          output: 'Execution strategy override cleared. Planner will run in auto mode.',
+        };
+      }
+      logger.info('[PlanCommandHandler] override applied', { strategy: result.strategy });
+      emitStrategyOverride(deps.runtimeBus, { strategy: result.strategy });
+      return {
+        ok: true,
+        output: `Execution strategy overridden to **${result.strategy.toUpperCase()}**.\n`
+          + AdaptivePlanner.explainReasonCode('OVERRIDE_IN_EFFECT'),
+      };
+    }
+
+    case 'clear': {
+      deps.adaptivePlanner.clearOverride();
+      deps.adaptivePlanner.setMode('auto');
+      logger.info('[PlanCommandHandler] mode and override reset to auto');
+      emitStrategyOverride(deps.runtimeBus, { strategy: 'auto', clearedBy: 'clear' });
+      return {
+        ok: true,
+        output: 'Planner mode and override reset to **auto**.',
+      };
+    }
+
+    case 'status': {
+      const mode     = deps.adaptivePlanner.getMode();
+      const override = deps.adaptivePlanner.getOverride();
+      const latest   = deps.adaptivePlanner.getLatest();
+      const lines = [
+        `Mode:     ${mode.toUpperCase()}`,
+        `Override: ${override ? override.toUpperCase() + ' [ACTIVE]' : 'none'}`,
+      ];
+      if (latest) {
+        lines.push(
+          `Last:     ${latest.selected.toUpperCase()}`,
+          `Reason:   ${latest.reasonCode}`,
+          `          ${AdaptivePlanner.explainReasonCode(latest.reasonCode)}`,
+        );
+      }
+      return { ok: true, output: lines.join('\n') };
+    }
+
+    default: {
+      return {
+        ok: false,
+        output: [
+          `Unknown /plan subcommand: '${subcommand}'.`,
+          '',
+          'Available commands:',
+          '  /plan mode [auto|single|cohort|background|remote]  - get or set mode',
+          '  /plan override <strategy>                          - force a strategy',
+          '  /plan explain                                      - explain last decision',
+          '  /plan status                                       - show current state',
+          '  /plan clear                                        - reset to auto',
+        ].join('\n'),
+      };
+    }
+  }
+}

package/src/core/system-message-router.ts

@@ -0,0 +1,210 @@
+/**
+ * SystemMessageRouter — routes system messages to the appropriate surfaces
+ * based on priority.
+ *
+ * Two tiers:
+ *   - 'high' — appears in both the main conversation AND the SystemMessagesPanel.
+ *     Use for: fatal errors, model/provider confirmations, session save/load,
+ *     compaction events (e.g. [Compaction] completed).
+ *   - 'low'  — appears in the SystemMessagesPanel only (panel-only routing).
+ *     Use for: scan results, provider discovery, plugin load/unload, feature
+ *     flag changes, tool execution status, permission decisions,
+ *     health/cascade events, debug/operational info.
+ *
+ * Usage:
+ * ```ts
+ * const router = createSystemMessageRouter(conversation, panel);
+ * router.routeSystemMessage('[Provider] anthropic registered', 'low');
+ * router.routeSystemMessage('[Session] Saved session abc123', 'high');
+ * ```
+ *
+ * The router can also be used as a drop-in replacement for
+ * conversation.addSystemMessage() calls — it classifies messages by priority
+ * automatically when using routeAuto().
+ *
+ * @remarks
+ * This router handles system messages (operational status, errors). It is
+ * distinct from NotificationRouter which handles domain-specific typed
+ * notifications with policy-based routing.
+ */
+
+import { getConfigSnapshot } from '../config/index.ts';
+import type { ConfigManager } from '../config/manager.ts';
+import type { ConversationManager } from './conversation.ts';
+import type { SystemMessagesPanel, SystemMessagePriority } from '../panels/system-messages-panel.ts';
+
+// ---------------------------------------------------------------------------
+// Priority classification patterns
+// ---------------------------------------------------------------------------
+
+/**
+ * Patterns that identify HIGH-priority messages:
+ * fatal errors, model/provider switches, session save/load, compaction.
+ */
+const HIGH_PRIORITY_RE =
+  /\bfatal\b|\bcrash\w*|\bunhandled exception\b|\[Model\]|\[Provider\].*switch|\[Session\].*(?:saved|loaded|restored)|\[Compaction\]|\[Recovery\].*Failed/i;
+
+/**
+ * Classify a message as high or low priority based on content.
+ * Used by routeAuto() when the caller doesn't specify priority.
+ *
+ * @internal
+ */
+function classifyPriority(message: string): SystemMessagePriority {
+  return HIGH_PRIORITY_RE.test(message) ? 'high' : 'low';
+}
+
+export type SystemMessageKind = 'system' | 'operational' | 'wrfc';
+export type SystemMessageTarget = 'conversation' | 'panel' | 'both';
+
+function defaultTargetForKind(kind: SystemMessageKind): SystemMessageTarget {
+  if (kind === 'wrfc') return 'both';
+  return 'panel';
+}
+
+function classifyKind(message: string): SystemMessageKind {
+  if (/^\[WRFC\]/i.test(message)) return 'wrfc';
+  if (/^\[(Scan|Local|Agents|MCP|Plugin|Hook|Tool|Exec|Remote|Bridge|Approval)\]/i.test(message)) {
+    return 'operational';
+  }
+  return 'system';
+}
+
+function targetForKind(
+  configManager: Pick<ConfigManager, 'getRaw'>,
+  kind: SystemMessageKind,
+): SystemMessageTarget {
+  const ui = getConfigSnapshot(configManager).ui;
+  if (kind === 'wrfc') return ui.wrfcMessages;
+  if (kind === 'operational') return ui.operationalMessages;
+  return ui.systemMessages;
+}
+
+function resolveDelivery(
+  target: SystemMessageTarget,
+  hasPanel: boolean,
+): { readonly toPanel: boolean; readonly toConversation: boolean } {
+  if (target === 'both') {
+    return { toPanel: hasPanel, toConversation: true };
+  }
+  if (target === 'conversation') {
+    return { toPanel: false, toConversation: true };
+  }
+  return hasPanel
+    ? { toPanel: true, toConversation: false }
+    : { toPanel: false, toConversation: true };
+}
+
+// ---------------------------------------------------------------------------
+// SystemMessageRouter
+// ---------------------------------------------------------------------------
+
+/**
+ * Routes system messages to the conversation and/or the SystemMessagesPanel
+ * based on priority level.
+ */
+export class SystemMessageRouter {
+  constructor(
+    private readonly conversation: ConversationManager,
+    private panel: SystemMessagesPanel | null,
+    private readonly getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultTargetForKind,
+  ) {}
+
+  // ── Public API ────────────────────────────────────────────────────────────
+
+  /**
+   * Route a system message with explicit priority.
+   *
+   * - 'high': delivered to both conversation AND panel.
+   * - 'low':  delivered to panel only (conversation is not touched).
+   *
+   * @param message  - Message text.
+   * @param priority - 'high' | 'low'.
+   */
+  routeTypedSystemMessage(
+    message: string,
+    priority: SystemMessagePriority,
+    kind: SystemMessageKind,
+  ): void {
+    const target = this.getTargetForKind(kind);
+    const delivery = resolveDelivery(target, this.panel !== null);
+    if (delivery.toPanel) {
+      this.panel?.push(message, priority);
+    }
+    if (delivery.toConversation) {
+      this.conversation.addSystemMessage(message);
+    }
+  }
+
+  routeSystemMessage(message: string, priority: SystemMessagePriority): void {
+    this.routeTypedSystemMessage(message, priority, classifyKind(message));
+  }
+
+  /**
+   * Automatically classify the message priority by content and route.
+   *
+   * Useful as a drop-in replacement for conversation.addSystemMessage()
+   * when you want the router to determine priority.
+   *
+   * @param message - Message text.
+   */
+  routeAuto(message: string): void {
+    const priority = classifyPriority(message);
+    this.routeTypedSystemMessage(message, priority, classifyKind(message));
+  }
+
+  /**
+   * High-priority convenience shortcut.
+   * Equivalent to routeSystemMessage(message, 'high').
+   */
+  high(message: string): void {
+    this.routeSystemMessage(message, 'high');
+  }
+
+  /**
+   * Low-priority convenience shortcut.
+   * Equivalent to routeSystemMessage(message, 'low').
+   */
+  low(message: string): void {
+    this.routeSystemMessage(message, 'low');
+  }
+
+  wrfc(message: string, priority: SystemMessagePriority = 'high'): void {
+    this.routeTypedSystemMessage(message, priority, 'wrfc');
+  }
+
+  /**
+   * Returns the current panel reference.
+   */
+  getPanel(): SystemMessagesPanel | null {
+    return this.panel;
+  }
+
+  /**
+   * Replace the panel reference after construction (late binding).
+   * Pass null to detach the panel.
+   */
+  setPanel(panel: SystemMessagesPanel | null): void {
+    this.panel = panel;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a SystemMessageRouter wired to the given conversation and panel.
+ *
+ * @param conversation - The ConversationManager for high-priority messages.
+ * @param panel        - The SystemMessagesPanel for all messages. Can be null
+ *                       (router still works; messages to panel are silently
+ *                       dropped until a panel is available).
+ */
+export function createSystemMessageRouter(
+  conversation: ConversationManager,
+  panel: SystemMessagesPanel | null = null,
+  getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultTargetForKind,
+): SystemMessageRouter {
+  return new SystemMessageRouter(conversation, panel, getTargetForKind);
+}

package/src/core/transcript-events/classify.ts

@@ -0,0 +1,95 @@
+import type { ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { TranscriptEvent } from '@pellux/goodvibes-sdk/platform/core/transcript-events/types';
+import type { ConversationMessageSnapshot } from '../conversation.ts';
+
+function summarizeText(text: string, max = 96): string {
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+
+function classifySystemKind(text: string): TranscriptEvent['kind'] {
+  if (text.includes('[Remote]') || text.includes('[Teleport]') || text.includes('[Bridge]')) return 'remote_status';
+  if (text.includes('[WRFC]') || text.includes('[Review]')) return 'review_state';
+  if (text.includes('[Policy]') || text.includes('[Security]')) return 'policy_warning';
+  if (text.includes('[Health]') || text.includes('[Local]') || text.includes('[Scan]') || text.includes('[Forensics]')) return 'diagnostic_notice';
+  if (text.includes('[Session]') || text.includes('[Recovery]') || text.includes('[Resume]')) return 'session_restore';
+  if (text.includes('[Approval]')) {
+    return /(allowed|approved|denied|rejected|granted)/i.test(text) ? 'approval_resolution' : 'approval_request';
+  }
+  if (text.includes('[Task]') || text.includes('[Tasks]') || text.includes('[Agent]')) return 'task_transition';
+  return 'system_notice';
+}
+
+function toolCallEvents(messageIndex: number, toolCalls: readonly ToolCall[]): TranscriptEvent[] {
+  return toolCalls.map((call, index) => ({
+    id: `msg-${messageIndex}-tool-call-${index}`,
+    kind: 'tool_call',
+    messageIndex,
+    groupKey: `tool:${call.id}`,
+    title: call.name,
+    detail: summarizeText(JSON.stringify(call.arguments ?? {})),
+    relatedCallId: call.id,
+  }));
+}
+
+export function classifyTranscriptMessages(messages: readonly ConversationMessageSnapshot[]): TranscriptEvent[] {
+  const events: TranscriptEvent[] = [];
+  messages.forEach((message, messageIndex) => {
+    switch (message.role) {
+      case 'user': {
+        const content = typeof message.content === 'string'
+          ? message.content
+          : message.content.map((part) => part.type === 'text' ? part.text : '[image]').join(' ');
+        events.push({
+          id: `msg-${messageIndex}-user`,
+          kind: 'user_input',
+          messageIndex,
+          groupKey: `user:${messageIndex}`,
+          title: 'User input',
+          detail: summarizeText(content),
+        });
+        break;
+      }
+      case 'assistant': {
+        if (message.content.trim()) {
+          events.push({
+            id: `msg-${messageIndex}-assistant`,
+            kind: 'assistant_output',
+            messageIndex,
+            groupKey: `assistant:${messageIndex}`,
+            title: 'Assistant output',
+            detail: summarizeText(message.content),
+          });
+        }
+        if (message.toolCalls?.length) {
+          events.push(...toolCallEvents(messageIndex, message.toolCalls));
+        }
+        break;
+      }
+      case 'tool':
+        events.push({
+          id: `msg-${messageIndex}-tool-result`,
+          kind: 'tool_result',
+          messageIndex,
+          groupKey: `tool:${message.callId}`,
+          title: message.toolName ?? 'Tool result',
+          detail: summarizeText(message.content),
+          relatedCallId: message.callId,
+        });
+        break;
+      case 'system': {
+        const kind = classifySystemKind(message.content);
+        events.push({
+          id: `msg-${messageIndex}-system`,
+          kind,
+          messageIndex,
+          groupKey: `${kind}:${messageIndex}`,
+          title: kind.replace(/_/g, ' '),
+          detail: summarizeText(message.content),
+        });
+        break;
+      }
+    }
+  });
+  return events;
+}

package/src/core/transcript-events/index.ts

@@ -0,0 +1,15 @@
+import { classifyTranscriptMessages } from './classify.ts';
+import { groupTranscriptEvents } from '@pellux/goodvibes-sdk/platform/core/transcript-events/grouping';
+import type { ConversationMessageSnapshot } from '../conversation.ts';
+
+export { classifyTranscriptMessages } from './classify.ts';
+export { groupTranscriptEvents } from '@pellux/goodvibes-sdk/platform/core/transcript-events/grouping';
+export type { TranscriptEvent, TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core/transcript-events/types';
+export type { TranscriptEventGroup } from '@pellux/goodvibes-sdk/platform/core/transcript-events/grouping';
+
+export function buildTranscriptEventIndex(messages: readonly ConversationMessageSnapshot[]) {
+  const events = classifyTranscriptMessages(messages);
+  const groups = groupTranscriptEvents(events);
+  return { events, groups };
+}
+

package/src/daemon/cli.ts

@@ -0,0 +1,88 @@
+import { homedir } from 'node:os';
+import { ConfigManager } from '../config/manager.ts';
+import { RuntimeEventBus } from '../runtime/events/index.ts';
+import { createRuntimeStore } from '../runtime/store/index.ts';
+import { createRuntimeServices } from '../runtime/services.ts';
+import { DaemonServer } from './server.ts';
+import { HttpListener } from './http-listener.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { GlobalNetworkTransportInstaller } from '../runtime/network/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+type DaemonCliOwnership = {
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+};
+
+type DaemonCliTokens = {
+  readonly daemonToken: string | undefined;
+  readonly httpToken: string | undefined;
+};
+
+function resolveDaemonCliOwnership(): DaemonCliOwnership {
+  return {
+    workingDirectory: process.cwd(),
+    homeDirectory: homedir(),
+  };
+}
+
+function readDaemonCliTokens(env: NodeJS.ProcessEnv): DaemonCliTokens {
+  const daemonToken = env.GOODVIBES_DAEMON_TOKEN;
+  return {
+    daemonToken,
+    httpToken: env.GOODVIBES_HTTP_TOKEN ?? daemonToken,
+  };
+}
+
+async function main(): Promise<void> {
+  const { workingDirectory: workingDir, homeDirectory } = resolveDaemonCliOwnership();
+  const config = new ConfigManager({ workingDir, homeDir: homeDirectory });
+  new GlobalNetworkTransportInstaller().install(config);
+  const runtimeBus = new RuntimeEventBus();
+  const runtimeStore = createRuntimeStore();
+  const runtimeServices = createRuntimeServices({
+    configManager: config,
+    runtimeBus,
+    runtimeStore,
+    getConversationTitle: () => 'goodvibes daemon',
+    workingDir,
+    homeDirectory,
+  });
+
+  const userAuth = runtimeServices.localUserAuthManager;
+  const daemon = new DaemonServer({ runtimeBus, userAuth, runtimeServices });
+  const listener = new HttpListener({
+    hookDispatcher: runtimeServices.hookDispatcher,
+    userAuth,
+    configManager: config,
+  });
+  const { daemonToken, httpToken } = readDaemonCliTokens(process.env);
+
+  daemon.enable({ daemon: true }, daemonToken);
+  listener.enable({ httpListener: true }, httpToken);
+
+  await Promise.all([
+    daemon.start(),
+    config.get('danger.httpListener') ? listener.start() : Promise.resolve(),
+  ]);
+
+  const shutdown = async (): Promise<void> => {
+    await Promise.allSettled([listener.stop(), daemon.stop()]);
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => void shutdown());
+  process.on('SIGTERM', () => void shutdown());
+
+  logger.info('goodvibes daemon host started', {
+    daemon: config.get('danger.daemon'),
+    httpListener: config.get('danger.httpListener'),
+  });
+}
+
+void main().catch(async (error) => {
+  logger.error('goodvibes daemon host failed', {
+    error: summarizeError(error),
+  });
+  process.exit(1);
+});