@pellux/goodvibes-tui 1.17.0 → 1.19.0

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

@@ -18,6 +18,7 @@ export type SettingsCategory =
   | 'tools'
   | 'helper'
   | 'tts'
+  | 'voice'
   | 'service'
   | 'daemon'
   | 'controlPlane'
@@ -46,6 +47,8 @@ export type SettingsCategory =
   | 'notifications'
   | 'release'
   | 'update'
+  | 'power'
+  | 'memory'
   | 'danger';
 
 export type SettingsFocusPane = 'categories' | 'settings';
@@ -55,11 +58,11 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
   readonly categories: readonly SettingsCategory[];
 }> = [
   { label: 'Interface', categories: ['display', 'ui', 'behavior', 'notifications', 'permissions', 'policy', 'security'] },
-  { label: 'AI Routing', categories: ['provider', 'pricing', 'subscriptions', 'helper', 'tools', 'tts'] },
+  { label: 'AI Routing', categories: ['provider', 'pricing', 'subscriptions', 'helper', 'tools', 'tts', 'voice'] },
   { label: 'Service & Network', categories: ['service', 'daemon', 'network', 'controlPlane', 'httpListener', 'web', 'relay'] },
   { label: 'Surfaces & Cloud', categories: ['surfaces', 'integrations', 'mcp', 'cloudflare'] },
   { label: 'Automation', categories: ['batch', 'automation', 'checkin', 'watchers', 'orchestration', 'planner', 'wrfc'] },
-  { label: 'Runtime & Data', categories: ['storage', 'atRest', 'sandbox', 'fetch', 'agents', 'runtime', 'cache', 'telemetry', 'diagnostics', 'learning'] },
+  { label: 'Runtime & Data', categories: ['storage', 'atRest', 'sandbox', 'fetch', 'agents', 'runtime', 'power', 'memory', 'cache', 'telemetry', 'diagnostics', 'learning'] },
   { label: 'Advanced', categories: ['release', 'update', 'danger'] },
 ];
 

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/main.ts

@@ -39,10 +39,10 @@ import { createSessionContinuityHintsBuilder } from './runtime/session-continuit
 import { resolveWebSurfaceUrl } from '@pellux/goodvibes-sdk/platform/runtime/feature-announcements';
 import { readLastSessionPointer, writeRecoveryFile } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
-import { createPersistRecoverySnapshot, createRecoveryFileOps, createReopenRecoveryPanels, handleErrorAffordanceKey, resolveStartupRecoveryInfo } from './shell/recovery-input-helpers.ts';
+import { autoRestoreRecoverySession, createPersistRecoverySnapshot, createReopenRecoveryPanels, handleErrorAffordanceKey } from './shell/recovery-input-helpers.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
-import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
+import { buildPersistedSessionContext, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState } from './cli/tui-startup.ts';
@@ -57,7 +57,7 @@ import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
 import { footerFleetCost } from './panels/fleet-read-model.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
-import { wireStreamEventMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
+import { wireStreamEventMetrics, createStreamMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { buildContextStatusHint } from './renderer/context-status-hint.ts';
 import { isEffectiveDangerMode } from './config/index.ts';
@@ -67,6 +67,9 @@ import { createSessionAutoTitler } from './core/session-auto-titler.ts';
 import { makeComposerEditorOpener } from './input/composer-editor.ts';
 import { evaluateSessionMaintenance } from '@/runtime/index.ts';
 import { createCancelGeneration } from './core/turn-cancellation.ts';
+import { wireInteractionSeams, createMemoryProvenanceUi } from './runtime/interaction-seams.ts';
+import { createPowerChipSource } from './core/power-chip-source.ts';
+import { fetchDaemonPowerState, installKeepAwakeRemoteForward } from './runtime/power-keepawake-remote.ts';
 import { wrapRequestPermissionWithAlert } from './core/approval-alert.ts';
 import { createTerminalNotifier } from './core/terminal-notifier.ts';
 import { setPanelFrameRequester } from './panels/base-panel.ts';
@@ -160,17 +163,7 @@ async function main() {
   // Cached from the overlay-aware clamp the renderer computes (conversation-layout) each frame so scroll() clamps against exactly what is displayed, not a footer estimate.
   let lastMaxScroll: number | null = null;
   // Stream and tool-timer state; mutated by wireStreamEventMetrics handlers, read during render.
-  const streamMetrics: StreamMetrics = {
-    startTime: 0,
-    deltaCount: 0,
-    tokenSpeed: 0,
-    ttftMs: undefined,
-    ttftRecorded: false,
-    activeToolStartedAtMs: undefined,
-    activeToolName: undefined,
-    lastDeltaAtMs: undefined, stallEpisode: 0,
-    reconnectAttempt: undefined, reconnectMaxAttempts: undefined,
-  };
+  const streamMetrics: StreamMetrics = createStreamMetrics();
 
   const getPromptContentWidth = () => computePromptContentWidth(stdout.columns);
 
@@ -203,9 +196,13 @@ async function main() {
   const unsubs: Array<() => void> = [];
   let recoveryInterval: ReturnType<typeof setInterval> | null = null;
   let stopSpokenOutputForExit: (() => Promise<void>) | null = null;
-  let recoveryPending = false;
-  // Which file the current recovery prompt should load/delete from (see recovery-input-helpers.ts).
-  let recoverySource: 'live' | 'preserved' = 'live';
+  // The optional "used N memories" provenance chip (default OFF) — see interaction-seams.ts.
+  const memoryProvenanceUi = createMemoryProvenanceUi({ render: () => render(), memorySpine: ctx.services.memorySpine });
+  // Topology-aware keep-awake: the chip renders the DAEMON's state in adopted-external mode (power-chip-source.ts) and every toggle is forwarded to that daemon (power-keepawake-remote.ts) so keep-awake survives the TUI closing in BOTH topologies.
+  const isExternalDaemon = () => uiServices.platform.externalServices?.inspect()?.daemonStatus?.mode === 'external';
+  const powerChipSource = createPowerChipSource({ powerManager: ctx.services.powerManager, render: () => render(), isExternalDaemon,
+    onPowerEvent: (cb) => uiServices.events.ops.on('OPS_POWER_STATE_CHANGED', cb as never), fetchDaemonPowerState: () => fetchDaemonPowerState({ configManager, homeDirectory, isExternalDaemon }) });
+  unsubs.push(powerChipSource.stop, installKeepAwakeRemoteForward({ configManager, homeDirectory, isExternalDaemon }));
 
   const lifecycle = installProcessLifecycle({
     stdin,
@@ -329,6 +326,10 @@ async function main() {
   // Late-patched: bootstrap.ts populates uiServices.platform.externalServices AFTER commandContext is built.
   commandContext.platform.externalServices = uiServices.platform.externalServices;
   commandContext.cancelGeneration = cancelGeneration;
+  wireInteractionSeams(commandContext, {
+    orchestrator, powerManager: ctx.services.powerManager, readPowerSurface: () => powerChipSource.get(), render: () => render(), notify: (m) => systemMessageRouter.high(m),
+    getActiveToolCallId: () => streamMetrics.activeToolCallId, toggleMemoryProvenance: () => memoryProvenanceUi.toggle(),
+  });
   commandContext.isGenerating = () => orchestrator.isThinking;
   commandContext.jumpToBookmark = jumpToBookmark; commandContext.scrollToLine = scrollToLine;
   commandContext.clearScreen = () => {
@@ -373,7 +374,7 @@ async function main() {
         surfaceRegistry: ctx.services.surfaceRegistry,
         subscriptionManager: ctx.services.subscriptionManager,
         secretsManager: ctx.services.secretsManager,
-        tokenAuditor: ctx.services.tokenAuditor,
+        pairingTokens: ctx.services.pairingTokens, tokenAuditor: ctx.services.tokenAuditor,
         replayEngine: ctx.services.replayEngine,
         webhookNotifier: ctx.services.webhookNotifier,
         policyRuntimeState: ctx.services.policyRuntimeState,
@@ -496,6 +497,8 @@ async function main() {
       // Cross-surface spine posture segment (adopted-daemon mode only).
       sessionSpineStatus: (() => { const s = uiServices.platform.externalServices?.inspect(); return s?.sessionSpineActive && s.sessionSpineStatus && s.sessionSpineStatus !== 'unknown' ? s.sessionSpineStatus : undefined; })(), runningAgentCount, runningProcessCount,
       webSurfaceUrl: configManager.get('web.enabled') ? resolveWebSurfaceUrl(configManager) : undefined,
+      // Always-visible "sleep disabled" chip — topology-aware: the DAEMON's state in adopted-external mode, the in-process manager otherwise (power-chip-source.ts).
+      powerKeepAwake: powerChipSource.get().keepAwake,
       // Composer must not read as focused while the panel/process indicator owns keyboard focus.
       promptFocused: !input.panelFocused && !input.indicatorFocused,
       indicatorFocused: input.indicatorFocused,
@@ -586,7 +589,7 @@ async function main() {
       viewport.push(...thinking);
       // Live tool timer: render the currently executing tool row with ticking elapsed.
       if (streamMetrics.activeToolName !== undefined && streamMetrics.activeToolStartedAtMs !== undefined) {
-        const liveToolCall = { id: 'live', name: streamMetrics.activeToolName, arguments: {} };
+        const liveToolCall = { id: streamMetrics.activeToolCallId ?? 'live', name: streamMetrics.activeToolName, arguments: {} };
         viewport.push(...renderToolCallBlock(liveToolCall, 'executing', undefined, conversationWidth, undefined, undefined, undefined, streamMetrics.activeToolStartedAtMs));
       }
     }
@@ -595,9 +598,8 @@ async function main() {
       viewport.push(...PermissionPromptUI.createPromptLines(conversationWidth, pendingPermission, pendingPermission.hunkState, pendingPermission.detailsExpanded, pendingPermission.requestedBy, PermissionPromptUI.promptViewState(pendingPermission, conversationWidth, approvalBroker)));
     }
 
-    orchestrator.messageQueue.forEach(msg => {
-      viewport.push(...UIFactory.createQueuedMessageFragment(conversationWidth, msg.text));
-    });
+    viewport.push(...UIFactory.createQueuedMessageList(conversationWidth, orchestrator.listQueuedMessages()));
+    viewport.push(...memoryProvenanceUi.renderChip(conversationWidth, configManager));
 
     viewport = applyConversationOverlays(viewport, {
       input,
@@ -686,6 +688,8 @@ async function main() {
   });
   unsubs.push(...turnUnsubs);
 
+  unsubs.push(uiServices.events.turns.on('TURN_COMPLETED', (evt) => memoryProvenanceUi.onTurnCompleted(evt)));
+
   // Stable turn context for failover retry — set in submitInput, read by retryTurn.
   let retryCtx: { count: number; text: string; content?: ContentPart[]; opts?: Parameters<typeof orchestrator.handleUserInput>[2] } | null = null;
   // One-key retry affordance, active right after a user-visible TURN_ERROR: 'r' re-submits on the
@@ -735,15 +739,10 @@ async function main() {
   stdin.on('data', (raw: string) => {
     const data = themeProbe.filterInput(raw); if (data.length === 0) return;
     const blocking = handleBlockingShellInput({
-      data, pendingPermission, recoveryPending, conversation, systemMessageRouter, render,
+      data, pendingPermission, render,
       abortTurn: () => orchestrator.abort(),
-      ...createRecoveryFileOps(() => recoverySource, { homeDirectory }),
-      homeDirectory, sessionId: runtime.sessionId,
-      persistSnapshot: createPersistRecoverySnapshot({ sessionManager: ctx.services.sessionManager, runtime, conversation }),
-      reopenPanels: createReopenRecoveryPanels({ panelManager, render }),
     });
     pendingPermission = blocking.pendingPermission;
-    recoveryPending = blocking.recoveryPending;
     if (blocking.handled) {
       return;
     }
@@ -765,26 +764,27 @@ async function main() {
   process.on('unhandledRejection', unhandledRejectionHandler);
   stdout.on('resize', resizeHandler);
 
+  // --- Silent crash-recovery restore (no prompt/banner) ---
+  // Restore the newest crash snapshot in place, replay any post-snapshot
+  // journal turns, reopen its panels, and emit a single one-line receipt. The
+  // SDK scopes both the load and the follow-up delete to that snapshot's own
+  // session id, so a concurrent session's snapshot is never touched. Runs
+  // before the initial render so the restored content shows immediately.
+  autoRestoreRecoverySession({
+    workingDirectory: workingDir,
+    homeDirectory,
+    conversation,
+    persistSnapshot: createPersistRecoverySnapshot({ sessionManager: ctx.services.sessionManager, runtime, conversation }),
+    reopenPanels: createReopenRecoveryPanels({ panelManager, render }),
+    systemMessageRouter,
+  });
+
   // Initial render
   conversation.rebuildHistory();
   render();
 
-  // --- Crash recovery check (also checks the preserve-on-dismiss sibling; see recovery-input-helpers.ts) ---
-  const recoveryInfo = resolveStartupRecoveryInfo({ workingDirectory: workingDir, homeDirectory });
-  if (recoveryInfo) {
-    recoverySource = recoveryInfo.source;
-    systemMessageRouter.high(`[Recovery] Found unsaved session from ${new Date(recoveryInfo.timestamp).toLocaleString()}. Title: "${recoveryInfo.title}". Press Ctrl+R to restore, Esc to discard, or start typing to ignore it.`);
-    for (const line of formatReturnContextForDisplay(recoveryInfo.returnContext)) {
-      systemMessageRouter.low(`[Recovery] ${line}`);
-    }
-    render();
-    recoveryPending = true;
-  }
-
   // --- Auto-save to recovery file every 60s ---
   recoveryInterval = setInterval(() => {
-    // Skip while an earlier recovery prompt is unresolved (avoids racing preserve-on-dismiss).
-    if (recoveryPending) return;
     const snapshot = conversation.toJSON() as { messages: Array<import('./core/conversation.ts').ConversationMessageSnapshot> };
     const persisted = buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints());
     writeRecoveryFile(

package/src/panels/builtin/operations.ts

@@ -1,6 +1,10 @@
 import type { PanelManager } from '../panel-manager.ts';
 import { FleetPanel } from '../fleet-panel.ts';
 import { createFleetReadModel } from '../fleet-read-model.ts';
+import { FleetActs, type FleetDiffSurface } from '../fleet-acts.ts';
+import { createFleetGateway } from '../fleet-gateway.ts';
+import { FleetSpawn, createAcpSpawnGateway } from '../fleet-spawn.ts';
+import { DiffPanel } from '../diff-panel.ts';
 import { LocalAuthPanel } from '../local-auth-panel.ts';
 import { NotificationsPanel } from '../notifications-panel.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
@@ -43,6 +47,55 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
   // to the honest COMMUNICATION_CONSUMED steer-ack signal (fleet-read-model.ts).
   const fleetReadModel = createFleetReadModel(ui.runtime.processRegistry, ui.runtime.runtimeBus);
 
+  // The Fleet panel's waiting-on-human acts (pick / conflict / discard) drive
+  // gateway verbs over the same operator invoke path the command layer uses, and
+  // reuse the shared DiffPanel (candidate diffs + the pick confirm overlay) and
+  // the CI fix-session jump affordance. Built here so the panel stays thin.
+  const fleetNotify = deps.fleetActsNotify ?? (() => {});
+  const armFixSessionAttach = deps.armFixSessionAttach ?? (() => {});
+  const diffSurface: FleetDiffSurface = {
+    show: (_title, unifiedDiff) => {
+      let panel = manager.getAllOpen().find((p) => p.id === 'diff');
+      if (!panel) { try { panel = manager.open('diff'); } catch { return; } }
+      manager.activateById('diff');
+      if (!manager.isVisible()) manager.show();
+      manager.focusPanels();
+      (panel as DiffPanel).loadRawDiff(unifiedDiff);
+    },
+    armConfirm: (opts) => {
+      let panel = manager.getAllOpen().find((p) => p.id === 'diff');
+      if (!panel) { try { panel = manager.open('diff'); } catch { return; } }
+      manager.activateById('diff');
+      if (!manager.isVisible()) manager.show();
+      manager.focusPanels();
+      (panel as DiffPanel).confirmOverlay.arm(opts);
+    },
+    close: () => { manager.close('diff'); },
+  };
+  const fleetActs = new FleetActs({
+    resolveGateway: () => createFleetGateway({
+      configManager: deps.configManager,
+      homeDirectory: ui.environment.shellPaths.homeDirectory,
+      armFixSessionAttach,
+    }),
+    diffSurface,
+    notify: fleetNotify,
+    markDirty: deps.requestRender ?? (() => {}),
+    findNode: (nodeId: string) => fleetReadModel.getSnapshot().rows.find((r) => r.node.id === nodeId)?.node ?? null,
+  });
+
+  // The ACP spawn affordance ('n'): host a discovered third-party agent as an
+  // acp-agent row over the same operator invoke path the acts use.
+  const fleetSpawn = new FleetSpawn({
+    resolveGateway: () => createAcpSpawnGateway({
+      configManager: deps.configManager,
+      homeDirectory: ui.environment.shellPaths.homeDirectory,
+    }),
+    currentDirectory: () => ui.environment.shellPaths.workingDirectory,
+    notify: fleetNotify,
+    markDirty: deps.requestRender ?? (() => {}),
+  });
+
   manager.registerType({
     id: 'fleet',
     name: 'Fleet',
@@ -63,7 +116,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
       resolveSessionLogPath: (agentId: string) => ui.environment.shellPaths.resolveProjectPath('tui', 'sessions', `${agentId}.jsonl`),
       // Queue a message for a live in-process agent/wrfc-subtask member.
       steer: (id: string, text: string) => fleetReadModel.steer(id, text),
-    }, deps.configManager),
+    }, deps.configManager, fleetActs, fleetSpawn),
   });
 
   // Compat: '/panel open <id>' (and any saved layout/muscle memory) for

package/src/panels/builtin/shared.ts

@@ -150,6 +150,18 @@ export interface BuiltinPanelDeps {
    * cross-panel navigation instead of printing a "/panel open …" signpost.
    */
   openPanel?: (panelId: string) => void;
+  /**
+   * Surface a Fleet act result/receipt/error to the operator (late-bound to the
+   * command context's print, which the Fleet pick/conflict/discard acts use for
+   * their receipts — the same conversation sink the command flow prints to).
+   */
+  fleetActsNotify?: (message: string) => void;
+  /**
+   * Hand a spawned session id to the shared one-key jump/attach affordance (the
+   * CI fix-session machinery). Late-bound: main.ts patches it onto the command
+   * context after bootstrap; the Fleet conflict-resolve act reuses it verbatim.
+   */
+  armFixSessionAttach?: (sessionId: string) => void;
 }
 
 export type ResolvedBuiltinPanelDeps = Omit<

package/src/panels/builtin-modals.ts

@@ -1,12 +1,12 @@
-import { networkInterfaces } from 'node:os';
-import { readFileSync } from 'node:fs';
 import type { PanelManager } from './panel-manager.ts';
 import { requireUiServices, type ResolvedBuiltinPanelDeps } from './builtin/shared.ts';
 import type { ConfigModalSurface, ConfigModalView } from '../input/config-modal-types.ts';
 import { createProviderRuntimeInspectionQuery } from '../runtime/ui-service-queries.ts';
 import { createRuntimeProviderApi } from '@/runtime/index.ts';
 import { copyToClipboard } from '../utils/clipboard.ts';
-import { getOrCreateCompanionToken, buildCompanionConnectionInfo } from '@pellux/goodvibes-sdk/platform/pairing';
+import { ensurePublicBaseUrl } from '../core/pairing-origin.ts';
+import { availablePairingOffers, mintPairingHandoff, defaultPairingTokenName } from '../core/pairing-handoff.ts';
+import { probePairingTailscale, runPairingTailscaleServe } from '../core/pairing-tailscale-gateway.ts';
 // ── Providers & Connectivity + Security subset ────────────────────────────────
 import { createServicesModalSurface } from './modals/services-modal.ts';
 import { createSubscriptionModalSurface } from './modals/subscription-modal.ts';
@@ -24,9 +24,11 @@ import { createSecurityModalSurface } from './modals/security-modal.ts';
 import { createPolicyModalSurface } from './modals/policy-modal.ts';
 import { createKnowledgeModalSurface } from './modals/knowledge-modal.ts';
 import { createMemoryModalSurface, type MemoryModalDeps } from './modals/memory-modal.ts';
+import { createMemoryConsolidationGateway } from './memory-consolidation-gateway.ts';
 import { createWorkPlanModalSurface } from './modals/work-plan-modal.ts';
 import { createKeybindingsModalSurface } from './modals/keybindings-modal.ts';
 import { createPairingModalSurface, type PairingModalConnectionInfo } from './modals/pairing-modal.ts';
+import { createDevicesModalSurface } from './modals/devices-modal.ts';
 import { createPlanningModalSurface } from './modals/planning-modal.ts';
 
 /**
@@ -131,6 +133,13 @@ export function registerBuiltinModals(manager: PanelManager, deps: ResolvedBuilt
 
   manager.registerModalSurface(createMemoryModalSurface({
     memoryRegistry: deps.memoryRegistry as MemoryModalDeps['memoryRegistry'],
+    // Lazily resolved — a fresh factory call per Proposals-tab fetch, exactly
+    // like the Fleet gateway (fleet-gateway.ts) — so a daemon that comes up
+    // AFTER this session started is still reachable on the next refresh.
+    resolveConsolidationGateway: () => createMemoryConsolidationGateway({
+      configManager: deps.configManager,
+      homeDirectory: ui.environment.shellPaths.homeDirectory,
+    }),
   }));
   manager.registerModalRedirect('memory', 'memory-modal');
 
@@ -144,13 +153,24 @@ export function registerBuiltinModals(manager: PanelManager, deps: ResolvedBuilt
   }));
   manager.registerModalRedirect('docs', 'keybindings-modal');
 
+  const tailscaleGatewayDeps = { configManager: deps.configManager, homeDirectory: ui.environment.shellPaths.homeDirectory };
   manager.registerModalSurface(createPairingModalSurface({
     getConnectionInfo: () => buildPairingConnectionInfo(deps),
     controlPlaneReadModel: ui.readModels.controlPlane,
     copyToClipboard,
+    probeTailscale: () => probePairingTailscale(tailscaleGatewayDeps),
+    runTailscaleServe: () => runPairingTailscaleServe(tailscaleGatewayDeps),
   }));
   manager.registerModalRedirect('qr-code', 'pairing-modal');
 
+  // Paired-device management (settings security domain): list/rename/revoke/
+  // migrate-shared over the same per-device token store the pairing QR mints into.
+  manager.registerModalSurface(createDevicesModalSurface({
+    pairingTokens: ui.platform.pairingTokens,
+    copyToClipboard,
+  }));
+  manager.registerModalRedirect('devices', 'devices-modal');
+
   manager.registerModalSurface(createPlanningModalSurface({
     service: deps.projectPlanningService,
     projectId: deps.projectPlanningProjectId,
@@ -171,15 +191,33 @@ export function registerBuiltinModals(manager: PanelManager, deps: ResolvedBuilt
  * Mirrors the retired QrPanel factory's construction.
  */
 function buildPairingConnectionInfo(deps: ResolvedBuiltinPanelDeps): PairingModalConnectionInfo | null {
-  if (!deps.daemonHomeDir) return null;
   try {
-    const daemonHomeDir = deps.daemonHomeDir;
-    const tokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
-    const daemonPort = deps.configManager.get('controlPlane.port');
-    const daemonHost = String(process.env['GOODVIBES_DAEMON_HOST'] ?? getLocalNetworkIp());
-    const daemonUrl = `http://${daemonHost}:${daemonPort}`;
-    const bootstrapPassword = readBootstrapPassword(deps.localUserAuthManager.getBootstrapCredentialPath());
-    return buildCompanionConnectionInfo({ daemonUrl, token: tokenRecord.token, password: bootstrapPassword, surface: 'tui' }) as PairingModalConnectionInfo;
+    const ui = requireUiServices(deps);
+    const configManager = deps.configManager;
+    // Freeze a stable web origin once (never clobbering a user-set value).
+    const webOrigin = ensurePublicBaseUrl(configManager);
+    const offers = availablePairingOffers({
+      relayEnabled: configManager.get('relay.enabled') === true,
+      // The TUI composition always wires a step-up service ⇒ the passkey offer is
+      // presentable; the web app declines it if the device has no authenticator.
+      stepUpAvailable: true,
+    });
+    // Mint a fresh per-device token and encode the canonical `#pair=` deep link —
+    // the same mint the pairing.handoff.create verb performs, no raw JSON blob.
+    const handoff = mintPairingHandoff({
+      pairingTokens: ui.platform.pairingTokens,
+      name: defaultPairingTokenName(),
+      offers,
+      webOrigin: webOrigin.origin,
+    });
+    return {
+      url: webOrigin.origin,
+      token: handoff.token.token,
+      tokenName: handoff.token.name,
+      deepLink: handoff.deepLink ?? handoff.fragment,
+      offers: handoff.offers,
+      posture: handoff.posture,
+    };
   } catch {
     return null;
   }
@@ -195,24 +233,3 @@ function unwiredSurface(name: string, title: string, reason: string): ConfigModa
   };
 }
 
-function getLocalNetworkIp(): string {
-  const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    for (const net of nets[name] ?? []) {
-      if (net.family === 'IPv4' && !net.internal) return net.address;
-    }
-  }
-  return 'localhost';
-}
-
-function readBootstrapPassword(credentialPath: string): string | undefined {
-  try {
-    const content = readFileSync(credentialPath, 'utf-8');
-    for (const line of content.split('\n')) {
-      if (line.startsWith('password=')) return line.slice('password='.length).trim();
-    }
-  } catch {
-    // credential file may not exist yet
-  }
-  return undefined;
-}

package/src/panels/diff-panel.ts

@@ -5,7 +5,7 @@
 import type { Line } from '../types/grid.ts';
 import { createStyledCell, createEmptyLine } from '../types/grid.ts';
 import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
-import { GitService } from '@pellux/goodvibes-sdk/platform/git';
+import { GitService, type StructuredDiff, type StructuredDiffFile } from '@pellux/goodvibes-sdk/platform/git';
 import { BasePanel } from './base-panel.ts';
 import { UI_TONES, DIFF_TONES } from '../renderer/ui-primitives.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
@@ -199,6 +199,19 @@ function extractDiffFilePath(trimmed: string): string {
   return 'unknown';
 }
 
+/** Reconstruct one file's unified-diff text from a StructuredDiffFile (header + hunks, prefixes re-attached; no size cap). */
+function reconstructStructuredFile(file: StructuredDiffFile): string {
+  const out: string[] = [...file.headerLines];
+  for (const hunk of file.hunks) {
+    out.push(hunk.header);
+    for (const line of hunk.lines) {
+      const prefix = line.kind === 'add' ? '+' : line.kind === 'del' ? '-' : ' ';
+      out.push(`${prefix}${line.text}`);
+    }
+  }
+  return out.join('\n');
+}
+
 function splitIntoDiffEntries(raw: string): DiffEntry[] {
   const entries: DiffEntry[] = [];
   // Split on "diff --git" / "diff --cc" / "diff --combined" lines
@@ -306,6 +319,26 @@ export class DiffPanel extends BasePanel {
     this.markDirty();
   }
 
+  /**
+   * Ingest a StructuredDiff (GitService.diffStructured — the FULL, uncapped
+   * working-tree diff). Each file becomes one DiffEntry (unified text
+   * reconstructed) so the existing tabs/renderer work unchanged; the old
+   * 4,000-char slice is gone and a diff of any length renders complete.
+   */
+  loadStructuredDiff(diff: StructuredDiff): void {
+    this.entries = diff.files.map((file) => {
+      const raw = reconstructStructuredFile(file);
+      return {
+        filePath: file.newPath ?? file.oldPath ?? 'unknown',
+        raw,
+        lines: parseDiff(raw),
+      };
+    });
+    this.selectedFile = 0;
+    this.scrollOffset = 0;
+    this.markDirty();
+  }
+
   /**
    * Defensive gate mirroring GitPanel's own notGitRepo messaging — short-
    * circuits before any of this panel's self-load git spawns run, instead of