@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/input/commands/operator-actions-runtime.ts

@@ -0,0 +1,138 @@
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import {
+  buildOperatorActionRequest,
+  formatOperatorActionFailure,
+  formatOperatorActionPreview,
+  formatOperatorActionSuccess,
+  postOperatorAction,
+  type OperatorActionId,
+} from '../../agent/operator-actions.ts';
+import { resolveAgentConnectedHostConnection } from '../../agent/routine-schedule-promotion.ts';
+import { requireShellPaths } from './runtime-services.ts';
+import { stripYesFlag } from './confirmation.ts';
+
+interface OperatorActionOptionParse {
+  readonly note?: string;
+  readonly remember?: boolean;
+  readonly errors: readonly string[];
+}
+
+function parseOperatorActionOptions(args: readonly string[]): OperatorActionOptionParse {
+  const errors: string[] = [];
+  let note: string | undefined;
+  let remember: boolean | undefined;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === '--note') {
+      const value = args[index + 1];
+      if (!value) {
+        errors.push('--note requires text');
+        continue;
+      }
+      note = value;
+      index += 1;
+      continue;
+    }
+    if (token === '--remember') {
+      remember = true;
+      continue;
+    }
+    if (token === '--no-remember') {
+      remember = false;
+      continue;
+    }
+    errors.push(`Unknown option ${token}`);
+  }
+  return { note, remember, errors };
+}
+
+export async function executeConfirmedOperatorAction(
+  ctx: CommandContext,
+  action: OperatorActionId,
+  targetField: 'approvalId' | 'jobId' | 'runId' | 'scheduleId',
+  targetId: string,
+  rawArgs: readonly string[],
+  usage: string,
+): Promise<void> {
+  const parsed = stripYesFlag(rawArgs);
+  const options = parseOperatorActionOptions(parsed.rest);
+  if (options.errors.length > 0) {
+    ctx.print([`Usage: ${usage}`, ...options.errors.map((error) => `  ${error}`)].join('\n'));
+    return;
+  }
+  const request = buildOperatorActionRequest({
+    action,
+    [targetField]: targetId,
+    note: options.note,
+    remember: options.remember,
+  });
+  if (!request.ok) {
+    ctx.print(request.error);
+    return;
+  }
+  const requestSummary = `/${action} ${targetId}`;
+  if (!parsed.yes) {
+    ctx.print(`${formatOperatorActionPreview(request, requestSummary)}\nUsage: ${usage}`);
+    return;
+  }
+  const shellPaths = requireShellPaths(ctx);
+  const connection = resolveAgentConnectedHostConnection(ctx.platform.configManager, shellPaths.homeDirectory);
+  const result = await postOperatorAction(connection, request);
+  ctx.print(result.ok ? formatOperatorActionSuccess(connection.baseUrl, result) : formatOperatorActionFailure(result));
+}
+
+function approvalActionFromSubcommand(sub: string): OperatorActionId | null {
+  if (sub === 'approve') return 'approvals.approve';
+  if (sub === 'deny') return 'approvals.deny';
+  if (sub === 'cancel') return 'approvals.cancel';
+  return null;
+}
+
+function automationActionFromParts(scope: string, verb: string): {
+  readonly action: OperatorActionId;
+  readonly targetField: 'jobId' | 'runId' | 'scheduleId';
+} | null {
+  if ((scope === 'job' || scope === 'jobs') && verb === 'run') return { action: 'automation.jobs.run', targetField: 'jobId' };
+  if ((scope === 'job' || scope === 'jobs') && verb === 'pause') return { action: 'automation.jobs.pause', targetField: 'jobId' };
+  if ((scope === 'job' || scope === 'jobs') && verb === 'resume') return { action: 'automation.jobs.resume', targetField: 'jobId' };
+  if ((scope === 'run' || scope === 'runs') && verb === 'cancel') return { action: 'automation.runs.cancel', targetField: 'runId' };
+  if ((scope === 'run' || scope === 'runs') && verb === 'retry') return { action: 'automation.runs.retry', targetField: 'runId' };
+  if ((scope === 'schedule' || scope === 'schedules') && verb === 'run') return { action: 'schedules.run', targetField: 'scheduleId' };
+  return null;
+}
+
+export async function handleApprovalOperatorAction(args: readonly string[], ctx: CommandContext): Promise<boolean> {
+  const sub = (args[0] ?? '').toLowerCase();
+  const action = approvalActionFromSubcommand(sub);
+  if (!action) return false;
+  const approvalId = args[1] ?? '';
+  const usage = `/approval ${sub} <approval-id> [--note <text>] [--remember|--no-remember] --yes`;
+  if (!approvalId) {
+    ctx.print(`Usage: ${usage}`);
+    return true;
+  }
+  await executeConfirmedOperatorAction(ctx, action, 'approvalId', approvalId, args.slice(2), usage);
+  return true;
+}
+
+export function registerOperatorActionRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'automation',
+    aliases: ['auto'],
+    description: 'Run confirmed connected-host automation actions from the Agent TUI',
+    usage: 'job <run|pause|resume> <job-id> --yes | run <cancel|retry> <run-id> --yes | schedule run <schedule-id> --yes',
+    argsHint: 'job run <id> --yes | run cancel <id> --yes | schedule run <id> --yes',
+    async handler(args, ctx) {
+      const scope = (args[0] ?? '').toLowerCase();
+      const verb = (args[1] ?? '').toLowerCase();
+      const targetId = args[2] ?? '';
+      const mapping = automationActionFromParts(scope, verb);
+      const usage = '/automation job <run|pause|resume> <job-id> --yes | /automation run <cancel|retry> <run-id> --yes | /automation schedule run <schedule-id> --yes';
+      if (!mapping || !targetId) {
+        ctx.print(`Usage: ${usage}`);
+        return;
+      }
+      await executeConfirmedOperatorAction(ctx, mapping.action, mapping.targetField, targetId, args.slice(3), usage);
+    },
+  });
+}

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

@@ -57,21 +57,6 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
       else ctx.scrollToLine?.(nextLine);
     },
   });
-
-  registry.register({
-    name: 'profiles',
-    aliases: ['profile'],
-    description: 'Blocked copied config-profile command; Agent uses isolated profile homes',
-    usage: 'disabled',
-    argsHint: 'disabled',
-    handler(_args, ctx) {
-      ctx.print([
-        'Copied config profiles are disabled in GoodVibes Agent.',
-        'Use /agent profiles or /agent-profile to create and manage isolated Agent profile homes.',
-      ].join('\n'));
-    },
-  });
-
   registry.register({
     name: 'prev-error',
     aliases: ['pe'],
@@ -153,7 +138,7 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         if (verbosity !== 'minimal' && verbosity !== 'normal' && verbosity !== 'verbose') {
-          ctx.print(`Invalid verbosity "${verbosity}". Valid values: minimal, normal, verbose`);
+          ctx.print(`Invalid verbosity "${verbosity}". Valid values minimal, normal, verbose.`);
           return;
         }
         if (!parsed.yes) {
@@ -161,7 +146,11 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         mgr.setDomainVerbosity(domain, verbosity as 'minimal' | 'normal' | 'verbose');
-        ctx.print(`Domain "${domain}" verbosity set to: ${verbosity}`);
+        ctx.print([
+          'Domain verbosity set',
+          `  domain ${domain}`,
+          `  verbosity ${verbosity}`,
+        ].join('\n'));
         return;
       }
 

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

@@ -1,5 +1,6 @@
 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 { requireShellPaths } from './runtime-services.ts';
 
@@ -44,21 +45,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 +79,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 +97,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 +143,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 +165,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 +178,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 +219,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 +232,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 +250,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 +262,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 +282,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 +292,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 +307,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'));
     },