@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -5,19 +5,26 @@
  * Delivery is resolved from the message KIND ('system' | 'wrfc' |
  * 'operational'), which maps to a configurable routing target
  * (ui.systemMessages / ui.wrfcMessages / ui.operationalMessages, each
- * 'panel' | 'conversation' | 'both'). resolveSystemMessageDelivery() turns that
- * target — plus whether a panel is attached — into a { toPanel, toConversation }
- * decision. The priority ('high' | 'low') only sets the panel emphasis; it does
- * not by itself decide conversation delivery.
+ * 'panel' | 'conversation' | 'both'). resolveSystemMessageDelivery() turns
+ * that target — plus whether a panel is attached — into a { toPanel,
+ * toConversation } decision.
  *
- * Critical override: errors, provider failovers, and compaction/context notices
- * (see FORCE_CONVERSATION_PREFIXES) ALWAYS also reach the main conversation,
- * regardless of target, so the user never has to open the SystemMessagesPanel
- * to discover them.
+ * W6.1 (the purge): the SystemMessagesPanel this router used to optionally
+ * push into was DELETE-disposition (no surviving human surface — a picker
+ * over the old panel registry, not something worth a dedicated console) and
+ * has been removed entirely, so this router now always resolves with
+ * `hasPanel = false`. Per resolveSystemMessageDelivery's own contract that
+ * means EVERY kind/target combination (including 'panel'-only) falls back
+ * to `toConversation: true` — nothing this router routes can vanish; it all
+ * reaches conversation.addTypedSystemMessage(), which the transcript
+ * renders as a navigable system line. This is deliberate, not a regression:
+ * operational chatter that used to be tucked away in a rarely-opened panel
+ * now surfaces inline, same as the messages that were already forced there
+ * (see FORCE_CONVERSATION_PREFIXES below).
  *
  * Usage:
  * ```ts
- * const router = createSystemMessageRouter(conversation, panel);
+ * const router = createSystemMessageRouter(conversation);
  * router.routeSystemMessage('[Provider] anthropic registered', 'low');
  * router.routeSystemMessage('[Session] Saved session abc123', 'high');
  * ```
@@ -33,7 +40,7 @@
  */
 
 import type { ConversationManager } from './conversation';
-import type { SystemMessagesPanel, SystemMessagePriority } from '../panels/system-messages-panel.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   classifySystemMessageKind,
   classifySystemMessagePriority,
@@ -42,19 +49,27 @@ import {
   type SystemMessageKind,
   type SystemMessageTarget,
 } from '@/runtime/index.ts';
+import {
+  classifyNoise,
+  foldProviderReplayLines,
+  providerNameFromReplay,
+  type NoiseGateDeps,
+} from './system-message-noise.ts';
 
 export type {
   SystemMessageKind,
   SystemMessageTarget,
 } from '@/runtime/index.ts';
 
+/** Panel emphasis level. Panel delivery was removed in W6.1 (see file doc); kept as the priority vocabulary for callers and for the SDK's delivery-resolution signature. */
+export type SystemMessagePriority = 'high' | 'low';
+
 /**
  * Message categories that are operationally critical enough that the user must
  * see them inline in the main conversation, regardless of the configured
- * routing target (ui.systemMessages defaults to panel-only). Errors, provider
- * failovers, and compaction/context notices fall here: a user should never have
- * to open the SystemMessagesPanel to discover that a turn errored, a provider
- * failed over, or the context was compacted.
+ * routing target. Errors, provider failovers, and compaction/context notices
+ * fall here: a user should never have to go hunting to discover that a turn
+ * errored, a provider failed over, or the context was compacted.
  *
  * Detection is by the stable message prefix tag, mirroring how the SDK
  * classifiers key off message content. This deliberately does NOT force every
@@ -72,14 +87,19 @@ function mustReachConversation(message: string): boolean {
 // ---------------------------------------------------------------------------
 
 /**
- * Routes system messages to the conversation and/or the SystemMessagesPanel
- * based on priority level.
+ * Routes system messages to the conversation based on priority level and
+ * configured target. See file doc for the W6.1 panel removal.
  */
 export class SystemMessageRouter {
+  /** Buffered provider "from last session" replay lines, folded on a microtask. */
+  private providerReplayBuffer: string[] = [];
+  private providerReplayScheduled = false;
+
   constructor(
     private readonly conversation: ConversationManager,
-    private panel: SystemMessagesPanel | null,
     private readonly getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultSystemMessageTarget,
+    /** Noise-gate dependencies (WRFC terminal-chain lookup). See system-message-noise.ts. */
+    private readonly noiseDeps: NoiseGateDeps = {},
   ) {}
 
   // ── Public API ────────────────────────────────────────────────────────────
@@ -87,28 +107,40 @@ export class SystemMessageRouter {
   /**
    * Route a system message.
    *
-   * Delivery is resolved from the kind and its configured target; priority only
-   * sets panel emphasis. Critical notices (errors/failover/compaction, see
-   * FORCE_CONVERSATION_PREFIXES) are additionally forced into the conversation.
+   * Delivery is resolved from the kind and its configured target. Critical
+   * notices (errors/failover/compaction, see FORCE_CONVERSATION_PREFIXES)
+   * are additionally forced into the conversation.
    *
    * @param message  - Message text.
-   * @param priority - 'high' | 'low'.
+   * @param priority - 'high' | 'low' (kept for callers; no longer changes
+   *                   delivery now that there is no panel to emphasize on).
    * @param kind     - Classification kind ('system' | 'wrfc' | 'operational');
    *                   used to resolve routing target and conversation navigability.
    */
   routeTypedSystemMessage(
     message: string,
-    priority: SystemMessagePriority,
+    _priority: SystemMessagePriority,
     kind: SystemMessageKind,
   ): void {
-    const target = this.getTargetForKind(kind);
-    const delivery = resolveSystemMessageDelivery(target, this.panel !== null);
-    if (delivery.toPanel) {
-      this.panel?.push(message, priority);
+    // Noise gate — keep first-run plumbing out of the transcript while the
+    // information stays reachable via other live surfaces. (UX-B item 1.)
+    const verdict = classifyNoise(message, this.noiseDeps);
+    if (verdict.action === 'drop') return;
+    if (verdict.action === 'foldProviderReplay') {
+      this.bufferProviderReplay(message);
+      return;
     }
-    // Critical notices (errors, failover, compaction) must surface inline even
-    // when the configured target is panel-only — otherwise a user without the
-    // SystemMessagesPanel open would never see them.
+
+    this.deliver(message, kind);
+  }
+
+  /** Post-noise-gate delivery: resolve target and append to the conversation. */
+  private deliver(message: string, kind: SystemMessageKind): void {
+    const target = this.getTargetForKind(kind);
+    // hasPanel is always false post-W6.1 — resolveSystemMessageDelivery's own
+    // contract means every target ('panel' | 'conversation' | 'both')
+    // resolves toConversation: true in that case (see file doc).
+    const delivery = resolveSystemMessageDelivery(target, false);
     const toConversation = delivery.toConversation || mustReachConversation(message);
     if (toConversation) {
       // addTypedSystemMessage threads the kind into the conversation so the
@@ -117,6 +149,45 @@ export class SystemMessageRouter {
     }
   }
 
+  /**
+   * Buffer a provider "from last session" replay line and schedule a microtask
+   * flush. The SDK emits the whole persisted-provider burst synchronously, so a
+   * single microtask captures the full burst and folds it to one quiet line.
+   * (UX-B item 1b.)
+   */
+  private bufferProviderReplay(message: string): void {
+    this.providerReplayBuffer.push(message);
+    if (this.providerReplayScheduled) return;
+    this.providerReplayScheduled = true;
+    queueMicrotask(() => this.flushProviderReplay());
+  }
+
+  /**
+   * Record the folded provider-replay summary and reset the buffer.
+   *
+   * Papercut sweep item 2: this used to `deliver()` the folded line into the
+   * transcript — one line instead of a burst, but still boot plumbing the
+   * user never asked to see there ("the transcript at boot shows product
+   * signal only"). The persisted-provider set this summarizes is reachable
+   * on demand via `/health provider` (providers-modal lists every registered
+   * provider, discovered/local ones included) and `/model` (lists every
+   * selectable model, discovered ones included) — so nothing is lost by
+   * keeping it out of the transcript. It still goes to the activity log
+   * (.goodvibes/logs/activity.md) for diagnosis. Only this boot-only "— from
+   * last session" burst moves; unrelated provider-discovery lines emitted
+   * mid-session (e.g. "[Scan] Found …", "[Scan] … no longer reachable") are
+   * untouched — they never match PROVIDER_REPLAY_RE, so they never enter this
+   * buffer/fold path and keep reaching the transcript as live product signal.
+   */
+  flushProviderReplay(): void {
+    this.providerReplayScheduled = false;
+    if (this.providerReplayBuffer.length === 0) return;
+    const summary = foldProviderReplayLines(this.providerReplayBuffer);
+    const providerNames = this.providerReplayBuffer.map(providerNameFromReplay);
+    this.providerReplayBuffer = [];
+    logger.info(summary, { count: providerNames.length, providers: providerNames });
+  }
+
   routeSystemMessage(message: string, priority: SystemMessagePriority): void {
     this.routeTypedSystemMessage(message, priority, classifySystemMessageKind(message));
   }
@@ -153,21 +224,6 @@ export class SystemMessageRouter {
   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;
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -175,17 +231,14 @@ export class SystemMessageRouter {
 // ---------------------------------------------------------------------------
 
 /**
- * Create a SystemMessageRouter wired to the given conversation and panel.
+ * Create a SystemMessageRouter wired to the given conversation.
  *
- * @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).
+ * @param conversation - The ConversationManager all routed messages reach.
  */
 export function createSystemMessageRouter(
   conversation: ConversationManager,
-  panel: SystemMessagesPanel | null = null,
   getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultSystemMessageTarget,
+  noiseDeps: NoiseGateDeps = {},
 ): SystemMessageRouter {
-  return new SystemMessageRouter(conversation, panel, getTargetForKind);
+  return new SystemMessageRouter(conversation, getTargetForKind, noiseDeps);
 }

package/src/core/turn-cancellation.ts

@@ -0,0 +1,25 @@
+import type { Orchestrator } from './orchestrator';
+import type { SpokenTurnRuntime } from '../audio/spoken-turn-wiring.ts';
+
+/**
+ * Builds the shared "cancel the active turn" action: stops any in-flight
+ * spoken output, then aborts the orchestrator's turn if one is actively
+ * streaming. Extracted from main.ts so the file can stay under its 800-line
+ * cap while still wiring `commandContext.isGenerating` (see W1.6 FIX 1).
+ *
+ * Returns whether SPEECH was actively stopped — a Ctrl+C that silenced live
+ * TTS is consumed by that job (batch replay D5), same as a press that
+ * cleared a non-empty prompt; the quit chord starts from a quiet state.
+ */
+export function createCancelGeneration(
+  orchestrator: Orchestrator,
+  spokenTurns: Pick<SpokenTurnRuntime, 'stop'>,
+): () => boolean {
+  return () => {
+    const stoppedSpeech = spokenTurns.stop('Spoken output stopped.');
+    if (orchestrator.isThinking) {
+      orchestrator.abort();
+    }
+    return stoppedSpeech;
+  };
+}

package/src/core/turn-event-wiring.ts

@@ -6,7 +6,12 @@ import type { HookDispatcher, HookPhase, HookCategory, HookEventPath } from '@pe
 import type { ConversationManager } from './conversation.ts';
 import { journalPathFor, openTranscriptJournal, type TranscriptJournal } from './transcript-journal.ts';
 import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
 import { maybeNotifyLongTask, readNotifyAfterSeconds, type LongTaskStatus } from './long-task-notifier.ts';
+import type { FocusTracker } from './focus-tracker.ts';
+import { shouldFireAlert, FORCE_NOTIFY_DURATION_MS } from './alert-gating.ts';
+import { createBudgetBreachNotifier, type BudgetBreachNotifier } from './budget-breach-notifier.ts';
+import { readBudgetAlertUsd } from '../export/cost-utils.ts';
 
 /** Infer the options param of persistConversation to pick up SessionManager correctly. */
 type PersistOptions = NonNullable<Parameters<typeof persistConversation>[5]>;
@@ -14,11 +19,13 @@ type PersistOptions = NonNullable<Parameters<typeof persistConversation>[5]>;
 /** Minimal orchestrator surface required by turn-event wiring. */
 interface TurnOrchestrator {
   readonly lastInputTokens: number;
+  /** Cumulative session usage — same object CostTrackerPanel reads, used here for budget-breach checks. */
+  readonly usage: { readonly input: number; readonly output: number; readonly cacheRead: number; readonly cacheWrite: number };
 }
 
 /** Minimal provider registry surface required by turn-event wiring. */
 interface TurnProviderRegistry {
-  getCurrentModel(): { readonly contextWindow: number };
+  getCurrentModel(): { readonly contextWindow: number; readonly id?: string };
   getContextWindowForModel(model: { readonly contextWindow: number }): number;
 }
 
@@ -57,6 +64,16 @@ export interface WireTurnEventHandlersOptions {
    * when absent.
    */
   readonly webhookNotifier?: WebhookNotifier | null;
+  /**
+   * Terminal focus tracker (W2.3). Gates the long-task, budget-breach, and
+   * agent/chain-failure desktop alerts wired in this module — see
+   * alert-gating.ts. Optional; when absent, none of the new W2.3 alert
+   * behavior is gated by focus (long-task keeps its pre-W2.3 always-fire
+   * behavior, and budget-breach/failure alerts are skipped entirely, since
+   * they are new-in-W2.3 and have no pre-existing unconditional-fire path
+   * to fall back to).
+   */
+  readonly focusTracker?: Pick<FocusTracker, 'shouldAlertWhenUnfocused'> | null;
   /**
    * Minimal test seam: injectable clock for controlling Date.now() in tests.
    * Defaults to the real Date.now when absent.
@@ -94,13 +111,14 @@ export function wireTurnEventHandlers(
   options: WireTurnEventHandlersOptions,
 ): WireTurnEventHandlersResult {
   const {
-    events, conversation, runtime, configManager, hookDispatcher,
+    events, conversation, runtime, configManager, hookDispatcher, orchestrator, providerRegistry,
     workingDir, homeDirectory, sessionManager, gitStatusProvider,
-    lastGitInfoRef, buildSessionContinuityHints, render, webhookNotifier,
+    lastGitInfoRef, buildSessionContinuityHints, render, webhookNotifier, focusTracker,
     _clock = Date.now,
   } = options;
 
   const unsubs: Array<() => void> = [];
+  const configGet = (k: string): unknown => configManager.get(k as Parameters<typeof configManager.get>[0]);
 
   // Create the per-session transcript journal. Path mirrors recovery-file
   // convention (homeDirectory-scoped). Created lazily on first append.
@@ -112,6 +130,13 @@ export function wireTurnEventHandlers(
   // Track turn start time for long-task notification threshold.
   let turnStartTime: number | null = null;
 
+  // Budget-breach edge-trigger checker (W2.3) — one instance per session,
+  // piggybacking on the same TURN_COMPLETED handler as the long-task
+  // notification below rather than adding a second TURN_COMPLETED subscription.
+  const budgetBreachNotifier: BudgetBreachNotifier | null = focusTracker
+    ? createBudgetBreachNotifier({ focusTracker, configGet, webhookNotifier: webhookNotifier ?? null, sessionId: runtime.sessionId })
+    : null;
+
   const refreshGit = (): void => {
     gitStatusProvider.refresh().then((info) => { lastGitInfoRef.value = info; render(); }).catch(() => { /* non-fatal */ });
   };
@@ -140,7 +165,15 @@ export function wireTurnEventHandlers(
       sessionId: runtime.sessionId,
       thresholdSeconds: notifyThreshold,
       webhookNotifier: webhookNotifier ?? null,
+      focusTracker,
+      configGet,
     });
+    // Budget-breach alert (W2.3): edge-triggered, piggybacks on this same
+    // TURN_COMPLETED handler rather than a second subscription.
+    if (budgetBreachNotifier) {
+      const sessionModel = providerRegistry.getCurrentModel().id ?? 'unknown';
+      budgetBreachNotifier.check(orchestrator.usage, sessionModel, readBudgetAlertUsd(configGet));
+    }
     // Auto-save after every LLM turn so kills don't lose the session
     try {
       const snapshot = conversation.toJSON() as { messages: Array<import('./conversation.ts').ConversationMessageSnapshot>; timestamp?: number };
@@ -180,5 +213,41 @@ export function wireTurnEventHandlers(
     refreshGit();
   }));
 
+  // Agent/chain-failure desktop alerts (W2.3). The SDK's WebhookNotifier and
+  // Notifier already fire webhook/Slack/Discord notifications for these two
+  // events unconditionally (attachToRuntimeBus in the SDK's
+  // platform/integrations — pre-existing, not focus-gated: an out-of-band
+  // push to another device is useful regardless of terminal focus). What was
+  // missing was a desktop notification, gated by focus like the other three
+  // alert classes — that's the only thing added here, to avoid double-firing
+  // a webhook that's already covered.
+  if (focusTracker) {
+    unsubs.push(events.agents.on('AGENT_FAILED', (payload) => {
+      if (!shouldFireAlert(focusTracker, configGet, 'behavior.notifyOnAgentFailure')) return;
+      try {
+        notifyCompletion('GoodVibes — agent failed', `agent ${payload.agentId.slice(0, 8)} failed: ${payload.error}`, FORCE_NOTIFY_DURATION_MS);
+      } catch (err) {
+        logger.debug('turn-event-wiring: agent-failure notify error', { error: String(err) });
+      }
+    }));
+    unsubs.push(events.workflows.on('WORKFLOW_CHAIN_FAILED', (payload) => {
+      if (!shouldFireAlert(focusTracker, configGet, 'behavior.notifyOnChainFailure')) return;
+      try {
+        // An operator cancellation is an intended stop, not a failure — narrate it
+        // as cancelled (the reason already carries the landed-work count from the
+        // chain's edit ledger), so the notification never contradicts the cancelled
+        // chain/owner/cohort surfaces.
+        if (payload.failureKind === 'cancelled') {
+          notifyCompletion('GoodVibes — WRFC chain cancelled', `chain ${payload.chainId.slice(0, 12)} cancelled: ${payload.reason}`, FORCE_NOTIFY_DURATION_MS);
+        } else {
+          const kindLabel = payload.failureKind === 'transport' ? 'transient transport error' : payload.reason;
+          notifyCompletion('GoodVibes — WRFC chain failed', `chain ${payload.chainId.slice(0, 12)} failed: ${kindLabel}`, FORCE_NOTIFY_DURATION_MS);
+        }
+      } catch (err) {
+        logger.debug('turn-event-wiring: chain-failure notify error', { error: String(err) });
+      }
+    }));
+  }
+
   return { refreshGit, unsubs, transcriptJournal };
 }

package/src/daemon/cli.ts

@@ -1,7 +1,7 @@
 import { homedir, networkInterfaces } from 'node:os';
 import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
-import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { ConfigManager, resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import { formatProviderModel, getModelIdFromProviderModel, getProviderIdFromModel } from '../config/provider-model.ts';
 import { RuntimeEventBus, GlobalNetworkTransportInstaller } from '@/runtime/index.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
@@ -27,6 +27,7 @@ import {
   persistProviders,
 } from '@pellux/goodvibes-sdk/platform/discovery';
 import { createSafeHostServeFactory } from './safe-serve.ts';
+import { isDaemonServiceSubcommand, resolveInstalledDaemonBinary, runDaemonServiceCli } from './service-commands.ts';
 
 import {
   parseGoodVibesCli,
@@ -161,6 +162,32 @@ async function main(): Promise<void> {
     process.env['GOODVIBES_DAEMON_HOST'] = cliFlags.hostname;
     logger.info('daemon: --hostname flag applied', { hostname: cliFlags.hostname });
   }
+
+  // D7a Layer 1: `install-service` / `uninstall-service` / `service-status` manage
+  // the systemd USER unit for the shared daemon. They run BEFORE the daemon boots —
+  // no runtime/services are constructed — and exit with the honest result code.
+  const serviceSubcommand = cli.positionals[0];
+  if (isDaemonServiceSubcommand(serviceSubcommand)) {
+    const host = String(process.env.GOODVIBES_DAEMON_HOST ?? config.get('controlPlane.host') ?? '127.0.0.1');
+    const port = Number(config.get('controlPlane.port'));
+    const binaryPath = resolveInstalledDaemonBinary({ moduleUrl: import.meta.url });
+    const result = await runDaemonServiceCli({
+      subcommand: serviceSubcommand,
+      binaryPath,
+      homeDir: homeDirectory,
+      host,
+      port,
+      // migrate-service only: never auto-migrate — requires the same explicit
+      // consent as any other non-interactive destructive confirmation.
+      confirmMigration: cliFlags.yes,
+    });
+    for (const line of result.lines) {
+      // eslint-disable-next-line no-console
+      console.log(line);
+    }
+    process.exit(result.exitCode);
+  }
+
   const runtimeBus = new RuntimeEventBus();
   const runtimeStore = createRuntimeStore();
   const featureFlags = createFeatureFlagManager();
@@ -269,7 +296,7 @@ async function main(): Promise<void> {
   process.on('SIGTERM', handleSignal);
 
   logger.info('goodvibes daemon host started', {
-    daemon: config.get('danger.daemon'),
+    daemon: resolveDaemonEnabled(config),
     httpListener: config.get('danger.httpListener'),
   });
 

package/src/daemon/handlers/register.ts

@@ -111,7 +111,14 @@ export function registerCatalogHandler<TBody, TResult>(
 ): Unregister {
   const descriptor = catalog.get(methodId);
   if (!descriptor) {
-    throw new HandlerError(`Unknown gateway method: ${methodId}`, 'UNKNOWN_METHOD', 404);
+    // 'METHOD_NOT_FOUND' (not the old locally-coined 'UNKNOWN_METHOD') so this lines
+    // up byte-for-byte with SDKErrorCodes.METHOD_NOT_FOUND — the code the SDK's own
+    // uncataloged-method 404 now carries (method-catalog.ts's GatewayMethodCatalog
+    // .invoke(), daemon/control-plane.ts's invokeGatewayMethodCall, and daemon-sdk's
+    // control-routes.ts getGatewayMethod/invokeGatewayMethod). A literal string, not
+    // an import of SDKErrorCodes: the pinned SDK (0.38.0) predates that constant, and
+    // matching the value this way needs no SDK version bump to stay aligned.
+    throw new HandlerError(`Unknown gateway method: ${methodId}`, 'METHOD_NOT_FOUND', 404);
   }
 
   const wrapped = async (inv: GatewayMethodInvocation): Promise<unknown> => {