@pellux/goodvibes-tui 1.18.0 → 1.19.0

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

@@ -2,6 +2,7 @@ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { createVoiceProvisionGateway, renderVoiceProvision, runVoiceSetupWithProgress, VOICE_SETUP_ANNOUNCEMENT } from '../../core/voice-provision-gateway.ts';
 
 interface VoiceBundle {
   readonly version: 1;
@@ -222,11 +223,31 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
 
   registry.register({
     name: 'voice',
-    description: 'Review or toggle always-speak mode (same switch as /tts on|off) and package portable voice metadata',
-    usage: '[review|enable|disable|bundle export <path>|bundle inspect <path>]',
-    handler(args, ctx) {
+    description: 'Review or toggle always-speak mode, provision the managed local voice runtime (setup/status), and package portable voice metadata',
+    usage: '[review|status|setup|enable|disable|bundle export <path>|bundle inspect <path>]',
+    async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const sub = (args[0] ?? 'review').toLowerCase();
+      if (sub === 'status' || sub === 'setup') {
+        // The one-act managed install returns a final receipt (no per-phase
+        // streaming over the verb), so the announcement block prints first and
+        // the receipt/failure block follows once the (possibly long,
+        // multi-hundred-MB) install resolves.
+        const resolution = createVoiceProvisionGateway({
+          configManager: ctx.platform.configManager,
+          // Lazy: the daemon-disabled / no-base-URL refusals resolve before shell paths.
+          homeDirectory: () => requireShellPaths(ctx).homeDirectory,
+        });
+        if (sub === 'setup') {
+          // Print the up-front announcement, then drive the install with live
+          // per-component progress polled from voice.local.status.
+          if (resolution.available) ctx.print(VOICE_SETUP_ANNOUNCEMENT);
+          await runVoiceSetupWithProgress(resolution, { print: (block) => ctx.print(block) });
+          return;
+        }
+        ctx.print(await renderVoiceProvision(sub, resolution));
+        return;
+      }
       if (sub === 'review') {
         const enabled = Boolean(ctx.platform.configManager.get('ui.voiceEnabled') ?? false);
         ctx.print([
@@ -273,7 +294,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
           return;
         }
       }
-      ctx.print('Usage: /voice [review|enable|disable|bundle export <path>|bundle inspect <path>]');
+      ctx.print('Usage: /voice [review|status|setup|enable|disable|bundle export <path>|bundle inspect <path>]');
     },
   });
 }

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

@@ -21,6 +21,8 @@ import {
 } from './runtime-services.ts';
 import { getOperatorRpc, describeOperatorRpcError } from './operator-rpc.ts';
 import { formatQuotaSnapshotLine, renderMetricMap, telemetryScopeRefusalLine } from './health-metrics-format.ts';
+import { createMemoryDiagnosticsGateway, renderMemoryDiagnostics } from '../../core/memory-diagnostics-gateway.ts';
+import { requireShellPaths } from './runtime-services.ts';
 
 function renderSandboxHealthSummary(configManager: ConfigManager): string[] {
   const backend = String(configManager.get('sandbox.vmBackend') ?? 'local');
@@ -42,7 +44,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
     name: 'health',
     aliases: ['doctor'],
     description: 'Health workspace for startup posture, service readiness, sandbox posture, and provider health',
-    usage: '[report|review|open|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|metrics|continuity|worktrees|maintenance|term|repair [domain]] — bare and report stay a cross-domain transcript report (see also /health provider for the providers modal)',
+    usage: '[report|review|open|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|memory|metrics|continuity|worktrees|maintenance|term|repair [domain]] — bare and report stay a cross-domain transcript report (see also /health provider for the providers modal)',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       const readModels = requireReadModels(ctx);
@@ -52,6 +54,18 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
+      if (sub === 'memory') {
+        // The MemoryGovernor snapshot (ops.memory.get): tier, budget vs RSS,
+        // per-cache footprints, paused jobs, tripwire — read-only, honest 501
+        // when a daemon predates the governor verb.
+        const resolution = createMemoryDiagnosticsGateway({
+          configManager: ctx.platform.configManager,
+          homeDirectory: () => requireShellPaths(ctx).homeDirectory,
+        });
+        ctx.print(await renderMemoryDiagnostics(resolution));
+        return;
+      }
+
       if (sub === 'services') {
         const registry = requireServiceRegistry(ctx);
         const all = registry.getAll();

package/src/input/tts-settings-actions.ts

@@ -2,6 +2,7 @@ import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandContext } from './command-registry.ts';
 import type { SelectionItem } from './selection-modal.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { localVoiceSetupOffer } from './voice-local-settings.ts';
 
 function getStreamingTtsProviders(ctx: CommandContext): Array<{ id: string; label: string; capabilities: readonly string[] }> {
   const registry = ctx.platform.voiceProviderRegistry;
@@ -28,14 +29,32 @@ export function openTtsProviderPicker(ctx: CommandContext): boolean {
   }
 
   const current = String(ctx.platform.configManager.get('tts.provider') ?? '').trim();
-  const items: SelectionItem[] = providers.map((provider) => ({
-    id: provider.id,
-    label: provider.label,
-    detail: provider.id === current ? `${provider.id}  (current)` : provider.id,
-    category: 'streaming TTS providers',
-    primaryAction: 'select',
-    actions: '[Enter] set provider',
-  }));
+  const items: SelectionItem[] = providers.map((provider) => {
+    // The managed local engine renders beside ElevenLabs; when it is not yet
+    // provisioned, its detail line offers the size-labeled one-act install so
+    // the operator sees the download cost before committing to /voice setup.
+    if (provider.id === 'local') {
+      const offer = localVoiceSetupOffer((key) => ctx.platform.configManager.get(key as Parameters<typeof ctx.platform.configManager.get>[0]));
+      if (!offer.provisioned) {
+        return {
+          id: provider.id,
+          label: provider.label,
+          detail: provider.id === current ? `${offer.detail}  (current)` : offer.detail,
+          category: 'streaming TTS providers',
+          primaryAction: 'select',
+          actions: offer.actions,
+        };
+      }
+    }
+    return {
+      id: provider.id,
+      label: provider.label,
+      detail: provider.id === current ? `${provider.id}  (current)` : provider.id,
+      category: 'streaming TTS providers',
+      primaryAction: 'select',
+      actions: '[Enter] set provider',
+    };
+  });
 
   ctx.openSelection('Choose TTS Provider', items, { preSelectId: current, allowSearch: true }, (result) => {
     if (!result) return;

package/src/input/voice-local-settings.ts

@@ -0,0 +1,52 @@
+// ---------------------------------------------------------------------------
+// voice-local-settings.ts — the managed local-voice setup affordance the voice
+// settings surfaces render beside ElevenLabs.
+//
+// The local engine registers in the voice provider registry regardless of
+// whether it is provisioned yet (its status is honestly "unconfigured", never
+// an error). When it is NOT provisioned, the settings/provider-picker surface
+// offers the one-act install with its download size declared up front — the
+// size is computed synchronously from the pinned piper manifest
+// (piperProvisionBytes) so no daemon round-trip is needed just to label the
+// offer. Platforms with no pinned managed build say so honestly.
+// ---------------------------------------------------------------------------
+
+import { currentVoicePlatform, piperProvisionBytes } from '@pellux/goodvibes-sdk/platform/voice';
+import { formatVoiceBytes } from '../core/voice-provision-status.ts';
+
+export interface LocalVoiceSetupOffer {
+  /** A pinned managed piper build exists for the current platform. */
+  readonly supported: boolean;
+  /** The local TTS engine + model config keys are set (managed install applied or user-set). */
+  readonly provisioned: boolean;
+  /** Human size label for the one-act install ("~85 MB" or an honest unavailable note). */
+  readonly sizeLabel: string;
+  /** The detail line the provider picker renders for the local engine. */
+  readonly detail: string;
+  /** The picker action hint (advertises /voice setup only where it can actually provision). */
+  readonly actions: string;
+}
+
+/**
+ * Compute the managed local-voice setup offer from config, with the download
+ * size declared up front. `provisioned` reflects whether the local TTS engine
+ * binary + model keys are set; an unprovisioned-but-supported platform offers
+ * the size-labeled /voice setup one-act.
+ */
+export function localVoiceSetupOffer(configGet: (key: string) => unknown): LocalVoiceSetupOffer {
+  const platform = currentVoicePlatform();
+  const bytes = platform ? piperProvisionBytes(platform) : null;
+  const supported = bytes !== null && bytes !== undefined;
+  const ttsBinary = String(configGet('voice.local.ttsBinary') ?? '').trim();
+  const ttsModel = String(configGet('voice.local.ttsModelPath') ?? '').trim();
+  const provisioned = ttsBinary.length > 0 && ttsModel.length > 0;
+  const sizeLabel = supported ? `~${formatVoiceBytes(bytes)}` : 'unavailable on this platform';
+
+  let detail: string;
+  if (!supported) detail = 'local voice: no managed build for this platform (set voice.local.* by hand to use it)';
+  else if (provisioned) detail = 'local voice: configured (managed engine set)';
+  else detail = `local voice: not set up — run /voice setup (${sizeLabel})`;
+
+  const actions = supported && !provisioned ? '[Enter] select · /voice setup to provision' : '[Enter] set provider';
+  return { supported, provisioned, sizeLabel, detail, actions };
+}

package/src/runtime/code-index-services.ts

@@ -64,6 +64,15 @@ export interface CodeIndexServicesDeps {
   readonly workingDirectory: string;
   readonly configManager: Pick<ConfigManager, 'get'>;
   readonly memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry;
+  /**
+   * Memory-governor backpressure (optional): when the governor pauses the
+   * 'code-index-reindex' job, the tool-site reindex scheduler stops scheduling
+   * new work; the critical tier refuses new reindex work outright via
+   * admitExpensiveWork. Absent (most test fixtures) → never paused, always
+   * admitted, exactly as before.
+   */
+  readonly isReindexPaused?: (() => boolean) | undefined;
+  readonly admitExpensiveWork?: ((label: string) => { allowed: boolean; reason?: string | undefined }) | undefined;
 }
 
 /**
@@ -128,7 +137,12 @@ export function createCodeIndexServices(deps: CodeIndexServicesDeps): CodeIndexS
   const codeIndexReindexScheduler = new CodeIndexReindexScheduler({
     target: codeIndexStore,
     workingDirectory: deps.workingDirectory,
-    isEnabled: () => isCodeInjectionSettingEnabled(deps.configManager),
+    // Honor governor backpressure: a paused code-index reindex job stops
+    // scheduling new work until the governor resumes it, and the critical
+    // memory tier refuses new reindex work outright (mirrors the SDK).
+    isEnabled: () => isCodeInjectionSettingEnabled(deps.configManager)
+      && !(deps.isReindexPaused?.() ?? false)
+      && (deps.admitExpensiveWork?.('code-index reindex').allowed ?? true),
   });
   return { codeIndexStore, codeIndexReindexScheduler };
 }

package/src/runtime/knowledge-services.ts

@@ -0,0 +1,94 @@
+// ---------------------------------------------------------------------------
+// knowledge-services.ts — the knowledge/wiki + home-graph stack (TUI wiring)
+//
+// Constructs the three KnowledgeStores (regular wiki, agent, home-graph), their
+// semantic services, the ingest services, the home-graph service, and the
+// project-planning + work-plan stores. Extracted into its own module rather
+// than built inline in services.ts, which sits at the architecture check's
+// 800-line cap (scripts/check-architecture.ts) — new/large construction blocks
+// get their own module and a single wiring call there (mirrors
+// createWorkstreamServices / createDurabilityServices / createCodeIndexServices).
+//
+// The semantic services + ingest services receive the memory-governor
+// backpressure seams (isBackgroundPaused for the knowledge-self-improvement job
+// + admitExpensiveWork for the critical-tier refusal), mirroring the SDK's own
+// createRuntimeServices. The web-knowledge gap repairer is wired by the caller
+// AFTER webSearchService exists (it is constructed later in services.ts), using
+// the semantic + ingest handles this returns.
+// ---------------------------------------------------------------------------
+
+import {
+  HomeGraphService,
+  GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_EXTENSION,
+  KnowledgeService,
+  KnowledgeSemanticService,
+  KnowledgeStore,
+  ProjectPlanningService,
+  createProviderBackedKnowledgeSemanticLlm,
+  projectPlanningProjectIdFromPath,
+} from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { RuntimeEventBus } from '@/runtime/index.ts';
+import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+
+const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
+const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
+
+export interface KnowledgeServicesDeps {
+  readonly configManager: ConfigManager;
+  readonly providerRegistry: ProviderRegistry;
+  readonly artifactStore: ArtifactStore;
+  readonly memoryRegistry: MemoryRegistry;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+  /** True while the 'knowledge-self-improvement' job is governor-paused. */
+  readonly isBackgroundPaused: () => boolean;
+  /** Critical-tier admission gate for expensive knowledge work. */
+  readonly admitExpensiveWork: (label: string) => { allowed: boolean; reason?: string | undefined };
+}
+
+export interface KnowledgeServices {
+  readonly knowledgeStore: KnowledgeStore;
+  readonly agentKnowledgeStore: KnowledgeStore;
+  readonly homeGraphKnowledgeStore: KnowledgeStore;
+  readonly knowledgeSemanticService: KnowledgeSemanticService;
+  readonly homeGraphSemanticService: KnowledgeSemanticService;
+  readonly agentKnowledgeSemanticService: KnowledgeSemanticService;
+  readonly knowledgeService: KnowledgeService;
+  readonly agentKnowledgeService: KnowledgeService;
+  readonly homeGraphService: HomeGraphService;
+  readonly projectPlanningService: ProjectPlanningService;
+  readonly projectPlanningProjectId: string;
+  readonly workPlanStore: WorkPlanStore;
+}
+
+/** Construct the knowledge/wiki + home-graph stack with governor backpressure wired in. */
+export function createKnowledgeServices(deps: KnowledgeServicesDeps): KnowledgeServices {
+  const { configManager, providerRegistry, artifactStore, memoryRegistry, runtimeBus, isBackgroundPaused, admitExpensiveWork } = deps;
+  const knowledgeStore = new KnowledgeStore({ configManager, dbFileName: REGULAR_KNOWLEDGE_DB_FILE });
+  const agentKnowledgeStore = new KnowledgeStore({ configManager, dbFileName: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE });
+  const homeGraphKnowledgeStore = new KnowledgeStore({ configManager, dbFileName: HOME_GRAPH_KNOWLEDGE_DB_FILE });
+  const knowledgeSemanticLlm = createProviderBackedKnowledgeSemanticLlm(providerRegistry, { timeoutMs: 20_000, maxConcurrent: 1 });
+  const knowledgeSemanticService = new KnowledgeSemanticService(knowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, isBackgroundPaused, admitExpensiveWork });
+  const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, objectProfiles: HOME_GRAPH_KNOWLEDGE_EXTENSION.objectProfiles, isBackgroundPaused, admitExpensiveWork });
+  const agentKnowledgeSemanticService = new KnowledgeSemanticService(agentKnowledgeStore, { llm: knowledgeSemanticLlm, maxLlmSourcesPerReindex: 3, isBackgroundPaused, admitExpensiveWork });
+  const knowledgeService = new KnowledgeService(knowledgeStore, artifactStore, undefined, { memoryRegistry, runtimeBus, semanticService: knowledgeSemanticService, admitExpensiveWork });
+  knowledgeService.attachRuntimeBus(runtimeBus);
+  const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, { memoryRegistry, runtimeBus, semanticService: agentKnowledgeSemanticService, admitExpensiveWork });
+  agentKnowledgeService.attachRuntimeBus(runtimeBus);
+  const homeGraphService = new HomeGraphService(homeGraphKnowledgeStore, artifactStore, { semanticService: homeGraphSemanticService, admitExpensiveWork });
+  const projectPlanningProjectId = projectPlanningProjectIdFromPath(deps.workingDirectory);
+  const projectPlanningService = new ProjectPlanningService(knowledgeStore, { defaultProjectId: projectPlanningProjectId });
+  const workPlanStore = new WorkPlanStore({ homeDirectory: deps.homeDirectory, projectId: projectPlanningProjectId, projectRoot: deps.workingDirectory });
+  return {
+    knowledgeStore, agentKnowledgeStore, homeGraphKnowledgeStore,
+    knowledgeSemanticService, homeGraphSemanticService, agentKnowledgeSemanticService,
+    knowledgeService, agentKnowledgeService, homeGraphService,
+    projectPlanningService, projectPlanningProjectId, workPlanStore,
+  };
+}

package/src/runtime/legacy-daemon-migration.ts

@@ -41,7 +41,7 @@
  *     exercised deterministically via fakes and never touches a real running
  *     service in tests.
  */
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { basename, dirname, join } from 'node:path';
@@ -118,12 +118,22 @@ export function buildManagedDaemonServiceManager(params: BuildManagedDaemonServi
     homeDir: params.homeDir,
     surfaceRoot: 'tui',
   });
+  // The unit's ExecStart deliberately carries NO endpoint flags
+  // (--hostname/--port): the daemon resolves controlPlane.hostMode/host/port
+  // from the user's settings at boot, so a later config change (or a host
+  // already configured for hostMode=network / a non-default port) keeps its
+  // endpoint without a unit rewrite. Baking endpoint values here is what
+  // silently re-pinned custom-configured hosts back to the values current at
+  // install time. scripts/install.sh writes the same shape — the two paths
+  // must produce the identical running daemon (see the installer parity test).
+  // `params.host`/`params.port` remain inputs because the migration engine
+  // still needs them for its read-only port-liveness probe.
   const definition: ManagedServiceDefinition = {
     name: MANAGED_SERVICE_NAME,
     description: MANAGED_SERVICE_DESCRIPTION,
     workingDirectory,
     command: params.binaryPath,
-    args: ['--daemon-home', params.homeDir, '--hostname', params.host, '--port', String(params.port)],
+    args: ['--daemon-home', params.homeDir],
     env: {},
     restartOnFailure: true,
   };
@@ -217,8 +227,7 @@ export function detectLegacyUnit(input: DetectLegacyUnitInput): LegacyUnitInfo {
   const path = legacyUnitPath(input.homeDir);
   const fileExists = input.legacyUnitFileExists ?? existsSync;
   if (!fileExists(path)) return { present: false, active: false, path };
-  const run: ManagedServiceActionRunner = input.actionRunner
-    ?? ((command, args) => spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8' }) as ManagedServiceActionResult);
+  const run: ManagedServiceActionRunner = input.actionRunner ?? defaultActionRunner(SYSTEMCTL_TIMEOUT_MS);
   const result = run('systemctl', ['--user', 'is-active', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const state = (result.stdout ?? '').trim();
   const active = (result.status ?? 1) === 0 && state === 'active';
@@ -270,6 +279,30 @@ export function legacyUnitNote(legacy: LegacyUnitInfo, trackedServiceName: strin
   );
 }
 
+/**
+ * Hard ceiling on every systemctl invocation made through a DEFAULT action
+ * runner in this module. The reconcile below runs on the daemon's own startup
+ * path, and `spawnSync` without a timeout blocks the single JS event loop for
+ * as long as the child runs — a wedged user D-Bus (a real incident class on
+ * this host) would freeze an already-listening daemon indefinitely. A timed-out
+ * call reports `status: null`, which every status check in this module treats
+ * as failure, so a wedge degrades to an honest refusal instead of a hang.
+ */
+export const SYSTEMCTL_TIMEOUT_MS = 5_000;
+
+export function defaultActionRunner(timeoutMs: number): ManagedServiceActionRunner {
+  return (command, args) =>
+    spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8', timeout: timeoutMs }) as ManagedServiceActionResult;
+}
+
+/** Parse a `systemctl show -p MainPID --value` reply: a positive integer pid, or undefined when absent/unparseable/0. */
+export function parseMainPid(result: { status?: number | null; stdout?: string | null | undefined }): number | undefined {
+  if ((result.status ?? 1) !== 0) return undefined;
+  const parsed = Number.parseInt((result.stdout ?? '').trim(), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+
 /**
  * Read-only, best-effort TCP connect probe used ONLY by the legacy-absent
  * branch to tell "nothing is listening on this port" apart from "an
@@ -490,8 +523,7 @@ export async function runLegacyDaemonMigration(
   }
 
   // New unit verified healthy — now, and only now, retire the legacy unit.
-  const run: ManagedServiceActionRunner = params.actionRunner
-    ?? ((command, args) => spawnSync(command, args, { stdio: 'pipe', encoding: 'utf-8' }) as ManagedServiceActionResult);
+  const run: ManagedServiceActionRunner = params.actionRunner ?? defaultActionRunner(SYSTEMCTL_TIMEOUT_MS);
   const stopResult = run('systemctl', ['--user', 'stop', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const disableResult = run('systemctl', ['--user', 'disable', `${LEGACY_SERVICE_UNIT_NAME}.service`]);
   const removeFile = params.legacyUnitFileRemove ?? ((path: string) => rmSync(path, { force: true }));