@pellux/goodvibes-tui 1.7.0 → 1.9.1

package/src/runtime/bootstrap.ts

@@ -36,12 +36,16 @@ 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';
@@ -183,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 {
@@ -192,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.
@@ -262,6 +274,7 @@ export async function bootstrapRuntime(
     runtimeBus,
     runtimeStore: store,
     services,
+    sessionSpine,
     conversation,
     runtime,
     orchestrator,
@@ -287,6 +300,25 @@ 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;
@@ -343,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;
@@ -355,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),
     };
   };
 
@@ -413,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,
@@ -423,6 +528,7 @@ export async function bootstrapRuntime(
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
+      syncSessionSpineToHostStatus(externalServices.daemonStatus, companionTokenRecord.token);
       requestRender();
       return inspectExternalServices();
     },
@@ -461,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
@@ -486,6 +592,7 @@ export async function bootstrapRuntime(
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
+      syncSessionSpineToHostStatus(externalServices.daemonStatus, companionTokenRecord.token);
       requestRender();
     },
     onError: (error) => {
@@ -630,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

@@ -38,7 +38,7 @@
 // ---------------------------------------------------------------------------
 
 import { join } from 'node:path';
-import { CodeIndexStore } from '@pellux/goodvibes-sdk/platform/state';
+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';
@@ -67,8 +67,26 @@ export interface CodeIndexServicesDeps {
   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/. */
@@ -108,5 +126,10 @@ export function createCodeIndexServices(deps: CodeIndexServicesDeps): CodeIndexS
   if (isCodeIndexAutoStartEnabled(deps.configManager)) {
     codeIndexStore.scheduleBuild();
   }
-  return { codeIndexStore };
+  const codeIndexReindexScheduler = new CodeIndexReindexScheduler({
+    target: codeIndexStore,
+    workingDirectory: deps.workingDirectory,
+    isEnabled: () => isCodeInjectionSettingEnabled(deps.configManager),
+  });
+  return { codeIndexStore, codeIndexReindexScheduler };
 }