@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/runtime/bootstrap.ts

@@ -36,12 +36,17 @@ import {
 import { scheduleBackgroundMcpDiscovery, startBackgroundProviderRegistration } from '@/runtime/index.ts';
 import { restoreSavedModel } from '@/runtime/index.ts';
 import { startExternalServices, type ExternalServicesHandle, type HostServiceStatus } from '@/runtime/index.ts';
-import { getOrCreateCompanionToken, pruneStaleOperatorTokens } from '@pellux/goodvibes-sdk/platform/pairing';
-import { workspaceOperatorTokenCandidates } from './operator-token-cleanup.ts';
+import { createHttpTransport } from '@/runtime/index.ts';
+import { foldLegacySpineStore, deriveSpineFooterStatus } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
+import { createTuiSpineTransport, type SpineSessionsClient } from './session-spine-transport.ts';
+import { pruneStaleOperatorTokens } from '@pellux/goodvibes-sdk/platform/pairing';
+import { resolveDaemonCompanionToken, workspaceOperatorTokenCandidates } from './operator-token-cleanup.ts';
 import type { UiRuntimeServices } from './ui-services.ts';
 import { createDeferredStartupCoordinator } from '@/runtime/index.ts';
 import { initializeBootstrapCore } from './bootstrap-core.ts';
 import { createBootstrapShell } from './bootstrap-shell.ts';
+import { announceResumeState } from './resume-notice.ts';
+import { buildSharedOrchestratorCoreServices } from './orchestrator-core-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { DaemonServer } from '@pellux/goodvibes-sdk/platform/daemon';
 import { HttpListener } from '@pellux/goodvibes-sdk/platform/daemon';
@@ -110,19 +115,15 @@ export type BootstrapContext = RuntimeContext & {
   /** Command registry used by InputHandler. main.ts needs this to wire input. */
   commandRegistry: import('../input/command-registry.ts').CommandRegistry;
   /**
-   * System message router instantiated at startup, wired to conversation and panel manager.
+   * System message router instantiated at startup, wired to conversation.
    *
    * @remarks
    * Route operational messages through this rather than calling
-   * conversation.addSystemMessage() directly so that low-priority messages
-   * stay out of the main conversation and go to the SystemMessagesPanel instead.
+   * conversation.addSystemMessage() directly so routing-target config
+   * (panel/conversation/both) and the forced-inline critical prefixes stay
+   * centralized in one place.
    */
   systemMessageRouter: SystemMessageRouter;
-  /**
-   * Wire the agent detail modal opener after InputHandler is constructed in main.ts.
-   * Call with `(id) => input.agentDetailModal.open(id)` once the InputHandler is ready.
-   */
-  setOpenAgentDetail: (fn: (agentId: string) => void) => void;
 };
 
 // ── Bootstrap function ────────────────────────────────────────────────────
@@ -186,6 +187,9 @@ export async function bootstrapRuntime(
     setRenderRequest,
     runtimeSessionIdRef,
     wrfcPersistence,
+    sessionSpine,
+    sessionInboundInputs,
+    sessionUnionCache,
   } = await initializeBootstrapCore(stdout, options, (limit) => controlPlaneRecentEventsRef.value(limit));
   const providerRegistry = services.providerRegistry;
   const {
@@ -195,6 +199,11 @@ export async function bootstrapRuntime(
     pluginManager,
   } = services;
 
+  // D4b: a liveness flip is only PAINTED once something calls requestRender();
+  // without this, the footer's spine segment sat correct-but-undrawn until
+  // incidental activity redrew it (minutes, during an idle stretch).
+  sessionUnionCache.setOnTransition(() => requestRender());
+
   // ── Phase 6: Orchestrator + AcpManager ───────────────────────────────────
 
   // Mutable function refs so main.ts can patch these after constructing the scroll/viewport state.
@@ -235,15 +244,11 @@ export async function bootstrapRuntime(
       logger.debug('companion handleUserInput safety catch', { error: String(err) });
     });
   };
+  // Shared payload (single source of truth, includes wo805's memoryRegistry —
+  // see orchestrator-core-services.ts) plus this site's cacheHitTracker.
   orchestrator.setCoreServices({
-    configManager,
-    providerRegistry,
+    ...buildSharedOrchestratorCoreServices({ services, configManager, providerRegistry }),
     cacheHitTracker: services.cacheHitTracker,
-    planManager: services.planManager,
-    adaptivePlanner: services.adaptivePlanner,
-    sessionMemoryStore: services.sessionMemoryStore,
-    sessionLineageTracker: services.sessionLineageTracker,
-    idempotencyStore: services.idempotencyStore,
   });
   conversation.setSessionLineageTracker(services.sessionLineageTracker);
 
@@ -269,6 +274,7 @@ export async function bootstrapRuntime(
     runtimeBus,
     runtimeStore: store,
     services,
+    sessionSpine,
     conversation,
     runtime,
     orchestrator,
@@ -294,10 +300,31 @@ export async function bootstrapRuntime(
   wrfcPersistence.rehydrate();
   const commandRegistry = shell.commandRegistry;
   const commandContext = shell.commandContext;
+  // Boot resume notice (UX-D item 1): after rehydrate() so chain history is
+  // ready, before the operator can type anything. Fire-and-forget — the
+  // checkpoint-count lookup is async (WorkspaceCheckpointManager.list() awaits
+  // its own init()), and this must not block the rest of bootstrap the way
+  // main.ts's `void workspaceCheckpointManager.init().catch(() => {})`
+  // deliberately doesn't either. Local file I/O only; resolves well before a
+  // human can react to the first rendered frame.
+  void announceResumeState({
+    workingDirectory: services.workingDirectory,
+    homeDirectory: services.homeDirectory,
+    surfaceRoot: 'tui',
+    sessionManager: services.sessionManager,
+    checkpointManager: services.workspaceCheckpointManager,
+    chainHistory: wrfcPersistence.knownChains,
+    memoryAvailable: Boolean(commandContext.clients?.knowledgeApi?.memory),
+    router: systemMessageRouter,
+  }).catch(() => {
+    // Best-effort — never let the resume notice block or crash boot.
+  });
   const gitStatusProvider = shell.gitStatusProvider;
   const inputHistory = shell.inputHistory;
   const lastGitInfoRef = shell.lastGitInfoRef;
-  const setOpenAgentDetail = shell.setOpenAgentDetail;
+  // W1.6 FIX 2: dispose the header's live-repo-state poll (git-status.ts
+  // startPolling) on shutdown, same pattern as acpTaskSyncInterval above.
+  bootstrapUnsubs.push(() => gitStatusProvider.stopPolling());
   const pluginCommandRegistry = {
     register(command: {
       readonly name: string;
@@ -348,7 +375,70 @@ export async function bootstrapRuntime(
 
   const hostServiceIsActive = (status: HostServiceStatus): boolean => status.mode === 'embedded' || status.mode === 'external';
 
-  const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked';
+  // 'blocked' (occupied by an unverified process) and 'incompatible' (occupied
+  // by a GoodVibes daemon we refused to adopt on a wire-version mismatch) both
+  // mean the configured port is held and unusable by this TUI instance.
+  const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked' || status.mode === 'incompatible';
+
+  // PERMANENT DESIGN (docs/decisions/2026-07-06-session-spine-mode-branch-is-permanent.md):
+  // 'embedded'/'external' are two distinct, both-supported daemon topologies, not
+  // migration stages — the ONE client-selection point for the session spine, driven by
+  // the SAME authoritative HostServiceMode adopt-or-start already computed above.
+  // 'embedded' (daemon.embedInProcess=true) means THIS process's own SharedSessionBroker
+  // already IS the daemon's broker — nothing to mirror TO, so the spine stays
+  // permanently dormant. Every other mode ('disabled'/'blocked'/'incompatible'/
+  // 'unavailable') also stays local-only and honest. Only 'external' (a separately-
+  // running daemon this TUI adopted) activates the wire mirror.
+  let spineActiveForBaseUrl: string | null = null;
+  const syncSessionSpineToHostStatus = (daemonStatus: HostServiceStatus, sharedDaemonToken: string): void => {
+    if (daemonStatus.mode !== 'external') {
+      if (spineActiveForBaseUrl !== null) {
+        sessionSpine.deactivate(`daemon mode changed to '${daemonStatus.mode}'`);
+        sessionInboundInputs.deactivate(`daemon mode changed to '${daemonStatus.mode}'`);
+        spineActiveForBaseUrl = null;
+      }
+      // Keep the read facade honest per topology (permanent, not staged): 'embedded'
+      // means this process's broker IS the daemon's broker (local reads are the whole
+      // truth); every other non-external mode is local-only/dormant.
+      if (daemonStatus.mode === 'embedded') sessionUnionCache.markEmbedded();
+      else sessionUnionCache.deactivate(`daemon mode '${daemonStatus.mode}'`);
+      logger.info(`[bootstrap] session spine: daemon mode '${daemonStatus.mode}' — local-only (no spine mirror)`);
+      return;
+    }
+    const baseUrl = daemonStatus.baseUrl;
+    if (spineActiveForBaseUrl === baseUrl) return; // already wired to this exact adopted daemon
+    const httpTransport = createHttpTransport({ baseUrl, authToken: sharedDaemonToken });
+    const sessionsClient: SpineSessionsClient = {
+      register: (input) => httpTransport.operator.sessions.register(input),
+      close: (sessionId) => httpTransport.operator.sessions.close(sessionId),
+    };
+    sessionSpine.activate(createTuiSpineTransport(sessionsClient));
+    // D3: adopt the same daemon's wire for the INBOUND steer path — collect
+    // steer/follow-up inputs another live surface queued for this session and
+    // inject them into the turn machinery (acking delivery on the wire).
+    sessionInboundInputs.activate({
+      listInputs: async (sessionId, opts) => ({
+        inputs: await httpTransport.operator.sessions.inputs(sessionId, opts.limit, { state: opts.state, since: opts.since }),
+      }),
+      deliverInput: (sessionId, inputId, opts) => httpTransport.operator.sessions.deliverInput(sessionId, inputId, opts),
+    });
+    // 'external' only: adopt the same daemon's wire as the read facade's cross-surface
+    // union source (interval-refreshed; served synchronously to panels).
+    sessionUnionCache.activate({ list: (limit) => httpTransport.operator.sessions.list(limit) });
+    spineActiveForBaseUrl = baseUrl;
+    logger.info(`[bootstrap] session spine: adopted external daemon at ${baseUrl} — mirroring session identity`);
+    // Legacy fold: one-time (marker-guarded) import of this project's own
+    // pre-spine control-plane sessions.json into the now-adopted daemon.
+    const legacyStorePath = services.shellPaths.resolveProjectPath('tui', 'control-plane', 'sessions.json');
+    const fold = foldLegacySpineStore(sessionSpine, {
+      storePath: legacyStorePath,
+      markerPath: `${legacyStorePath}.spine-migrated`,
+      project: services.workingDirectory,
+    });
+    if (fold.folded > 0) {
+      logger.info(`[bootstrap] session spine: folded ${fold.folded} legacy local session(s) into the adopted daemon`);
+    }
+  };
 
   const inspectExternalServices = () => {
     const daemonStatus = externalServices.daemonStatus;
@@ -360,6 +450,16 @@ export async function bootstrapRuntime(
       httpListenerPortInUse: hostServiceIsBlocked(httpListenerStatus),
       daemonStatus,
       httpListenerStatus,
+      // Honest session-spine posture, independent of daemonRunning —
+      // 'external'-adopted-but-currently-unreachable degrades to 'offline' here
+      // even though daemonRunning might still read true from a stale handle.
+      // D4: sessionSpine.status() alone is ACTIVITY-gated (only updates on a
+      // register/heartbeat/close), so after the daemon dies mid-idle it would
+      // keep reading 'online'. Derive the footer status from the union cache's
+      // 5s liveness probe too — one signal, no new timer — so offline surfaces
+      // within one refresh interval of the daemon dying.
+      sessionSpineActive: sessionSpine.active,
+      sessionSpineStatus: deriveSpineFooterStatus(sessionSpine.status(), sessionUnionCache.crossSurfaceView),
     };
   };
 
@@ -418,7 +518,7 @@ export async function bootstrapRuntime(
       await waitForConfigDrivenRestarts(externalServices);
       await externalServices.stop();
       const daemonHomeDir = join(services.homeDirectory, '.goodvibes', 'daemon');
-      const companionTokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
+      const companionTokenRecord = resolveDaemonCompanionToken(daemonHomeDir);
       externalServicesPromise = startExternalServices(
         configManager,
         runtimeBus,
@@ -428,6 +528,7 @@ export async function bootstrapRuntime(
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
+      syncSessionSpineToHostStatus(externalServices.daemonStatus, companionTokenRecord.token);
       requestRender();
       return inspectExternalServices();
     },
@@ -466,7 +567,7 @@ export async function bootstrapRuntime(
       // bearer, so tokens scanned from the /qrcode panel's QR actually
       // authenticate against the embedded daemon this surface starts.
       const daemonHomeDir = join(services.homeDirectory, '.goodvibes', 'daemon');
-      const companionTokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
+      const companionTokenRecord = resolveDaemonCompanionToken(daemonHomeDir);
       // F3 resolution (TUI 0.19.20): remove stale pre-0.21.28 workspace-scoped operator
       // token files so only the canonical <daemonHomeDir>/operator-tokens.json survives.
       // The prune is best-effort — it silently skips missing files, no-ops when tokens
@@ -491,6 +592,7 @@ export async function bootstrapRuntime(
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
+      syncSessionSpineToHostStatus(externalServices.daemonStatus, companionTokenRecord.token);
       requestRender();
     },
     onError: (error) => {
@@ -628,7 +730,6 @@ export async function bootstrapRuntime(
     _getConfiguredProviderIds: () => services.providerRegistry.getConfiguredProviderIds(),
     commandRegistry,
     systemMessageRouter,
-    setOpenAgentDetail,
     shutdown: async (sessionData) => {
       // Clear bootstrap-owned subscriptions
       bootstrapUnsubs.forEach(fn => fn());
@@ -636,6 +737,12 @@ export async function bootstrapRuntime(
       runtimeUnsubs.forEach((fn) => fn());
       runtimeUnsubs.length = 0;
       forensicsCollector.dispose();
+      // Honest close on exit — fire-and-forget (never blocks shutdown);
+      // a no-op when the spine was never activated (embedded/local-only topology).
+      sessionSpine.close(runtime.sessionId);
+      sessionSpine.dispose();
+      sessionInboundInputs.dispose(); // D3: stop the inbound steer poll interval on exit
+      sessionUnionCache.dispose(); // stop the wire-refresh interval on exit
       await deferredStartup.drain(100);
       if (externalServicesPromise) {
         try {

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

@@ -0,0 +1,135 @@
+// ---------------------------------------------------------------------------
+// code-index-services.ts — Wave 5 (wo804, W5.3 Stage A TUI wiring)
+//
+// Constructs the TUI's repo source-tree code index: CodeIndexStore
+// (@pellux/goodvibes-sdk/platform/state, landed on SDK main as wo802/W5.3
+// Stage A). Extracted into its own module rather than built inline in
+// services.ts: services.ts sits at the architecture check's 800-line cap
+// (scripts/check-architecture.ts), so any new service gets its own
+// construction module and a single wiring call there (mirrors
+// createWorkstreamServices's one-function-bundle shape).
+//
+// Schema-initialized eagerly (mirrors memoryStore: construction + init()
+// happen unconditionally so the store is queryable — /codebase status, the
+// fleet node — even before any build has ever run). The actual walk/chunk/
+// embed build is NEVER auto-triggered by default: the hundreds of existing
+// test fixtures (and every headless invocation) construct RuntimeServices
+// without asking for a full source-tree walk, and init() alone never runs
+// one (mirrors the SDK's own RuntimeServices wiring in
+// platform/runtime/services.ts, which gates its equivalent scheduleBuild()
+// call behind an explicit autoStartCodeIndex option).
+//
+// REALITY-WINS DIVERGENCE from the SDK's own shape: the SDK's
+// RuntimeServicesOptions exposes autoStartCodeIndex as a constructor-time
+// boolean because that call site is a library entrypoint threaded by each
+// embedder. This TUI's createRuntimeServices has no such per-call knob —
+// auto-start is decided from a TUI-local config key instead
+// (CODE_INDEX_ENABLED_CONFIG_KEY, default OFF), so every construction path
+// (interactive main.ts, the daemon, and every test fixture) shares one
+// honest, user-visible on/off switch rather than needing to thread a new
+// boolean through every call site. With it off (the default), `/codebase
+// build` is the explicit, visible trigger — exactly the shape wo804's brief
+// asks for.
+//
+// Shares memoryEmbeddingRegistry with MemoryStore (constructed in
+// services.ts) so code + memory retrieval use one embedding provider and one
+// dimensionality, per the SDK design doc (code-index-store.ts's constructor
+// takes the SAME MemoryEmbeddingProviderRegistry instance memory uses).
+// ---------------------------------------------------------------------------
+
+import { join } from 'node:path';
+import { CodeIndexStore, CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryEmbeddingProviderRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { ConfigKey, ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { readBooleanConfig } from '../core/alert-gating.ts';
+
+/**
+ * TUI-local synthetic config key (not yet in the SDK's ConfigKey union) that
+ * gates the code index's auto-build on construction. Default OFF — see this
+ * module's header doc. Surfaced in /config via a synthetic entry
+ * (settings-modal-data.ts) exactly like behavior.notifyAfterSeconds.
+ */
+export const CODE_INDEX_ENABLED_CONFIG_KEY = 'storage.codeIndexEnabled';
+
+/**
+ * Honest, generous bounds passed EXPLICITLY to CodeIndexStore (values equal
+ * to its own internal defaults) so /codebase status and the settings
+ * description can state them in one place without reaching into store
+ * internals or duplicating magic numbers.
+ */
+export const CODE_INDEX_MAX_FILES = 5000;
+export const CODE_INDEX_MAX_FILE_BYTES = 512 * 1024;
+export const CODE_INDEX_MAX_TOTAL_BYTES = 256 * 1024 * 1024;
+
+export interface CodeIndexServicesDeps {
+  readonly workingDirectory: string;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry;
+}
+
+/**
+ * Whether Stage B code auto-injection / tool-site reindex may run: the SAME
+ * storage.codeIndexEnabled switch that gates auto-build. Read live so a runtime
+ * /config toggle takes effect without restart. (The separate, default-off
+ * `agent-passive-code-injection` feature flag gates injection additionally; this
+ * is only the storage-side setting the SDK asks embedders to respect.)
+ */
+export function isCodeInjectionSettingEnabled(configManager: Pick<ConfigManager, 'get'>): boolean {
+  return isCodeIndexAutoStartEnabled(configManager);
+}
+
+export interface CodeIndexServices {
+  readonly codeIndexStore: CodeIndexStore;
+  /**
+   * Wave-5 Stage B tool-site incremental reindex scheduler, bound to codeIndexStore and
+   * gated live on storage.codeIndexEnabled. Threaded into both SDK orchestrators (main +
+   * agent) so a successful write/edit debounces an incremental reindex, and into the command
+   * context so /codebase status can report the last reindex activity honestly.
+   */
+  readonly codeIndexReindexScheduler: CodeIndexReindexScheduler;
+}
+
+/** Absolute path to the TUI's code-index sqlite file, sibling to memory.sqlite under .goodvibes/tui/. */
+export function codeIndexDbPath(workingDirectory: string): string {
+  return join(workingDirectory, '.goodvibes', 'tui', 'code-index.sqlite');
+}
+
+/**
+ * Whether the code index's initial build should auto-start on construction.
+ * Exported so /codebase status and the settings modal read the exact same
+ * config key + default this module decides auto-start from.
+ */
+export function isCodeIndexAutoStartEnabled(configManager: Pick<ConfigManager, 'get'>): boolean {
+  return readBooleanConfig(
+    (key) => configManager.get(key as ConfigKey),
+    CODE_INDEX_ENABLED_CONFIG_KEY,
+    false,
+  );
+}
+
+/**
+ * Constructs the TUI's CodeIndexStore. Schema-init runs unconditionally
+ * (init() never throws — it degrades to an honest `available: false` +
+ * recorded error on failure, mirrored by CodeIndexStats/describeDegradation);
+ * the initial full build only fires when isCodeIndexAutoStartEnabled() is
+ * true, via the SAME fire-and-forget scheduleBuild() an explicit
+ * `/codebase build` invocation uses.
+ */
+export function createCodeIndexServices(deps: CodeIndexServicesDeps): CodeIndexServices {
+  const codeIndexStore = new CodeIndexStore(
+    deps.workingDirectory,
+    codeIndexDbPath(deps.workingDirectory),
+    deps.memoryEmbeddingRegistry,
+    { maxFiles: CODE_INDEX_MAX_FILES, maxFileBytes: CODE_INDEX_MAX_FILE_BYTES, maxTotalBytes: CODE_INDEX_MAX_TOTAL_BYTES },
+  );
+  codeIndexStore.init();
+  if (isCodeIndexAutoStartEnabled(deps.configManager)) {
+    codeIndexStore.scheduleBuild();
+  }
+  const codeIndexReindexScheduler = new CodeIndexReindexScheduler({
+    target: codeIndexStore,
+    workingDirectory: deps.workingDirectory,
+    isEnabled: () => isCodeInjectionSettingEnabled(deps.configManager),
+  });
+  return { codeIndexStore, codeIndexReindexScheduler };
+}