@pellux/goodvibes-agent 1.5.7 → 1.5.9

package/src/audio/spoken-turn-controller.ts

@@ -6,6 +6,35 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { TtsTextChunker } from './text-chunker.ts';
 import type { StreamingAudioPlayer } from './player.ts';
 
+/**
+ * How many synthesis requests may sit in the pipeline at once (synthesizing,
+ * waiting to play, or playing). 2 = the chunk being played plus ONE prefetch,
+ * so the next audio is ready the moment the current sink drains. Bounding
+ * this is what keeps a streaming answer from bursting N concurrent requests
+ * at the voice provider — ElevenLabs plans allow as few as 3 concurrent, and
+ * an unbounded burst 429s the whole turn. The SDK config schema has no tts.*
+ * key for pipeline tuning, so this is a constant by design.
+ */
+const SYNTHESIS_PIPELINE_WINDOW = 2;
+
+/**
+ * Upper bound for one merged synthesis request's text. The ElevenLabs
+ * provider passes request text through verbatim (no cap of its own); the API
+ * caps text per request by plan — 2,500 chars on the lowest tiers, 5,000 on
+ * most others. 1,500 stays safely under every plan while still folding a
+ * multi-paragraph answer into one or two requests.
+ */
+const SYNTHESIS_MERGE_MAX_CHARS = 1500;
+
+/**
+ * Backoff schedule for transient synthesis failures (429 rate/concurrency
+ * limits, transient 5xx, network drops): first retry after 1s, second after
+ * 2.5s, then the chunk is skipped honestly and the turn continues. The SDK's
+ * provider errors are plain Error strings with the HTTP status embedded — no
+ * Retry-After header is exposed — so the schedule is fixed, not server-driven.
+ */
+const SYNTHESIS_RETRY_DELAYS_MS = [1000, 2500] as const;
+
 export interface SpokenTurnControllerOptions {
   readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
   readonly configManager: Pick<ConfigManager, 'get'>;
@@ -14,6 +43,9 @@ export interface SpokenTurnControllerOptions {
   readonly now?: () => number;
   readonly setInterval?: typeof setInterval;
   readonly clearInterval?: typeof clearInterval;
+  /** Injectable clock for retry backoff timers (tests use fakes). */
+  readonly setTimeout?: typeof setTimeout;
+  readonly clearTimeout?: typeof clearTimeout;
 }
 
 export class SpokenTurnController {
@@ -25,6 +57,16 @@ export class SpokenTurnController {
   private readonly abortControllers = new Set<AbortController>();
   private timer: ReturnType<typeof setInterval> | null = null;
   private errorReportedForTurn = false;
+  private noPlayerNoticed = false;
+  /** Chunker output waiting to be merged into a synthesis request. */
+  private pendingTexts: string[] = [];
+  /** Requests currently in the pipeline (synthesizing / waiting / playing). */
+  private pipelineDepth = 0;
+  /** Bumped on every teardown so stale pipeline releases are ignored. */
+  private pipelineGeneration = 0;
+  private pumpScheduled = false;
+  /** Set when TURN_COMPLETED arrives; the turn releases once the pipeline drains. */
+  private completedTurnId: string | null = null;
   private readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
   private readonly configManager: Pick<ConfigManager, 'get'>;
   private readonly player: StreamingAudioPlayer;
@@ -32,6 +74,8 @@ export class SpokenTurnController {
   private readonly now: () => number;
   private readonly setIntervalImpl: typeof setInterval;
   private readonly clearIntervalImpl: typeof clearInterval;
+  private readonly setTimeoutImpl: typeof setTimeout;
+  private readonly clearTimeoutImpl: typeof clearTimeout;
 
   constructor(options: SpokenTurnControllerOptions) {
     this.voiceService = options.voiceService;
@@ -41,6 +85,8 @@ export class SpokenTurnController {
     this.now = options.now ?? (() => Date.now());
     this.setIntervalImpl = options.setInterval ?? setInterval;
     this.clearIntervalImpl = options.clearInterval ?? clearInterval;
+    this.setTimeoutImpl = options.setTimeout ?? setTimeout;
+    this.clearTimeoutImpl = options.clearTimeout ?? clearTimeout;
   }
 
   submitNextTurn(prompt: string): boolean {
@@ -48,25 +94,65 @@ export class SpokenTurnController {
     if (!normalized) return false;
     this.stop();
     if (!this.player.available) {
-      this.notify?.('[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.');
+      if (!this.noPlayerNoticed) {
+        this.noPlayerNoticed = true;
+        this.notify?.('[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.');
+      }
       return false;
     }
+    // Reset the no-player notice if player becomes available again.
+    this.noPlayerNoticed = false;
     this.pendingPrompt = normalized;
     return true;
   }
 
-  stop(message?: string): void {
+  /**
+   * Returns whether speech was actually ACTIVE when stopped. The notice only
+   * prints in that case — stop() on an idle controller used to notify anyway,
+   * spamming "[TTS] Spoken output stopped." on every Ctrl+C (an earlier replay
+   * fix); callers use the return to decide whether the press "did a
+   * job" (see handleCtrlC's consume-on-speech-stop).
+   */
+  stop(message?: string): boolean {
+    const wasActive = this.pendingPrompt !== null || this.activeTurnId !== null
+      || this.chunker !== null || this.abortControllers.size > 0;
     this.pendingPrompt = null;
     this.activeTurnId = null;
     this.chunker?.reset();
     this.chunker = null;
     this.stopTimer();
+    this.resetPipeline();
     for (const controller of this.abortControllers) controller.abort();
     this.abortControllers.clear();
     this.player.stop();
     this.playbackChain = Promise.resolve();
     this.errorReportedForTurn = false;
-    if (message) this.notify?.(`[TTS] ${message}`);
+    if (message && wasActive) this.notify?.(`[TTS] ${message}`);
+    return wasActive;
+  }
+
+  /**
+   * Exit-path teardown: drops everything not yet audible (pending arm,
+   * buffered text, queued chunks) but lets the audio the user is already
+   * hearing finish naturally, capped at `drainTimeoutMs`, before the hard
+   * stop. Deliberate interrupts (Ctrl+C, /tts stop, turn cancel) keep their
+   * instant path through stop(); this is only for exiting the app while the
+   * final audio of a completed response is still draining.
+   */
+  async stopForExit(drainTimeoutMs = 2000): Promise<void> {
+    this.pendingPrompt = null;
+    this.activeTurnId = null;
+    this.chunker?.reset();
+    this.chunker = null;
+    this.stopTimer();
+    this.resetPipeline();
+    // Cancel chunks that have not started playing; the chunk currently in the
+    // sink is not in this set (its controller is released before playback).
+    for (const controller of this.abortControllers) controller.abort();
+    this.abortControllers.clear();
+    await this.player.waitForDrain(drainTimeoutMs);
+    // Backstop: anything still alive after the window is torn down hard.
+    this.stop();
   }
 
   handleTurnEvent(event: TurnEvent): void {
@@ -77,7 +163,7 @@ export class SpokenTurnController {
     if (!this.activeTurnId || event.turnId !== this.activeTurnId) return;
 
     if (event.type === 'STREAM_DELTA') {
-      this.enqueueChunks(this.chunker?.push(event.content) ?? []);
+      this.queueTexts(this.chunker?.push(event.content) ?? []);
       return;
     }
     if (event.type === 'STREAM_END') {
@@ -101,30 +187,33 @@ export class SpokenTurnController {
     this.errorReportedForTurn = false;
     this.chunker = new TtsTextChunker({ now: this.now });
     this.playbackChain = Promise.resolve();
+    this.resetPipeline();
     this.startTimer();
     this.notify?.(`[TTS] Live playback queued through ${this.player.label}.`);
   }
 
   private finishTurn(turnId: string): void {
     if (turnId !== this.activeTurnId) return;
-    this.enqueueChunks(this.chunker?.flushAll() ?? []);
+    this.queueTexts(this.chunker?.flushAll() ?? []);
     this.stopTimer();
-    const chain = this.playbackChain;
-    chain.finally(() => {
-      if (this.activeTurnId !== turnId) return;
-      this.activeTurnId = null;
-      this.chunker = null;
-      this.abortControllers.clear();
-    }).catch(() => {
-      // Errors are already reported in the queued task.
-    });
+    this.completedTurnId = turnId;
+    // Nothing pending and nothing in flight releases immediately; otherwise
+    // the last pipeline slot to free performs the release.
+    this.maybeReleaseTurn();
+  }
+
+  private resetPipeline(): void {
+    this.pendingTexts = [];
+    this.pipelineDepth = 0;
+    this.pipelineGeneration++;
+    this.completedTurnId = null;
   }
 
   private startTimer(): void {
     this.stopTimer();
     this.timer = this.setIntervalImpl(() => {
       if (!this.activeTurnId || !this.chunker) return;
-      this.enqueueChunks(this.chunker.flushDue());
+      this.queueTexts(this.chunker.flushDue());
     }, 250);
   }
 
@@ -134,45 +223,163 @@ export class SpokenTurnController {
     this.timer = null;
   }
 
-  private enqueueChunks(chunks: readonly string[]): void {
+  /**
+   * Chunker output does NOT map 1:1 to synthesis requests. Text queues here
+   * and the pump merges everything pending into one request whenever a
+   * pipeline slot is free — so the request count tracks how often the model
+   * out-paces the audio, not how many sentences it wrote. A short answer that
+   * arrives before the first pump tick is exactly one request.
+   */
+  private queueTexts(chunks: readonly string[]): void {
     for (const chunk of chunks) {
-      this.enqueueChunk(chunk);
+      if (chunk.trim()) this.pendingTexts.push(chunk);
+    }
+    if (this.pendingTexts.length > 0) this.schedulePump();
+  }
+
+  /**
+   * Deferred one tick so text delivered in the same synchronous burst (fast
+   * deltas, or a turn that completes instantly) coalesces into a single
+   * request instead of firing per sentence boundary.
+   */
+  private schedulePump(): void {
+    if (this.pumpScheduled) return;
+    this.pumpScheduled = true;
+    queueMicrotask(() => {
+      this.pumpScheduled = false;
+      this.pump();
+    });
+  }
+
+  private pump(): void {
+    while (this.activeTurnId && this.pendingTexts.length > 0 && this.pipelineDepth < SYNTHESIS_PIPELINE_WINDOW) {
+      this.dispatchChunk(this.takeMergedText());
     }
+    this.maybeReleaseTurn();
   }
 
-  private enqueueChunk(text: string): void {
+  /** Merge everything pending into one request, capped at the per-request text limit. */
+  private takeMergedText(): string {
+    let merged = '';
+    while (this.pendingTexts.length > 0) {
+      const next = this.pendingTexts[0]!;
+      if (!merged && next.length > SYNTHESIS_MERGE_MAX_CHARS) {
+        // A single oversized entry (e.g. a large end-of-turn flush): split at
+        // a word boundary under the per-request cap; the rest stays queued.
+        const cut = findSplitIndex(next, SYNTHESIS_MERGE_MAX_CHARS);
+        this.pendingTexts[0] = next.slice(cut).trim();
+        return next.slice(0, cut).trim();
+      }
+      if (merged && merged.length + 1 + next.length > SYNTHESIS_MERGE_MAX_CHARS) break;
+      merged = merged ? `${merged} ${next}` : next;
+      this.pendingTexts.shift();
+    }
+    return merged;
+  }
+
+  private dispatchChunk(text: string): void {
     const turnId = this.activeTurnId;
     if (!turnId || !text.trim()) return;
     const sequence = ++this.chunkSequence;
+    const generation = this.pipelineGeneration;
+    this.pipelineDepth++;
     const abortController = new AbortController();
     this.abortControllers.add(abortController);
-    const resultPromise = this.synthesize(text, turnId, sequence, abortController.signal)
+    const resultPromise = this.synthesizeWithRetry(text, turnId, sequence, abortController.signal)
       .then((result) => ({ ok: true as const, result }))
       .catch((error: unknown) => ({ ok: false as const, error }));
 
     this.playbackChain = this.playbackChain.then(async () => {
-      if (abortController.signal.aborted) return;
-      const result = await resultPromise;
-      this.abortControllers.delete(abortController);
-      if (!result.ok) {
-        this.reportError(result.error);
-        return;
+      try {
+        if (abortController.signal.aborted) {
+          this.abortControllers.delete(abortController);
+          return;
+        }
+        const result = await resultPromise;
+        this.abortControllers.delete(abortController);
+        // Re-check after the await: an abort that landed while synthesis was
+        // in flight (deliberate stop or exit) makes the rejection expected —
+        // it must not be reported, and it must not hard-stop a sink that may
+        // still be draining the previous chunk.
+        if (abortController.signal.aborted) return;
+        if (!result.ok) {
+          // Retries are exhausted (or the failure was not transient). Skip
+          // just this chunk and keep speaking the rest of the turn — a gap in
+          // speech beats losing the whole response.
+          this.reportSkippedChunk(result.error);
+          return;
+        }
+        await this.player.play(result.result.chunks, {
+          format: String(result.result.format ?? 'mp3'),
+          signal: abortController.signal,
+        });
+      } finally {
+        this.releasePipelineSlot(generation);
       }
-      await this.player.play(result.result.chunks, {
-        format: String(result.result.format ?? 'mp3'),
-        signal: abortController.signal,
-      });
     }).catch((error: unknown) => {
       this.abortControllers.delete(abortController);
       this.reportError(error);
     });
   }
 
+  private releasePipelineSlot(generation: number): void {
+    if (generation !== this.pipelineGeneration) return;
+    this.pipelineDepth = Math.max(0, this.pipelineDepth - 1);
+    if (this.pendingTexts.length > 0) {
+      this.schedulePump();
+      return;
+    }
+    this.maybeReleaseTurn();
+  }
+
+  private maybeReleaseTurn(): void {
+    if (!this.completedTurnId || this.completedTurnId !== this.activeTurnId) return;
+    if (this.pendingTexts.length > 0 || this.pipelineDepth > 0 || this.pumpScheduled) return;
+    this.activeTurnId = null;
+    this.completedTurnId = null;
+    this.chunker = null;
+    this.abortControllers.clear();
+  }
+
+  private async synthesizeWithRetry(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this.synthesize(text, turnId, sequence, signal);
+      } catch (error) {
+        const retryable = attempt < SYNTHESIS_RETRY_DELAYS_MS.length
+          && !signal.aborted
+          && isTransientSynthesisError(error);
+        if (!retryable) throw error;
+        await this.delay(SYNTHESIS_RETRY_DELAYS_MS[attempt]!, signal);
+      }
+    }
+  }
+
+  /** Abortable backoff sleep — an abort clears the timer and rejects, so a stop mid-backoff leaves nothing running. */
+  private delay(ms: number, signal: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new Error('Synthesis retry cancelled'));
+        return;
+      }
+      const timer = this.setTimeoutImpl(() => {
+        signal.removeEventListener('abort', onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        this.clearTimeoutImpl(timer);
+        reject(new Error('Synthesis retry cancelled'));
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+    });
+  }
+
   private synthesize(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
     return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
       text,
       voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
       format: 'mp3',
+      speed: readOptionalConfigNumber(this.configManager, 'tts.speed'),
       signal,
       metadata: {
         source: 'goodvibes-agent',
@@ -183,12 +390,23 @@ export class SpokenTurnController {
     });
   }
 
+  /**
+   * One synthesis request failed after its retries. Report once per turn and
+   * keep going — the rest of the response still plays.
+   */
+  private reportSkippedChunk(error: unknown): void {
+    if (this.errorReportedForTurn) return;
+    this.errorReportedForTurn = true;
+    this.notify?.(`[TTS] Skipping part of the spoken response — synthesis kept failing (${summarizeError(error)}). Playback continues with the rest.`);
+  }
+
   private reportError(error: unknown): void {
     if (this.errorReportedForTurn) return;
     this.errorReportedForTurn = true;
     this.activeTurnId = null;
     this.chunker = null;
     this.stopTimer();
+    this.resetPipeline();
     for (const controller of this.abortControllers) controller.abort();
     this.abortControllers.clear();
     this.player.stop();
@@ -197,7 +415,41 @@ export class SpokenTurnController {
   }
 }
 
+/**
+ * Transient = worth a bounded retry: rate/concurrency limits (HTTP 429),
+ * transient server errors (5xx), and network-level drops. The SDK's voice
+ * providers throw plain Error strings with the HTTP status embedded in the
+ * message, so classification is by message content.
+ */
+function isTransientSynthesisError(error: unknown): boolean {
+  const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  if (message.includes('429') || message.includes('rate limit') || message.includes('rate_limit')
+    || message.includes('too many requests') || message.includes('concurrent')) return true;
+  if (/http 5\d\d/.test(message)) return true;
+  return message.includes('fetch failed') || message.includes('network')
+    || message.includes('timed out') || message.includes('timeout')
+    || message.includes('econnreset') || message.includes('socket');
+}
+
+/** Split point at or under `limit`, preferring the last word boundary. */
+function findSplitIndex(text: string, limit: number): number {
+  const space = text.lastIndexOf(' ', limit);
+  return space > 0 ? space : limit;
+}
+
 function readOptionalConfigString(configManager: Pick<ConfigManager, 'get'>, key: ConfigKey): string | undefined {
   const value = String(configManager.get(key) ?? '').trim();
   return value || undefined;
 }
+
+/**
+ * readOptionalConfigNumber — reads a numeric config value by key.
+ *
+ * Accepts a string key and casts it, returning undefined when the value is
+ * absent, zero, or not a finite positive number.
+ */
+function readOptionalConfigNumber(configManager: Pick<ConfigManager, 'get'>, key: string): number | undefined {
+  const raw = configManager.get(key as ConfigKey);
+  const value = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+  return isFinite(value) && value > 0 ? value : undefined;
+}

package/src/audio/spoken-turn-wiring.ts

@@ -1,13 +1,17 @@
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { UiRuntimeEvents } from '@/runtime/index.ts';
 import type { VoiceService } from '@pellux/goodvibes-sdk/platform/voice';
+import type { StreamingAudioPlayer } from './player.ts';
 import { LocalStreamingAudioPlayer } from './player.ts';
 import { SpokenTurnController } from './spoken-turn-controller.ts';
 
 export interface SpokenTurnRuntime {
   readonly unsubs: readonly (() => void)[];
   submitNextTurn(prompt: string): boolean;
-  stop(message?: string): void;
+  /** Returns whether speech was actually active (see controller.stop). */
+  stop(message?: string): boolean;
+  /** Exit-path stop: lets the audio already playing drain, bounded (see controller.stopForExit). */
+  stopForExit(drainTimeoutMs?: number): Promise<void>;
 }
 
 export interface WireSpokenTurnRuntimeOptions {
@@ -15,13 +19,19 @@ export interface WireSpokenTurnRuntimeOptions {
   readonly configManager: ConfigManager;
   readonly events: UiRuntimeEvents;
   readonly notify: (message: string) => void;
+  /**
+   * Optional player factory — injected in tests to avoid spawning real
+   * subprocesses. Defaults to LocalStreamingAudioPlayer.
+   */
+  readonly playerFactory?: () => StreamingAudioPlayer;
 }
 
 export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): SpokenTurnRuntime {
+  const player = options.playerFactory ? options.playerFactory() : new LocalStreamingAudioPlayer();
   const controller = new SpokenTurnController({
     voiceService: options.voiceService,
     configManager: options.configManager,
-    player: new LocalStreamingAudioPlayer(),
+    player,
     notify: options.notify,
   });
 
@@ -40,5 +50,6 @@ export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): Sp
     unsubs,
     submitNextTurn: (prompt) => controller.submitNextTurn(prompt),
     stop: (message) => controller.stop(message),
+    stopForExit: (drainTimeoutMs) => controller.stopForExit(drainTimeoutMs),
   };
 }

package/src/cli/local-library-command-shared.ts

@@ -7,7 +7,7 @@ import type { CliCommandRuntime } from './management.ts';
 /**
  * Shared prelude for the Agent-local library CLI commands (personas, skills,
  * skill bundles): option parsing, success/failure envelopes, and registry
- * accessors. Split out of local-library-command.ts (W4-H1 ruling: the file
+ * accessors. Split out of local-library-command.ts (the file
  * cleanly contained three independent command handlers glued together) so
  * personas-command.ts, skills-command.ts, and skill-bundle-command.ts can
  * share one option-parsing/output prelude without duplicating it.

package/src/cli/memory-command.ts

@@ -1,10 +1,10 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { createShellPathService } from '@/runtime/index.ts';
 import {
   MemoryEmbeddingProviderRegistry,
   MemoryRegistry,
   MemoryStore,
+  resolveCanonicalMemoryDbPath,
   type MemoryBundle,
   type MemoryClass,
   type MemoryLink,
@@ -18,7 +18,6 @@ import {
 } from '@pellux/goodvibes-sdk/platform/state';
 import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
 import { formatAgentRecordReference, formatAgentRecordReviewState } from '../agent/record-labels.ts';
-import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import type { CliCommandOutput } from './types.ts';
 import type { CliCommandRuntime } from './management.ts';
 
@@ -196,11 +195,15 @@ function timestamp(value: number): string {
   return new Date(value).toISOString().slice(0, 19).replace('T', ' ');
 }
 
+// The CLI no longer opens a private per-surface agent/memory.sqlite. It opens the
+// ONE canonical cross-surface store (~/.goodvibes/shared/memory.sqlite) so a memory
+// added via `goodvibes-agent memory add` is visible to the runtime, the TUI, and the
+// SDK — and vice-versa. The old CLI-written store is folded into the canonical store
+// (loss-free, idempotent) by the runtime's foldAgentLegacyMemory at boot, since that
+// fold already sources shellPaths.resolveUserPath('agent', 'memory.sqlite') — the exact
+// path this function used to write to.
 function memoryDbPath(runtime: CliCommandRuntime): string {
-  return createShellPathService({
-    workingDirectory: runtime.workingDirectory,
-    homeDirectory: runtime.homeDirectory,
-  }).resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'memory.sqlite');
+  return resolveCanonicalMemoryDbPath(runtime.homeDirectory);
 }
 
 async function withMemory<T>(runtime: CliCommandRuntime, fn: (context: MemoryContext) => Promise<T> | T): Promise<T> {

package/src/cli/resume-relaunch-notice.ts

@@ -1,7 +1,7 @@
 import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
 
 /**
- * RESUME-ON-RELAUNCH (W4-A4).
+ * RESUME-ON-RELAUNCH.
  *
  * The dogfood finding: relaunching the agent after a normal (non-crash) exit
  * silently starts fresh with no offer or notice about the prior session — the

package/src/cli/tui-startup.ts

@@ -116,7 +116,7 @@ export function applyInitialTuiCliState(options: {
     // Normal relaunch: onboarding is done and the user didn't ask for
     // onboarding or an explicit `sessions resume`. Surface an honest,
     // non-blocking resume affordance instead of silently starting fresh
-    // (the W4-A4 dogfood finding) — never auto-resume, declining is
+    // (a dogfood finding) — never auto-resume, declining is
     // frictionless (just start typing).
     surfaceResumeRelaunchNotice({
       getLastSessionPointer: () => readLastSessionPointer({

package/src/config/credential-status.ts

@@ -1,7 +1,7 @@
 /**
  * credential-status.ts — client-side, secret-FREE credential STATUS read.
  *
- * W6-C1 (E7 config sharing). When GoodVibes Agent acts as a CLIENT of an adopted
+ * When GoodVibes Agent acts as a CLIENT of an adopted
  * external daemon, it reads credential *status* (configured / usable) from the
  * daemon's shared store over the wire — the `credentials.get` operator method
  * (GET /config/credentials, admin + read:config). It NEVER receives raw secret

package/src/config/index.ts

@@ -56,7 +56,7 @@ export function getConfiguredSystemPrompt(configManager: Pick<ConfigManager, 'ge
 
 export { getConfiguredApiKeys, resolveApiKeys } from '@pellux/goodvibes-sdk/platform/config';
 
-// W6-C1 (E7): the daemon-client credential STATUS read (secret-free, honest-degrade).
+// The daemon-client credential STATUS read (secret-free, honest-degrade).
 // Value reads above stay local/env; only the status VISIBILITY path moves to the daemon.
 export {
   deriveCredentialAvailability,

package/src/config/secrets.ts

@@ -16,7 +16,7 @@ import {
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from './surface.ts';
 
-// W6-C1 host-vs-client split (E7 config sharing): this SecretsManager is the LOCAL-HOST
+// Host-vs-client split: this SecretsManager is the LOCAL-HOST
 // read path — pinned to GOODVIBES_AGENT_SURFACE_ROOT, it resolves secret VALUES from the
 // surface store/env for provider auth, unchanged. When the Agent acts as a CLIENT of an
 // adopted external daemon, credential *status* (configured/usable — never bytes) is read

package/src/core/conversation-rendering.ts

@@ -123,8 +123,8 @@ export function renderConversationAssistantMessage(
     // `numWidth=6` (fits 999,999 lines, but wastes 3-4 gutter columns on typical
     // messages) or rendering the numbered output into a scratch buffer and trimming.
     // Neither is clearly better than the current two-pass measurement approach.
-    // The 4α commit message claim that this "eliminates double-parse when line
-    // numbers are enabled" was inaccurate: 4α eliminated the legacy
+    // An earlier commit message's claim that this "eliminates double-parse when line
+    // numbers are enabled" was inaccurate: that commit eliminated the legacy
     // `renderMarkdown()` duplicate used for code-block line-number mode ('code').
     // The 'all' mode double-call is a deliberate design choice and remains unchanged.
     const measureWidth = showAllLineNumbers ? width : 0;

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

@@ -9,7 +9,7 @@
  * 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
+ * (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).
  */
@@ -46,7 +46,7 @@ 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
+ * (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.
  */
@@ -57,7 +57,7 @@ const TERMINAL_CAPTURED_RE = /^\[Terminal\] Captured \d+ direct /;
  * 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.
+  // Agent-specific — 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;

package/src/core/thinking-overlay.ts

@@ -1,5 +1,5 @@
 /**
- * thinking-overlay.ts (W4-R4) — the thinking-indicator overlay + its honest
+ * thinking-overlay.ts — 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

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

@@ -42,7 +42,7 @@ function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string, status:
 /**
  * The submission data table for the kinds this module builds itself (delegate-task and
  * workplan/notify/secret/profile kinds keep dispatching to their own sibling submission
- * modules below, unchanged). W4-H2: split out of the single ~570-line
+ * modules below, unchanged). Split out of the single ~570-line
  * `buildAgentWorkspaceBasicCommandEditorSubmission` if-chain, mirroring the
  * construction-side split in agent-workspace-basic-command-editors.ts.
  */

package/src/input/agent-workspace-basic-command-editors.ts

@@ -127,7 +127,7 @@ function modelPinUnpinSpec(kind: AgentWorkspaceBasicOwnCommandEditorKind): Agent
 
 /**
  * The field-spec data table for the kinds this module builds itself (the rest are
- * delegated to sibling domain modules above). W4-H2: split out of the single
+ * delegated to sibling domain modules above). Split out of the single
  * ~600-line `createAgentWorkspaceBasicCommandEditor` if-chain into a data table, the
  * same shape used by every other agent-workspace command-editor domain.
  */