@pellux/goodvibes-tui 1.9.2 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "1.9.2",
+  "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/spoken-turn-wiring.ts

@@ -3,7 +3,7 @@ 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)[];
@@ -37,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,
   });
 

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/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';
@@ -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/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

@@ -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/recall-bundle.ts

@@ -4,11 +4,11 @@ import type { CommandContext } from '../command-registry.ts';
 import type { MemoryBundle, MemorySearchFilter } from '@pellux/goodvibes-sdk/platform/state';
 import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope, resolveBundlePath } from './recall-shared.ts';
 import { requireShellPaths } from './runtime-services.ts';
-import { getMemoryApi } from './recall-query.ts';
+import { getMemorySpine } from './recall-query.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
-export function handleRecallExport(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallExport(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -40,7 +40,7 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
     filter.cls = cls;
   }
 
-  const bundle = memory.exportBundle(filter);
+  const bundle = await memory.exportBundle(filter);
   const targetPath = resolveBundlePath(pathArg, requireShellPaths(context));
   mkdirSync(dirname(targetPath), { recursive: true });
   writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');
@@ -48,7 +48,7 @@ export function handleRecallExport(args: string[], context: CommandContext): voi
 }
 
 export async function handleRecallImport(args: string[], context: CommandContext): Promise<void> {
-  const memory = getMemoryApi(context);
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -84,8 +84,8 @@ function inspectBundle(bundle: MemoryBundle): string {
   ].join('\n');
 }
 
-export function handleRecallHandoffExport(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallHandoffExport(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -100,7 +100,7 @@ export function handleRecallHandoffExport(args: string[], context: CommandContex
     context.print(`[recall] Unknown scope "${scopeRaw ?? ''}". Valid: ${VALID_SCOPES.join(', ')}`);
     return;
   }
-  const bundle = memory.exportBundle({ scope: scopeRaw });
+  const bundle = await memory.exportBundle({ scope: scopeRaw });
   const targetPath = resolveBundlePath(pathArg, requireShellPaths(context));
   mkdirSync(dirname(targetPath), { recursive: true });
   writeFileSync(targetPath, JSON.stringify(bundle, null, 2) + '\n', 'utf-8');

package/src/input/commands/recall-capture.ts

@@ -7,10 +7,10 @@ import {
   buildPolicyPreflightMemoryAddOptions,
 } from '@pellux/goodvibes-sdk/platform/state';
 import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
-import { getMemoryApi } from './recall-query.ts';
+import { getMemorySpine } from './recall-query.ts';
 
 export async function handleRecallAdd(args: string[], context: CommandContext): Promise<void> {
-  const memory = getMemoryApi(context);
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -70,7 +70,7 @@ export async function handleRecallAdd(args: string[], context: CommandContext):
 }
 
 export async function handleRecallCapture(args: string[], context: CommandContext): Promise<void> {
-  const memory = getMemoryApi(context);
+  const memory = getMemorySpine(context);
   const pluginManager = context.extensions.pluginManager;
   if (!memory) {
     return;

package/src/input/commands/recall-query.ts

@@ -1,8 +1,19 @@
 import type { CommandContext } from '../command-registry.ts';
 import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { MemorySpineClient } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import type { MemorySearchFilter } from '@pellux/goodvibes-sdk/platform/state';
 import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
 
+/**
+ * The local, host-only `MemoryApi` — kept for `/recall explain` and `/recall
+ * vector` only. Both are ruled explicitly out of the wire catalog in
+ * docs/decisions/2026-07-06-memory-wire-full-detach.md (SDK repo): `explain`
+ * is a client-side projection over whatever read surface is active, not a
+ * store operation, and vector-index rebuild is host/admin maintenance a wire
+ * client does not own. Every other `/recall` subcommand reads/writes through
+ * {@link getMemorySpine} instead, so it detaches fully from the local store
+ * file when a daemon is adopted.
+ */
 export function getMemoryApi(context: CommandContext): MemoryApi | null {
   const memoryApi = context.clients?.knowledgeApi?.memory;
   if (!memoryApi) {
@@ -12,8 +23,23 @@ export function getMemoryApi(context: CommandContext): MemoryApi | null {
   return memoryApi;
 }
 
-export function handleRecallSearch(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+/**
+ * The cross-surface memory spine client — routes local when offline/embedded,
+ * over the wire when a daemon has been adopted, never both. `/recall`'s
+ * browse/link/queue/export/import subcommands use this so they never read a
+ * divergent local copy while a daemon owns the canonical store.
+ */
+export function getMemorySpine(context: CommandContext): MemorySpineClient | null {
+  const memorySpine = context.clients?.memorySpine;
+  if (!memorySpine) {
+    context.print('[recall] Memory spine is not available in this runtime.');
+    return null;
+  }
+  return memorySpine;
+}
+
+export async function handleRecallSearch(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -54,8 +80,8 @@ export function handleRecallSearch(args: string[], context: CommandContext): voi
   if (queryTokens.length) filter.query = queryTokens.join(' ');
   if (semantic) filter.semantic = true;
 
-  const semanticResults = semantic ? memory.searchSemantic(filter) : [];
-  const results = semantic ? semanticResults.map((entry) => entry.record) : memory.search(filter);
+  const semanticResults = semantic ? await memory.searchSemantic(filter) : [];
+  const results = semantic ? semanticResults.map((entry) => entry.record) : await memory.list(filter);
   if (!results.length) {
     context.print('[recall] No records found.');
     return;
@@ -110,8 +136,8 @@ function formatVectorStats(
   ].join('\n');
 }
 
-export function handleRecallGet(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallGet(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -120,7 +146,7 @@ export function handleRecallGet(args: string[], context: CommandContext): void {
     context.print('[recall] Usage: /recall get <id>');
     return;
   }
-  const record = memory.get(id);
+  const record = await memory.get(id);
   if (!record) {
     context.print(`[recall] Record not found: ${id}`);
     return;
@@ -142,7 +168,7 @@ export function handleRecallGet(args: string[], context: CommandContext): void {
     }
   }
 
-  const links = memory.linksFor(id);
+  const links = await memory.linksFor(id);
   if (links.length) {
     context.print('  Links:');
     for (const link of links) {
@@ -154,7 +180,7 @@ export function handleRecallGet(args: string[], context: CommandContext): void {
 }
 
 export async function handleRecallLink(args: string[], context: CommandContext): Promise<void> {
-  const memory = getMemoryApi(context);
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -171,8 +197,8 @@ export async function handleRecallLink(args: string[], context: CommandContext):
   context.print(`[recall] Linked: ${fromId} -> ${toId} [${relation}]`);
 }
 
-export function handleRecallRemove(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallRemove(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -181,7 +207,7 @@ export function handleRecallRemove(args: string[], context: CommandContext): voi
     context.print('[recall] Usage: /recall remove <id>');
     return;
   }
-  const removed = memory.delete(id);
+  const removed = await memory.delete(id);
   if (!removed) {
     context.print(`[recall] Record not found: ${id}`);
     return;
@@ -189,8 +215,8 @@ export function handleRecallRemove(args: string[], context: CommandContext): voi
   context.print(`[recall] Deleted: ${id}`);
 }
 
-export function handleRecallList(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallList(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -207,7 +233,7 @@ export function handleRecallList(args: string[], context: CommandContext): void
     filter.scope = scope;
   }
 
-  const records = memory.search(filter);
+  const records = await memory.list(filter);
   if (!records.length) {
     context.print('[recall] No records.');
     return;

package/src/input/commands/recall-review.ts

@@ -1,10 +1,10 @@
 import type { CommandContext } from '../command-registry.ts';
 import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope } from './recall-shared.ts';
-import { getMemoryApi } from './recall-query.ts';
+import { getMemoryApi, getMemorySpine } from './recall-query.ts';
 import { buildMainSessionTurnInjectionsText, buildTurnInjectionsText } from '../../renderer/turn-injection.ts';
 
-export function handleRecallQueue(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallQueue(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -29,7 +29,7 @@ export function handleRecallQueue(args: string[], context: CommandContext): void
   // When a scope filter is requested, fetch a larger pool then slice to the
   // requested limit so scope-sparse queues still return meaningful results.
   const fetchLimit = scopeFilter ? 1000 : limit;
-  const rawQueue = memory.reviewQueue(fetchLimit);
+  const rawQueue = await memory.reviewQueue(fetchLimit);
   const queue = scopeFilter
     ? rawQueue.filter((record) => record.scope === scopeFilter).slice(0, limit)
     : rawQueue;
@@ -45,8 +45,8 @@ export function handleRecallQueue(args: string[], context: CommandContext): void
   }
 }
 
-export function handleRecallReview(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallReview(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -64,7 +64,7 @@ export function handleRecallReview(args: string[], context: CommandContext): voi
   const reviewedBy = byIdx !== -1 ? rest[byIdx + 1] : 'operator';
   const staleReason = reasonIdx !== -1 ? rest.slice(reasonIdx + 1).join(' ') : undefined;
 
-  const record = memory.review(id, {
+  const record = await memory.updateReview(id, {
     state: stateRaw,
     confidence: Number.isFinite(confidence) ? confidence : undefined,
     reviewedBy,
@@ -137,8 +137,8 @@ export function handleRecallInjections(args: string[], context: CommandContext):
   context.print(buildTurnInjectionsText(agentId, record.turnInjections ?? []));
 }
 
-export function handleRecallPromote(args: string[], context: CommandContext): void {
-  const memory = getMemoryApi(context);
+export async function handleRecallPromote(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
   if (!memory) {
     return;
   }
@@ -148,7 +148,7 @@ export function handleRecallPromote(args: string[], context: CommandContext): vo
     context.print(`[recall] Usage: /recall promote <id> <${VALID_SCOPES.join('|')}>`);
     return;
   }
-  const record = memory.update(id, { scope });
+  const record = await memory.update(id, { scope });
   if (!record) {
     context.print(`[recall] Record not found: ${id}`);
     return;

package/src/input/settings-modal-data.ts

@@ -15,6 +15,7 @@ import { buildSubscriptionEntries } from './settings-modal-subscriptions.ts';
 import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import { CODE_INDEX_ENABLED_CONFIG_KEY } from '../runtime/code-index-services.ts';
+import { BUDGET_ALERT_USD_CONFIG_KEY, BUDGET_ALERT_USD_DEFAULT, readBudgetAlertUsd } from '../export/cost-utils.ts';
 import {
   THEME_MODE_CONFIG_KEY,
   THEME_MODE_VALUES,
@@ -146,6 +147,18 @@ export function buildSettingGroups(
     behaviorEntries.push(buildNotifyAfterSecondsSyntheticEntry(configManager));
   }
 
+  // Inject the synthetic behavior.budgetAlertUsd entry into the behavior
+  // category. This key is TUI-local (not in the SDK ConfigKey union), which
+  // previously left it with no schema-driven inspection surface at all: it
+  // never appeared in /config, and /settings-sync show rejects any key not
+  // in CONFIG_KEYS. The Cost panel's 'b' key and /cost budget <usd> remain
+  // the primary way to change it; this entry makes the current effective
+  // value (and whether it's still the "no budget configured" default)
+  // visible from /config behavior too, same rationale as notifyAfterSeconds.
+  if (behaviorEntries && !behaviorEntries.some((e) => e.setting.key === (BUDGET_ALERT_USD_CONFIG_KEY as ConfigKey))) {
+    behaviorEntries.push(buildBudgetAlertUsdSyntheticEntry(configManager));
+  }
+
   // Inject the W2.3 alert-class toggles + master focus gate. TUI-local
   // synthetic settings, same rationale as notifyAfterSeconds above.
   if (behaviorEntries) {
@@ -287,6 +300,47 @@ export function buildNotifyAfterSecondsSyntheticEntry(configManager: Pick<Config
   };
 }
 
+// ---------------------------------------------------------------------------
+// behavior.budgetAlertUsd synthetic setting
+// ---------------------------------------------------------------------------
+
+/**
+ * The synthetic ConfigSetting descriptor for behavior.budgetAlertUsd.
+ *
+ * This key is TUI-local and is not yet in the SDK ConfigKey union — it never
+ * appeared in CONFIG_SCHEMA, so it was invisible to every schema-driven
+ * inspection surface (/config, /settings-sync show <key>) even though the
+ * value round-trips correctly through configManager.get/set. The descriptor
+ * is injected into the behavior settings group so /config behavior shows the
+ * real current threshold, not just the behavior.notifyOnBudgetBreach gate.
+ *
+ * 0 = no budget configured (disabled). Any positive number = the USD
+ * threshold. Default matches BUDGET_ALERT_USD_DEFAULT in cost-utils.ts, the
+ * single source of truth CostTrackerPanel and budget-breach-notifier.ts share.
+ */
+export const BUDGET_ALERT_USD_SYNTHETIC_SETTING: ConfigSetting = {
+  key: BUDGET_ALERT_USD_CONFIG_KEY as ConfigKey,
+  type: 'number',
+  default: BUDGET_ALERT_USD_DEFAULT,
+  description: 'Session cost-budget alert threshold in USD (0 = no budget configured). Set via the Cost panel\'s "b" key or /cost budget <usd>; this entry only displays the current effective value.',
+};
+
+/**
+ * Build the synthetic SettingEntry for behavior.budgetAlertUsd.
+ *
+ * Delegates parsing/fallback to readBudgetAlertUsd (cost-utils.ts) so this
+ * display entry can never disagree with what CostTrackerPanel and the
+ * background budget-breach notifier actually read.
+ */
+export function buildBudgetAlertUsdSyntheticEntry(configManager: Pick<ConfigManager, 'get'>): SettingEntry {
+  const currentValue = readBudgetAlertUsd((key) => configManager.get(key as ConfigKey));
+  return {
+    setting: BUDGET_ALERT_USD_SYNTHETIC_SETTING,
+    currentValue,
+    isDefault: currentValue === BUDGET_ALERT_USD_DEFAULT,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // W2.3 alert-class synthetic settings — behavior.notifyOn* + notifyOnlyWhenUnfocused
 // ---------------------------------------------------------------------------

package/src/main.ts

@@ -32,7 +32,7 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerBuiltinPanels } from './panels/builtin-panels.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
-import { buildSharedOrchestratorCoreServices } from './runtime/orchestrator-core-services.ts';
+import { buildSharedOrchestratorCoreServices, refreshMemoryRecallSnapshot } from './runtime/orchestrator-core-services.ts';
 import type { HITLMode } from '@pellux/goodvibes-sdk/platform/state';
 import { readLastSessionPointer, writeRecoveryFile } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
@@ -288,6 +288,7 @@ async function main() {
         // Snapshot pre-submission state for failover retryTurn; also clears visited set.
         retryCtx = { count: conversation.getMessageCount(), text: processedText, content, opts: inputOptions };
         streamResult.clearFailoverVisited();
+        await refreshMemoryRecallSnapshot(ctx.services); // pre-turn recall-snapshot refresh (SDK 1.2.0 full detach)
         orchestrator.handleUserInput(processedText, content, inputOptions).catch((err: unknown) => {
           logger.debug('handleUserInput safety catch (already handled by runTurn)', { error: summarizeError(err) });
         });
@@ -700,7 +701,7 @@ async function main() {
     const { count, text, content: rContent, opts: rOpts } = retryCtx;
     // Roll back to pre-submission count, then re-submit. SDK gap — no retry-in-place (see handoff).
     conversation.removeMessagesAfter(count);
-    orchestrator.handleUserInput(text, rContent, rOpts).catch((e: unknown) => logger.debug('retryTurn', { error: summarizeError(e) }));
+    void refreshMemoryRecallSnapshot(ctx.services).then(() => orchestrator.handleUserInput(text, rContent, rOpts)).catch((e: unknown) => logger.debug('retryTurn', { error: summarizeError(e) }));
   };
   const streamResult: WireStreamEventMetricsResult = wireStreamEventMetrics({
     events: uiServices.events, orchestrator, providerRegistry,

package/src/panels/builtin/shared.ts

@@ -3,7 +3,7 @@ import type { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import type { Orchestrator } from '../../core/orchestrator';
-import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import type { ApprovalBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
 import type { SessionReadFacade } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import type { AutomationManager } from '@pellux/goodvibes-sdk/platform/automation';
@@ -79,8 +79,8 @@ export interface BuiltinPanelDeps {
    * copy via CommandContext.extensions.evalRegistry).
    */
   evalRegistry?: import('../eval-registry.ts').EvalRegistry;
-  /** MemoryRegistry for the Memory panel. */
-  memoryRegistry?: MemoryRegistry;
+  /** Host-vs-client memory access for the Memory modal — the spine client, never the raw registry (routes over the wire when a daemon is adopted). */
+  memoryRegistry?: MemoryAccess;
   /** Shared policy runtime state for governance/policy diagnostics. */
   policyRuntimeState?: import('@/runtime/index.ts').PolicyRuntimeState;
   /** Approval broker for control-plane/operator panels. */