@pellux/goodvibes-agent 1.5.5 → 1.5.6

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

@@ -0,0 +1,108 @@
+/**
+ * System-message noise policy — decides whether an operational status message
+ * should reach the Recent feed / transcript unchanged, be dropped, or be folded.
+ * Every noisy source these rules catch funnels through SystemMessageRouter, so
+ * this one classifier is where first-run plumbing is kept out of the user's
+ * stream while the information stays reachable elsewhere (activity log, /health,
+ * /model, the fleet/agents surface).
+ *
+ * Ported from the TUI (src/core/system-message-noise.ts). The TUI regexes are
+ * kept VERBATIM (provider-replay fold / agents-snapshot drop / stale-replay
+ * drop); the only agent-specific addition is the `[Terminal] Captured …` rule
+ * (W4-R2, absorbing A8 papercut #3 — the stdout-capture leak). Dropped noise is
+ * drop-from-the-feed, NOT delete: the captured-write detail stays reachable via
+ * the activity log (the terminal-output guard logs each intercept + the count).
+ */
+
+export interface NoiseGateDeps {
+  /**
+   * True when a WRFC chain is terminal (passed/failed) or gone (killed/removed).
+   * Used to suppress stale "[Replay] … transitioned … waiting for action"
+   * re-notifications for chains that can no longer act. Absent → never suppress.
+   */
+  readonly isChainTerminal?: (chainId: string) => boolean;
+}
+
+export type NoiseVerdict =
+  /** Pass through to the feed/transcript unchanged. */
+  | { readonly action: 'emit' }
+  /** Suppress entirely — reachable via another live surface. */
+  | { readonly action: 'drop' }
+  /** Provider "from last session" replay line — buffer and fold to one line. */
+  | { readonly action: 'foldProviderReplay' };
+
+const EMIT: NoiseVerdict = { action: 'emit' };
+const DROP: NoiseVerdict = { action: 'drop' };
+const FOLD: NoiseVerdict = { action: 'foldProviderReplay' };
+
+/** Matches the SDK's per-provider persisted-replay line (1b). */
+const PROVIDER_REPLAY_RE = / — from last session$/;
+
+/** Matches the SDK's 30s periodic running-agents snapshot (1d). */
+const AGENTS_RUNNING_SNAPSHOT_RE = /^\[Agents\] \d+ running:/;
+
+/** Extracts the chain id from a "[Replay]… WRFC chain <id> transitioned …" line (1c). */
+const REPLAY_CHAIN_RE = /WRFC chain (\S+) transitioned .* waiting for action/;
+
+/**
+ * Matches the terminal-output guard's aggregate captured-write notice
+ * (W4-R2, agent-specific). First-run plumbing writes a burst of direct stdout
+ * that the guard intercepts and would otherwise summarize into the Recent feed;
+ * the count stays reachable in the activity log, so the feed copy is dropped.
+ */
+const TERMINAL_CAPTURED_RE = /^\[Terminal\] Captured \d+ direct /;
+
+/**
+ * Classify one system message. Pure aside from the injected `isChainTerminal`
+ * lookup, so it is trivially testable.
+ */
+export function classifyNoise(message: string, deps: NoiseGateDeps): NoiseVerdict {
+  // agent (W4-R2) — the terminal-output guard's aggregate captured-write notice.
+  // Kept out of the Recent feed; the detail stays in the activity log.
+  if (TERMINAL_CAPTURED_RE.test(message)) {
+    return DROP;
+  }
+
+  // 1b — provider-discovery replay burst ("[Local] … — from last session").
+  if (message.startsWith('[Local]') && PROVIDER_REPLAY_RE.test(message)) {
+    return FOLD;
+  }
+
+  // 1d — periodic "[Agents] N running:" status snapshot. The same live detail
+  // is shown in the fleet/agents surface and the footer count, so the periodic
+  // transcript churn is dropped. Meaningful lifecycle lines ("[Agents] ✓ …",
+  // "[Agents] Cohort …", "[Agents] ✗ …") do not match.
+  if (AGENTS_RUNNING_SNAPSHOT_RE.test(message)) {
+    return DROP;
+  }
+
+  // 1c — stale "[Replay] … waiting for action" for a terminal/killed chain.
+  if (message.startsWith('[Replay]') && deps.isChainTerminal) {
+    const match = REPLAY_CHAIN_RE.exec(message);
+    if (match && deps.isChainTerminal(match[1])) return DROP;
+  }
+
+  return EMIT;
+}
+
+/** Provider name from a "[Local] <name> at host:port (…) — from last session" line. */
+export function providerNameFromReplay(message: string): string {
+  const match = /^\[Local\]\s+(.+?)\s+at\s/.exec(message);
+  if (match) return match[1];
+  // Fallback: first token after the tag.
+  const bare = /^\[Local\]\s+(\S+)/.exec(message);
+  return bare ? bare[1] : 'provider';
+}
+
+/**
+ * Build the single folded summary line for a burst of provider-replay lines.
+ * Names a few providers; the full list stays reachable via /health and /model.
+ */
+export function foldProviderReplayLines(messages: readonly string[]): string {
+  const names = messages.map(providerNameFromReplay);
+  const count = names.length;
+  const noun = count === 1 ? 'provider' : 'providers';
+  const shown = names.slice(0, 3).join(', ');
+  const extra = count > 3 ? `, +${count - 3} more` : '';
+  return `[Local] Restored ${count} ${noun} from last session (${shown}${extra})`;
+}

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

@@ -20,6 +20,7 @@
 
 import type { ConversationManager } from './conversation';
 import type { ActivityFeed } from './activity-feed.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   classifySystemMessageKind,
   classifySystemMessagePriority,
@@ -28,6 +29,12 @@ import {
   type SystemMessageKind,
   type SystemMessageTarget,
 } from '@/runtime/index.ts';
+import {
+  classifyNoise,
+  foldProviderReplayLines,
+  providerNameFromReplay,
+  type NoiseGateDeps,
+} from './system-message-noise.ts';
 
 export type {
   SystemMessageKind,
@@ -41,10 +48,16 @@ export type SystemMessagePriority = 'high' | 'low';
  * based on priority level and per-kind targets.
  */
 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 feed: ActivityFeed | 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 ────────────────────────────────────────────────────────────────
@@ -54,6 +67,16 @@ export class SystemMessageRouter {
     priority: SystemMessagePriority,
     kind: SystemMessageKind,
   ): void {
+    // Noise gate — keep first-run plumbing out of the Recent feed / transcript
+    // while the information stays reachable via other live surfaces (activity
+    // log, /health, /model). Dropped noise is drop-from-the-feed, not delete.
+    const verdict = classifyNoise(message, this.noiseDeps);
+    if (verdict.action === 'drop') return;
+    if (verdict.action === 'foldProviderReplay') {
+      this.bufferProviderReplay(message);
+      return;
+    }
+
     const target = this.getTargetForKind(kind);
     const delivery = resolveSystemMessageDelivery(target, this.feed !== null);
     if (delivery.toPanel) {
@@ -64,6 +87,35 @@ 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.
+   */
+  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 to the activity log and reset the
+   * buffer. The boot-only "— from last session" burst stays out of the Recent
+   * feed; the persisted-provider set it summarizes is reachable on demand via
+   * /health and /model, and the fold line is logged for diagnosis. Only the
+   * boot burst folds — mid-session provider-discovery lines never match
+   * PROVIDER_REPLAY_RE, so they still reach the feed 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));
   }
@@ -117,6 +169,7 @@ export function createSystemMessageRouter(
   conversation: ConversationManager,
   feed: ActivityFeed | null = null,
   getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultSystemMessageTarget,
+  noiseDeps: NoiseGateDeps = {},
 ): SystemMessageRouter {
-  return new SystemMessageRouter(conversation, feed, getTargetForKind);
+  return new SystemMessageRouter(conversation, feed, getTargetForKind, noiseDeps);
 }

package/src/core/thinking-overlay.ts

@@ -0,0 +1,83 @@
+/**
+ * thinking-overlay.ts (W4-R4) — the thinking-indicator overlay + its honest
+ * stall clock, extracted from main.ts's render loop.
+ *
+ * The SDK orchestrator surfaces no lastDeltaAtMs / reconnect signal directly, so
+ * ThinkingStallClock derives a per-turn last-delta clock from streaming
+ * output-token advances — a real, honest proxy that degrades gracefully with
+ * zero new SDK events. buildThinkingOverlay turns that into the honest waiting
+ * state (via UIFactory.createThinkingFragment, which consumes the SDK
+ * presentation contract's waitingPhrase).
+ */
+
+import { UIFactory, type ThinkingStallInfo } from '../renderer/ui-factory.ts';
+import type { Line } from '../types/grid.ts';
+import type { Orchestrator } from './orchestrator.ts';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+
+/**
+ * Per-turn last-delta clock. tick() seeds at turn start, then pushes the clock
+ * forward whenever the streaming output-token count advances; reset() clears it
+ * so the next turn re-seeds. Suppresses stall detection while a tool is active
+ * (the model isn't producing tokens then — a "Stalled" label would be a false
+ * positive).
+ */
+export class ThinkingStallClock {
+  private startedAt: number | null = null;
+  private lastDeltaAt = 0;
+  private lastOutputTokens = 0;
+
+  tick(streamingOutputTokens: number, toolActive: boolean, nowMs: number): ThinkingStallInfo | undefined {
+    if (this.startedAt === null) {
+      this.startedAt = nowMs;
+      this.lastDeltaAt = nowMs;
+      this.lastOutputTokens = streamingOutputTokens;
+    } else if (streamingOutputTokens > this.lastOutputTokens) {
+      this.lastDeltaAt = nowMs;
+      this.lastOutputTokens = streamingOutputTokens;
+    }
+    return UIFactory.computeRenderStallInfo({ toolActive, lastDeltaAtMs: this.lastDeltaAt, nowMs });
+  }
+
+  reset(): void {
+    this.startedAt = null;
+  }
+}
+
+export interface ThinkingOverlayDeps {
+  readonly orchestrator: Pick<Orchestrator,
+    'isThinking' | 'getSpinner' | 'thinkingFrame' | 'streamingInputTokens' | 'streamingOutputTokens'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  /** The raw snapshot tool preview (a truthy value means a tool is executing). */
+  readonly streamToolPreview: string | undefined;
+  readonly streamTokenSpeed: number;
+  readonly approvalPending: boolean;
+  readonly width: number;
+  readonly clock: ThinkingStallClock;
+}
+
+/**
+ * Build the thinking-indicator overlay lines. Returns [] when not thinking (and
+ * resets the stall clock so the next turn re-seeds). The stall/approval signals
+ * drive the honest waiting state inside createThinkingFragment.
+ */
+export function buildThinkingOverlay(deps: ThinkingOverlayDeps): Line[] {
+  if (!deps.orchestrator.isThinking) {
+    deps.clock.reset();
+    return [];
+  }
+  const showSpeed = deps.configManager.get('display.showTokenSpeed') as boolean;
+  const showPreview = deps.configManager.get('display.showToolPreview') as boolean;
+  const stallInfo = deps.clock.tick(deps.orchestrator.streamingOutputTokens, !!deps.streamToolPreview, Date.now());
+  return UIFactory.createThinkingFragment(
+    deps.width,
+    deps.orchestrator.getSpinner(),
+    deps.orchestrator.thinkingFrame,
+    showSpeed ? deps.streamTokenSpeed : undefined,
+    showPreview ? deps.streamToolPreview : undefined,
+    deps.orchestrator.streamingInputTokens > 0 ? deps.orchestrator.streamingInputTokens : undefined,
+    deps.orchestrator.streamingOutputTokens > 0 ? deps.orchestrator.streamingOutputTokens : undefined,
+    stallInfo,
+    deps.approvalPending,
+  );
+}

package/src/input/agent-workspace-access-command-editor-submission.ts

@@ -1,149 +1,116 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import type { AgentWorkspaceAccessCommandEditorKind } from './agent-workspace-access-command-editors.ts';
 import { isAgentWorkspaceAccessCommandEditorKind } from './agent-workspace-access-command-editors.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceCommandSubmissionHandler, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { buildCommandEditorSubmissionFromTable, dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceAccessCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
+export type AgentWorkspaceAccessCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceAccessCommandSubmissionKind(kind: string): kind is AgentWorkspaceAccessCommandEditorKind {
   return isAgentWorkspaceAccessCommandEditorKind(kind as AgentWorkspaceAccessCommandEditorKind);
 }
 
-function isAffirmative(value: string): boolean {
-  return /^(y|yes|true)$/i.test(value.trim());
-}
-
-function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceAccessCommandEditorSubmission {
-  return {
-    kind: 'editor',
-    editor: { ...editor, message },
-    status: message,
-  };
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceCommandEditorSubmission {
+  return editorMessageSubmission(editor, message);
 }
 
-function dispatch(command: string, title: string, detail: string, safety: AgentWorkspaceActionResult['safety']): AgentWorkspaceAccessCommandEditorSubmission {
-  return {
-    kind: 'dispatch',
-    command,
-    status: `${title}.`,
-    actionResult: {
-      kind: 'dispatched',
-      title,
-      detail,
-      command,
-      safety,
-    },
-  };
-}
-
-export function buildAgentWorkspaceAccessCommandEditorSubmission(
-  editor: AgentWorkspaceLocalEditor,
-  readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceAccessCommandEditorSubmission {
-  if (editor.kind === 'auth-show') {
-    return dispatch(
-      `/auth show ${quoteSlashCommandArg(readField('provider'))}`,
-      'Opening provider auth inspection',
-      'The workspace handed a read-only provider auth inspection command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'auth-repair') {
-    return dispatch(
-      `/auth repair ${quoteSlashCommandArg(readField('provider'))}`,
-      'Opening provider auth repair review',
-      'The workspace handed a read-only provider auth repair review command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'auth-bundle-export') {
+const ACCESS_COMMAND_SUBMISSION_HANDLERS: Readonly<Record<AgentWorkspaceAccessCommandEditorKind, AgentWorkspaceCommandSubmissionHandler>> = {
+  'auth-show': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/auth show ${quoteSlashCommandArg(readField('provider'))}`,
+    'Opening provider auth inspection',
+    'The workspace handed a read-only provider auth inspection command to the shell-owned command router.',
+    'read-only',
+  ),
+  'auth-repair': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/auth repair ${quoteSlashCommandArg(readField('provider'))}`,
+    'Opening provider auth repair review',
+    'The workspace handed a read-only provider auth repair review command to the shell-owned command router.',
+    'read-only',
+  ),
+  'auth-bundle-export': (editor, readField) => {
     if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Auth review bundle export not confirmed. Type yes, then press Enter.');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       `/auth bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening auth review bundle export',
       'The workspace handed a confirmed auth review bundle export command to the shell-owned command router.',
       'safe',
     );
-  }
-  if (editor.kind === 'auth-bundle-inspect') {
-    return dispatch(
-      `/auth bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
-      'Opening auth review bundle inspection',
-      'The workspace handed a read-only auth review bundle inspect command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'trust-bundle-export') {
+  },
+  'auth-bundle-inspect': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/auth bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+    'Opening auth review bundle inspection',
+    'The workspace handed a read-only auth review bundle inspect command to the shell-owned command router.',
+    'read-only',
+  ),
+  'trust-bundle-export': (editor, readField) => {
     if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Trust bundle export not confirmed. Type yes, then press Enter.');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       `/trust bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening trust bundle export',
       'The workspace handed a confirmed trust bundle export command to the shell-owned command router.',
       'safe',
     );
-  }
-  if (editor.kind === 'trust-bundle-inspect') {
-    return dispatch(
-      `/trust bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
-      'Opening trust bundle inspection',
-      'The workspace handed a read-only trust bundle inspect command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'subscription-bundle-export') {
+  },
+  'trust-bundle-inspect': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/trust bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+    'Opening trust bundle inspection',
+    'The workspace handed a read-only trust bundle inspect command to the shell-owned command router.',
+    'read-only',
+  ),
+  'subscription-bundle-export': (editor, readField) => {
     if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Subscription bundle export not confirmed. Type yes, then press Enter.');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       `/subscription bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening subscription bundle export',
       'The workspace handed a confirmed subscription bundle export command to the shell-owned command router.',
       'safe',
     );
-  }
-  if (editor.kind === 'subscription-bundle-inspect') {
-    return dispatch(
-      `/subscription bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
-      'Opening subscription bundle inspection',
-      'The workspace handed a read-only subscription bundle inspect command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'voice-enable' || editor.kind === 'voice-disable') {
-    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, `Voice interaction ${editor.kind === 'voice-enable' ? 'enable' : 'disable'} not confirmed. Type yes, then press Enter.`);
-    const mode = editor.kind === 'voice-enable' ? 'enable' : 'disable';
-    return dispatch(
-      `/voice ${mode} --yes`,
-      `Opening voice interaction ${mode}`,
-      `The workspace handed a confirmed voice ${mode} command to the shell-owned command router.`,
-      'safe',
-    );
-  }
-  if (editor.kind === 'voice-bundle-export') {
+  },
+  'subscription-bundle-inspect': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/subscription bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+    'Opening subscription bundle inspection',
+    'The workspace handed a read-only subscription bundle inspect command to the shell-owned command router.',
+    'read-only',
+  ),
+  'voice-enable': (editor, readField) => voiceEnableDisable(editor, readField),
+  'voice-disable': (editor, readField) => voiceEnableDisable(editor, readField),
+  'voice-bundle-export': (editor, readField) => {
     if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Voice bundle export not confirmed. Type yes, then press Enter.');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       `/voice bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
       'Opening voice bundle export',
       'The workspace handed a confirmed voice bundle export command to the shell-owned command router.',
       'safe',
     );
-  }
-  return dispatch(
+  },
+  'voice-bundle-inspect': (_editor, readField) => dispatchCommandEditorSubmission(
     `/voice bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
     'Opening voice bundle inspection',
     'The workspace handed a read-only voice bundle inspect command to the shell-owned command router.',
     'read-only',
+  ),
+};
+
+function voiceEnableDisable(editor: AgentWorkspaceLocalEditor, readField: AgentWorkspaceFieldReader): AgentWorkspaceCommandEditorSubmission {
+  if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, `Voice interaction ${editor.kind === 'voice-enable' ? 'enable' : 'disable'} not confirmed. Type yes, then press Enter.`);
+  const mode = editor.kind === 'voice-enable' ? 'enable' : 'disable';
+  return dispatchCommandEditorSubmission(
+    `/voice ${mode} --yes`,
+    `Opening voice interaction ${mode}`,
+    `The workspace handed a confirmed voice ${mode} command to the shell-owned command router.`,
+    'safe',
+  );
+}
+
+export function buildAgentWorkspaceAccessCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceCommandEditorSubmission {
+  return buildCommandEditorSubmissionFromTable(
+    editor.kind as AgentWorkspaceAccessCommandEditorKind,
+    editor,
+    readField,
+    ACCESS_COMMAND_SUBMISSION_HANDLERS,
   );
 }