@pellux/goodvibes-agent 0.1.117 → 1.0.1

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

@@ -1,38 +1,14 @@
 import { discoverPersonas, type DiscoveredPersonaRecord } from '../../agent/persona-discovery.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../../agent/persona-registry.ts';
+import { formatAgentRecordOrigin, formatAgentRecordReviewState } from '../../agent/record-labels.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { parseAgentLocalLibraryArgs, type ParsedAgentLocalLibraryArgs } from './agent-local-library-args.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
-interface ParsedPersonaArgs {
-  readonly rest: readonly string[];
-  readonly flags: ReadonlyMap<string, string>;
-  readonly yes: boolean;
-}
+const PERSONA_VALUE_FLAGS = ['name', 'description', 'body', 'tags', 'triggers'] as const;
 
-function parsePersonaArgs(args: readonly string[]): ParsedPersonaArgs {
-  const flags = new Map<string, string>();
-  const rest: string[] = [];
-  let yes = false;
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index] ?? '';
-    if (token === '--yes') {
-      yes = true;
-      continue;
-    }
-    if (token.startsWith('--')) {
-      const key = token.slice(2);
-      const next = args[index + 1];
-      if (next !== undefined && !next.startsWith('--')) {
-        flags.set(key, next);
-        index += 1;
-      } else {
-        flags.set(key, 'true');
-      }
-      continue;
-    }
-    rest.push(token);
-  }
-  return { rest, flags, yes };
+function parsePersonaArgs(args: readonly string[]): ParsedAgentLocalLibraryArgs {
+  return parseAgentLocalLibraryArgs(args, { valueFlags: PERSONA_VALUE_FLAGS });
 }
 
 function splitList(value: string | undefined): readonly string[] {
@@ -44,21 +20,33 @@ function registryFromContext(ctx: CommandContext): AgentPersonaRegistry {
   return AgentPersonaRegistry.fromShellPaths(requireShellPaths(ctx));
 }
 
+function formatPersonaReceipt(title: string, persona: Pick<AgentPersonaRecord, 'id' | 'name'>, extra: readonly string[] = []): string {
+  const activeSuffix = extra.some((line) => line.includes('active yes') || line.includes('active: yes')) ? ' (active)' : '';
+  const normalizedExtra = extra.map((line) => line.replace(/^  active /, '  active: '));
+  return [
+    `${title} ${persona.id}: ${persona.name}${activeSuffix}`,
+    `  id ${persona.id}`,
+    `  name ${persona.name}`,
+    ...normalizedExtra,
+  ].join('\n');
+}
+
 function summarizePersona(persona: AgentPersonaRecord, activePersonaId: string | null): string {
   const active = persona.id === activePersonaId ? 'active' : 'inactive';
-  const tags = persona.tags.length > 0 ? ` tags=${persona.tags.join(',')}` : '';
-  return `  ${persona.id}  ${active}  ${persona.reviewState}  ${persona.name} - ${persona.description}${tags}`;
+  const review = formatAgentRecordReviewState(persona.reviewState);
+  const tags = persona.tags.length > 0 ? ` tags ${persona.tags.join(', ')}` : '';
+  return `  ${persona.id}  ${active}  ${review}  ${persona.name} - ${persona.description}${tags}`;
 }
 
 function renderList(title: string, registry: AgentPersonaRegistry, personas: readonly AgentPersonaRecord[]): string {
   const snapshot = registry.snapshot();
   if (personas.length === 0) {
-    return `${title}\n  No local Agent personas yet. Create one with /personas create --name <name> --description <summary> --body <instructions>.`;
+    return `${title}\n  No local Agent personas yet.\n  No Agent-local personas yet. Create one with /personas create --name <name> --description <summary> --body <instructions>.`;
   }
   return [
     `${title} (${personas.length})`,
-    `  store: ${snapshot.path}`,
-    `  active: ${snapshot.activePersona?.name ?? '(none)'}`,
+    `  store ${snapshot.path}`,
+    `  active ${snapshot.activePersona?.name ?? '(none)'}`,
     ...personas.map((persona) => summarizePersona(persona, snapshot.activePersonaId)),
   ].join('\n');
 }
@@ -66,11 +54,10 @@ function renderList(title: string, registry: AgentPersonaRegistry, personas: rea
 function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | null): string {
   return [
     `Persona ${persona.name}`,
-    `  id: ${persona.id}`,
+    `  id ${persona.id}`,
     `  active: ${persona.id === activePersonaId ? 'yes' : 'no'}`,
-    `  review: ${persona.reviewState}`,
-    `  source: ${persona.source}`,
-    `  provenance: ${persona.provenance}`,
+    `  review: ${formatAgentRecordReviewState(persona.reviewState)}`,
+    `  origin: ${formatAgentRecordOrigin(persona.source, persona.provenance)}`,
     `  tags: ${persona.tags.join(', ') || '(none)'}`,
     `  triggers: ${persona.triggers.join(', ') || '(none)'}`,
     `  created: ${persona.createdAt}`,
@@ -85,7 +72,7 @@ function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | nu
 
 function summarizeDiscoveredPersona(persona: DiscoveredPersonaRecord): string {
   const description = persona.description ? ` - ${persona.description}` : '';
-  return `  ${persona.name}  ${persona.origin}${description}\n    path: ${persona.path}`;
+  return `  ${persona.name}  ${persona.origin}${description}\n    path ${persona.path}`;
 }
 
 function renderDiscoveredPersonas(personas: readonly DiscoveredPersonaRecord[]): string {
@@ -131,18 +118,18 @@ async function importDiscoveredPersona(args: readonly string[], ctx: CommandCont
   }
   const discovered = findDiscoveredPersona(await discoverPersonas(requireShellPaths(ctx)), name);
   if (!discovered) {
-    ctx.print(`Unknown discovered Agent persona: ${name}\nRun /personas discover to inspect available persona files.`);
+    ctx.print(`Unknown discovered Agent persona ${name}\nRun /personas discover to inspect available persona files.`);
     return;
   }
   if (!parsed.yes) {
     ctx.print([
       'Agent persona import preview',
-      `  name: ${discovered.name}`,
-      `  origin: ${discovered.origin}`,
-      `  path: ${discovered.path}`,
-      `  description: ${discovered.description || '(none)'}`,
-      `  body characters: ${discovered.body.length}`,
-      '  next: rerun with --yes to import into the Agent-local persona registry',
+      `  name ${discovered.name}`,
+      `  origin ${discovered.origin}`,
+      `  path ${discovered.path}`,
+      `  description ${discovered.description || '(none)'}`,
+      `  body characters ${discovered.body.length}`,
+      '  next rerun with --yes to import into the Agent-local persona registry',
     ].join('\n'));
     return;
   }
@@ -153,10 +140,10 @@ async function importDiscoveredPersona(args: readonly string[], ctx: CommandCont
     tags: frontmatterList(discovered, 'tags'),
     triggers: frontmatterList(discovered, 'triggers'),
     source: 'imported',
-    provenance: `discovered:${discovered.origin}:${discovered.path}`,
+    provenance: `Imported file (${discovered.origin}): ${discovered.path}`,
   });
   if (parsed.flags.get('use') === 'true') personaRegistry.setActive(persona.id);
-  ctx.print(`Imported Agent persona ${persona.id}: ${persona.name}${parsed.flags.get('use') === 'true' ? ' (active)' : ''}`);
+  ctx.print(formatPersonaReceipt('Imported Agent persona', persona, [`  active ${parsed.flags.get('use') === 'true' ? 'yes' : 'no'}`]));
 }
 
 function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
@@ -166,14 +153,17 @@ function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
 }
 
 function printError(ctx: CommandContext, error: unknown): void {
-  ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+  ctx.print([
+    'Error',
+    `  message ${error instanceof Error ? error.message : String(error)}`,
+  ].join('\n'));
 }
 
 export function registerPersonasRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'personas',
     aliases: ['persona'],
-    description: 'Manage local GoodVibes Agent personas',
+    description: 'Manage Agent-local personas',
     usage: '[list|discover|import-discovered <name> --yes|search <query>|show <id>|create --name <name> --description <summary> --body <instructions>|update <id> [--name ...] [--description ...] [--body ...]|use <id>|active|clear|review <id>|stale <id> <reason...>|delete <id> --yes]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'list').toLowerCase();
@@ -204,7 +194,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
           }
           const snapshot = registryStore.snapshot();
           const persona = registryStore.get(id);
-          ctx.print(persona ? renderPersona(persona, snapshot.activePersonaId) : `Unknown persona: ${id}`);
+          ctx.print(persona ? renderPersona(persona, snapshot.activePersonaId) : `Unknown Agent persona ${id}`);
           return;
         }
         if (sub === 'create') {
@@ -217,9 +207,9 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             tags: splitList(parsed.flags.get('tags')),
             triggers: splitList(parsed.flags.get('triggers')),
             source: 'user',
-            provenance: 'slash-command',
+            provenance: 'Command',
           });
-          ctx.print(`Created Agent persona ${persona.id}: ${persona.name}`);
+          ctx.print(formatPersonaReceipt('Created Agent persona', persona));
           return;
         }
         if (sub === 'update') {
@@ -235,9 +225,9 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             body: parsed.flags.get('body'),
             tags: parsed.flags.has('tags') ? splitList(parsed.flags.get('tags')) : undefined,
             triggers: parsed.flags.has('triggers') ? splitList(parsed.flags.get('triggers')) : undefined,
-            provenance: 'slash-command',
+            provenance: 'Command',
           });
-          ctx.print(`Updated Agent persona ${updated.id}: ${updated.name}`);
+          ctx.print(formatPersonaReceipt('Updated Agent persona', updated));
           return;
         }
         if (sub === 'use') {
@@ -247,7 +237,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const persona = registryStore.setActive(id);
-          ctx.print(`Active Agent persona: ${persona.name} (${persona.id})`);
+          ctx.print(`Active Agent persona: ${persona.name}\n${formatPersonaReceipt('Active Agent persona', persona)}`);
           return;
         }
         if (sub === 'active') {
@@ -267,7 +257,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const persona = registryStore.markReviewed(id);
-          ctx.print(`Reviewed Agent persona ${persona.id}.`);
+          ctx.print(formatPersonaReceipt('Reviewed Agent persona', persona));
           return;
         }
         if (sub === 'stale') {
@@ -277,7 +267,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const persona = registryStore.markStale(id, args.slice(2).join(' '));
-          ctx.print(`Marked Agent persona ${persona.id} stale.`);
+          ctx.print(formatPersonaReceipt('Marked Agent persona stale', persona));
           return;
         }
         if (sub === 'delete' || sub === 'remove') {
@@ -292,7 +282,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
             return;
           }
           const removed = registryStore.deletePersona(id);
-          ctx.print(`Deleted Agent persona ${removed.id}: ${removed.name}`);
+          ctx.print(formatPersonaReceipt('Deleted Agent persona', removed));
           return;
         }
         ctx.print('Usage: /personas [list|discover|import-discovered|search <query>|show <id>|create|update|use|active|clear|review|stale|delete]');

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

@@ -111,7 +111,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
       }
 
       if (args[0] === 'panel') {
-        ctx.print('Planning panels are not part of the Agent workspace. Use /plan status or /plan list.');
+        ctx.print('Use /plan status or /plan list for compact command output. Open Agent Workspace -> Work -> Planning status or Saved plans for the workspace view.');
         return;
       }
 

package/src/input/commands/platform-access-runtime.ts

@@ -3,6 +3,7 @@ import { dirname } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { buildAuthInspectionSnapshot, inspectProviderAuth } from '@/runtime/index.ts';
+import { formatAgentRecordSource } from '../../agent/record-labels.ts';
 import { requireSecretsManager, requireServiceRegistry, requireShellPaths, requireSubscriptionManager } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
@@ -18,11 +19,11 @@ interface AuthReviewBundle {
 function inspectAuthBundle(bundle: AuthReviewBundle): string {
   return [
     'Auth Review Bundle',
-    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
-    `  externalRuntimeAuth: ${bundle.externalRuntimeAuth}`,
-    `  stored secrets: ${bundle.secretKeys.length}`,
-    `  active subscriptions: ${bundle.activeSubscriptions.length}`,
-    `  pending subscriptions: ${bundle.pendingSubscriptions.length}`,
+    `  exported at ${new Date(bundle.exportedAt).toISOString()}`,
+    `  connected host auth ${bundle.externalRuntimeAuth}`,
+    `  stored secrets ${bundle.secretKeys.length}`,
+    `  active subscriptions ${bundle.activeSubscriptions.length}`,
+    `  pending subscriptions ${bundle.pendingSubscriptions.length}`,
   ].join('\n');
 }
 
@@ -66,12 +67,12 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
         const builtinProviders = listBuiltinSubscriptionProviders().map((entry) => entry.provider);
         ctx.print([
           'Auth Review',
-          '  connected-host auth: managed outside goodvibes-agent',
-          `  stored secrets: ${snapshot.secretKeyCount}`,
-          `  built-in providers: ${builtinProviders.length}${builtinProviders.length > 0 ? ` (${builtinProviders.join(', ')})` : ''}`,
-          `  active subscriptions: ${snapshot.activeSubscriptions}${snapshot.activeSubscriptions > 0 ? ` (${snapshot.providers.filter((provider) => provider.activeSubscription).map((provider) => provider.provider).join(', ')})` : ''}`,
-          `  pending subscriptions: ${snapshot.pendingSubscriptions}${snapshot.pendingSubscriptions > 0 ? ` (${snapshot.providers.filter((provider) => provider.pendingLogin).map((provider) => provider.provider).join(', ')})` : ''}`,
-          ...snapshot.providers.map((provider) => `  ${provider.provider}  freshness=${provider.freshness}  mode=${provider.callbackMode}  configured=${provider.configured ? 'yes' : 'no'}`),
+          '  connected host auth managed outside goodvibes-agent',
+          `  stored secrets ${snapshot.secretKeyCount}`,
+          `  built-in providers ${builtinProviders.length}${builtinProviders.length > 0 ? ` (${builtinProviders.join(', ')})` : ''}`,
+          `  active subscriptions ${snapshot.activeSubscriptions}${snapshot.activeSubscriptions > 0 ? ` (${snapshot.providers.filter((provider) => provider.activeSubscription).map((provider) => provider.provider).join(', ')})` : ''}`,
+          `  pending subscriptions ${snapshot.pendingSubscriptions}${snapshot.pendingSubscriptions > 0 ? ` (${snapshot.providers.filter((provider) => provider.pendingLogin).map((provider) => provider.provider).join(', ')})` : ''}`,
+          ...snapshot.providers.map((provider) => `  ${provider.provider}  auth ${provider.freshness}  finish manual  configured ${provider.configured ? 'yes' : 'no'}`),
         ].join('\n'));
         return;
       }
@@ -89,19 +90,18 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
         });
         ctx.print([
           `Auth Provider ${provider}`,
-          `  configured: ${inspection.configured ? 'yes' : 'no'}`,
-          ...(inspection.source ? [`  source: ${inspection.source}`] : []),
-          `  freshness: ${inspection.freshness}`,
-          `  callbackMode: ${inspection.callbackMode}`,
-          ...(inspection.redirectUri ? [`  redirectUri: ${inspection.redirectUri}`] : []),
-          ...(inspection.localCallback ? [`  localCallback: ${inspection.localCallback}`] : []),
-          `  activeSubscription: ${inspection.activeSubscription ? 'yes' : 'no'}`,
-          `  pendingLogin: ${inspection.pendingLogin ? 'yes' : 'no'}`,
-          `  overrideAmbientApiKeys: ${inspection.overrideAmbientApiKeys ? 'yes' : 'no'}`,
-          ...(inspection.tokenType ? [`  tokenType: ${inspection.tokenType}`] : []),
-          ...(inspection.expiresAt ? [`  expiresAt: ${new Date(inspection.expiresAt).toISOString()}`] : []),
-          ...inspection.issues.map((issue) => `  issue: ${issue}`),
-          ...inspection.nextActions.map((action) => `  next: ${action}`),
+          `  configured ${inspection.configured ? 'yes' : 'no'}`,
+          ...(inspection.source ? [`  origin ${formatAgentRecordSource(inspection.source)}`] : []),
+          `  freshness ${inspection.freshness}`,
+          '  finish mode explicit manual',
+          ...(inspection.redirectUri ? [`  redirect URI ${inspection.redirectUri}`] : []),
+          `  active subscription ${inspection.activeSubscription ? 'yes' : 'no'}`,
+          `  pending login ${inspection.pendingLogin ? 'yes' : 'no'}`,
+          `  ambient API key override ${inspection.overrideAmbientApiKeys ? 'yes' : 'no'}`,
+          ...(inspection.tokenType ? [`  token type ${inspection.tokenType}`] : []),
+          ...(inspection.expiresAt ? [`  expires at ${new Date(inspection.expiresAt).toISOString()}`] : []),
+          ...inspection.issues.map((issue) => `  issue ${issue}`),
+          ...inspection.nextActions.map((action) => `  next ${action}`),
         ].join('\n'));
         return;
       }
@@ -119,12 +119,12 @@ export function registerPlatformAccessRuntimeCommands(registry: CommandRegistry)
         });
         ctx.print([
           `Auth Repair ${provider}`,
-          `  configured: ${inspection.configured ? 'yes' : 'no'}`,
-          `  freshness: ${inspection.freshness}`,
-          `  callbackMode: ${inspection.callbackMode}`,
-          ...inspection.issues.map((issue) => `  issue: ${issue}`),
+          `  configured ${inspection.configured ? 'yes' : 'no'}`,
+          `  freshness ${inspection.freshness}`,
+          '  finish mode explicit manual',
+          ...inspection.issues.map((issue) => `  issue ${issue}`),
           ...(inspection.nextActions.length > 0
-            ? ['  next:', ...inspection.nextActions.map((action) => `    ${action}`)]
+            ? ['  next', ...inspection.nextActions.map((action) => `    ${action}`)]
             : ['  No active repair actions suggested.']),
         ].join('\n'));
         return;

package/src/input/commands/provider-accounts-runtime.ts

@@ -2,13 +2,34 @@ import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import type {
   ProviderAccountRecord,
   ProviderAccountSnapshot,
-} from '@/runtime/index.ts';
+  ProviderAuthRoute,
+  ProviderRouteRecord,
+} from '../../panels/provider-account-snapshot.ts';
+import { buildProviderAccountSnapshot } from '../../panels/provider-account-snapshot.ts';
 import {
-  requireOperatorClient,
+  requireProvider,
+  requireServiceRegistry,
+  requireSubscriptionManager,
 } from './runtime-services.ts';
+import { formatProviderAuthRouteId } from '../../provider-auth-route-display.ts';
+
+function formatRouteList(routes: readonly ProviderAuthRoute[]): string {
+  return routes.map((route) => formatProviderAuthRouteId(route)).join(', ');
+}
+
+function formatRouteRecord(route: ProviderRouteRecord): string {
+  return `${formatProviderAuthRouteId(route.route)}  ${route.usable ? 'usable' : 'blocked'}  auth ${route.freshness}  ${route.detail}`;
+}
 
 async function loadProviderAccountSnapshot(context: CommandContext): Promise<ProviderAccountSnapshot> {
-  return await requireOperatorClient(context).providers.accountSnapshot();
+  return await buildProviderAccountSnapshot({
+    providerModels: requireProvider(context).providerRegistry,
+    services: requireServiceRegistry(context),
+    subscriptions: requireSubscriptionManager(context),
+    environment: {
+      hasEnvironmentVariable: (name: string) => Boolean(process.env[name]),
+    },
+  });
 }
 
 function findProviderAccountRecord(
@@ -28,7 +49,7 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        ctx.print('Provider account panels are not part of the Agent workspace. Use /accounts review.');
+        ctx.print('Open Agent Workspace -> Setup -> Provider accounts for the workspace view, or run /accounts review for compact command output.');
         return;
       }
       const snapshot = await loadProviderAccountSnapshot(ctx);
@@ -36,16 +57,16 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
         const providerId = args[1];
         const record = findProviderAccountRecord(snapshot, providerId);
         if (!record) {
-          ctx.print(providerId ? `Unknown provider account: ${providerId}` : 'Usage: /accounts routes <provider>');
+          ctx.print(providerId ? `Unknown provider account ${providerId}` : 'Usage: /accounts routes <provider>');
           return;
         }
         ctx.print([
           `Provider Routes ${record.providerId}`,
-          `  preferred: ${record.preferredRoute}`,
-          `  active: ${record.activeRoute}`,
-          `  reason: ${record.activeRouteReason}`,
-          ...record.routeRecords.map((route) => `  ${route.route}  usable=${route.usable ? 'yes' : 'no'}  freshness=${route.freshness}  ${route.detail}`),
-          ...record.routeRecords.flatMap((route) => route.issues.map((issue) => `    issue: ${issue}`)),
+          `  preferred route ${formatProviderAuthRouteId(record.preferredRoute)}`,
+          `  active route ${formatProviderAuthRouteId(record.activeRoute)}`,
+          `  reason ${record.activeRouteReason}`,
+          ...record.routeRecords.map((route) => `  ${formatRouteRecord(route)}`),
+          ...record.routeRecords.flatMap((route) => route.issues.map((issue) => `    issue ${issue}`)),
         ].join('\n'));
         return;
       }
@@ -53,17 +74,17 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
         const providerId = args[1];
         const record = findProviderAccountRecord(snapshot, providerId);
         if (!record) {
-          ctx.print(providerId ? `Unknown provider account: ${providerId}` : 'Usage: /accounts repair <provider>');
+          ctx.print(providerId ? `Unknown provider account ${providerId}` : 'Usage: /accounts repair <provider>');
           return;
         }
         ctx.print([
           `Provider Account Repair ${record.providerId}`,
-          `  active route: ${record.activeRoute}`,
-          `  preferred route: ${record.preferredRoute}`,
-          ...(record.fallbackRisk ? [`  fallback: ${record.fallbackRisk}`] : []),
-          ...(record.issues.map((issue) => `  issue: ${issue}`)),
+          `  active route ${formatProviderAuthRouteId(record.activeRoute)}`,
+          `  preferred route ${formatProviderAuthRouteId(record.preferredRoute)}`,
+          ...(record.fallbackRisk ? [`  routing risk ${record.fallbackRisk}`] : []),
+          ...(record.issues.map((issue) => `  issue ${issue}`)),
           ...(record.recommendedActions.length > 0
-            ? ['  next:', ...record.recommendedActions.map((action) => `    ${action}`)]
+            ? ['  next', ...record.recommendedActions.map((action) => `    ${action}`)]
             : ['  No active repair actions suggested.']),
         ].join('\n'));
         return;
@@ -72,39 +93,39 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
         const providerId = args[1];
         const record = findProviderAccountRecord(snapshot, providerId);
         if (!record) {
-          ctx.print(providerId ? `Unknown provider account: ${providerId}` : 'Usage: /accounts show <provider>');
+          ctx.print(providerId ? `Unknown provider account ${providerId}` : 'Usage: /accounts show <provider>');
           return;
         }
         ctx.print([
           `Provider Account ${record.providerId}`,
-          `  preferredRoute: ${record.preferredRoute}`,
-          `  activeRoute: ${record.activeRoute}`,
-          `  authFreshness: ${record.authFreshness}`,
-          `  configured: ${record.configured ? 'yes' : 'no'}`,
-          `  oauthReady: ${record.oauthReady ? 'yes' : 'no'}`,
-          `  pendingLogin: ${record.pendingLogin ? 'yes' : 'no'}`,
-          `  availableRoutes: ${record.availableRoutes.join(', ')}`,
-          `  modelCount: ${record.modelCount}`,
-          `  routeReason: ${record.activeRouteReason}`,
-          ...(record.fallbackRoute ? [`  fallbackRoute: ${record.fallbackRoute}`] : []),
-          ...(record.fallbackRisk ? [`  fallbackRisk: ${record.fallbackRisk}`] : []),
-          ...(record.expiresAt ? [`  expiresAt: ${new Date(record.expiresAt).toISOString()}`] : []),
-          ...record.routeRecords.map((route) => `  route ${route.route}: usable=${route.usable ? 'yes' : 'no'} freshness=${route.freshness} — ${route.detail}`),
-          ...record.routeRecords.flatMap((route) => route.issues.map((issue) => `    issue: ${issue}`)),
-          ...record.usageWindows.map((entry) => `  window: ${entry.label} — ${entry.detail}`),
-          ...record.issues.map((issue) => `  issue: ${issue}`),
-          ...record.notes.map((note) => `  note: ${note}`),
-          ...record.recommendedActions.map((action) => `  next: ${action}`),
+          `  preferred route ${formatProviderAuthRouteId(record.preferredRoute)}`,
+          `  active route ${formatProviderAuthRouteId(record.activeRoute)}`,
+          `  auth freshness ${record.authFreshness}`,
+          `  configured ${record.configured ? 'yes' : 'no'}`,
+          `  OAuth ready ${record.oauthReady ? 'yes' : 'no'}`,
+          `  pending login ${record.pendingLogin ? 'yes' : 'no'}`,
+          `  available routes ${formatRouteList(record.availableRoutes)}`,
+          `  model count ${record.modelCount}`,
+          `  route reason ${record.activeRouteReason}`,
+          ...(record.fallbackRoute ? [`  fallback route ${formatProviderAuthRouteId(record.fallbackRoute)}`] : []),
+          ...(record.fallbackRisk ? [`  routing risk ${record.fallbackRisk}`] : []),
+          ...(record.expiresAt ? [`  expires at ${new Date(record.expiresAt).toISOString()}`] : []),
+          ...record.routeRecords.map((route) => `  route ${formatRouteRecord(route)}`),
+          ...record.routeRecords.flatMap((route) => route.issues.map((issue) => `    issue ${issue}`)),
+          ...record.usageWindows.map((entry) => `  window ${entry.label} — ${entry.detail}`),
+          ...record.issues.map((issue) => `  issue ${issue}`),
+          ...record.notes.map((note) => `  note ${note}`),
+          ...record.recommendedActions.map((action) => `  next ${action}`),
         ].join('\n'));
         return;
       }
       ctx.print([
         'Provider Account Review',
-        `  providers: ${snapshot.providers.length}`,
-        `  configured: ${snapshot.configuredCount}`,
-        `  issues: ${snapshot.issueCount}`,
+        `  providers ${snapshot.providers.length}`,
+        `  configured ${snapshot.configuredCount}`,
+        `  issues ${snapshot.issueCount}`,
         ...snapshot.providers.map((record) => (
-          `  ${record.providerId}  active=${record.activeRoute}  preferred=${record.preferredRoute}  freshness=${record.authFreshness}  models=${record.modelCount}  issues=${record.issues.length}`
+          `  ${record.providerId}  active route ${formatProviderAuthRouteId(record.activeRoute)}  preferred route ${formatProviderAuthRouteId(record.preferredRoute)}  auth ${record.authFreshness}  models ${record.modelCount}  issues ${record.issues.length}`
         )),
       ].join('\n'));
     },

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

@@ -2,14 +2,14 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { networkInterfaces } from 'node:os';
 import {
   buildCompanionConnectionInfo,
+  type CompanionConnectionInfo,
   encodeConnectionPayload,
-  formatConnectionBlock,
   generateQrMatrix,
   renderQrToString,
 } from '@pellux/goodvibes-sdk/platform/pairing';
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../../config/surface.ts';
 import { resolveRuntimeEndpointBinding } from '../../cli/endpoints.ts';
-import { connectedHostTokenRequiredMessage, readConnectedHostOperatorToken } from '../../runtime/connected-host-auth.ts';
+import { connectedHostOperatorTokenFingerprint, connectedHostTokenRequiredMessage, readConnectedHostOperatorToken } from '../../runtime/connected-host-auth.ts';
 import { requirePlatform, requireShellPaths } from './runtime-services.ts';
 
 function getLocalNetworkIp(): string {
@@ -31,13 +31,42 @@ function urlHostForBindHost(host: string): string {
   return host || '127.0.0.1';
 }
 
+function formatTokenLine(token: string, showToken: boolean): string {
+  if (showToken) return `Token:          ${token}`;
+  return `Token:          present sha256:${connectedHostOperatorTokenFingerprint(token)} (hidden in text; QR contains pairing payload)`;
+}
+
+function formatAgentPairingBlock(info: CompanionConnectionInfo, qr: string, showToken: boolean): string {
+  return [
+    `GoodVibes Agent companion pairing v${info.version}`,
+    '━━━━━━━━━━━━━━━━━━━━━━━━',
+    `Connected host: ${info.url}`,
+    `Surface:        ${info.surface}`,
+    `User:           ${info.username}`,
+    formatTokenLine(info.token, showToken),
+    '',
+    'Scan to connect:',
+    '',
+    qr,
+    '',
+    showToken
+      ? 'Manual token display was explicitly confirmed for this command.'
+      : 'For manual setup, rerun /pair --show-token --yes to print the token once.',
+    'Agent is waiting for the companion app to connect to the owning GoodVibes host.',
+  ].join('\n');
+}
+
+function shouldShowToken(args: readonly string[]): boolean {
+  return args.includes('--show-token') || args.includes('--manual-token');
+}
+
 export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'qrcode',
     aliases: ['qr', 'pair'],
     description: 'Print companion pairing details and a QR code',
     usage: '',
-    handler(_args, ctx) {
+    handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const configManager = requirePlatform(ctx).configManager;
       const tokenRecord = readConnectedHostOperatorToken(shellPaths.homeDirectory);
@@ -46,16 +75,26 @@ export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
       const binding = resolveRuntimeEndpointBinding(configManager, 'controlPlane');
-      const daemonUrl = `http://${urlHostForBindHost(binding.host)}:${binding.port}`;
+      const connectedHostUrl = `http://${urlHostForBindHost(binding.host)}:${binding.port}`;
       const info = buildCompanionConnectionInfo({
-        daemonUrl,
+        daemonUrl: connectedHostUrl,
         token: tokenRecord.token,
         username: 'admin',
         surface: GOODVIBES_AGENT_PAIRING_SURFACE,
       });
       const payload = encodeConnectionPayload(info);
       const qr = renderQrToString(generateQrMatrix(payload));
-      ctx.print([formatConnectionBlock(info, payload), '', qr].join('\n'));
+      const showToken = shouldShowToken(args);
+      if (showToken && !args.includes('--yes')) {
+        ctx.print([
+          'Manual companion token display requires confirmation.',
+          '  rerun: /pair --show-token --yes',
+          `  token fingerprint: sha256:${connectedHostOperatorTokenFingerprint(tokenRecord.token)}`,
+          '  QR pairing remains available without printing the raw token.',
+        ].join('\n'));
+        return;
+      }
+      ctx.print(formatAgentPairingBlock(info, qr, showToken));
     },
   });
 }