@pellux/goodvibes-tui 1.9.2 → 1.10.1

package/src/runtime/orchestrator-core-services.ts

@@ -12,7 +12,7 @@ export type OrchestratorCoreServicesSource = Pick<
   | 'sessionMemoryStore'
   | 'sessionLineageTracker'
   | 'idempotencyStore'
-  | 'memoryRegistry'
+  | 'memorySpine'
   | 'codeIndexStore'
   | 'codeIndexReindexScheduler'
 >;
@@ -32,6 +32,18 @@ export type OrchestratorCoreServicesSource = Pick<
  * omitted it independently; routing them through this one function (with
  * src/test/runtime/orchestrator-core-services.test.ts pinning the field) is
  * what keeps that from regressing.
+ *
+ * SDK 1.2.0 FULL DETACH: the SDK's turn loop reads `memoryRegistry.getAll()`
+ * SYNCHRONOUSLY (`TurnKnowledgeRegistrySource`), but the memory spine's wire
+ * reads are asynchronous — a sync function cannot await the wire. Per
+ * docs/decisions/2026-07-06-memory-wire-full-detach.md (SDK repo) this is
+ * satisfied by the spine's freshness-stamped recall snapshot instead of the
+ * raw local `memoryRegistry`: `getAll()` reads `memorySpine.recallSnapshot()`,
+ * which returns whatever the last `refreshRecallSnapshot()` (an async
+ * pre-turn hook — see the `handleUserInput` call sites) captured, honestly
+ * empty/stale until refreshed. This is what lets per-turn knowledge injection
+ * detach from the local store file when a daemon is adopted, instead of
+ * always reading the (possibly divergent) local registry regardless of mode.
  */
 export function buildSharedOrchestratorCoreServices(input: {
   readonly services: OrchestratorCoreServicesSource;
@@ -47,7 +59,7 @@ export function buildSharedOrchestratorCoreServices(input: {
     sessionMemoryStore: services.sessionMemoryStore,
     sessionLineageTracker: services.sessionLineageTracker,
     idempotencyStore: services.idempotencyStore,
-    memoryRegistry: services.memoryRegistry,
+    memoryRegistry: { getAll: () => services.memorySpine.recallSnapshot().records },
     // Main-session code auto-injection + tool-site reindex. Injection is
     // additionally gated by the default-off `agent-passive-code-injection` flag inside the
     // SDK; here we supply the source, the live storage.codeIndexEnabled predicate, and the
@@ -57,3 +69,16 @@ export function buildSharedOrchestratorCoreServices(input: {
     codeIndexReindexScheduler: services.codeIndexReindexScheduler,
   };
 }
+
+/**
+ * The async pre-turn hook: refreshes the memory spine's recall snapshot over
+ * the CURRENT route (wire when adopted, local otherwise) so the synchronous
+ * per-turn knowledge injection (`memoryRegistry.getAll()` above) reads
+ * up-to-date records instead of whatever the previous refresh captured.
+ * Failures are swallowed — an honest stale/empty snapshot (with its own
+ * degradation note, surfaced via `recallSnapshot().note`) is preferable to
+ * blocking the user's turn on a memory-read failure.
+ */
+export async function refreshMemoryRecallSnapshot(services: Pick<RuntimeServices, 'memorySpine'>): Promise<void> {
+  await services.memorySpine.refreshRecallSnapshot().catch(() => {});
+}

package/src/runtime/services.ts

@@ -24,6 +24,7 @@ import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
 import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
 import { AgentManager, OverflowHandler, ProcessManager, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
 import { FileStateCache, FileUndoManager, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, resolveCanonicalMemoryDbPath, type CodeIndexStore, type CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
+import { MemorySpineClient, createLocalMemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { RuntimeEventBus } from '@/runtime/index.ts';
 import { createDomainDispatch } from './store/index.ts';
@@ -166,6 +167,8 @@ export interface RuntimeServices {
   readonly workPlanStore: WorkPlanStore;
   readonly memoryStore: MemoryStore;
   readonly memoryRegistry: MemoryRegistry;
+  /** Host-vs-client memory access: local until bootstrap.ts activates it for an adopted 'external' daemon (mirrors sessionSpine). */
+  readonly memorySpine: MemorySpineClient;
   readonly serviceRegistry: ServiceRegistry;
   readonly secretsManager: SecretsManager;
   readonly subscriptionManager: SubscriptionManager;
@@ -234,12 +237,7 @@ export interface RuntimeServices {
   readonly fileUndoManager: FileUndoManager;
   readonly workspaceCheckpointManager: WorkspaceCheckpointManager;
   readonly integrationHelpers: IntegrationHelperService;
-  /**
-   * Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory.
-   * Called by WorkspaceSwapManager after the new directory has been verified.
-   * Stores that require a process restart emit a warn-level log; they continue serving
-   * the old path until the daemon restarts with the new --working-dir.
-   */
+  /** Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory, called by WorkspaceSwapManager after verification; stores needing a process restart just warn-log and keep serving the old path until the daemon restarts with the new --working-dir. */
   rerootStores(newWorkingDir: string): Promise<void>;
 }
 
@@ -393,6 +391,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     embeddingRegistry: memoryEmbeddingRegistry,
   });
   const memoryRegistry = new MemoryRegistry(memoryStore);
+  // Local-until-adopted access facade for spine-shaped consumers (the Memory
+  // modal): bootstrap.ts activates the wire transport when a compatible
+  // external daemon is adopted, same signal as the session spine.
+  const memorySpine = new MemorySpineClient({ local: createLocalMemoryAccess(memoryRegistry) });
   const deliveryManager = new AutomationDeliveryManager({
     configManager,
     serviceRegistry,
@@ -526,14 +528,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     automationBridge: automationManager,
   });
 
-  // Daemon handler surfaces: attach HOST handlers to the SDK-auto-registered
-  // builtin gateway descriptors (channels.* / email.* / calendar.*). The SDK
-  // owns every id/descriptor/schema; this only fills the handler slot via
-  // catalog.register(descriptor, handler, { replace: true }). Routing returns
-  // the resolver the inbox surface consumes; triage decorates channels.inbox.list.
-  // The remote surface reuses the SAME DistributedRuntimeManager the SDK facade
-  // injects, so its peer/work methods share one persistent store; remote.peers.*
-  // stay SDK-published routes (not catalog methods).
+  // Daemon handler surfaces: attach HOST handlers to the SDK-auto-registered builtin
+  // gateway descriptors (channels.* / email.* / calendar.*) via catalog.register(descriptor,
+  // handler, { replace: true }) — the SDK owns every id/descriptor/schema. The remote
+  // surface reuses the SAME DistributedRuntimeManager the SDK facade injects.
   const handlerLogger: HandlerLogger = {
     info: (message, meta) => console.info(message, meta ?? ''),
     warn: (message, meta) => console.warn(message, meta ?? ''),
@@ -725,6 +723,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     workPlanStore,
     memoryStore,
     memoryRegistry,
+    memorySpine,
     serviceRegistry,
     secretsManager,
     subscriptionManager,

package/src/version.ts

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

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

@@ -1,271 +0,0 @@
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
-import type { TurnEvent } from '@/runtime/index.ts';
-import type { VoiceService, VoiceSynthesisStreamResult } from '@pellux/goodvibes-sdk/platform/voice';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { TtsTextChunker } from './text-chunker.ts';
-import type { StreamingAudioPlayer } from './player.ts';
-
-export interface SpokenTurnControllerOptions {
-  readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
-  readonly configManager: Pick<ConfigManager, 'get'>;
-  readonly player: StreamingAudioPlayer;
-  readonly notify?: (message: string) => void;
-  readonly now?: () => number;
-  readonly setInterval?: typeof setInterval;
-  readonly clearInterval?: typeof clearInterval;
-}
-
-export class SpokenTurnController {
-  private pendingPrompt: string | null = null;
-  private activeTurnId: string | null = null;
-  private chunker: TtsTextChunker | null = null;
-  private chunkSequence = 0;
-  private playbackChain: Promise<void> = Promise.resolve();
-  private readonly abortControllers = new Set<AbortController>();
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private errorReportedForTurn = false;
-  private noPlayerNoticed = false;
-  private readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
-  private readonly configManager: Pick<ConfigManager, 'get'>;
-  private readonly player: StreamingAudioPlayer;
-  private readonly notify?: (message: string) => void;
-  private readonly now: () => number;
-  private readonly setIntervalImpl: typeof setInterval;
-  private readonly clearIntervalImpl: typeof clearInterval;
-
-  constructor(options: SpokenTurnControllerOptions) {
-    this.voiceService = options.voiceService;
-    this.configManager = options.configManager;
-    this.player = options.player;
-    this.notify = options.notify;
-    this.now = options.now ?? (() => Date.now());
-    this.setIntervalImpl = options.setInterval ?? setInterval;
-    this.clearIntervalImpl = options.clearInterval ?? clearInterval;
-  }
-
-  submitNextTurn(prompt: string): boolean {
-    const normalized = prompt.trim();
-    if (!normalized) return false;
-    this.stop();
-    if (!this.player.available) {
-      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;
-  }
-
-  /**
-   * 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();
-    for (const controller of this.abortControllers) controller.abort();
-    this.abortControllers.clear();
-    this.player.stop();
-    this.playbackChain = Promise.resolve();
-    this.errorReportedForTurn = false;
-    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();
-    // 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 {
-    if (event.type === 'TURN_SUBMITTED') {
-      this.maybeStartTurn(event.turnId, event.prompt);
-      return;
-    }
-    if (!this.activeTurnId || event.turnId !== this.activeTurnId) return;
-
-    if (event.type === 'STREAM_DELTA') {
-      this.enqueueChunks(this.chunker?.push(event.content) ?? []);
-      return;
-    }
-    if (event.type === 'STREAM_END') {
-      return;
-    }
-    if (event.type === 'TURN_COMPLETED') {
-      this.finishTurn(event.turnId);
-      return;
-    }
-    if (event.type === 'TURN_CANCEL' || event.type === 'TURN_ERROR' || event.type === 'PREFLIGHT_FAIL') {
-      this.stop(event.type === 'TURN_CANCEL' ? 'Spoken output stopped.' : 'Spoken output stopped because the turn did not complete.');
-    }
-  }
-
-  private maybeStartTurn(turnId: string, prompt: string): void {
-    if (!this.pendingPrompt) return;
-    if (prompt.trim() !== this.pendingPrompt) return;
-    this.pendingPrompt = null;
-    this.activeTurnId = turnId;
-    this.chunkSequence = 0;
-    this.errorReportedForTurn = false;
-    this.chunker = new TtsTextChunker({ now: this.now });
-    this.playbackChain = Promise.resolve();
-    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.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.
-    });
-  }
-
-  private startTimer(): void {
-    this.stopTimer();
-    this.timer = this.setIntervalImpl(() => {
-      if (!this.activeTurnId || !this.chunker) return;
-      this.enqueueChunks(this.chunker.flushDue());
-    }, 250);
-  }
-
-  private stopTimer(): void {
-    if (!this.timer) return;
-    this.clearIntervalImpl(this.timer);
-    this.timer = null;
-  }
-
-  private enqueueChunks(chunks: readonly string[]): void {
-    for (const chunk of chunks) {
-      this.enqueueChunk(chunk);
-    }
-  }
-
-  private enqueueChunk(text: string): void {
-    const turnId = this.activeTurnId;
-    if (!turnId || !text.trim()) return;
-    const sequence = ++this.chunkSequence;
-    const abortController = new AbortController();
-    this.abortControllers.add(abortController);
-    const resultPromise = this.synthesize(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);
-      // 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 route into reportError, which would print a spurious error
-      // and hard-stop a sink that may still be draining the previous chunk.
-      if (abortController.signal.aborted) return;
-      if (!result.ok) {
-        this.reportError(result.error);
-        return;
-      }
-      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 synthesize(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
-    // tts.speed: VoiceSynthesisRequest accepts speed (number | undefined).
-    // No ConfigKey for tts.speed exists in the current SDK schema — pending
-    // SDK schema addition. Speed is not threaded from config until that key
-    // is added. See docs/voice-and-live-tts.md § Speed.
-    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-tui',
-        feature: 'live-tts',
-        turnId,
-        sequence,
-      },
-    });
-  }
-
-  private reportError(error: unknown): void {
-    if (this.errorReportedForTurn) return;
-    this.errorReportedForTurn = true;
-    this.activeTurnId = null;
-    this.chunker = null;
-    this.stopTimer();
-    for (const controller of this.abortControllers) controller.abort();
-    this.abortControllers.clear();
-    this.player.stop();
-    this.playbackChain = Promise.resolve();
-    this.notify?.(`[TTS] Live playback stopped: ${summarizeError(error)}`);
-  }
-}
-
-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.
- *
- * `tts.speed` is not yet a ConfigKey in the SDK schema. This helper accepts
- * a string key and casts it, returning undefined when the value is absent,
- * zero, or not a finite positive number. Once `tts.speed` is added to the
- * SDK schema the cast can be removed and the key typed statically.
- *
- * SDK handoff note: add { key: 'tts.speed', type: 'number', default: 1,
- * description: '...' } to schema-domain-core.js and `tts: { ..., speed: 1 }`
- * to DEFAULT_CONFIG.tts to complete this feature.
- */
-function readOptionalConfigNumber(configManager: Pick<ConfigManager, 'get'>, key: string): number | undefined {
-  // Cast required: key is not yet a valid ConfigKey in the SDK schema.
-  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/text-chunker.ts

@@ -1,110 +0,0 @@
-export interface TtsTextChunkerOptions {
-  readonly minBoundaryChars?: number;
-  readonly maxChunkChars?: number;
-  readonly maxLatencyMs?: number;
-  readonly now?: () => number;
-}
-
-export class TtsTextChunker {
-  private buffer = '';
-  private firstBufferedAt: number | null = null;
-  private readonly minBoundaryChars: number;
-  private readonly maxChunkChars: number;
-  private readonly maxLatencyMs: number;
-  private readonly now: () => number;
-
-  constructor(options: TtsTextChunkerOptions = {}) {
-    this.minBoundaryChars = options.minBoundaryChars ?? 24;
-    this.maxChunkChars = options.maxChunkChars ?? 320;
-    this.maxLatencyMs = options.maxLatencyMs ?? 1_000;
-    this.now = options.now ?? (() => Date.now());
-  }
-
-  push(delta: string): string[] {
-    if (!delta) return [];
-    if (this.firstBufferedAt === null) this.firstBufferedAt = this.now();
-    this.buffer += delta;
-    return this.drainReady(false);
-  }
-
-  flushDue(): string[] {
-    if (!this.buffer.trim() || this.firstBufferedAt === null) return [];
-    if (this.now() - this.firstBufferedAt < this.maxLatencyMs) return [];
-    return this.drainReady(true);
-  }
-
-  flushAll(): string[] {
-    if (!this.buffer.trim()) {
-      this.buffer = '';
-      this.firstBufferedAt = null;
-      return [];
-    }
-    return [this.takeChunk(this.buffer.length)].filter(Boolean);
-  }
-
-  reset(): void {
-    this.buffer = '';
-    this.firstBufferedAt = null;
-  }
-
-  private drainReady(forceLatencyFlush: boolean): string[] {
-    const chunks: string[] = [];
-    while (this.buffer.trim()) {
-      const boundary = this.findBoundary(forceLatencyFlush);
-      if (boundary <= 0) break;
-      const chunk = this.takeChunk(boundary);
-      if (chunk) chunks.push(chunk);
-      forceLatencyFlush = false;
-    }
-    return chunks;
-  }
-
-  private findBoundary(forceLatencyFlush: boolean): number {
-    const latestSentence = this.findLatestSentenceBoundary();
-    if (latestSentence >= this.minBoundaryChars) return latestSentence;
-
-    if (this.buffer.length >= this.maxChunkChars) {
-      return this.findWordBoundaryBefore(this.maxChunkChars) || this.maxChunkChars;
-    }
-
-    if (forceLatencyFlush) {
-      return this.buffer.length;
-    }
-
-    return -1;
-  }
-
-  private findLatestSentenceBoundary(): number {
-    let best = -1;
-    for (let i = 0; i < this.buffer.length; i++) {
-      const char = this.buffer[i];
-      if (char !== '.' && char !== '!' && char !== '?' && char !== ';' && char !== ':' && char !== '\n') {
-        continue;
-      }
-      const next = this.buffer[i + 1];
-      if (i === this.buffer.length - 1 || next === undefined || /\s/.test(next)) {
-        best = i + 1;
-      }
-    }
-    return best;
-  }
-
-  private findWordBoundaryBefore(index: number): number {
-    const max = Math.min(index, this.buffer.length);
-    for (let i = max; i > 0; i--) {
-      if (/\s/.test(this.buffer[i - 1] ?? '')) return i;
-    }
-    return -1;
-  }
-
-  private takeChunk(end: number): string {
-    const raw = this.buffer.slice(0, end);
-    this.buffer = this.buffer.slice(end);
-    this.firstBufferedAt = this.buffer.trim() ? this.now() : null;
-    return normalizeSpeechText(raw);
-  }
-}
-
-export function normalizeSpeechText(text: string): string {
-  return text.replace(/\s+/g, ' ').trim();
-}