@pellux/goodvibes-tui 1.0.0 → 1.7.0

package/src/runtime/ui-services.ts

@@ -55,6 +55,7 @@ export interface UiPlatformServices {
   readonly tokenAuditor: RuntimeServices['tokenAuditor'];
   readonly replayEngine: RuntimeServices['replayEngine'];
   readonly webhookNotifier: RuntimeServices['webhookNotifier'];
+  readonly focusTracker: RuntimeServices['focusTracker'];
   readonly policyRuntimeState: RuntimeServices['policyRuntimeState'];
   readonly externalServices?: {
     inspect(): {
@@ -101,6 +102,10 @@ export interface UiRuntimeSharedServices {
     readonly distributedRuntime: RuntimeServices['distributedRuntime'];
     readonly remoteRunnerRegistry: RuntimeServices['remoteRunnerRegistry'] & RemoteRunnerRegistry;
     readonly remoteSupervisor: RuntimeServices['remoteSupervisor'] & RemoteSupervisor;
+    /** W2.2: the shared live process registry backing the Fleet panel. */
+    readonly processRegistry: RuntimeServices['processRegistry'];
+    /** Wave-3 (W3.2): the shared runtime event bus — the Fleet panel subscribes to its 'communication' domain for the honest steer-consumed signal. */
+    readonly runtimeBus: RuntimeServices['runtimeBus'];
   };
 }
 
@@ -167,6 +172,7 @@ export function createUiRuntimeServices(
       tokenAuditor: runtimeServices.tokenAuditor,
       replayEngine: runtimeServices.replayEngine,
       webhookNotifier: runtimeServices.webhookNotifier,
+      focusTracker: runtimeServices.focusTracker,
       policyRuntimeState: runtimeServices.policyRuntimeState,
     },
     planning: {
@@ -183,6 +189,8 @@ export function createUiRuntimeServices(
       distributedRuntime: runtimeServices.distributedRuntime,
       remoteRunnerRegistry: runtimeServices.remoteRunnerRegistry,
       remoteSupervisor: runtimeServices.remoteSupervisor,
+      processRegistry: runtimeServices.processRegistry,
+      runtimeBus: runtimeServices.runtimeBus,
     },
     events: createUiRuntimeEvents(runtimeServices.runtimeBus),
     readModels: createUiReadModels(runtimeServices, options),

package/src/runtime/workstream-services.ts

@@ -0,0 +1,195 @@
+// ---------------------------------------------------------------------------
+// workstream-services.ts — Wave 4 (wo703)
+//
+// Constructs the TUI's OrchestrationEngine instance (@pellux/goodvibes-sdk/
+// platform/orchestration, landed on SDK main as wo701/W4.1) and a thin
+// command-facing facade around it. 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
+// createWorkflowServices's one-function-bundle shape).
+//
+// Why a facade, not the bare engine: createOrchestrationEngine() is a pure
+// construction call with no auto-start and NO concept of a not-yet-launched
+// "proposal" a human can review/edit before anything is spent — its only
+// creation entry point, createWorkstream(), immediately materializes a real,
+// ticking-eligible Workstream. The /workstream command module
+// (input/commands/workstream-runtime.ts) needs a create -> propose -> approve
+// -> launch flow (Pillar-3 doctrine: render the plan in the transcript before
+// spending anything, mirroring /plan's approve step). REALITY-WINS DIVERGENCE
+// from the wo703 design brief: the brief recommended an "engine-owned/
+// journal-backed" draft so `/workstream status` could re-render a pending
+// proposal after a restart; the real engine (verified against the linked SDK
+// build) exposes no pre-creation draft concept at all, so WorkstreamDraft
+// below is process-lifetime-only state, owned by this module's facade
+// instance (constructed once, threaded onto CommandContext) — never a
+// module-level ambient global. A draft that existed only in memory is lost on
+// restart, same as an unsent chat draft; that is a real, stated limitation,
+// not a bug.
+// ---------------------------------------------------------------------------
+
+import {
+  createOrchestrationEngine,
+  fromChainSpec,
+  type CreateWorkstreamInput,
+  type OrchestrationEngine,
+} from '@pellux/goodvibes-sdk/platform/orchestration';
+export type { OrchestrationEngine } from '@pellux/goodvibes-sdk/platform/orchestration';
+import { AdaptivePlanner, type DecompositionGate, type PlannerInputs } from '@pellux/goodvibes-sdk/platform/core';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
+import type { RuntimeEventBus } from '@/runtime/index.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
+
+export interface WorkstreamServicesDeps {
+  readonly agentManager: Pick<AgentManager, 'spawn' | 'getStatus' | 'cancel' | 'registerCancellationSignal' | 'releaseCancellationSignal'>;
+  readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
+  readonly adaptivePlanner: AdaptivePlanner;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly projectRoot: string;
+}
+
+/** A not-yet-launched /workstream proposal. See this file's header doc for why it lives here rather than on the engine. */
+export interface WorkstreamDraft {
+  readonly id: string;
+  task: string;
+  spec: CreateWorkstreamInput;
+  readonly gate: DecompositionGate;
+  approved: boolean;
+  readonly createdAt: number;
+}
+
+/** `ctx.session.workstreamEngine`'s real shape: the live engine plus the draft-proposal bookkeeping the engine itself has no concept of. */
+export interface WorkstreamCommandService {
+  readonly engine: OrchestrationEngine;
+  proposeDraft(task: string): WorkstreamDraft;
+  getDraft(id: string): WorkstreamDraft | undefined;
+  listDrafts(): WorkstreamDraft[];
+  /** Re-derive a held draft's spec from a new task string. Clears any prior approval — an edit must be re-approved. */
+  editDraft(id: string, task: string): WorkstreamDraft | undefined;
+  approveDraft(id: string): WorkstreamDraft | undefined;
+  removeDraft(id: string): boolean;
+  /** Materialize an approved draft into a real, running Workstream (engine.createWorkstream + start), then drop the draft. Null when the draft is missing or not approved. */
+  launchDraft(id: string): { workstreamId: string } | null;
+}
+
+export interface WorkstreamServices {
+  readonly orchestrationEngine: OrchestrationEngine;
+  readonly workstreamCommands: WorkstreamCommandService;
+}
+
+/**
+ * Placeholder planner inputs until a richer risk/latency signal is wired in.
+ * `/workstream create` is inherently a multi-step authoring surface, so
+ * isMultiStep is always true; the rest are neutral defaults that let
+ * AdaptivePlanner's real scoring run rather than short-circuiting it.
+ */
+function buildPlannerInputs(task: string): PlannerInputs {
+  return {
+    riskScore: 0.3,
+    latencyBudgetMs: Number.POSITIVE_INFINITY,
+    isMultiStep: true,
+    remoteAvailable: false,
+    backgroundEligible: false,
+    taskDescription: task,
+  };
+}
+
+function createWorkstreamCommandService(
+  engine: OrchestrationEngine,
+  adaptivePlanner: AdaptivePlanner,
+  configManager: Pick<ConfigManager, 'get' | 'getCategory'>,
+): WorkstreamCommandService {
+  const drafts = new Map<string, WorkstreamDraft>();
+
+  /**
+   * fromChainSpec is the SDK's own bridge from "a task string" to a real,
+   * launchable engineer -> review CreateWorkstreamInput — the same two-phase
+   * shape WrfcController.createChain would otherwise start (see
+   * controller-compat.ts). AdaptivePlanner.proposeWorkstream's own
+   * PlanProposal is deliberately NOT used for the rendered shape: it always
+   * degrades to a fictional single-phase fallback in this wave (nothing yet
+   * supplies it a `raw` LLM decomposition — no planning-agent-spawn pipeline
+   * exists in the shipped SDK surface this item compiles against), which
+   * would silently disagree with what launchDraft actually creates. Showing
+   * the real fromChainSpec shape keeps the proposal and the launch
+   * byte-for-byte the same plan. proposeWorkstream is still called (below)
+   * for its `gate` — the real strategy/reason-code rationale — which stays
+   * meaningful even without a raw decomposition.
+   */
+  function buildSpec(task: string): CreateWorkstreamInput {
+    return fromChainSpec({ id: `item-${crypto.randomUUID().slice(0, 8)}`, task }, configManager);
+  }
+
+  return {
+    engine,
+    proposeDraft(task: string): WorkstreamDraft {
+      const { gate } = adaptivePlanner.proposeWorkstream(buildPlannerInputs(task));
+      const draft: WorkstreamDraft = {
+        id: `wsd_${crypto.randomUUID().slice(0, 8)}`,
+        task,
+        spec: buildSpec(task),
+        gate,
+        approved: false,
+        createdAt: Date.now(),
+      };
+      drafts.set(draft.id, draft);
+      return draft;
+    },
+    getDraft: (id) => drafts.get(id),
+    listDrafts: () => Array.from(drafts.values()).sort((a, b) => a.createdAt - b.createdAt),
+    editDraft(id, task) {
+      const draft = drafts.get(id);
+      if (!draft) return undefined;
+      draft.task = task;
+      draft.spec = buildSpec(task);
+      draft.approved = false;
+      return draft;
+    },
+    approveDraft(id) {
+      const draft = drafts.get(id);
+      if (!draft) return undefined;
+      draft.approved = true;
+      return draft;
+    },
+    removeDraft: (id) => drafts.delete(id),
+    launchDraft(id) {
+      const draft = drafts.get(id);
+      if (!draft || !draft.approved) return null;
+      const workstream = engine.createWorkstream(draft.spec);
+      engine.start(workstream.id);
+      drafts.delete(id);
+      return { workstreamId: workstream.id };
+    },
+  };
+}
+
+/**
+ * Constructs the TUI's OrchestrationEngine instance and its command-facing
+ * facade. `persist` and `createWorktree` are left at the engine's own
+ * defaults: journal-backed snapshots under .goodvibes/orchestration/ (so
+ * resumeAllFromDisk below has something to resume) and a plain
+ * AgentWorktree(projectRoot) — the same "shared working directory, no real
+ * per-item isolation" behavior WrfcController itself uses today (see
+ * phase-runner.ts's own REALITY-WINS divergence doc in the SDK).
+ */
+export function createWorkstreamServices(deps: WorkstreamServicesDeps): WorkstreamServices {
+  const orchestrationEngine = createOrchestrationEngine({
+    agentManager: deps.agentManager,
+    configManager: deps.configManager,
+    runtimeBus: deps.runtimeBus,
+    projectRoot: deps.projectRoot,
+    priceUsage: (model, usage) => {
+      const modelId = model ?? 'unknown';
+      if (!isModelPriced(modelId)) return null;
+      return calcSessionCost(usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens, modelId);
+    },
+  });
+  // Honest resume: a prior process's still-in-flight workstreams pick back up
+  // (and reappear in the fleet tree) instead of silently vanishing on
+  // restart. Never throws — persistence.ts guards every read/parse and
+  // quarantines an unrecognized snapshot rather than propagating.
+  orchestrationEngine.resumeAllFromDisk();
+  const workstreamCommands = createWorkstreamCommandService(orchestrationEngine, deps.adaptivePlanner, deps.configManager);
+  return { orchestrationEngine, workstreamCommands };
+}

package/src/shell/blocking-input.ts

@@ -4,9 +4,12 @@ import type { SessionSnapshot } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 import { replayJournalForSession } from '../core/session-recovery.ts';
+import { applyHunkKey, buildModifiedEditArgs, type HunkSelectionState } from '../permissions/hunk-selection.ts';
 
 export type PendingPermissionState = PermissionRequest & {
-  resolve: (approved: boolean, remember?: boolean) => void;
+  resolve: (approved: boolean, remember?: boolean, modifiedArgs?: Record<string, unknown>) => void;
+  /** Present only when isHunkSelectable(request) was true when the prompt was opened. */
+  hunkState?: HunkSelectionState;
 };
 
 export type BlockingInputHandlerOptions = {
@@ -73,6 +76,24 @@ export function handleBlockingShellInput(
 
   if (pendingPermission) {
     const req = pendingPermission;
+
+    if (req.hunkState) {
+      const { state, commit } = applyHunkKey(req.hunkState, data);
+      if (commit === 'apply') {
+        req.resolve(true, false, buildModifiedEditArgs(req, state));
+        render();
+        return { handled: true, pendingPermission: null, recoveryPending };
+      }
+      if (commit === 'cancel') {
+        req.resolve(false, false);
+        abortTurn();
+        render();
+        return { handled: true, pendingPermission: null, recoveryPending };
+      }
+      render();
+      return { handled: true, pendingPermission: { ...req, hunkState: state }, recoveryPending };
+    }
+
     const key = data.toLowerCase().trim();
 
     if (key === 'y') {

package/src/shell/ui-openers.ts

@@ -10,8 +10,10 @@ import type { FeatureFlagManager } from '@/runtime/index.ts';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { MemoryEmbeddingProviderRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
-import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
+import type { EmbeddingProviderPickerEntry, ModelPickerTargetInfo } from '../input/model-picker.ts';
+import type { SelectionItem } from '../input/selection-modal.ts';
 import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
@@ -28,6 +30,8 @@ type WireShellUiOpenersOptions = {
   subscriptionManager: SubscriptionManager;
   secretsManager?: Pick<SecretsManager, 'delete' | 'get' | 'set'>;
   serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'>;
+  /** B29: backs the model picker's 'embeddings' target and its own item-list mode. */
+  memoryEmbeddingRegistry: Pick<MemoryEmbeddingProviderRegistry, 'getDefaultProviderId' | 'setDefaultProvider' | 'status'>;
   workingDirectory: string;
   homeDirectory: string;
   getConfiguredProviderIds: () => string[];
@@ -93,6 +97,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     subscriptionManager,
     secretsManager,
     serviceRegistry,
+    memoryEmbeddingRegistry,
     workingDirectory,
     homeDirectory,
     getConfiguredProviderIds,
@@ -125,6 +130,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     if (target === 'helper') return String(configManager.get('helper.globalModel') || runtime.model);
     if (target === 'tool') return String(configManager.get('tools.llmModel') || runtime.model);
     if (target === 'tts') return String(configManager.get('tts.llmModel') || runtime.model);
+    if (target === 'embeddings') return memoryEmbeddingRegistry.getDefaultProviderId();
     return runtime.model;
   };
 
@@ -134,10 +140,29 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     if (target === 'helper') return String(configManager.get('helper.globalProvider') || runtime.provider);
     if (target === 'tool') return String(configManager.get('tools.llmProvider') || runtime.provider);
     if (target === 'tts') return String(configManager.get('tts.llmProvider') || runtime.provider);
+    if (target === 'embeddings') return memoryEmbeddingRegistry.getDefaultProviderId();
     return runtime.provider;
   };
 
-  const buildModelPickerTargets = (): ModelPickerTargetInfo[] => {
+  /**
+   * Fetch the embedding-provider status list once per picker-open and shape
+   * it into the picker's own tiny item type. Uses the registry's async
+   * `.status()` (not the sync `.list()`) specifically because `.list()` does
+   * not carry `configured` — and unconfigured providers must be shown
+   * honestly, not hidden.
+   */
+  async function resolveEmbeddingProviderEntries(): Promise<EmbeddingProviderPickerEntry[]> {
+    const statuses = await memoryEmbeddingRegistry.status();
+    return statuses.map((status) => ({
+      id: status.id,
+      label: status.label,
+      dimensions: status.dimensions,
+      configured: status.configured,
+      ...(status.detail ? { detail: status.detail } : {}),
+    }));
+  }
+
+  const buildModelPickerTargets = (embeddingEntries: EmbeddingProviderPickerEntry[]): ModelPickerTargetInfo[] => {
     const mainProvider = getProviderIdFromModel(configManager.get('provider.model') || runtime.provider).trim();
     const mainModel = String(configManager.get('provider.model') || runtime.model || '').trim();
     const helperProvider = String(configManager.get('helper.globalProvider') ?? '').trim();
@@ -146,6 +171,11 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     const toolModel = String(configManager.get('tools.llmModel') ?? '').trim();
     const ttsProvider = String(configManager.get('tts.llmProvider') ?? '').trim();
     const ttsModel = String(configManager.get('tts.llmModel') ?? '').trim();
+    const embeddingProviderId = memoryEmbeddingRegistry.getDefaultProviderId();
+    const embeddingEntry = embeddingEntries.find((entry) => entry.id === embeddingProviderId);
+    const embeddingNote = embeddingEntry
+      ? `${embeddingEntry.id} · ${embeddingEntry.dimensions}d${embeddingEntry.configured ? '' : ' · unconfigured'}`
+      : `${embeddingProviderId} · unregistered`;
 
     return [
       {
@@ -184,6 +214,16 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
         enabled: true,
         inherited: ttsProvider.length === 0 && ttsModel.length === 0,
       },
+      {
+        target: 'embeddings',
+        label: 'Embeddings',
+        description: 'Embedding provider used for memory search and the code index. Not an LLM route — no model concept.',
+        provider: embeddingProviderId,
+        model: '',
+        enabled: true,
+        inherited: false,
+        configuredNote: embeddingNote,
+      },
     ];
   };
 
@@ -199,8 +239,10 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
         input.modelPicker.pinnedIds = new Set(pinned);
       });
       void input.modelPicker.loadRecentModels().catch(() => {}); // best-effort: prefetch for UI, failure is non-visible
+      const embeddingEntries = await resolveEmbeddingProviderEntries();
+      input.modelPicker.embeddingProviders = embeddingEntries;
       input.modalOpened('modelPicker');
-      input.modelPicker.setTargetInfos(buildModelPickerTargets());
+      input.modelPicker.setTargetInfos(buildModelPickerTargets(embeddingEntries));
       input.modelPicker.openAllModels(models, getCurrentModelForPickerTarget());
       render();
     })().catch((error: unknown) => {
@@ -219,8 +261,10 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       input.modelPicker.configuredProviders = configuredIds;
       const secretProviderIds = await resolveSecretProviderIds();
       input.modelPicker.configuredViaMap = buildConfiguredViaMap(providers, configuredIds, subscriptionManager, secretProviderIds);
+      const embeddingEntries = await resolveEmbeddingProviderEntries();
+      input.modelPicker.embeddingProviders = embeddingEntries;
       input.modalOpened('modelPicker');
-      input.modelPicker.setTargetInfos(buildModelPickerTargets());
+      input.modelPicker.setTargetInfos(buildModelPickerTargets(embeddingEntries));
       input.modelPicker.openProviders(providers, getCurrentProviderForPickerTarget());
       render();
     })().catch((error: unknown) => {
@@ -229,6 +273,15 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     });
   };
 
+  commandContext.completeEmbeddingProviderSelection = (providerId: string) => {
+    try {
+      memoryEmbeddingRegistry.setDefaultProvider(providerId);
+    } catch (error: unknown) {
+      commandContext.print?.(`Failed to set embedding provider: ${summarizeError(error)}`);
+    }
+    render();
+  };
+
   commandContext.openSelection = (title, items, opts, callback) => {
     input.openSelection(title, items, opts, callback);
   };
@@ -281,6 +334,47 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     render();
   };
 
+  // W6.1 (the purge): open a MIGRATE-TO-MODAL surface by name. Fed from both
+  // ctx.openModal(name) (migrated command front-doors) and PanelManager's
+  // open()-time modal-redirect callback (a legacy panel id resolving to a modal
+  // name). Surfaces are registered in builtin-modals.ts; a name with no
+  // registered surface degrades honestly to a print rather than a blank modal.
+  // The stack name is the stable 'config' slot (one config modal at a time —
+  // opening another swaps the surface), so Esc close/return and the modal-stack
+  // machinery need only the single 'config' case (handler-ui-state.ts).
+  // Some panel-id redirects (and migrated front-doors) resolve to a NATIVE
+  // modal that is not a ConfigModalSurface — e.g. `sessions` -> `sessionPicker`,
+  // where 'sessionPicker' is the real session-picker modal opened by
+  // commandContext.openSessionPicker below, NOT a registered config surface.
+  // getModalSurface can never find these, so consult this small name->opener
+  // dispatch FIRST. Each entry reuses the same opener the front-door command
+  // uses (no duplicated open logic); resolved lazily so wiring order does not
+  // matter. Any name that is neither a native modal nor a registered surface
+  // still falls through to the honest "not available" print below.
+  const nativeModalOpeners: Record<string, () => void> = {
+    // openSessionPicker is wired below in this same function; call it lazily
+    // (optional-chained for the type, always present at invoke time).
+    sessionPicker: () => commandContext.openSessionPicker?.(),
+  };
+
+  commandContext.openModal = (name: string) => {
+    const openNative = nativeModalOpeners[name];
+    if (openNative) {
+      openNative();
+      return;
+    }
+    const surface = panelManager.getModalSurface(name);
+    if (!surface) {
+      commandContext.print(`'${name}' is not available yet in this build.`);
+      render();
+      return;
+    }
+    input.modalOpened('config');
+    input.configModal.open(surface, render);
+    render();
+  };
+  panelManager.setOpenModalCallback(commandContext.openModal);
+
   commandContext.openMcpWorkspace = () => {
     input.openMcpWorkspace(commandContext);
     render();
@@ -296,25 +390,43 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     // Focus ownership lives in PanelManager (focusTarget); read it there rather
     // than tracking a parallel input.panelFocused flag. Toggle semantics: if the
     // workspace is visible AND already focused, hide it; otherwise reveal and
-    // focus it (opening the panel list when nothing is open yet).
+    // focus it (opening a picker when nothing is open yet).
     if (panelManager.isVisible() && panelManager.getFocusTarget() === 'panel') {
       panelManager.hide();
       panelManager.focusPrompt();
       conversation.setSplashSuppressed(false);
       conversation.rebuildHistory();
-    } else {
-      if (panelManager.getAllOpen().length === 0) {
-        try {
-          panelManager.open('panel-list');
-        } catch {
-          // non-fatal
-        }
-      }
-      panelManager.show();
-      panelManager.focusPanels();
-      conversation.setSplashSuppressed(true);
-      conversation.rebuildHistory();
+      render();
+      return;
+    }
+    if (panelManager.getAllOpen().length === 0) {
+      // W6.1 (the purge): 'panel-list' (a browse-all-panels picker PANEL)
+      // was DELETE-disposition — a picker over a handful of panels is dead
+      // weight now. Its replacement is this selection MODAL, built from the
+      // live registry (PanelManager.getRegisteredTypes()) rather than a
+      // hardcoded list, so it can never list a retired/deleted id.
+      const items: SelectionItem[] = panelManager.getRegisteredTypes().map((entry) => ({
+        id: entry.id,
+        label: `${entry.icon} ${entry.name}`,
+        detail: entry.description,
+        category: entry.category,
+        primaryAction: 'select',
+      }));
+      commandContext.openSelection?.('Open Panel', items, { allowSearch: true }, (result) => {
+        if (!result) return;
+        panelManager.open(result.item.id);
+        panelManager.show();
+        panelManager.focusPanels();
+        conversation.setSplashSuppressed(true);
+        conversation.rebuildHistory();
+        render();
+      });
+      return;
     }
+    panelManager.show();
+    panelManager.focusPanels();
+    conversation.setSplashSuppressed(true);
+    conversation.rebuildHistory();
     render();
   };
 

package/src/utils/format-duration.ts

@@ -1,16 +1,21 @@
 /**
  * Shared ms-duration formatters for the panel layer.
  *
- * Three families are exported, each matching a distinct behavior cluster.
+ * Two families are exported, each matching a distinct behavior cluster.
  * DO NOT replace these with formatElapsed from utils/format-elapsed.ts —
  * formatElapsed floors to integer seconds and lacks the null/'?ms' guards
  * that the latency panels require.
+ *
+ * W6.1 (the purge): formatShortDuration (used only by incident-review-panel
+ * and eval-panel, both removed — RETIRE-INTO-FLEET and DELETE respectively)
+ * was removed as a genuinely orphaned export — no remaining caller anywhere
+ * in src/.
  */
 
 /**
  * Format a latency value in milliseconds with sub-second precision.
  *
- * Used by: debug-panel, provider-health-panel
+ * Used by: provider-health-panel
  *
  *   ms <= 0     → 'n/a'
  *   ms >= 10000 → '12.3s'    (one decimal)
@@ -27,7 +32,7 @@ export function formatLatencyMs(ms: number): string {
 /**
  * Format a task/agent duration with minute-rolling notation.
  *
- * Used by: tool-inspector-panel, agent-inspector-shared
+ * Used by: agent-inspector-shared
  *
  *   ms < 1000   → '500ms'
  *   ms < 60000  → '3.5s'
@@ -38,18 +43,3 @@ export function formatDuration(ms: number): string {
   if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
   return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
 }
-
-/**
- * Format a short eval/forensics duration; treats undefined as '?ms'.
- *
- * Used by: incident-review-panel, eval-panel
- *
- *   undefined → '?ms'
- *   ms < 1000 → '500ms'
- *   else      → '1.5s'
- */
-export function formatShortDuration(ms: number | undefined): string {
-  if (ms === undefined) return '?ms';
-  if (ms < 1000)        return `${ms}ms`;
-  return `${(ms / 1000).toFixed(1)}s`;
-}

package/src/utils/splash-lines.ts

@@ -24,7 +24,7 @@ const versionLine = (version: string) =>
   `　✦　v${version}　█　terminal AI assistant　█　自動ｺｰﾄﾞ 　✦`;
 
 /** Fixed hint line — the three primary shell entry points. */
-const HINT_LINE = 'Ctrl+P panels  /  ? help  /  F2 processes';
+const HINT_LINE = 'Ctrl+P panels  /  ? help  /  F2 fleet';
 
 export interface SplashOptions {
   workingDir?: string;

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.0.0';
+let _version = '1.7.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;