@pellux/goodvibes-agent 1.5.8 → 1.6.0

package/src/tools/agent-local-registry-memory.ts

@@ -12,6 +12,20 @@
  * search so an unavailable index degrades honestly (stated reason, literal
  * fallback) instead of silently returning zero matches that read as "nothing
  * was ever stored."
+ *
+ * MEMORY-SPINE WIRING (SDK 1.2.0 full-detach catalog). Every action below now
+ * routes through `memorySpine` — local by default, or over the wire the moment
+ * the agent has adopted a daemon (see services.ts's memorySpineClient).
+ * get/create/review/stale/delete and the literal `search` path use the five
+ * 1.1.0 core verbs (get/add/updateReview/updateReview/delete/honestSearch);
+ * `list` and `update` use the 1.2.0 extended verbs of the same name
+ * (list/update); the SEMANTIC search path uses the 1.2.0 `searchSemantic`
+ * extended verb. Only the index-health check (`registry.vectorStats()`) stays
+ * on the raw local `registry` — vector-index diagnostics are maintenance a
+ * store performs on its OWN index, so reporting them honestly means reading
+ * this process's own index, not a wire-forwarded view of the daemon's (see the
+ * CLI's identical ruling in memory-command-wire.ts). That is a deliberate,
+ * stated scope limit, not an oversight.
  */
 import {
   HASHED_MEMORY_EMBEDDING_PROVIDER,
@@ -22,6 +36,7 @@ import {
   type MemorySemanticSearchResult,
   type MemoryVectorStats,
 } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
 import { formatAgentRecordReference, formatAgentRecordReviewState } from '../agent/record-labels.ts';
 import {
@@ -105,9 +120,16 @@ function renderMemorySearch(mode: string, query: string, lines: readonly string[
   return [`Agent-local memory search (${mode})`, `query ${query || '(all)'}`, ...lines].join('\n');
 }
 
-export async function handleMemory(registry: MemoryRegistry, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): Promise<string> {
+export async function handleMemory(
+  registry: MemoryRegistry,
+  memorySpine: MemoryAccess,
+  action: AgentLocalRegistryAction,
+  args: AgentLocalRegistryToolArgs,
+): Promise<string> {
   if (action === 'list') {
-    const records = registry.getAll();
+    // list() is a 1.2.0 extended verb — routes through the spine (no filter =
+    // getAll semantics, matching the previous registry.getAll() call exactly).
+    const records = await memorySpine.list();
     return records.length === 0
       ? 'Agent-local memory\nNo Agent-local memory records.'
       : ['Agent-local memory', ...records.map(formatMemory)].join('\n');
@@ -116,20 +138,27 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     const query = readString(args.query);
     const wantsLiteral = args.semantic === false;
     if (wantsLiteral) {
-      const records = registry.search({ query, limit: 10 });
+      // Literal search IS wire-covered — routes through the spine (honestSearch
+      // with no `semantic` flag is exactly a literal scan; see
+      // runHonestMemorySearch in the SDK).
+      const { records } = await memorySpine.honestSearch({ query, limit: 10 });
       return renderMemorySearch('literal — explicitly requested', query, records.map(formatMemory));
     }
     // SEMANTIC BY DEFAULT: natural-language recall must not depend on the query text
     // appearing as a literal substring in the stored summary/detail. Check index
     // health FIRST so an unavailable index degrades honestly instead of silently
-    // returning zero matches that read as "nothing was ever stored."
+    // returning zero matches that read as "nothing was ever stored." The health
+    // check itself stays on the raw local registry (vector-index diagnostics are
+    // this process's own — see the file-header note); the actual search, once the
+    // index is known healthy, is the 1.2.0 searchSemantic extended verb and
+    // routes through the spine.
     const stats = registry.vectorStats();
     const unavailable = describeMemoryIndexUnavailable(stats);
     if (unavailable) {
       const records = registry.search({ query, limit: 10 });
       return renderMemorySearch(`literal fallback — ${unavailable}`, query, records.map(formatMemory));
     }
-    const results = registry.searchSemantic({ query, limit: 10 });
+    const results = await memorySpine.searchSemantic({ query, limit: 10 });
     const consultedSemanticIndex = query.length > 0 && results.some((entry) => entry.similarity > 0);
     const caveat = describeMemoryIndexCaveat(stats);
     const mode = !consultedSemanticIndex && query.length > 0
@@ -140,7 +169,7 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     return renderMemorySearch(mode, query, results.map(formatMemoryMatch));
   }
   if (action === 'get') {
-    const record = registry.get(requireId(args));
+    const record = await memorySpine.get(requireId(args));
     if (!record) return `Unknown Agent-local memory ${readString(args.id)}`;
     return [
       formatMemory(record),
@@ -158,7 +187,7 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     const tags = readStringList(args.tags);
     const confidence = readOptionalConfidence(args.confidence);
     assertNoSecretLikeMemoryText([summary, detail, ...tags]);
-    const record = await registry.add({
+    const record = await memorySpine.add({
       scope: readMemoryScope(args),
       cls: requireMemoryClass(args),
       summary,
@@ -174,11 +203,13 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     ].join('\n');
   }
   if (action === 'update') {
+    // update() is a 1.2.0 extended verb (summary/detail/tags/scope patch) — routes
+    // through the spine.
     const summary = readString(args.summary || args.description);
     const detail = readString(args.detail || args.body);
     const tags = args.tags === undefined ? undefined : [...readStringList(args.tags)];
     assertNoSecretLikeMemoryText([summary, detail, ...(tags ?? [])]);
-    const record = registry.update(requireId(args), {
+    const record = await memorySpine.update(requireId(args), {
       summary: summary || undefined,
       detail: detail || undefined,
       tags,
@@ -192,7 +223,7 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     ].join('\n');
   }
   if (action === 'review') {
-    const record = registry.review(requireId(args), {
+    const record = await memorySpine.updateReview(requireId(args), {
       state: 'reviewed',
       confidence: readOptionalConfidence(args.confidence),
       reviewedBy: 'agent',
@@ -204,7 +235,7 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
     ].join('\n');
   }
   if (action === 'stale') {
-    const record = registry.review(requireId(args), {
+    const record = await memorySpine.updateReview(requireId(args), {
       state: 'stale',
       staleReason: readString(args.reason) || 'Marked stale by Agent.',
     });
@@ -217,7 +248,7 @@ export async function handleMemory(registry: MemoryRegistry, action: AgentLocalR
   if (action === 'delete') {
     const id = requireId(args);
     requireConfirmedDelete(args, 'Agent-local memory');
-    if (!registry.delete(id)) return `Unknown Agent-local memory ${id}`;
+    if (!(await memorySpine.delete(id))) return `Unknown Agent-local memory ${id}`;
     return [
       'Deleted Agent-local memory',
       `  id ${id}`,

package/src/tools/agent-local-registry-tool.ts

@@ -2,6 +2,7 @@ import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentNoteRegistry, type AgentNoteRecord } from '../agent/note-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
@@ -512,7 +513,7 @@ function handleRoutine(shellPaths: ShellPathService, action: AgentLocalRegistryA
   throw new Error(`Action ${action} is not valid for routines.`);
 }
 
-export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memoryRegistry: MemoryRegistry): Tool {
+export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memoryRegistry: MemoryRegistry, memorySpine: MemoryAccess): Tool {
   return {
     definition: {
       name: 'agent_local_registry',
@@ -560,7 +561,7 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memor
       if (!isDomain(args.domain)) return registryError(`Unknown domain. Valid values ${DOMAINS.join(', ')}.`);
       if (!isAction(args.action)) return registryError(`Unknown action. Valid values ${ACTIONS.join(', ')}.`);
       try {
-        if (args.domain === 'memory') return registryOutput(await handleMemory(memoryRegistry, args.action, args));
+        if (args.domain === 'memory') return registryOutput(await handleMemory(memoryRegistry, memorySpine, args.action, args));
         if (args.domain === 'note') return registryOutput(handleNote(shellPaths, args.action, args));
         if (args.domain === 'persona') return registryOutput(handlePersona(shellPaths, args.action, args));
         if (args.domain === 'skill') return registryOutput(handleSkill(shellPaths, args.action, args));
@@ -573,6 +574,6 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memor
   };
 }
 
-export function registerAgentLocalRegistryTool(registry: ToolRegistry, shellPaths: ShellPathService, memoryRegistry: MemoryRegistry): void {
-  registry.register(createAgentLocalRegistryTool(shellPaths, memoryRegistry));
+export function registerAgentLocalRegistryTool(registry: ToolRegistry, shellPaths: ShellPathService, memoryRegistry: MemoryRegistry, memorySpine: MemoryAccess): void {
+  registry.register(createAgentLocalRegistryTool(shellPaths, memoryRegistry, memorySpine));
 }

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.5.8';
+let _version = '1.6.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;

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

@@ -1,203 +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 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) {
-      this.notify?.('[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.');
-      return false;
-    }
-    this.pendingPrompt = normalized;
-    return true;
-  }
-
-  stop(message?: string): void {
-    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) this.notify?.(`[TTS] ${message}`);
-  }
-
-  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);
-      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> {
-    return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
-      text,
-      voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
-      format: 'mp3',
-      signal,
-      metadata: {
-        source: 'goodvibes-agent',
-        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;
-}

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();
-}