@pellux/goodvibes-tui 1.9.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -99,7 +99,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "1.0.0",
+    "@pellux/goodvibes-sdk": "1.3.3",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/audio/player.ts

@@ -15,6 +15,14 @@ export interface StreamingAudioPlayer {
   readonly available: boolean;
   play(chunks: AsyncIterable<VoiceAudioChunk>, options: StreamingAudioPlaybackOptions): Promise<void>;
   stop(): void;
+  /**
+   * Resolves once the currently playing sink has finished naturally (its
+   * process closed) or after `timeoutMs`, whichever comes first; resolves
+   * immediately when nothing is playing. The exit path uses this to let the
+   * audio the user is already hearing finish inside a short bounded window
+   * instead of killing it mid-drain. stop() remains the instant cut.
+   */
+  waitForDrain(timeoutMs: number): Promise<void>;
 }
 
 export interface StreamingAudioPlaybackOptions {
@@ -25,6 +33,8 @@ export interface StreamingAudioPlaybackOptions {
 interface SpawnProcess {
   readonly stdin: Writable;
   once(event: 'close', listener: () => void): this;
+  once(event: 'spawn', listener: () => void): this;
+  once(event: 'error', listener: (error: unknown) => void): this;
   kill(signal?: NodeJS.Signals | number): boolean;
 }
 type SpawnProcessFactory = (command: string, args: readonly string[]) => SpawnProcess;
@@ -32,6 +42,13 @@ type SpawnProcessFactory = (command: string, args: readonly string[]) => SpawnPr
 export interface LocalStreamingAudioPlayerOptions {
   readonly env?: NodeJS.ProcessEnv;
   readonly spawnProcess?: SpawnProcessFactory;
+  /**
+   * Injected player command — the test seam companion to `spawnProcess`.
+   * When set, the constructor uses it verbatim instead of scanning PATH, so
+   * deterministic fake-sink tests never depend on mpv/ffplay being installed
+   * on the machine running them. Pass null to model "no player found".
+   */
+  readonly command?: StreamingAudioPlayerCommand | null;
 }
 
 export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
@@ -40,7 +57,9 @@ export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
   private readonly spawnProcess: SpawnProcessFactory;
 
   constructor(options: LocalStreamingAudioPlayerOptions = {}) {
-    this.command = resolveStreamingAudioPlayerCommand(options.env ?? process.env);
+    this.command = options.command !== undefined
+      ? options.command
+      : resolveStreamingAudioPlayerCommand(options.env ?? process.env);
     this.spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
   }
 
@@ -67,12 +86,27 @@ export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
     options.signal?.addEventListener('abort', abort, { once: true });
 
     try {
+      // Head survival: hold the first audio byte until the sink has actually
+      // started (its 'spawn' event) instead of writing into a process that has
+      // not exec'd yet. Writing before the player is up is the spawn race that
+      // clipped the beginning of playback. A spawn failure rejects here so the
+      // caller can report it honestly rather than swallowing a dead player.
+      await awaitReady(proc, options.signal);
+      if (options.signal?.aborted) return;
+
       for await (const chunk of chunks) {
         if (options.signal?.aborted) break;
         if (chunk.data.byteLength === 0) continue;
         await writeStdin(proc, chunk.data);
       }
-      proc.stdin.end();
+
+      // An intentional interrupt (turn cancel / quit chord / /tts stop) has
+      // already torn the process down via `abort` and must cut immediately —
+      // do not wait on a graceful drain. A natural end-of-speech, by contrast,
+      // closes stdin and waits for the sink to play out every buffered sample
+      // so the tail of the response is never truncated.
+      if (options.signal?.aborted) return;
+      try { proc.stdin.end(); } catch { /* ignore */ }
       await waitForExit(proc);
     } finally {
       options.signal?.removeEventListener('abort', abort);
@@ -87,14 +121,33 @@ export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
     try { proc.stdin.destroy(); } catch { /* ignore */ }
     try { proc.kill('SIGTERM'); } catch { /* ignore */ }
   }
+
+  waitForDrain(timeoutMs: number): Promise<void> {
+    const proc = this.activeProcess;
+    if (!proc) return Promise.resolve();
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(settle, timeoutMs);
+      proc.once('close', settle);
+    });
+  }
 }
 
 export function resolveStreamingAudioPlayerCommand(env: NodeJS.ProcessEnv = process.env): StreamingAudioPlayerCommand | null {
   const mpv = findExecutable('mpv', env);
   if (mpv) {
+    // No --cache=no: mpv's read-ahead cache buffers the incoming pipe so the
+    // opening audio survives device-open latency and network jitter instead of
+    // underrunning while the output device is still spinning up.
     return {
       command: mpv,
-      args: ['--no-terminal', '--really-quiet', '--force-window=no', '--cache=no', '-'],
+      args: ['--no-terminal', '--really-quiet', '--force-window=no', '-'],
       label: 'mpv',
     };
   }
@@ -102,18 +155,51 @@ export function resolveStreamingAudioPlayerCommand(env: NodeJS.ProcessEnv = proc
   if (ffplay) {
     return {
       command: ffplay,
-      args: ['-nodisp', '-autoexit', '-loglevel', 'error', '-i', 'pipe:0'],
+      args: FFPLAY_BASE_ARGS,
       label: 'ffplay',
     };
   }
   return null;
 }
 
+// ffplay -autoexit quits as soon as its input ends, before the audio output
+// buffer has drained — that clips the tail of the response. `apad` appends a
+// short run of silence so the real audio is fully played out and only the
+// trailing silence gets trimmed.
+const FFPLAY_APAD = ['-af', 'apad=pad_dur=0.3'] as const;
+const FFPLAY_BASE_ARGS = ['-nodisp', '-autoexit', '-loglevel', 'error', ...FFPLAY_APAD, '-i', 'pipe:0'] as const;
+
 function buildPlayerArgs(command: StreamingAudioPlayerCommand, format?: string): readonly string[] {
   if (command.label !== 'ffplay' || !format) return command.args;
   const normalized = format.trim().toLowerCase();
   if (!normalized || normalized.includes('/')) return command.args;
-  return ['-nodisp', '-autoexit', '-loglevel', 'error', '-f', normalized, '-i', 'pipe:0'];
+  return ['-nodisp', '-autoexit', '-loglevel', 'error', ...FFPLAY_APAD, '-f', normalized, '-i', 'pipe:0'];
+}
+
+/**
+ * awaitReady — resolves once the spawned player has actually started (its
+ * 'spawn' event), rejects if it fails to start ('error'), and resolves early
+ * if the caller aborts during startup so an intentional interrupt is never
+ * blocked. This is the readiness gate that keeps the first audio byte from
+ * being written into a not-yet-running sink.
+ */
+function awaitReady(proc: SpawnProcess, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) return Promise.resolve();
+  return new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const settle = (action: () => void) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener('abort', onAbort);
+      action();
+    };
+    const onSpawn = () => settle(resolve);
+    const onError = (error: unknown) => settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+    const onAbort = () => settle(resolve);
+    proc.once('spawn', onSpawn);
+    proc.once('error', onError);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
 }
 
 function findExecutable(name: string, env: NodeJS.ProcessEnv): string | null {

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

@@ -3,13 +3,15 @@ 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';
+import { SpokenTurnController } from '@pellux/goodvibes-sdk/platform/voice';
 
 export interface SpokenTurnRuntime {
   readonly unsubs: readonly (() => void)[];
   submitNextTurn(prompt: string): boolean;
   /** 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 {
@@ -35,10 +37,15 @@ export interface WireSpokenTurnRuntimeOptions {
  */
 export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): SpokenTurnRuntime {
   const player = options.playerFactory ? options.playerFactory() : new LocalStreamingAudioPlayer();
+  // The TUI's subprocess-based player already satisfies the SDK's AudioSink
+  // interface unchanged (see docs/decisions/2026-07-06-spoken-turn-tts-policy-sdk-hoist.md
+  // in the SDK repo) — only the option name (`sink` not `player`) and the
+  // attribution `source` are new.
   const controller = new SpokenTurnController({
     voiceService: options.voiceService,
     configManager: options.configManager,
-    player,
+    sink: player,
+    source: 'goodvibes-tui',
     notify: options.notify,
   });
 
@@ -63,5 +70,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/management-utils.ts

@@ -20,6 +20,7 @@ import { spawn } from 'node:child_process';
 import { networkInterfaces } from 'node:os';
 import type { ConfigManager, GoodVibesConfig } from '../config/index.ts';
 import { bootstrapRuntime } from '../runtime/bootstrap.ts';
+import { refreshMemoryRecallSnapshot } from '../runtime/orchestrator-core-services.ts';
 import { createRuntimeServices } from '../runtime/services.ts';
 import { createRuntimeStore } from '../runtime/store/index.ts';
 import type { RuntimeServices } from '../runtime/services.ts';
@@ -317,6 +318,9 @@ export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promis
   });
 
   try {
+    // Async pre-turn refresh of the memory-spine recall snapshot (SDK 1.2.0
+    // full-detach) — see the matching comment in main.ts's submitInput.
+    await refreshMemoryRecallSnapshot(ctx.services);
     await ctx.orchestrator.handleUserInput(prompt);
     await done;
     if (outputFormat === 'json') {

package/src/config/credential-availability.ts

@@ -1,5 +1,5 @@
 /**
- * credential-availability.ts — W6-C1 client-side credential-status read.
+ * credential-availability.ts — client-side credential-status read.
  *
  * When the TUI acts as a CLIENT of an adopted external daemon (the host-service
  * `mode === 'external'` topology — see runtime/bootstrap.ts), provider/model/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: client-side credential-status read (honest-degrade, status-only). When the
+// Client-side credential-status read (honest-degrade, status-only). When the
 // TUI acts as a client of an adopted external daemon it reads provider/model/secret
 // STATUS from that daemon's `credentials.get`, never from its own surfaceRoot store.
 export {

package/src/core/turn-cancellation.ts

@@ -8,7 +8,7 @@ import type { SpokenTurnRuntime } from '../audio/spoken-turn-wiring.ts';
  * cap while still wiring `commandContext.isGenerating` (see W1.6 FIX 1).
  *
  * Returns whether SPEECH was actively stopped — a Ctrl+C that silenced live
- * TTS is consumed by that job (batch replay D5), same as a press that
+ * TTS is consumed by that job (an earlier replay fix), same as a press that
  * cleared a non-empty prompt; the quit chord starts from a quiet state.
  */
 export function createCancelGeneration(

package/src/daemon/cli.ts

@@ -163,7 +163,7 @@ async function main(): Promise<void> {
     logger.info('daemon: --hostname flag applied', { hostname: cliFlags.hostname });
   }
 
-  // D7a Layer 1: `install-service` / `uninstall-service` / `service-status` manage
+  // Service lifecycle: `install-service` / `uninstall-service` / `service-status` manage
   // the systemd USER unit for the shared daemon. They run BEFORE the daemon boots —
   // no runtime/services are constructed — and exit with the honest result code.
   const serviceSubcommand = cli.positionals[0];
@@ -204,7 +204,7 @@ async function main(): Promise<void> {
     homeDirectory,
   });
 
-  // F2: Load persisted providers from disk so the provider registry is pre-populated
+  // Load persisted providers from disk so the provider registry is pre-populated
   // on standalone daemon startup (same machinery the TUI uses after /scan).
   const discoveryRoots = { homeDirectory, surfaceRoot: 'tui' };
   const persistedProviders = loadPersistedProviders(discoveryRoots);
@@ -213,7 +213,7 @@ async function main(): Promise<void> {
     logger.info('daemon: loaded persisted providers', { count: persistedProviders.length });
   }
 
-  // F2: Run a background LAN scan (non-blocking). Discovered servers are registered
+  // Run a background LAN scan (non-blocking). Discovered servers are registered
   // and persisted so subsequent daemon restarts benefit from the warm cache.
   void scan().then((result) => {
     if (result.servers.length > 0) {
@@ -245,7 +245,7 @@ async function main(): Promise<void> {
   // If no explicit daemon token is set, use the companion token so mobile apps can connect.
   const daemonHomeDir = join(homeDirectory, '.goodvibes', 'daemon');
   const companionTokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
-  // F3 resolution (TUI 0.19.20): remove stale pre-0.21.28 workspace-scoped operator
+  // Fix (TUI 0.19.20): remove stale pre-0.21.28 workspace-scoped operator
   // token files so only the canonical <daemonHomeDir>/operator-tokens.json survives.
   const prune = pruneStaleOperatorTokens({
     daemonHomeDir,

package/src/daemon/service-commands.ts

@@ -1,5 +1,5 @@
 /**
- * D7a Layer 1 (TUI wiring) — `goodvibes-daemon install-service | uninstall-service
+ * TUI wiring — `goodvibes-daemon install-service | uninstall-service
  * | service-status`.
  *
  * The daemon is a SYSTEM SERVICE. These subcommands install it as a durable host
@@ -7,8 +7,8 @@
  * on Windows) so N surfaces share ONE daemon that survives reboots, instead of
  * every surface spawning a session-scoped daemon.
  *
- * W3 drift note: the SDK's D7a-era `systemd-user-service.ts` (a Linux-only,
- * bespoke systemd shim) was dead code and got deleted in SDK W3-S5. The SDK's
+ * Drift note: the SDK's older `systemd-user-service.ts` (a Linux-only,
+ * bespoke systemd shim) was dead code and got deleted from the SDK. The SDK's
  * REAL wired service machinery — reached in production by the daemon's own HTTP
  * `/api/service/*` routes via facade-composition.ts — is
  * `PlatformServiceManager` (`@pellux/goodvibes-sdk/platform/daemon`): a single
@@ -26,7 +26,7 @@
  *     stray "enabled" symlink may remain until `systemctl --user daemon-reload`
  *     (offered back as a suggested follow-up) or the next login cleans it up.
  *
- * W4-D1: a fourth subcommand, `migrate-service`, closes the Wave-3 "detect and
+ * A fourth subcommand, `migrate-service`, closes the earlier "detect and
  * disclose only" inheritance (W3 Finding 4, below) with a GUIDED, CONSENTED
  * takeover of the legacy `goodvibes-daemon.service` unit. Design constraints,
  * all load-bearing:
@@ -77,9 +77,9 @@ export {
 export type { ManagedServiceActionRunner } from '../runtime/legacy-daemon-migration.ts';
 
 // ---------------------------------------------------------------------------
-// W3 Finding 4: legacy-unit detection. W4-D1: guided migration.
+// Legacy-unit detection, plus guided migration.
 //
-// The prior D7a-era command installed the daemon's systemd unit under the
+// The prior command installed the daemon's systemd unit under the
 // literal name `goodvibes-daemon.service`. This module (rewired onto
 // PlatformServiceManager, see the file banner above) manages a DIFFERENT
 // unit name (`goodvibes`, SERVICE_NAME). A host that still has the legacy
@@ -243,7 +243,7 @@ function failed(action: 'install' | 'uninstall' | 'status', status: ManagedServi
 
 /**
  * `migrate-service`: the guided, consented takeover of the legacy
- * `goodvibes-daemon.service` unit (W4-D1). Thin wrapper over
+ * `goodvibes-daemon.service` unit. Thin wrapper over
  * `runLegacyDaemonMigration` (`../runtime/legacy-daemon-migration.ts`) — see
  * that module for the design constraints (never auto-migrate,
  * new-up-then-old-down, adopt-or-warn/never kill an unrecognized process,
@@ -314,7 +314,7 @@ export async function runDaemonServiceCli(input: DaemonServiceCliInput): Promise
       const extra: string[] = [];
       if (stopped.actionError) extra.push(`(it may not have been running: ${stopped.actionError})`);
       // W3 Finding 4: this command only ever touches the TRACKED unit
-      // (whatever name/path actually resolved, per F2 — not necessarily the
+      // (whatever name/path actually resolved — not necessarily the
       // SERVICE_NAME constant) above — say so explicitly when a legacy unit
       // also exists, so its continued presence is never a silent surprise.
       if (legacy.present) extra.push(legacyUnitNote(legacy, resolveManagedUnitName(uninstalled)));

package/src/export/cost-utils.ts

@@ -174,6 +174,14 @@ export interface BudgetAlertConfigAccess {
 /** Default for the `behavior.budgetAlertUsd` synthetic setting: 0 = no budget configured. */
 export const BUDGET_ALERT_USD_DEFAULT = 0;
 
+/**
+ * The dot-path config key backing the session cost-budget alert threshold.
+ * Shared by cost-tracker-panel.ts (get/set), settings-modal-data.ts (the
+ * settings-modal-visible synthetic entry), and readBudgetAlertUsd below, so
+ * the string literal lives in exactly one place.
+ */
+export const BUDGET_ALERT_USD_CONFIG_KEY = 'behavior.budgetAlertUsd';
+
 /**
  * readBudgetAlertUsd — read the session cost-budget alert threshold (USD) from
  * config. This is the single source of truth CostTrackerPanel and the
@@ -183,7 +191,7 @@ export const BUDGET_ALERT_USD_DEFAULT = 0;
  * when the key is absent or invalid.
  */
 export function readBudgetAlertUsd(configGet: (key: string) => unknown): number {
-  const raw = configGet('behavior.budgetAlertUsd');
+  const raw = configGet(BUDGET_ALERT_USD_CONFIG_KEY);
   const parsed = typeof raw === 'number' ? raw : Number(raw);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : BUDGET_ALERT_USD_DEFAULT;
 }

package/src/input/command-registry.ts

@@ -13,6 +13,7 @@ import type { KeybindingsManager } from './keybindings.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
 import type { OpenOnboardingWizardOptions } from './handler-ui-state.ts';
 import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { MemorySpineClient } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import type { HookApi } from '@pellux/goodvibes-sdk/platform/hooks';
 import type { McpApi } from '@pellux/goodvibes-sdk/platform/mcp';
 import type { ProviderApi } from '@pellux/goodvibes-sdk/platform/providers';
@@ -192,16 +193,16 @@ export interface CommandSessionServices {
    * fresh Orchestrator's zeroed default (W0.9).
    */
   readonly hydrateSessionUsage?: () => void;
-  /** Wave 4 (wo703): the orchestration engine's command-facing facade — see runtime/workstream-services.ts. */
+  /** The orchestration engine's command-facing facade — see runtime/workstream-services.ts. */
   readonly workstreamEngine?: import('../runtime/workstream-services.ts').WorkstreamCommandService;
-  /** Wave 5 (wo804): the repo source-tree code index — see runtime/code-index-services.ts. */
+  /** The repo source-tree code index — see runtime/code-index-services.ts. */
   readonly codeIndexStore?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexStore;
-  /** Wave-5 Stage B: tool-site reindex scheduler — `/codebase status` reports its last activity. */
+  /** Tool-site reindex scheduler — `/codebase status` reports its last activity. */
   readonly codeIndexReindexScheduler?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexReindexScheduler;
-  /** Wave-5 Stage B: whether the (default-off) `agent-passive-code-injection` flag is on — for `/codebase status`. */
+  /** Whether the (default-off) `agent-passive-code-injection` flag is on — for `/codebase status`. */
   readonly isPassiveCodeInjectionFlagEnabled?: () => boolean;
   /**
-   * Wave 5 (wo805): the MAIN interactive session's per-turn passive-injection
+   * The MAIN interactive session's per-turn passive-injection
    * honesty ring — `Orchestrator.getTurnInjections()`, the main-session
    * counterpart to `AgentRecord.turnInjections` (wo801). `/recall injections`
    * with no agent id reads this. Optional so command contexts built without an
@@ -285,6 +286,16 @@ export interface CommandContext
     readonly peer?: PeerClient;
     readonly providerApi?: ProviderApi;
     readonly knowledgeApi?: KnowledgeApi;
+    /**
+     * The cross-surface memory spine client (SDK 1.2.0 full-detach). `/recall`'s
+     * browse/link/queue/export/import subcommands read and write through this —
+     * not `knowledgeApi.memory` — so they fully detach from the local store file
+     * when a daemon has been adopted, per
+     * docs/decisions/2026-07-06-memory-wire-full-detach.md in the SDK repo.
+     * `explain` and the `vector` diagnostic subcommand stay on `knowledgeApi.memory`
+     * (host-side projection / host-only maintenance, ruled explicitly in that decision).
+     */
+    readonly memorySpine?: MemorySpineClient;
     readonly hookApi?: HookApi;
     readonly mcpApi?: McpApi;
     readonly opsApi?: OpsApi;

package/src/input/commands/config.ts

@@ -10,7 +10,7 @@ export function registerConfigCommand(registry: CommandRegistry): void {
     usage: '[category|key] | set <key> <value>',
     argsHint: '[category|key] | set <key> <value>',
     handler(args, ctx) {
-      // Batch replay D2: `/config set <key> <value>` used to fall through to
+      // An earlier replay fix: `/config set <key> <value>` used to fall through to
       // the workspace with the assignment silently ignored — the dishonest-
       // fallthrough class. `set` is now a real verb.
       if (args[0] === 'set') {

package/src/input/commands/control-room-runtime.ts

@@ -3,7 +3,7 @@ import { buildMcpAttackPathReview } from '@/runtime/index.ts';
 import { buildKnowledgeInjectionPrompt, selectKnowledgeForTask } from '@pellux/goodvibes-sdk/platform/state';
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { requireReadModels, requireSubscriptionManager, requireTokenAuditor } from './runtime-services.ts';
-import { getMemoryApi } from './recall-query.ts';
+import { getMemoryApi, getMemorySpine } from './recall-query.ts';
 
 export function registerControlRoomRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
@@ -198,7 +198,7 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     aliases: ['pmem'],
     description: 'Inspect durable project memory: risks, runbooks, and architecture notes',
     usage: '[open | queue [limit] | explain <task...> [--scope <path> ...]]',
-    handler(args, ctx) {
+    async handler(args, ctx) {
       const subcommand = (args[0] ?? 'open').toLowerCase();
       if (subcommand === 'open') {
         if (ctx.openMemoryPanel) {
@@ -208,11 +208,13 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
         ctx.print('Memory panel is not available in this runtime.');
         return;
       }
-      const memory = getMemoryApi(ctx);
-      if (!memory) return;
       if (subcommand === 'queue') {
+        // Repointed onto the memory spine (SDK 1.2.0 full-detach) so the
+        // queue reflects the daemon's own canonical store when adopted.
+        const memory = getMemorySpine(ctx);
+        if (!memory) return;
         const limit = Math.max(1, parseInt(args[1] ?? '10', 10) || 10);
-        const queue = memory.reviewQueue(limit);
+        const queue = await memory.reviewQueue(limit);
         if (queue.length === 0) {
           ctx.print('Knowledge review queue is empty.');
           return;
@@ -224,6 +226,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
         return;
       }
       if (subcommand === 'explain') {
+        // Stays on the local MemoryApi: `explain` is a host-side projection
+        // over whatever read surface is active, not a store operation
+        // (docs/decisions/2026-07-06-memory-wire-full-detach.md, SDK repo).
+        const memory = getMemoryApi(ctx);
+        if (!memory) return;
         const scopeIdx = args.indexOf('--scope');
         const scopeValues = scopeIdx !== -1
           ? args.slice(scopeIdx + 1).filter((token) => !token.startsWith('--'))

package/src/input/commands/incident-runtime.ts

@@ -3,7 +3,7 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import type { CommandRegistry } from '../command-registry.ts';
 import { buildIncidentMemoryAddOptions } from '@pellux/goodvibes-sdk/platform/state';
 import { requireShellPaths } from './runtime-services.ts';
-import { getMemoryApi } from './recall-query.ts';
+import { getMemorySpine } from './recall-query.ts';
 
 export function registerIncidentRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
@@ -74,7 +74,7 @@ export function registerIncidentRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (subcommand === 'capture') {
-        const memory = getMemoryApi(ctx);
+        const memory = getMemorySpine(ctx);
         if (!memory) return;
         if (!report) {
           ctx.print(`Incident not found: ${requestedId ?? 'latest'}`);

package/src/input/commands/memory.ts

@@ -29,7 +29,7 @@ import { VALID_CLASSES, VALID_REVIEW_STATES, VALID_SCOPES } from './recall-share
  * src/input/commands/session-content.ts) with no modal surface — so that
  * work order deliberately did NOT touch /memory and used /recall instead.
  *
- * W6-C3 update (Wave 6 core-verb pass, MEMORY fragmentation — worst-class
+ * Update from the core-verb naming pass (MEMORY fragmentation — worst-class
  * collision #2): the agent's own `/memory` command was a plain alias for its
  * `/recall`-equivalent the whole time, meaning "/memory" meant two unrelated
  * things depending which surface you were on. The session-notes command was
@@ -99,7 +99,7 @@ export const recallCommand: SlashCommand = {
 
       case 'search':
       case 'find':
-        handleRecallSearch(rest, context);
+        await handleRecallSearch(rest, context);
         break;
 
       case 'vector':
@@ -113,24 +113,24 @@ export const recallCommand: SlashCommand = {
 
       case 'get':
       case 'show':
-        handleRecallGet(rest, context);
+        await handleRecallGet(rest, context);
         break;
 
       case 'queue':
-        handleRecallQueue(rest, context);
+        await handleRecallQueue(rest, context);
         break;
 
       case 'review':
-        handleRecallReview(rest, context);
+        await handleRecallReview(rest, context);
         break;
 
       case 'stale':
-        handleRecallReview([rest[0] ?? '', 'stale', '--reason', ...rest.slice(1)], context);
+        await handleRecallReview([rest[0] ?? '', 'stale', '--reason', ...rest.slice(1)], context);
         break;
 
       case 'contradict':
       case 'contradicted':
-        handleRecallReview([rest[0] ?? '', 'contradicted', '--reason', ...rest.slice(1)], context);
+        await handleRecallReview([rest[0] ?? '', 'contradicted', '--reason', ...rest.slice(1)], context);
         break;
 
       case 'explain':
@@ -142,7 +142,7 @@ export const recallCommand: SlashCommand = {
         break;
 
       case 'promote':
-        handleRecallPromote(rest, context);
+        await handleRecallPromote(rest, context);
         break;
 
       case 'link':
@@ -151,17 +151,17 @@ export const recallCommand: SlashCommand = {
 
       case 'list':
       case 'ls':
-        handleRecallList(rest, context);
+        await handleRecallList(rest, context);
         break;
 
       case 'remove':
       case 'delete':
       case 'rm':
-        handleRecallRemove(rest, context);
+        await handleRecallRemove(rest, context);
         break;
 
       case 'export':
-        handleRecallExport(rest, context);
+        await handleRecallExport(rest, context);
         break;
 
       case 'import':
@@ -170,7 +170,7 @@ export const recallCommand: SlashCommand = {
 
       case 'handoff-export':
       case 'share':
-        handleRecallHandoffExport(rest, context);
+        await handleRecallHandoffExport(rest, context);
         break;
 
       case 'handoff-inspect':

package/src/input/commands/planning-runtime.ts

@@ -262,7 +262,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      // Defense (Wave 6 review): a single verb-looking token is almost never a
+      // Defense (review finding): a single verb-looking token is almost never a
       // real planning goal — it is a mistyped or removed subcommand. The
       // Planning modal used to dispatch `/plan dismiss`, which has no
       // subcommand and silently fell through to this free-form branch, seeding