@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/runtime/services.ts

@@ -1,11 +1,9 @@
 import { join } from 'node:path';
-import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { FocusTracker } from '../core/focus-tracker.ts';
+import { ConfigManager, ServiceRegistry, SubscriptionManager, ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
 import { SecretsManager } from '../config/secrets.ts';
-import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
-import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
 import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation';
-import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
-import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
+import { ChannelDeliveryRouter, ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
 import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
@@ -23,16 +21,10 @@ import {
 } from '@pellux/goodvibes-sdk/platform/knowledge';
 import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media';
 import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
-import { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
-import { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
-import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
-import { AgentOrchestrator } from '@pellux/goodvibes-sdk/platform/agents';
-import { ArchetypeLoader } from '@pellux/goodvibes-sdk/platform/agents';
-import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools';
-import { ModeManager } from '@pellux/goodvibes-sdk/platform/state';
-import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
-import { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-import { MemoryStore } from '@pellux/goodvibes-sdk/platform/state';
+import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
+import { AgentManager, OverflowHandler, ProcessManager, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
+import { FileStateCache, FileUndoManager, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, type CodeIndexStore } from '@pellux/goodvibes-sdk/platform/state';
+import { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { RuntimeEventBus } from '@/runtime/index.ts';
 import { createDomainDispatch } from './store/index.ts';
 import type { DomainDispatch, RuntimeStore } from './store/index.ts';
@@ -41,40 +33,20 @@ import { RemoteRunnerRegistry, RemoteSupervisor } from '@/runtime/index.ts';
 import { IntegrationHelperService } from '@/runtime/index.ts';
 import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from '@pellux/goodvibes-sdk/platform/voice';
 import { WebSearchProviderRegistry, WebSearchService } from '@pellux/goodvibes-sdk/platform/web-search';
-import { MemoryEmbeddingProviderRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import { PanelManager } from '../panels/panel-manager.ts';
 import { HookActivityTracker } from '@pellux/goodvibes-sdk/platform/hooks';
 import { HookDispatcher, createHookWorkbench, type HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
 import { PluginManager } from '@pellux/goodvibes-sdk/platform/plugins';
 import { BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { ProfileManager } from '@pellux/goodvibes-sdk/platform/profiles';
-import { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
-import { CrossSessionTaskRegistry } from '@pellux/goodvibes-sdk/platform/sessions';
-import { ApiTokenAuditor } from '@pellux/goodvibes-sdk/platform/security';
-import { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
+import { SessionManager, CrossSessionTaskRegistry, SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
+import { ApiTokenAuditor, UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
 import { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
-import { DeterministicReplayEngine } from '@pellux/goodvibes-sdk/platform/core';
-import { ProviderOptimizer } from '@pellux/goodvibes-sdk/platform/providers';
-import { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
-import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
-import { ProviderCapabilityRegistry } from '@pellux/goodvibes-sdk/platform/providers';
-import { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers';
-import { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers';
-import { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
-import { ModelLimitsService } from '@pellux/goodvibes-sdk/platform/providers';
-import { inferFallbackContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
+import { BenchmarkStore, CacheHitTracker, FavoritesStore, inferFallbackContextWindow, type ModelDefinition, ModelLimitsService, ProviderCapabilityRegistry, ProviderOptimizer, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { KeybindingsManager } from '../input/keybindings.ts';
-import { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
-import { SessionLineageTracker } from '@pellux/goodvibes-sdk/platform/core';
-import { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
-import { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core';
-import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
-import { FileStateCache } from '@pellux/goodvibes-sdk/platform/state';
-import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state';
+import { AdaptivePlanner, DeterministicReplayEngine, ExecutionPlanManager, SessionLineageTracker, SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
 import { IdempotencyStore } from '@/runtime/index.ts';
-import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools';
-import { ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
 import { ComponentHealthMonitor } from '@/runtime/index.ts';
 import { WorktreeRegistry } from '@/runtime/index.ts';
 import { SandboxSessionRegistry } from '@/runtime/index.ts';
@@ -83,10 +55,10 @@ import { isFeatureFlagEnabled } from './surface-feature-flags.ts';
 import type { FeatureFlagManager } from '@/runtime/index.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
 import { PolicyRuntimeState } from '@/runtime/index.ts';
-import {
-  createWorkflowServices,
-  type WorkflowServices,
-} from '@pellux/goodvibes-sdk/platform/tools';
+import { createProcessRegistry, type ProcessRegistry } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
+import { createWorkstreamServices, type OrchestrationEngine, type WorkstreamCommandService } from './workstream-services.ts';
+import { codeIndexDbPath, createCodeIndexServices } from './code-index-services.ts';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
 import {
   registerDaemonHandlers,
@@ -221,6 +193,8 @@ export interface RuntimeServices {
   readonly worktreeRegistry: WorktreeRegistry;
   readonly sandboxSessionRegistry: SandboxSessionRegistry;
   readonly webhookNotifier: WebhookNotifier;
+  /** Terminal focus tracker (W2.3) — fed by input/handler-feed.ts, read by the alert notifiers in core/. */
+  readonly focusTracker: FocusTracker;
   readonly replayEngine: DeterministicReplayEngine;
   readonly providerOptimizer: ProviderOptimizer;
   readonly providerCapabilityRegistry: ProviderCapabilityRegistry;
@@ -248,8 +222,16 @@ export interface RuntimeServices {
   readonly agentOrchestrator: AgentOrchestrator;
   readonly wrfcController: WrfcController;
   readonly processManager: ProcessManager;
+  /** Wave 4 (wo703): the phase/work-item orchestration engine — see runtime/workstream-services.ts. */
+  readonly orchestrationEngine: OrchestrationEngine;
+  readonly workstreamCommands: WorkstreamCommandService;
+  /** Wave 5 (wo804): the repo source-tree code index — see runtime/code-index-services.ts. */
+  readonly codeIndexStore: CodeIndexStore;
+  /** W2.1/W2.2: unified live process registry (agents, WRFC chains, workflows, watchers, background processes) backing the Fleet panel. */
+  readonly processRegistry: ProcessRegistry;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
+  readonly workspaceCheckpointManager: WorkspaceCheckpointManager;
   readonly integrationHelpers: IntegrationHelperService;
   /**
    * Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory.
@@ -272,6 +254,9 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const runtimeDispatch = createDomainDispatch(options.runtimeStore);
   const gatewayMethods = new GatewayMethodCatalog();
   const panelManager = new PanelManager();
+  // W6.1 (the purge): MIGRATE-TO-MODAL surface + redirect registration moved to
+  // registerBuiltinPanels (builtin-panels.ts), where the panels' resolved deps
+  // are available for the surfaces to close over.
   const keybindingsManager = new KeybindingsManager({
     configPath: shellPaths.resolveUserPath('tui', 'keybindings.json'),
   });
@@ -352,6 +337,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     executor: agentOrchestrator,
     configManager,
   });
+  agentOrchestrator.setConversationSink({ // Wave-3 Part C6 bridge (mirrors the SDK's own createRuntimeServices)
+    register: (agentId, source) => agentManager.registerConversationSource(agentId, source),
+    release: (agentId) => agentManager.releaseConversationSource(agentId),
+  });
   agentManager.setRuntimeBus(options.runtimeBus);
   const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
     agentManager,
@@ -580,6 +569,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const componentHealthMonitor = new ComponentHealthMonitor();
   const worktreeRegistry = new WorktreeRegistry(workingDirectory);
   const webhookNotifier = new WebhookNotifier();
+  const focusTracker = new FocusTracker();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
   const providerOptimizer = new ProviderOptimizer(
     providerRegistry,
@@ -603,8 +593,57 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     artifactStore,
   });
   const processManager = new ProcessManager();
+  // Wave 4 (wo703): the phase/work-item orchestration engine, constructed
+  // before the process registry so its fleet nodes (workstream/phase/
+  // work-item) can be folded in below via the registry's optional
+  // orchestrationEngine dep.
+  const { orchestrationEngine, workstreamCommands } = createWorkstreamServices({
+    agentManager, configManager, adaptivePlanner, runtimeBus: options.runtimeBus, projectRoot: workingDirectory,
+  });
+  // Wave 5 (wo804): repo source-tree code index, sharing memoryEmbeddingRegistry
+  // with MemoryStore above. Auto-build is config-gated (default off) — see
+  // code-index-services.ts's header doc.
+  const { codeIndexStore } = createCodeIndexServices({ workingDirectory, configManager, memoryEmbeddingRegistry });
+  // W2.1/W2.2: one shared process registry aggregating the managers above —
+  // the Fleet panel (panels/fleet-read-model.ts) is its first consumer.
+  // Constructed once here (not per-consumer) so the coalesced tick and the
+  // agent-activity side-table are shared, not duplicated.
+  const processRegistry = createProcessRegistry({
+    agentManager,
+    wrfcController,
+    orchestrationEngine, // Wave 4 (wo703): folds workstream/phase/work-item nodes into the fleet
+    codeIndexService: codeIndexStore, // Wave 5 (wo804): folds a single 'code-index' node into the fleet
+    processManager,
+    watcherRegistry,
+    workflow,
+    approvalBroker,
+    sessionBroker,
+    messageBus: agentMessageBus, // Wave-3: backs steer()/`steerable` (wo612 builds the composer UI on top)
+    automationManager, // Wave 6 (wo-F item d4): folds /schedule AutomationJobs into the fleet as 'schedule' nodes
+    runtimeBus: options.runtimeBus,
+    // Honest pricing: never fabricate a cost for an unrecognized model.
+    priceUsage: (model, usage) => {
+      const modelId = model ?? 'unknown';
+      if (!isModelPriced(modelId)) return null;
+      return calcSessionCost(usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens, modelId);
+    },
+  });
   const modeManager = new ModeManager();
   const fileUndoManager = new FileUndoManager();
+  const workspaceCheckpointManager = new WorkspaceCheckpointManager({
+    workspaceRoot: workingDirectory,
+    runtimeBus: options.runtimeBus,
+  });
+  // Fire-and-forget: subscriptions go live immediately if init() succeeds.
+  // If it rejects, WorkspaceCheckpointManager caches that rejection on
+  // `initPromise` and never clears it, so every later call (create/list/
+  // diff/restore — each awaits init() first) re-throws the same error
+  // forever: checkpointing becomes entirely unavailable for the rest of the
+  // session, not "degraded to manual-only". The `.catch(() => {})` here only
+  // exists to prevent an unhandled rejection at startup; the checkpoint
+  // commands (checkpoint-runtime.ts) are what actually catch and report the
+  // failure to the user, on first use.
+  void workspaceCheckpointManager.init().catch(() => {});
   const integrationHelpers = new IntegrationHelperService({
     workingDirectory,
     homeDirectory,
@@ -709,6 +748,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     worktreeRegistry,
     sandboxSessionRegistry,
     webhookNotifier,
+    focusTracker,
     replayEngine,
     providerOptimizer,
     providerCapabilityRegistry,
@@ -736,12 +776,20 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     agentOrchestrator,
     wrfcController,
     processManager,
+    orchestrationEngine,
+    workstreamCommands,
+    codeIndexStore,
+    processRegistry,
     modeManager,
     fileUndoManager,
+    workspaceCheckpointManager,
     integrationHelpers,
     async rerootStores(newWorkingDir: string): Promise<void> {
       const newMemoryDbPath = join(newWorkingDir, '.goodvibes', 'tui', 'memory.sqlite');
       await memoryStore.reroot(newMemoryDbPath);
+      // Wave 5 (wo804) risk #7: the code index must follow memory to the new
+      // tree, or it keeps pointing at the old working directory.
+      await codeIndexStore.reroot(newWorkingDir, codeIndexDbPath(newWorkingDir));
       await projectIndex.reroot(newWorkingDir);
     },
   };

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') {