@pellux/goodvibes-tui 1.27.0 → 2.0.1

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

@@ -0,0 +1,330 @@
+/**
+ * hosted-runtime.ts — `/hosted`, the front door to a conversation the DAEMON
+ * runs.
+ *
+ * Local sessions are unchanged and remain the default experience: a turn typed
+ * into the composer runs in this process, exactly as it always has. `/hosted`
+ * is the opt-in — it asks the daemon to compose the same loop on its side, so
+ * the conversation does not depend on this window staying open.
+ *
+ * ── The subcommands, and why they are these ───────────────────────────────
+ *
+ *   /hosted                    what this terminal is attached to, and what
+ *                              leaving would do
+ *   /hosted new [prompt…]      create one here and attach; `--survive` /
+ *                              `--kill` set this session's own detach override
+ *   /hosted list [--all]       every hosted session the daemon has
+ *   /hosted attach <id|n>      join one and backfill its transcript
+ *   /hosted say <text…>        steer the attached session (ordinary verb)
+ *   /hosted later <text…>      queue a follow-up (ordinary verb)
+ *   /hosted cancel [callId]    cancel one in-flight tool call (ordinary verb)
+ *   /hosted detach             leave — the policy the record names then applies
+ *   /hosted kill [id]          end it regardless of policy
+ *
+ * There is no `/hosted steer` beside `say` and no hosted-only cancel: those
+ * operations are `sessions.steer`, `sessions.followUp` and
+ * `sessions.toolCalls.cancel`, which resolve a hosted id daemon-side. This
+ * command spells each one once.
+ */
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { describeOperatorRpcError } from './operator-rpc.ts';
+import { requireShellPaths } from './runtime-services.ts';
+import {
+  createDaemonVerbCaller,
+  resolveControlPlaneBaseUrl,
+  resolveDaemonStateDirectory,
+} from '../../runtime/client/operator-endpoint.ts';
+import {
+  createHostedSessionsClient,
+  describeDetachEffect,
+  hostedSessionLabel,
+  type HostedDetachPolicy,
+  type HostedSessionRecord,
+  type HostedSessionsClient,
+} from '../../runtime/client/hosted-sessions.ts';
+import { watchHostedSession, type HostedSessionSubscription } from '../../runtime/client/hosted-session-stream.ts';
+import { getOrCreateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing';
+import { getSharedHostedSessionFeed, type HostedSessionFeed } from '../../panels/hosted-session-feed.ts';
+import { getSharedHostedSessionRoster } from '../../runtime/client/hosted-roster.ts';
+
+/** The last list this terminal printed, so `attach 2` means what the user just read. */
+let lastListedIds: readonly string[] = [];
+
+/** One row of `/hosted list`, in the record's own words. */
+export function renderHostedRecordLine(record: HostedSessionRecord, index: number): string {
+  const attached = record.attachedClients.length > 0 ? record.attachedClients.join(', ') : 'nobody';
+  const ended = record.status === 'terminated'
+    ? ` — ended: ${record.terminatedReason ?? 'no reason recorded'}`
+    : '';
+  return [
+    `  ${index + 1}. ${hostedSessionLabel(record)} [${record.status}]${ended}`,
+    `     id ${record.id}`,
+    `     ${describeDetachEffect(record)}`,
+    `     ${record.turnCount} turn(s), ${record.messageCount} message(s); attached: ${attached}`,
+  ].join('\n');
+}
+
+/** The status block `/hosted` with no arguments prints. */
+export function renderHostedStatus(feed: HostedSessionFeed): string {
+  const state = feed.getState();
+  if (!state.record) {
+    return [
+      'No hosted session is attached in this terminal.',
+      '  A hosted session runs inside the daemon, so it can outlive this window.',
+      '  /hosted new [prompt]   start one and attach',
+      '  /hosted list           see what already exists',
+    ].join('\n');
+  }
+  const record = state.record;
+  return [
+    `Attached to ${hostedSessionLabel(record)} [${record.status}]`,
+    `  id ${record.id}`,
+    `  workspace ${record.workspaceRoot}`,
+    `  ${describeDetachEffect(record)}`,
+    `  ${record.turnCount} turn(s), ${record.messageCount} message(s)`,
+    state.streaming
+      ? '  live event stream open'
+      : `  no live stream — ${state.streamNote ?? 'not subscribed'}`,
+    state.runningToolCalls.length > 0
+      ? `  running: ${state.runningToolCalls.map((call) => `${call.tool} (${call.callId})`).join(', ')}`
+      : '  no tool call is running',
+  ].join('\n');
+}
+
+/**
+ * Read `--survive` / `--kill` out of the arguments.
+ *
+ * Absent means "follow the `hostedSessions.detachPolicy` setting", which is a
+ * different thing from either value and is what most sessions want: the record
+ * then reports the setting's current answer rather than a snapshot of it.
+ */
+export function readDetachOverride(args: readonly string[]): {
+  readonly policy: HostedDetachPolicy | undefined;
+  readonly rest: string[];
+} {
+  const rest: string[] = [];
+  let policy: HostedDetachPolicy | undefined;
+  for (const arg of args) {
+    if (arg === '--survive') { policy = 'survive'; continue; }
+    if (arg === '--kill') { policy = 'kill'; continue; }
+    rest.push(arg);
+  }
+  return { policy, rest };
+}
+
+interface HostedCommandSeams {
+  readonly client: HostedSessionsClient;
+  readonly baseUrl: string | null;
+  readonly authToken: string | null;
+}
+
+/**
+ * Resolve everything a `/hosted` subcommand needs, or refuse honestly.
+ *
+ * The verbs go through `createDaemonVerbCaller` because every
+ * `sessions.hosted.*` verb is ws-declared with no REST path; the stream needs
+ * the base URL and bearer directly, which is the same resolution the verb
+ * caller performs internally.
+ */
+function resolveSeams(context: CommandContext): HostedCommandSeams | null {
+  const configManager = context.platform.configManager;
+  const homeDirectory = (): string => requireShellPaths(context).homeDirectory;
+  const client = createHostedSessionsClient(createDaemonVerbCaller({ configManager, homeDirectory }));
+  const baseUrl = resolveControlPlaneBaseUrl(configManager);
+  if (!baseUrl) return { client, baseUrl: null, authToken: null };
+  let authToken: string | null = null;
+  try {
+    authToken = getOrCreateCompanionToken('tui', {
+      daemonHomeDir: resolveDaemonStateDirectory(homeDirectory()),
+    }).token;
+  } catch {
+    // A token this terminal cannot mint is a stream it cannot open; the verbs
+    // resolve their own and still work, so this is not a refusal of the command.
+    authToken = null;
+  }
+  return { client, baseUrl, authToken };
+}
+
+/** Open the live stream for the attached session, and say so in the feed either way. */
+async function openStream(
+  seams: HostedCommandSeams,
+  sessionId: string,
+  feed: HostedSessionFeed,
+): Promise<void> {
+  // The feed owns the subscription handle: the exit path has to be able to
+  // close it too, and it has no way to reach a variable in this module.
+  feed.closeStream();
+  if (!seams.baseUrl) {
+    feed.setStreaming(false, 'no control-plane base URL is configured, so nothing can be watched live');
+    return;
+  }
+  if (!seams.authToken) {
+    feed.setStreaming(false, 'no bearer token could be read for the event stream');
+    return;
+  }
+  const token = seams.authToken;
+  const subscription: HostedSessionSubscription | null = await watchHostedSession({
+    baseUrl: seams.baseUrl,
+    sessionId,
+    getAuthToken: () => token,
+    onEvent: (event) => feed.apply(event),
+    onLifecycle: (update) => feed.applyLifecycle(update),
+    onTerminate: (error) => {
+      feed.setStreaming(false, `the event stream ended: ${describeOperatorRpcError(error)}`);
+    },
+  });
+  feed.bindStream(subscription ? () => subscription.close() : null);
+  feed.setStreaming(
+    subscription !== null,
+    subscription === null ? 'the daemon would not open an event stream' : null,
+  );
+}
+
+/** Attach to a session by id, backfill it, and start watching it. */
+async function attachSession(
+  seams: HostedCommandSeams,
+  sessionId: string,
+  feed: HostedSessionFeed,
+  context: CommandContext,
+): Promise<void> {
+  const attachment = await seams.client.attach(sessionId);
+  feed.attach(attachment.session, attachment.history);
+  await openStream(seams, attachment.session.id, feed);
+  context.print([
+    `[hosted] attached to ${hostedSessionLabel(attachment.session)} (${attachment.history.length} message(s) backfilled)`,
+    `  ${describeDetachEffect(attachment.session)}`,
+  ].join('\n'));
+  context.showPanel?.('hosted');
+}
+
+/** Turn `attach 2` into the id the user just read off `/hosted list`. */
+function resolveIdArgument(argument: string): string {
+  const index = Number.parseInt(argument, 10);
+  if (Number.isInteger(index) && index >= 1 && index <= lastListedIds.length) {
+    return lastListedIds[index - 1] as string;
+  }
+  return argument;
+}
+
+export function registerHostedRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'hosted',
+    description: 'Daemon-hosted sessions: start, join, steer and leave a conversation whose loop runs in the daemon',
+    usage: '[new|list|attach|say|later|cancel|detach|kill] [args]',
+    argsHint: '[new|list|attach|say|later|cancel|detach|kill]',
+    async handler(args, ctx) {
+      const feed = getSharedHostedSessionFeed();
+      const sub = (args[0] ?? '').toLowerCase();
+
+      if (sub === '' || sub === 'status') {
+        ctx.print(renderHostedStatus(feed));
+        return;
+      }
+
+      const seams = resolveSeams(ctx);
+      if (!seams) return;
+      const attachedId = feed.getState().record?.id ?? null;
+
+      try {
+        switch (sub) {
+          case 'new': {
+            const { policy, rest } = readDetachOverride(args.slice(1));
+            const workspaceRoot = requireShellPaths(ctx).workingDirectory;
+            const prompt = rest.join(' ').trim();
+            const record = await seams.client.create({
+              workspaceRoot,
+              ...(prompt ? { initialPrompt: prompt } : {}),
+              ...(policy ? { detachPolicy: policy } : {}),
+            });
+            ctx.print([
+              `[hosted] created ${hostedSessionLabel(record)} in ${record.workspaceRoot}`,
+              `  ${describeDetachEffect(record)}`,
+            ].join('\n'));
+            await attachSession(seams, record.id, feed, ctx);
+            return;
+          }
+          case 'list': {
+            const includeTerminated = args.includes('--all');
+            const records = await seams.client.list({ includeTerminated });
+            lastListedIds = records.map((record) => record.id);
+            // The session picker reads the same roster, so a list typed here is
+            // the list it shows — one answer, not two that drift.
+            if (!includeTerminated) getSharedHostedSessionRoster().accept(records);
+            if (records.length === 0) {
+              ctx.print(includeTerminated
+                ? '[hosted] the daemon is hosting no sessions, and has no retained terminated ones.'
+                : '[hosted] the daemon is hosting no sessions. Add --all to include ones that have ended.');
+              return;
+            }
+            ctx.print([
+              `Hosted sessions (${records.length}${includeTerminated ? ', including ended' : ''}):`,
+              ...records.map(renderHostedRecordLine),
+              '',
+              '  /hosted attach <id or number>',
+            ].join('\n'));
+            return;
+          }
+          case 'attach': {
+            const target = args[1];
+            if (!target) { ctx.print('Usage: /hosted attach <id or list number>'); return; }
+            await attachSession(seams, resolveIdArgument(target), feed, ctx);
+            return;
+          }
+          case 'say':
+          case 'later': {
+            if (!attachedId) { ctx.print('[hosted] no hosted session is attached — /hosted attach <id> first.'); return; }
+            const body = args.slice(1).join(' ').trim();
+            if (!body) { ctx.print(`Usage: /hosted ${sub} <text>`); return; }
+            if (sub === 'say') await seams.client.steer(attachedId, body);
+            else await seams.client.followUp(attachedId, body);
+            ctx.print(sub === 'say'
+              ? '[hosted] sent — its output arrives on the Hosted Session panel.'
+              : '[hosted] queued — it runs after the current turn.');
+            return;
+          }
+          case 'cancel': {
+            if (!attachedId) { ctx.print('[hosted] no hosted session is attached.'); return; }
+            const running = feed.getState().runningToolCalls;
+            const callId = args[1] ?? running[0]?.callId;
+            if (!callId) { ctx.print('[hosted] no tool call is running in this session. Pass a callId to cancel a specific one.'); return; }
+            const cancelled = await seams.client.cancelToolCall(attachedId, callId);
+            ctx.print(cancelled
+              ? `[hosted] cancelled tool call ${callId}.`
+              : `[hosted] the daemon did not cancel ${callId} — it may have already settled.`);
+            return;
+          }
+          case 'detach': {
+            if (!attachedId) { ctx.print('[hosted] no hosted session is attached.'); return; }
+            const record = await seams.client.detach(attachedId);
+            feed.clear();
+            ctx.print(record.status === 'terminated'
+              ? `[hosted] detached — the session ended (${record.terminatedReason ?? 'no reason recorded'}), which is what its detach policy said would happen.`
+              : '[hosted] detached — the session is still running in the daemon and can be reattached.');
+            return;
+          }
+          case 'kill': {
+            const target = args[1] ? resolveIdArgument(args[1]) : attachedId;
+            if (!target) { ctx.print('Usage: /hosted kill <id> (or attach one first)'); return; }
+            const record = await seams.client.kill(target);
+            if (target === attachedId) feed.clear();
+            ctx.print(`[hosted] ended ${hostedSessionLabel(record)} — ${record.terminatedReason ?? 'no reason recorded'}.`);
+            return;
+          }
+          default:
+            ctx.print('Usage: /hosted [status|new|list|attach|say|later|cancel|detach|kill]');
+            return;
+        }
+      } catch (error) {
+        ctx.print(`[hosted] ${describeOperatorRpcError(error)}`);
+      }
+    },
+  });
+}
+
+/**
+ * Tests drive the module-level list memory (`/hosted attach 2`); this resets it
+ * between them. The live stream is the feed's, and is reset with the feed.
+ */
+export function resetHostedCommandState(): void {
+  lastListedIds = [];
+}

package/src/input/commands/local-setup-review.ts

@@ -4,7 +4,7 @@ import type { CommandContext } from '../command-registry.ts';
 import { discoverSkills } from '../../panels/skills-panel.ts';
 import { buildSandboxReview, isRunningInWsl } from '@/runtime/index.ts';
 import { renderQemuWrapperTemplate } from '@/runtime/index.ts';
-import { getPluginDirectories } from '../../plugins/loader';
+import { getPluginDirectories } from '@pellux/goodvibes-sdk/platform/plugins';
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import type { SetupReviewSnapshot } from './local-setup-transfer.ts';
 import { requireProviderApi, requireReadModels, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from './runtime-services.ts';

package/src/input/commands/local-setup-transfer.ts

@@ -1,8 +1,8 @@
 import { dirname, join, resolve } from 'node:path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import type { CommandContext } from '../command-registry.ts';
-import type { ConfigKey } from '../../config/index.ts';
-import { CONFIG_SCHEMA } from '../../config/index.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { CONFIG_SCHEMA } from '@pellux/goodvibes-sdk/platform/config';
 import { requireShellPaths } from './runtime-services.ts';
 
 export interface SetupReviewSnapshot {

package/src/input/commands/local-setup.ts

@@ -1,9 +1,9 @@
 import { dirname, join } from 'path';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { atomicWriteFileSync } from '../../config/atomic-write.ts';
+import { atomicWriteFileSync } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
-import type { ConfigKey } from '../../config/index.ts';
-import { CONFIG_SCHEMA } from '../../config/index.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { CONFIG_SCHEMA } from '@pellux/goodvibes-sdk/platform/config';
 import { listHookPointContracts } from '@pellux/goodvibes-sdk/platform/hooks';
 import { renderQemuWrapperTemplate } from '@/runtime/index.ts';
 import type { SetupTransferBundle } from './local-setup-transfer.ts';

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

@@ -2,8 +2,8 @@ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { profileDataToConfigSnapshot } from '@pellux/goodvibes-sdk/platform/profiles';
-import { CONFIG_SCHEMA, type ConfigKey } from '../../config/index.ts';
-import { getProviderIdFromModel } from '../../config/provider-model.ts';
+import { CONFIG_SCHEMA, type ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { getProviderIdFromModel } from '@pellux/goodvibes-sdk/platform/providers';
 import { CONFIG_KEYS } from '@pellux/goodvibes-sdk/platform/config';
 import type { ManagedSettingsBundle } from '@/runtime/index.ts';
 import {

package/src/input/commands/operator-rpc.ts

@@ -1,103 +1,35 @@
 /**
- * operator-rpc.ts
+ * operator-rpc.ts — the command layer's handle on the daemon.
  *
- * Generic operator-verb dispatch for gateway methods that do not (yet) have a
- * named facade on the in-process `OperatorClient` (`ctx.clients.operator`,
- * always DirectTransport-backed in this TUI — see bootstrap-shell.ts). The
- * initiative cluster (`ci.*`, `checkin.*`, `principals.*`,
- * `channels.profiles.*`) ships in the operator contract but has not been
- * promoted to that narrow facade, so commands reach it the same way any
- * external operator client would: a real HTTP round-trip to the currently
- * configured control-plane daemon, using `createGoodVibesSdk`'s generic
- * `sdk.operator.invoke(methodId, input)` (typed against the installed
- * contract — see `@pellux/goodvibes-contracts`).
+ * The resolution itself (is the daemon enabled, what base URL, what bearer)
+ * moved to runtime/client/operator-endpoint.ts when the terminal app became a
+ * pure client: the runtime seams — approvals, config, credentials, sessions,
+ * fleet, tasks, devices, checkpoints — all need the same answer, and two copies
+ * of it is how one call ended up on a DirectTransport while another made a real
+ * request. This module keeps the command-context-shaped entry point and
+ * re-exports the rest so no command import site had to change.
  *
- * This is deliberately a fresh, lightweight connection per call (no pooling,
- * no persistent socket) — these are low-frequency, operator-initiated admin
- * calls, not hot-path session traffic. `getOperatorRpc` never throws: it
- * returns `{ available: false, reason }` up front for every case the caller
- * can decide about statically (daemon disabled, no reachable base URL), so
- * commands can print an honest "not available" line instead of guessing.
- * Once a call is made, a non-2xx response (including the 404 a not-yet-wired
- * verb returns) surfaces to the caller as a thrown `GoodVibesSdkError` —
- * callers should catch and render `describeOperatorRpcError` rather than
- * pretend the request succeeded.
+ * Every command verb is now a real HTTP round-trip to the configured
+ * control-plane daemon; there is no in-process catalog left to answer one.
  */
-import { join } from 'node:path';
-import { createGoodVibesSdk } from '@pellux/goodvibes-sdk';
-import type { GoodVibesSdk } from '@pellux/goodvibes-sdk';
-import { GoodVibesSdkError } from '@pellux/goodvibes-sdk';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import { resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
-import { getOrCreateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing';
+export {
+  describeOperatorRpcError,
+  resolveOperatorRpc,
+  type OperatorRpc,
+  type OperatorRpcAvailable,
+  type OperatorRpcUnavailable,
+} from '../../runtime/client/operator-endpoint.ts';
+
+import { resolveOperatorRpc } from '../../runtime/client/operator-endpoint.ts';
+import type { OperatorRpc } from '../../runtime/client/operator-endpoint.ts';
 import type { CommandContext } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
-export interface OperatorRpcUnavailable {
-  readonly available: false;
-  readonly reason: string;
-}
-
-export interface OperatorRpcAvailable {
-  readonly available: true;
-  readonly sdk: GoodVibesSdk;
-}
-
-export type OperatorRpc = OperatorRpcUnavailable | OperatorRpcAvailable;
-
-function resolveControlPlaneBaseUrl(configManager: ConfigManager): string | null {
-  // An explicitly declared external address wins; otherwise the URL is DERIVED
-  // from hostMode/host/port/tls.mode. This used to prefer a stored
-  // `controlPlane.baseUrl`, which had no writers and so drifted from the bind
-  // on port, scheme, and host at once.
-  // The cast drops once a published SDK carries this key in ConfigKey; the
-  // installed 1.14.0 predates it (same idiom cloudflare-control-plane.ts uses).
-  const explicit = String(configManager.get('controlPlane.publicBaseUrl' as never) ?? '').trim();
-  if (explicit) return explicit.replace(/\/+$/, '');
-  const host = String(configManager.get('controlPlane.host') ?? '').trim();
-  const port = configManager.get('controlPlane.port');
-  if (host && typeof port === 'number' && port > 0) {
-    const scheme = String(configManager.get('controlPlane.tls.mode') ?? 'off') !== 'off' ? 'https' : 'http';
-    // A wildcard bind is not a dial target; loopback is the interface it answers on.
-    const dialHost = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
-    return `${scheme}://${dialHost.includes(':') && !dialHost.startsWith('[') ? `[${dialHost}]` : dialHost}:${port}`;
-  }
-  return null;
-}
-
 /**
- * Context-free core of {@link getOperatorRpc}: resolve (or honestly refuse to
- * resolve) an operator SDK client wired to this workspace's control-plane
- * daemon from just the two things the resolution actually needs — the config
- * manager and the home directory. Shared by the command layer (via
- * getOperatorRpc) and the Fleet panel's gateway (fleet-gateway.ts) so both
- * reach the same daemon over the same generic invoke path, never two divergent
- * clients. Refusal reasons are surfaced verbatim so callers print them directly.
- */
-export function resolveOperatorRpc(deps: { readonly configManager: ConfigManager; readonly homeDirectory: string | (() => string) }): OperatorRpc {
-  const { configManager } = deps;
-  if (!resolveDaemonEnabled(configManager)) {
-    return { available: false, reason: 'the daemon is disabled (daemon.enabled=false) — no operator surface to reach. Enable it in /settings, then retry.' };
-  }
-  const baseUrl = resolveControlPlaneBaseUrl(configManager);
-  if (!baseUrl) {
-    return { available: false, reason: 'no control-plane base URL is configured (controlPlane.publicBaseUrl / controlPlane.host+port) — cannot reach the operator surface.' };
-  }
-  // Resolve the home directory only AFTER the static refusals — a caller whose
-  // shell paths are not wired (a disabled-daemon path) must still get the honest
-  // unavailable reason above, never a "shell paths not wired" throw.
-  const homeDirectory = typeof deps.homeDirectory === 'function' ? deps.homeDirectory() : deps.homeDirectory;
-  const daemonHomeDir = join(homeDirectory, '.goodvibes', 'daemon');
-  const token = getOrCreateCompanionToken('tui', { daemonHomeDir }).token;
-  const sdk = createGoodVibesSdk({ baseUrl, authToken: token });
-  return { available: true, sdk };
-}
-
-/**
- * Resolve (or honestly refuse to resolve) an operator SDK client wired to
- * this workspace's control-plane daemon. Reasons for refusal are surfaced
- * verbatim to the caller so `/ci`, `/checkin`, and `/principals` can print
- * them directly rather than inventing their own wording.
+ * Resolve (or honestly refuse to resolve) an operator SDK client wired to this
+ * workspace's control-plane daemon. Reasons for refusal are surfaced verbatim
+ * to the caller so commands print them directly rather than inventing their own
+ * wording.
  */
 export function getOperatorRpc(context: CommandContext): OperatorRpc {
   return resolveOperatorRpc({
@@ -107,21 +39,3 @@ export function getOperatorRpc(context: CommandContext): OperatorRpc {
     homeDirectory: () => requireShellPaths(context).homeDirectory,
   });
 }
-
-/**
- * Render a thrown operator-rpc error honestly: a 404 means this daemon has
- * not wired a handler for the verb (a live local runtime that simply doesn't
- * implement it yet), never "no result" or a fabricated empty state.
- */
-export function describeOperatorRpcError(error: unknown): string {
-  if (error instanceof GoodVibesSdkError) {
-    if (error.status === 404) {
-      return 'the connected daemon returned 404 — this operator verb is not wired up on that daemon yet.';
-    }
-    if (error.status === 401 || error.status === 403) {
-      return `the connected daemon rejected the request (${error.status}): ${error.message}`;
-    }
-    return `operator request failed${error.status ? ` (${error.status})` : ''}: ${error.message}`;
-  }
-  return error instanceof Error ? error.message : String(error);
-}

package/src/input/commands/payment-card-intake.ts

@@ -59,7 +59,7 @@
 
 import type { CommandRegistry, CommandContext } from '../command-registry.ts';
 import { persistSecretBackedConfigValue } from '../../config/secret-config.ts';
-import type { ConfigKey } from '../../config/index.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import { describeCardEntryRefusal, mayOfferCardEntryFlow } from '@pellux/goodvibes-sdk/platform/payments';
 import {
   PAYMENTS_CARD_NUMBER_CONFIG_KEY,

package/src/input/commands/permissions-provenance.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
-import type { ConfigManager, ConfigKey } from '../../config/index.ts';
-import { CONFIG_SCHEMA } from '../../config/index.ts';
+import type { ConfigManager, ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { CONFIG_SCHEMA } from '@pellux/goodvibes-sdk/platform/config';
 import { SHIPPED_CREDENTIAL_READ_RULES } from '@pellux/goodvibes-sdk/platform/permissions';
 
 // ---------------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import { resolve } from 'path';
 import type { PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins';
-import { getPluginDirectories, getUserPluginDirectory } from '../../plugins/loader';
+import { getPluginDirectories, getUserPluginDirectory } from '@pellux/goodvibes-sdk/platform/plugins';
 import type { CommandRegistry } from '../command-registry.ts';
 import {
   installEcosystemCatalogEntry,

package/src/input/commands/provider.ts

@@ -19,7 +19,7 @@ import type { RouteExplanation } from '@pellux/goodvibes-sdk/platform/providers'
 import type { FallbackTestResult, FallbackTransition } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ProviderApiModelRecord } from '@pellux/goodvibes-sdk/platform/providers';
 import { requireProviderApi } from './runtime-services.ts';
-import { featureEnablementWrite } from '../../runtime/feature-settings.ts';
+import { featureEnablementWrite } from '@pellux/goodvibes-terminal-shell';
 
 const PROVIDER_OPTIMIZER_FLAG = 'provider-optimizer';
 

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

@@ -1,13 +1,20 @@
 import type { CommandContext } from '../command-registry.ts';
 import type { CommandRegistry } from '../command-registry.ts';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
+import { RELAY_STATE_NOT_READABLE_HERE } from '../../runtime/relay-reachability-bridge.ts';
 
 /**
- * Register the /relay command — reachability status and QR-encodable pairing
- * for the SDK's outbound zero-knowledge relay (relay.* settings, gated by the
- * `relay-connect` feature flag). The live registration state lives only in
- * the running daemon's memory (`DaemonServer.getRelayReachability()`), reached
- * here through `ctx.platform.externalServices` — see relay-reachability-bridge.ts.
+ * Register the /relay command — the relay's configuration, its reachability
+ * state, and a QR-encodable pairing payload for the SDK's outbound
+ * zero-knowledge relay (relay.* settings, gated by the `relay-connect` feature
+ * flag).
+ *
+ * The CONFIGURATION half is read here, from this terminal's own config. The
+ * LIVE half is not: registration state and pairing live in the running daemon's
+ * memory (`DaemonServer.getRelayReachability()`), and no verb exposes either to
+ * a client — so both read 'unavailable' with the reason said out loud rather
+ * than a state this terminal is in no position to know. See
+ * relay-reachability-bridge.ts.
  */
 
 function relayConfigured(ctx: CommandContext): { enabled: boolean; url: string; rendezvousId: string; label: string; flagOn: boolean } {
@@ -32,14 +39,16 @@ async function renderStatus(ctx: CommandContext): Promise<void> {
     ].join('\n'));
     return;
   }
-  const live = ctx.platform.externalServices?.relayStatus() ?? 'disabled';
-  const state = live === 'registered' ? 'registered' : live === 'disabled' ? 'disabled' : 'offline';
+  const live = ctx.platform.externalServices?.relayStatus() ?? 'unavailable';
+  const state = live === 'registered' || live === 'disabled' || live === 'unavailable' ? live : 'offline';
   ctx.print([
     `Relay: ${state}`,
     `  rendezvous id: ${cfg.rendezvousId || '(not yet minted — start the daemon to generate one)'}`,
     `  url: ${cfg.url || '(not set)'}`,
     `  label: ${cfg.label || '(not set)'}`,
-    `  live connection state: ${live}`,
+    state === 'unavailable'
+      ? `  ${RELAY_STATE_NOT_READABLE_HERE}`
+      : `  live connection state: ${live}`,
     '  The relay operator sees only ciphertext and connection metadata — self-host your own relay for full control.',
   ].join('\n'));
 }
@@ -57,7 +66,7 @@ async function renderPair(ctx: CommandContext): Promise<void> {
   }
   const minted = await externalServices.mintRelayPairing();
   if (!minted) {
-    ctx.print('Could not mint a relay pairing payload — the relay connection may not be registered yet. Check /relay status.');
+    ctx.print(`Relay pairing cannot be minted from here. ${RELAY_STATE_NOT_READABLE_HERE}`);
     return;
   }
   const qrMatrix = generateQrMatrix(minted.encoded);

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

@@ -42,7 +42,7 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { WorkspaceCheckpoint, WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { buildRewindReceiptBlock } from '../../core/rewind-receipt.ts';
-import { getTurnAnchors, type TurnAnchor } from '../../core/rewind-turn-anchors.ts';
+import { getTurnAnchors, type TurnAnchor } from '@pellux/goodvibes-sdk/platform/rewind';
 import { createConversationRewindPort, type ConversationRewindPort } from '../../runtime/conversation-rewind-port.ts';
 import { requirePanelManager } from './runtime-services.ts';
 import { shortId } from './checkpoint-runtime.ts';

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

@@ -14,7 +14,7 @@ import type { CompactionQualityScore } from '../../renderer/compaction-quality.t
 import type { UiReadModels } from '../../runtime/ui-read-models.ts';
 import type { ShellPathService, SessionSurface } from '@/runtime/index.ts';
 import type { EcosystemCatalogPathOptions } from '@/runtime/index.ts';
-import type { PluginPathOptions } from '../../plugins/loader';
+import type { PluginPathOptions } from '@pellux/goodvibes-sdk/platform/plugins';
 import type { DirectTransport } from '@/runtime/index.ts';
 import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { HookApi } from '@pellux/goodvibes-sdk/platform/hooks';