@pellux/goodvibes-tui 1.27.1 → 2.0.2

package/src/input/commands/services-runtime.ts

@@ -1,6 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { atomicWriteFileSync } from '../../config/atomic-write.ts';
+import { atomicWriteFileSync } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
 import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';

package/src/input/commands/session-workflow.ts

@@ -8,7 +8,7 @@ import type { SessionReturnContextSummary } from '@/runtime/index.ts';
 import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import { requirePanelManager, requireProviderApi, requireSessionManager, requireSurface } from './runtime-services.ts';
 import { resumeSessionCore, reopenPanelsWithModalSkip, DEFAULT_PANEL_REOPEN_LIMIT } from '../../core/session-resume-core.ts';
-import { checkSessionLiveness } from '../../runtime/session-liveness-marker.ts';
+import { checkSessionLiveness } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 function parseTranscriptKind(raw: string | undefined): TranscriptEventKind | 'all' {

package/src/input/commands/settings-sync-runtime.ts

@@ -15,8 +15,8 @@ import {
   setManagedSettingLock,
   type SettingsSyncBundle,
 } from '@/runtime/index.ts';
-import { getProviderIdFromModel } from '../../config/provider-model.ts';
-import { type ConfigKey } from '../../config/index.ts';
+import { getProviderIdFromModel } from '@pellux/goodvibes-sdk/platform/providers';
+import { type ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import { CONFIG_KEYS } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
 import { openCommandPanel, requireShellPaths } from './runtime-services.ts';

package/src/input/commands/share-runtime.ts

@@ -10,7 +10,7 @@ import {
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { calcSessionCost, isModelPriced } from '../../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '@pellux/goodvibes-sdk/platform/providers';
 import {
   GistUploadTarget,
   NO_TOKEN_GUIDANCE,

package/src/input/commands/tasks-runtime.ts

@@ -1,17 +1,41 @@
-import type { CommandRegistry } from '../command-registry.ts';
+/**
+ * tasks-runtime.ts — `/tasks`.
+ *
+ * The reads are a UNION now: this surface's own runtime tasks (the exec, agent
+ * and ACP work the loop here spawned) plus the daemon's (scheduled work,
+ * channel-driven runs, tasks other surfaces submitted). Before the daemon
+ * became its own product one registry held both, and `tasks.list(500)` off the
+ * in-process transport answered synchronously. It no longer holds both, so this
+ * command crosses a wire and is async — the same shape `/ci` and the fleet act
+ * verbs already use.
+ *
+ * The list output is unchanged for a local-only fleet: same header, same
+ * columns, same 20-row cap, same filter semantics. What is added is the daemon
+ * half, and one honest line when the daemon could not be reached — a partial
+ * list of real tasks beats an error page, but it must not read as complete.
+ *
+ * Writes do NOT degrade that way. A lifecycle act against a task this terminal
+ * does not own is routed to the daemon's verb where one exists (cancel, retry)
+ * and refused by name where none does (update, complete, fail, pause and
+ * resume have no wire verb). Applying one locally would report success and
+ * change nothing on the process that actually runs the task.
+ */
+import type { CommandRegistry, CommandContext } from '../command-registry.ts';
 import type { RuntimeTask, TaskLifecycleState } from '@/runtime/index.ts';
 import { reviewWorktreeAttachments } from '@/runtime/index.ts';
 import { requireOperatorClient, requireOpsApi, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { createTasksClient, type TasksClient, type UnionTask } from '@pellux/goodvibes-sdk/platform/runtime/client';
+import { createDaemonVerbCaller } from '../../runtime/client/operator-endpoint.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
-function sortRuntimeTasks(tasks: RuntimeTask[]): RuntimeTask[] {
+function sortRuntimeTasks(tasks: readonly UnionTask[]): UnionTask[] {
   const statusOrder: TaskLifecycleState[] = ['running', 'queued', 'blocked', 'failed', 'completed', 'cancelled'];
   const ranking = new Map(statusOrder.map((status, index) => [status, index] as const));
   return [...tasks].sort((a, b) => {
-    const rankDelta = (ranking.get(a.status) ?? 99) - (ranking.get(b.status) ?? 99);
+    const rankDelta = (ranking.get(a.task.status) ?? 99) - (ranking.get(b.task.status) ?? 99);
     if (rankDelta !== 0) return rankDelta;
-    const aWhen = a.startedAt ?? a.queuedAt;
-    const bWhen = b.startedAt ?? b.queuedAt;
+    const aWhen = a.task.startedAt ?? a.task.queuedAt;
+    const bWhen = b.task.startedAt ?? b.task.queuedAt;
     return bWhen - aWhen;
   });
 }
@@ -28,13 +52,38 @@ function summarizeTaskResult(task: RuntimeTask): string {
   return normalized.length <= 140 ? normalized : `${normalized.slice(0, 137)}...`;
 }
 
+/** The union reader: the in-process source plus this workspace's daemon. */
+function tasksClientFor(ctx: CommandContext): TasksClient {
+  const operatorClient = requireOperatorClient(ctx);
+  return createTasksClient({
+    local: {
+      list: (limit) => operatorClient.tasks.list(limit),
+      get: (taskId) => operatorClient.tasks.get(taskId),
+    },
+    verbs: createDaemonVerbCaller({
+      configManager: ctx.platform.configManager,
+      // Lazy, matching getOperatorRpc: a disabled-daemon context with no shell
+      // paths wired still gets the honest reason instead of a throw.
+      homeDirectory: () => requireShellPaths(ctx).homeDirectory,
+    }),
+  });
+}
+
+/** The five lifecycle acts the operator contract carries no verb for. */
+const LOCAL_ONLY_ACTS = new Set(['update', 'complete', 'fail', 'pause', 'resume']);
+
+function refuseDaemonOwnedAct(taskId: string, subcommand: string): string {
+  return `${taskId} runs on the daemon, and the operator contract carries no ${subcommand} verb to reach it with. `
+    + 'Cancel and retry are available; the rest act on this terminal\'s own tasks.';
+}
+
 export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tasks',
     aliases: ['task'],
     description: 'Inspect and control runtime tasks',
     usage: '[list [status|kind] | show <taskId> | output <taskId> | create <kind> <owner> <title...> | update <taskId> <title|description|result> <value...> | complete <taskId> [result] | fail <taskId> <error...> | cancel <taskId> [note] | pause <taskId> [note] | resume <taskId> [note] | retry <taskId> [note]]',
-    handler(args, ctx) {
+    async handler(args, ctx) {
       if (args.length === 0) {
         if (ctx.showPanel) ctx.showPanel('tasks');
         else {
@@ -46,20 +95,31 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      const operatorClient = requireOperatorClient(ctx);
-      const tasks = sortRuntimeTasks([...operatorClient.tasks.list(500)]);
       const subcommand = args[0]?.toLowerCase() ?? 'list';
+      const tasksClient = tasksClientFor(ctx);
 
       if (subcommand === 'list') {
+        const { tasks: union, daemonUnavailable } = await tasksClient.list(500);
+        const tasks = sortRuntimeTasks(union);
         const filter = args[1]?.toLowerCase();
-        const filtered = tasks.filter((task) => !filter || task.status === filter || task.kind === filter);
+        const filtered = tasks.filter((entry) => !filter || entry.task.status === filter || entry.task.kind === filter);
+        // The daemon note rides ALONGSIDE whatever was found rather than
+        // replacing it: the local half is real work, and hiding it behind an
+        // error would lose tasks that are genuinely running here.
+        const daemonNote = daemonUnavailable
+          ? [`  (the daemon's tasks are not included: ${daemonUnavailable})`]
+          : [];
         if (filtered.length === 0) {
-          ctx.print(filter ? `No tasks matched "${filter}".` : 'No tasks recorded yet.');
+          ctx.print([
+            filter ? `No tasks matched "${filter}".` : 'No tasks recorded yet.',
+            ...daemonNote,
+          ].join('\n'));
           return;
         }
         ctx.print([
           `Runtime Tasks (${filtered.length})`,
-          ...filtered.slice(0, 20).map((task) => `  ${task.id}  ${task.status.padEnd(9)} ${task.kind.padEnd(11)} ${task.owner}  ${task.title}`),
+          ...filtered.slice(0, 20).map(({ task }) => `  ${task.id}  ${task.status.padEnd(9)} ${task.kind.padEnd(11)} ${task.owner}  ${task.title}`),
+          ...daemonNote,
         ].join('\n'));
         return;
       }
@@ -70,17 +130,19 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
           ctx.print('Usage: /tasks show <taskId>');
           return;
         }
-        const task = operatorClient.tasks.get(taskId);
-        if (!task) {
+        const found = await tasksClient.get(taskId);
+        if (!found) {
           ctx.print(`Unknown task: ${taskId}`);
           return;
         }
+        const { task, origin } = found;
         ctx.print([
           `Task ${task.id}`,
           `  title: ${task.title}`,
           `  kind: ${task.kind}`,
           `  status: ${task.status}`,
           `  owner: ${task.owner}`,
+          `  runs on: ${origin === 'local' ? 'this terminal' : 'the daemon'}`,
           `  cancellable: ${task.cancellable ? 'yes' : 'no'}`,
           `  queuedAt: ${new Date(task.queuedAt).toISOString()}`,
           `  startedAt: ${task.startedAt ? new Date(task.startedAt).toISOString() : 'n/a'}`,
@@ -111,11 +173,12 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
           ctx.print('Usage: /tasks output <taskId>');
           return;
         }
-        const task = operatorClient.tasks.get(taskId);
-        if (!task) {
+        const found = await tasksClient.get(taskId);
+        if (!found) {
           ctx.print(`Unknown task: ${taskId}`);
           return;
         }
+        const { task } = found;
         const payload = typeof task.result === 'string'
           ? task.result
           : task.result !== undefined
@@ -139,6 +202,10 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
           ctx.print(`Unknown task kind: ${kind}`);
           return;
         }
+        // Created HERE on purpose: a task this command creates is one this
+        // terminal's loop is expected to drive, so it belongs in the registry
+        // that drives it. Submitting work TO the daemon is what /schedule and
+        // the channel surfaces do.
         const task = opsApi.tasks.create({
           kind: kind as import('@/runtime/index.ts').TaskKind,
           owner,
@@ -149,58 +216,81 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      if (subcommand === 'update') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        const field = args[2];
-        const value = args.slice(3).join(' ').trim();
-        if (!taskId || !field || !value) {
-          ctx.print('Usage: /tasks update <taskId> <title|description|result> <value...>');
-          return;
-        }
-        if (field !== 'title' && field !== 'description' && field !== 'result') {
-          ctx.print(`Unsupported task update field: ${field}`);
-          return;
-        }
-        opsApi.tasks.update(taskId, field === 'result' ? { result: value } : { [field]: value });
-        ctx.print(`Updated task ${taskId} field ${field}.`);
+      const taskId = args[1];
+      if (!taskId) {
+        ctx.print(subcommand === 'update'
+          ? 'Usage: /tasks update <taskId> <title|description|result> <value...>'
+          : `Usage: /tasks ${subcommand} <taskId> [note]`);
         return;
       }
 
-      if (subcommand === 'complete') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        if (!taskId) {
-          ctx.print('Usage: /tasks complete <taskId> [result]');
-          return;
-        }
-        const result = args.slice(2).join(' ').trim() || undefined;
-        opsApi.tasks.complete(taskId, result);
-        ctx.print(`Completed task ${taskId}.`);
+      // Which registry owns this id decides what may be done to it. An act
+      // aimed at a daemon task must never be applied to a local record that
+      // does not exist — that reports success and changes nothing.
+      const found = await tasksClient.get(taskId);
+      if (!found) {
+        ctx.print(`Unknown task: ${taskId}`);
         return;
       }
 
-      if (subcommand === 'fail') {
-        const opsApi = requireOpsApi(ctx);
-        const taskId = args[1];
-        const errorText = args.slice(2).join(' ').trim();
-        if (!taskId || !errorText) {
-          ctx.print('Usage: /tasks fail <taskId> <error...>');
+      if (found.origin === 'daemon') {
+        if (LOCAL_ONLY_ACTS.has(subcommand)) {
+          ctx.print(refuseDaemonOwnedAct(taskId, subcommand));
+          return;
+        }
+        try {
+          switch (subcommand) {
+            case 'cancel':
+              await tasksClient.cancel(taskId);
+              ctx.print(`Cancelled task ${taskId} on the daemon.`);
+              return;
+            case 'retry':
+              await tasksClient.retry(taskId);
+              ctx.print(`Re-queued task ${taskId} on the daemon.`);
+              return;
+            default:
+              ctx.print(`Unknown tasks subcommand: ${subcommand}`);
+              return;
+          }
+        } catch (error) {
+          ctx.print(summarizeError(error));
           return;
         }
-        opsApi.tasks.fail(taskId, { error: errorText });
-        ctx.print(`Failed task ${taskId}.`);
-        return;
       }
 
-      const taskId = args[1];
-      const note = args.slice(2).join(' ').trim() || undefined;
-      if (!taskId) {
-        ctx.print(`Usage: /tasks ${subcommand} <taskId> [note]`);
-        return;
-      }
       const opsApi = requireOpsApi(ctx);
       try {
+        if (subcommand === 'update') {
+          const field = args[2];
+          const value = args.slice(3).join(' ').trim();
+          if (!field || !value) {
+            ctx.print('Usage: /tasks update <taskId> <title|description|result> <value...>');
+            return;
+          }
+          if (field !== 'title' && field !== 'description' && field !== 'result') {
+            ctx.print(`Unsupported task update field: ${field}`);
+            return;
+          }
+          opsApi.tasks.update(taskId, field === 'result' ? { result: value } : { [field]: value });
+          ctx.print(`Updated task ${taskId} field ${field}.`);
+          return;
+        }
+        if (subcommand === 'complete') {
+          opsApi.tasks.complete(taskId, args.slice(2).join(' ').trim() || undefined);
+          ctx.print(`Completed task ${taskId}.`);
+          return;
+        }
+        if (subcommand === 'fail') {
+          const errorText = args.slice(2).join(' ').trim();
+          if (!errorText) {
+            ctx.print('Usage: /tasks fail <taskId> <error...>');
+            return;
+          }
+          opsApi.tasks.fail(taskId, { error: errorText });
+          ctx.print(`Failed task ${taskId}.`);
+          return;
+        }
+        const note = args.slice(2).join(' ').trim() || undefined;
         switch (subcommand) {
           case 'cancel':
             opsApi.tasks.cancel(taskId, note);

package/src/input/commands/update-runtime.ts

@@ -3,29 +3,36 @@
  * download-verify-swap mechanics are the SDK's canonical update policy
  * module (platform/runtime/self-update — hoisted from this file's
  * semantics), the same mechanism the daemon's hourly loop and
- * scripts/install.sh follow: one update mechanism everywhere. This file owns
+ * the suite installer follow: one update mechanism everywhere. This file owns
  * only the /update UX: install-kind gating, target selection, and the
  * printed report.
  *
  * Subcommands:
  *   /update [check]           — resolve the latest release tag and report
  *                                whether this build is already current.
- *   /update apply              — for a binary install (scripts/install.sh),
- *                                download + verify + atomically swap the
- *                                app and daemon binaries, and refresh the
- *                                sqlite-vec native addon in lockstep so the
- *                                vector index never goes stale beside a new
- *                                binary. Every swap parks the outgoing file
- *                                at `<path>.previous`, so the replaced
- *                                version is always kept. For any other
- *                                install kind, prints the exact command to
- *                                run instead — it never attempts a swap it
- *                                can't do safely.
+ *   /update apply              — for a binary install (the curl installer),
+ *                                download + verify + atomically swap THIS
+ *                                app's binary, and refresh the sqlite-vec
+ *                                native addon in lockstep so the vector index
+ *                                never goes stale beside a new binary. Every
+ *                                swap parks the outgoing file at
+ *                                `<path>.previous`, so the replaced version is
+ *                                always kept. For any other install kind,
+ *                                prints the exact command to run instead — it
+ *                                never attempts a swap it can't do safely.
  *   /update rollback           — exchange each installed file with its kept
  *                                `.previous` counterpart: one command back to
  *                                the version that ran before the last update
  *                                (and, being an exchange, one more command
  *                                forward again).
+ *
+ * IT DOES NOT UPDATE THE DAEMON. `goodvibes-daemon` used to sit beside this
+ * binary as part of the same release, and this command swapped both. The daemon
+ * is its own product now, released from its own repository on its own version
+ * line, and it updates itself on an hourly loop. A swap from here would fetch
+ * an asset this repository's releases do not publish — and if one ever appeared
+ * under that name, would overwrite a working daemon with a build from the wrong
+ * line. The daemon is a neighbour in the install directory, not cargo.
  *   /update review              — install/subscription/sandbox posture,
  *                                unrelated to the update mechanics above.
  *   /update bundle export|inspect <path> — portable posture bundle, as before.
@@ -301,8 +308,6 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
   const baseUrl = releaseDownloadBaseUrl(latestTag);
   const io = options.io ?? realUpdateFileIo;
   const appBinaryPath = options.execPath;
-  const daemonBinaryPath = join(dirname(appBinaryPath), 'goodvibes-daemon');
-  const daemonBinaryPresent = io.exists(daemonBinaryPath);
 
   // The sqlite-vec native addon travels with the binaries: refresh it in the
   // same download-verify-swap pass so /update never leaves a new binary beside a
@@ -326,9 +331,6 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
 
   const targets: UpdateTarget[] = [
     { label: 'app binary', path: appBinaryPath, assetName: artifacts.app, executable: true },
-    ...(daemonBinaryPresent
-      ? [{ label: 'daemon binary', path: daemonBinaryPath, assetName: artifacts.daemon, executable: true }]
-      : []),
     ...(addon && addonTargetPath
       ? [{ label: 'vector addon', path: addonTargetPath, assetName: addon.assetName, executable: false }]
       : []),
@@ -360,15 +362,14 @@ export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
     [
       `Updated to ${latestTag}.`,
       `  app binary:    ${appBinaryPath}`,
-      daemonBinaryPresent
-        ? `  daemon binary: ${daemonBinaryPath}`
-        : `  daemon binary: not found at ${daemonBinaryPath} — left untouched`,
       ...(addonTargetPath ? [`  vector addon:  ${addonTargetPath}`] : []),
       '',
       'Restart goodvibes to run the new version.',
+      // Named, not silently omitted: someone who used to see two binaries swap
+      // here should read why only one did.
       serviceInfo.managed
-        ? `The daemon is managed by systemd — restart it with: ${serviceInfo.restartCommand}`
-        : 'The daemon restarts automatically the next time goodvibes launches.',
+        ? `The daemon updates itself on its own release line — this changed nothing about it (it runs under ${serviceInfo.unitName}.service).`
+        : 'The daemon updates itself on its own release line — this changed nothing about it.',
     ].join('\n'),
   );
 }
@@ -387,9 +388,9 @@ export interface RollbackUpdateOptions {
 /**
  * One-command rollback to the version that ran before the last update,
  * delegating the exchange mechanics to the SDK's rollbackKeptPrevious (the
- * same module the swap uses): every installed file (app binary, daemon
- * binary, vector addon) that has a kept `.previous` counterpart is EXCHANGED
- * with it — the previous version becomes live, and the version being rolled
+ * same module the swap uses): every installed file this command owns (the app
+ * binary and the vector addon) that has a kept `.previous` counterpart is
+ * EXCHANGED with it — the previous version becomes live, and the version being rolled
  * back is itself kept at `.previous`, so a second `/update rollback` rolls
  * forward again. Files without a kept counterpart are reported and left
  * untouched; nothing is downloaded.
@@ -408,9 +409,11 @@ export function rollbackUpdate(options: RollbackUpdateOptions): void {
 
   const io = options.io ?? realUpdateFileIo;
   const addon = resolveSqliteVecAsset(options.platform, options.arch);
+  // The daemon binary is deliberately absent: this command never replaced it,
+  // so it has nothing here to restore. Rolling back a file another product owns
+  // would undo an update this app did not perform.
   const targets = [
     { label: 'app binary', path: options.execPath },
-    { label: 'daemon binary', path: join(dirname(options.execPath), 'goodvibes-daemon') },
     ...(addon ? [{ label: 'vector addon', path: join(dirname(options.execPath), 'lib', addon.dirName, addon.fileName) }] : []),
   ];
 
@@ -431,8 +434,8 @@ export function rollbackUpdate(options: RollbackUpdateOptions): void {
       '',
       'Restart goodvibes to run the restored version.',
       serviceInfo.managed
-        ? `The daemon is managed by systemd — restart it with: ${serviceInfo.restartCommand}`
-        : 'The daemon restarts automatically the next time goodvibes launches.',
+        ? `The daemon was not rolled back — it updates itself on its own release line (it runs under ${serviceInfo.unitName}.service).`
+        : 'The daemon was not rolled back — it updates itself on its own release line.',
     ].join('\n'),
   );
 }

package/src/input/commands/work-plan-runtime.ts

@@ -1,6 +1,6 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
-import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
+import type { WorkPlanItemStatus, WorkPlanStore } from '@pellux/goodvibes-sdk/platform/workflow';
+import { WORK_PLAN_STATUSES } from '@pellux/goodvibes-sdk/platform/workflow';
 import { openModalCommand } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 

package/src/input/commands/workstream-attempts.ts

@@ -23,7 +23,7 @@ import type {
 import { AttemptError } from '@pellux/goodvibes-sdk/platform/orchestration';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { CommandContext } from '../command-registry.ts';
-import type { WorkstreamCommandService } from '../../runtime/workstream-services.ts';
+import type { WorkstreamCommandService } from '@pellux/goodvibes-sdk/platform/orchestration';
 import { requirePanelManager } from './runtime-services.ts';
 import { describeFailureReason, isTurnBudgetReason } from '../../core/turn-budget-outcome.ts';
 import { type AttemptGraphItem, renderDependentHoldLines } from './workstream-attempt-dependents.ts';

package/src/input/commands/workstream-runtime.ts

@@ -26,8 +26,8 @@
 
 import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
 import type { CreateWorkstreamInput, PhaseKind, PhaseRole, WorkItem, WorkItemState, Workstream, WorkstreamIsolation } from '@pellux/goodvibes-sdk/platform/orchestration';
-import type { WorkstreamCommandService, WorkstreamDraft, WorkstreamDraftProvenance } from '../../runtime/workstream-services.ts';
-import { validateAttempts } from '../../runtime/workstream-attempts-validation.ts';
+import type { WorkstreamCommandService, WorkstreamDraft, WorkstreamDraftProvenance } from '@pellux/goodvibes-sdk/platform/orchestration';
+import { validateAttempts } from '@pellux/goodvibes-sdk/platform/orchestration';
 import { handleAttemptsSubcommand } from './workstream-attempts.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';

package/src/input/commands.ts

@@ -80,6 +80,7 @@ import { registerReviewRuntimeCommands } from './commands/review-runtime.ts';
 import { registerPaletteRuntimeCommands } from './commands/palette-runtime.ts';
 import { registerCiRuntimeCommands } from './commands/ci-runtime.ts';
 import { registerCheckinRuntimeCommands } from './commands/checkin-runtime.ts';
+import { registerHostedRuntimeCommands } from './commands/hosted-runtime.ts';
 import { registerMailRuntimeCommands } from './commands/mail-runtime.ts';
 import { registerCalendarRuntimeCommands } from './commands/calendar-runtime.ts';
 import { registerPrincipalsRuntimeCommands } from './commands/principals-runtime.ts';
@@ -188,6 +189,7 @@ export const BUILTIN_COMMAND_GROUPS: readonly BuiltinCommandGroup[] = [
   { category: 'Policy', register: (registry) => registry.register(policyCommand) },
   { category: 'Providers', register: (registry) => registry.register(providerCommand) },
   { category: 'Eval', register: (registry) => registry.register(evalCommand) },
+  { category: 'Sessions & Replay', register: registerHostedRuntimeCommands },
   { category: 'Sessions & Replay', register: (registry) => registry.register(sessionCommand) },
   { category: 'Sessions & Replay', register: (registry) => registry.register(resumeCommand) },
   { category: 'Memory', register: (registry) => registry.register(recallCommand) },

package/src/input/feature-unit-layout.ts

@@ -22,7 +22,7 @@
 import { FEATURE_SETTINGS } from '@pellux/goodvibes-sdk/platform/runtime/state';
 import type { FeatureSetting } from '@pellux/goodvibes-sdk/platform/runtime/state';
 import type { ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
-import { getConfigSchemaSetting } from '../runtime/feature-settings.ts';
+import { getConfigSchemaSetting } from '@pellux/goodvibes-terminal-shell';
 import type { FlagEntry, SettingEntry, SettingsCategory } from './settings-modal-types.ts';
 
 /** Every enablement key — these rows render as feature headers, never as plain sub-rows. */

package/src/input/feed-context-factory.ts

@@ -11,8 +11,8 @@
  *     already-allocated context before each feed() dispatch.
  */
 import type { InputFeedContext } from './handler-feed.ts';
-import type { SelectionManager } from './selection.ts';
-import type { InfiniteBuffer } from '../core/history.ts';
+import type { SelectionManager } from '@pellux/goodvibes-terminal-shell';
+import type { InfiniteBuffer } from '@pellux/goodvibes-terminal-shell';
 import type { CommandRegistry, CommandContext } from './command-registry.ts';
 import type { AutocompleteEngine } from './autocomplete.ts';
 import type { FilePickerModal } from './file-picker.ts';
@@ -38,7 +38,7 @@ import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import type { KillRing } from './kill-ring.ts';
 import type { PanelMouseLayout } from './handler-feed-routes.ts';
-import type { FocusTracker } from '../core/focus-tracker.ts';
+import type { FocusTracker } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 
 /**

package/src/input/handler-content-actions.ts

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { copyToClipboard, pasteFromClipboard, pasteImageFromClipboard } from '../utils/clipboard.ts';
-import type { InfiniteBuffer } from '../core/history.ts';
+import type { InfiniteBuffer } from '@pellux/goodvibes-terminal-shell';
 import type { BlockMeta, ConversationManager } from '../core/conversation';
 import type { PermissionCategory } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
@@ -9,7 +9,7 @@ import type { BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { resolveAndValidatePath } from '@pellux/goodvibes-sdk/platform/utils';
 import { analyzePermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import type { SelectionManager } from './selection.ts';
+import type { SelectionManager } from '@pellux/goodvibes-terminal-shell';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export const MARKER_REGEX = /\[(TEXT|IMAGE): [^\]]+\]/g;

package/src/input/handler-feed-routes.ts

@@ -4,7 +4,7 @@ import type { InputHistory } from './input-history.ts';
 import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
 import type { CommandRegistry, CommandContext } from './command-registry.ts';
 import type { AutocompleteEngine } from './autocomplete.ts';
-import type { SelectionManager } from './selection.ts';
+import type { SelectionManager } from '@pellux/goodvibes-terminal-shell';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
 import {
   ensureInputCursorVisible as computeInputScrollTop,

package/src/input/handler-feed.ts

@@ -1,5 +1,5 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
-import type { InfiniteBuffer } from '../core/history.ts';
+import type { InfiniteBuffer } from '@pellux/goodvibes-terminal-shell';
 import type { CommandContext, CommandRegistry } from './command-registry.ts';
 import { AutocompleteEngine } from './autocomplete.ts';
 import { FilePickerModal } from './file-picker.ts';
@@ -40,12 +40,12 @@ import { handleCommandModeToken } from './handler-command-route.ts';
 import { handleGlobalShortcutToken } from './handler-shortcuts.ts';
 import type { Panel } from '../panels/types.ts';
 import { handlePanelIntegrationAction } from './panel-integration-actions.ts';
-import { SelectionManager } from './selection.ts';
+import { SelectionManager } from '@pellux/goodvibes-terminal-shell';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import type { KillRing } from './kill-ring.ts';
-import type { FocusTracker } from '../core/focus-tracker.ts';
+import type { FocusTracker } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 
 /**
  * InputFeedContext — The single long-lived context object passed to feedInputTokens

package/src/input/handler-modal-token-routes.ts

@@ -1,5 +1,5 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
-import type { InfiniteBuffer } from '../core/history.ts';
+import type { InfiniteBuffer } from '@pellux/goodvibes-terminal-shell';
 import type { ConversationManager } from '../core/conversation';
 import type { SelectionResult, SelectionModal } from './selection-modal.ts';
 import type { BookmarkModal } from './bookmark-modal.ts';

package/src/input/handler-onboarding-daemon-adopt.ts

@@ -6,7 +6,7 @@
  */
 import { join } from 'node:path';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { resolveDaemonCompanionToken } from '../runtime/operator-token-cleanup.ts';
+import { resolveDaemonCompanionToken } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { isLoopbackAddress } from './onboarding/onboarding-wizard-helpers.ts';
 import {
   buildManagedDaemonServiceManager,
@@ -22,6 +22,7 @@ import {
   isRuntimeEndpointActive,
   runtimePortDiagnostic,
 } from './onboarding/onboarding-runtime-status.ts';
+import { GOODVIBES_TUI_SURFACE_ROOT } from '../config/surface.ts';
 
 /**
  * Immediately (not deferred to the final wizard Apply):
@@ -60,7 +61,7 @@ export async function handleConnectExistingDaemonForHandler(handler: InputHandle
   handler.requestRender();
   try {
     const daemonHomeDir = join(handler.uiServices.environment.homeDirectory, '.goodvibes', 'daemon');
-    resolveDaemonCompanionToken(daemonHomeDir, token);
+    resolveDaemonCompanionToken(daemonHomeDir, GOODVIBES_TUI_SURFACE_ROOT, token);
     // hostMode has to move with the host. The control-plane URL is DERIVED from
     // hostMode/host/port, and 'local' pins the dial target to 127.0.0.1 no
     // matter what host is stored — so adopting a daemon on another machine

package/src/input/handler-onboarding.ts

@@ -1,7 +1,7 @@
 import { createOAuthLocalListener, resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
 import { summarizeError, openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
-import { getProviderIdFromModel } from '../config/provider-model.ts';
+import { getProviderIdFromModel } from '@pellux/goodvibes-sdk/platform/providers';
 import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
 import { enrichProviderAccountsSnapshot } from '../runtime/onboarding/provider-key-capture.ts';
 import { handleConnectExistingDaemonForHandler, handleMigrateLegacyDaemonServiceForHandler } from './handler-onboarding-daemon-adopt.ts';