@pellux/goodvibes-agent 0.1.111 → 0.1.112

package/docs/getting-started.md

@@ -96,9 +96,9 @@ Memory, personas, routines, and reusable Agent skills are local to GoodVibes Age
 /channels
 /agent-skills create --name "Morning Brief" --description "Daily briefing flow" --procedure "Check tasks, approvals, calendar, and unread state before summarizing." --enabled true
 /agent-skills enabled
-/skills local list
-/recall add fact Prefers concise morning briefings --scope project --tags preference
-/recall search morning
+/skills list
+/memory add fact "Prefers concise morning briefings" --scope project --tags preference
+/memory search morning
 ```
 
 The active persona plus enabled Agent routines, reviewed memory, and skills are injected into the main serial assistant conversation. Starting a routine records local usage and prints its steps; it does not spawn background agents or automation jobs. Promoting a routine to a schedule is an explicit `schedules.create` call, requires `--yes`, writes a local redacted promotion receipt, and preserves the rule that Agent Knowledge never falls back to default Knowledge/Wiki or non-Agent knowledge segments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.111",
+  "version": "0.1.112",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/cli/help.ts

@@ -366,7 +366,6 @@ const HELP_ALIASES: Record<string, string> = {
   skill: 'skills',
   'agent-skills': 'skills',
   memories: 'memory',
-  recall: 'memory',
   subscriptions: 'subscription',
   secret: 'secrets',
   session: 'sessions',

package/src/cli/parser.ts

@@ -26,7 +26,6 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   'agent-skills': 'skills',
   memory: 'memory',
   memories: 'memory',
-  recall: 'memory',
   routines: 'routines',
   routine: 'routines',
   auth: 'auth',
@@ -66,7 +65,6 @@ function createDefaultFlags(): GoodVibesCliFlags {
     provider: undefined,
     model: undefined,
     agentProfile: undefined,
-    daemonHome: undefined,
     runtimeUrl: undefined,
     workingDir: undefined,
     help: false,
@@ -286,12 +284,6 @@ export function parseGoodVibesCli(
       if (consumed.value !== undefined) flags = withFlag(flags, 'agentProfile', consumed.value);
       continue;
     }
-    if (name === '--daemon-home') {
-      const consumed = getValue(argv, index, inlineValue, name, errors);
-      index = consumed.nextIndex;
-      if (consumed.value !== undefined) flags = withFlag(flags, 'daemonHome', consumed.value);
-      continue;
-    }
     if (name === '--runtime-url' || name === '--runtime') {
       const consumed = getValue(argv, index, inlineValue, name, errors);
       index = consumed.nextIndex;

package/src/cli/types.ts

@@ -39,7 +39,6 @@ export interface GoodVibesCliFlags {
   readonly provider: string | undefined;
   readonly model: string | undefined;
   readonly agentProfile: string | undefined;
-  readonly daemonHome: string | undefined;
   readonly runtimeUrl: string | undefined;
   readonly workingDir: string | undefined;
   readonly help: boolean;

package/src/input/agent-workspace-categories.ts

@@ -52,7 +52,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Agent uses connected channel accounts. Pairing, account inspection, and readiness checks are visible here; inbound delivery and public channel exposure stay policy-gated.',
     actions: [
       { id: 'pair', label: 'Pair companion', detail: 'Open the QR pairing view for companion app setup.', command: '/pair', kind: 'command', safety: 'safe' },
-      { id: 'channel-readiness', label: 'Channel readiness', detail: 'Show a read-only readiness matrix for configured messaging and notification channels.', command: '/channels', kind: 'command', safety: 'read-only' },
+      { id: 'channel-readiness', label: 'Channel readiness', detail: 'Show the read-only readiness matrix, then use /channels attention or /channels show <id> for setup detail.', command: '/channels', kind: 'command', safety: 'read-only' },
       { id: 'notification-routes', label: 'Notification routes', detail: 'Inspect configured webhook notification URLs without sending a test message.', command: '/notify list', kind: 'command', safety: 'read-only' },
       { id: 'notification-add-webhook', label: 'Add webhook target', detail: 'Open a confirmed form that adds one webhook notification target for explicit reminder and routine delivery.', editorKind: 'notify-webhook', kind: 'editor', safety: 'safe' },
       { id: 'notification-remove-webhook', label: 'Remove webhook target', detail: 'Open a confirmed form that removes one exact webhook notification target from Agent delivery.', editorKind: 'notify-webhook-remove', kind: 'editor', safety: 'safe' },
@@ -116,10 +116,9 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     id: 'profiles',
     group: 'SETUP',
     label: 'Profiles',
-    summary: 'Isolated Agent homes, config profiles, and setup bundles.',
-    detail: 'Profiles isolate Agent state. Named homes and starter templates let one install behave like separate assistants for household, research, travel, operations, or personal workflows.',
+    summary: 'Isolated Agent homes, starter templates, and setup bundles.',
+    detail: 'Agent profiles isolate Agent state. Named homes and starter templates let one install behave like separate assistants for household, research, travel, operations, or personal workflows.',
     actions: [
-      { id: 'profiles-open', label: 'Open config profiles', detail: 'Open the config profile picker for display/provider/behavior profile files.', command: '/profiles', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-guide', label: 'Starter authoring guide', detail: 'Open the Agent-local starter authoring flow inside the Agent TUI.', command: '/agent-profile guide', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-templates', label: 'Browse starter templates', detail: 'List built-in and local Agent starter templates with persona, skill, routine, and source details.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
       { id: 'runtime-profile-list', label: 'List Agent profiles', detail: 'List isolated Agent profile homes under this Agent home.', command: '/agent-profile list', kind: 'command', safety: 'read-only' },
@@ -221,9 +220,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     summary: 'Visible task state, work plan, and approval posture.',
     detail: 'Use this workspace to inspect active operator state. Side-effecting approval decisions require explicit commands and confirmation outside this workspace.',
     actions: [
-      { id: 'workplan', label: 'Open work plan', detail: 'Open the workspace-scoped work plan panel.', command: '/workplan panel', kind: 'command', safety: 'read-only' },
-      { id: 'workplan-list', label: 'List work plan', detail: 'Print a concise work plan summary.', command: '/workplan list', kind: 'command', safety: 'read-only' },
-      { id: 'approvals', label: 'Review approvals', detail: 'Open/read approval posture. This workspace does not approve or deny requests.', command: '/approval open', kind: 'command', safety: 'read-only' },
+      { id: 'workplan', label: 'Review work plan', detail: 'Print a concise work plan summary in the main Agent transcript.', command: '/workplan list', kind: 'command', safety: 'read-only' },
+      { id: 'approvals', label: 'Review approvals', detail: 'Print the approval matrix without approving or denying requests.', command: '/approval matrix', kind: 'command', safety: 'read-only' },
     ],
   },
   {

package/src/input/agent-workspace-snapshot.ts

@@ -240,13 +240,6 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return [];
     }
   })();
-  const configProfileCount = (() => {
-    try {
-      return context.workspace?.profileManager?.list?.().length ?? 0;
-    } catch {
-      return 0;
-    }
-  })();
   const runtimeStarterTemplates = (() => {
     try {
       return listAgentRuntimeProfileTemplates(context.workspace?.shellPaths?.homeDirectory ?? '');
@@ -379,8 +372,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     mcpConnectedServerCount: mcpSnapshot.connectedCount,
     mcpQuarantinedServerCount: mcpSnapshot.quarantinedCount,
     mcpAllowAllServerCount: mcpSnapshot.allowAllCount,
-    browserSurfaceEnabled: readConfigBoolean(context, 'web.enabled', false),
-    browserSurfacePublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
+    browserToolExposureEnabled: readConfigBoolean(context, 'web.enabled', false),
+    browserToolPublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeProfileCount: runtimeProfiles.length,
     runtimeProfiles: runtimeProfiles.map(summarizeRuntimeProfile),
@@ -388,7 +381,6 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     runtimeStarterTemplateCount: runtimeStarterTemplates.length,
     localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
     runtimeStarterTemplates: runtimeStarterTemplates.map(summarizeStarterTemplate),
-    configProfileCount,
     setupChecklist,
     warnings,
   };

package/src/input/agent-workspace-types.ts

@@ -190,8 +190,8 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly mcpConnectedServerCount: number;
   readonly mcpQuarantinedServerCount: number;
   readonly mcpAllowAllServerCount: number;
-  readonly browserSurfaceEnabled: boolean;
-  readonly browserSurfacePublicBaseUrl: string;
+  readonly browserToolExposureEnabled: boolean;
+  readonly browserToolPublicBaseUrl: string;
   readonly activeRuntimeProfile: string;
   readonly runtimeProfileCount: number;
   readonly runtimeProfiles: readonly AgentWorkspaceRuntimeProfileItem[];
@@ -199,7 +199,6 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly runtimeStarterTemplateCount: number;
   readonly localStarterTemplateCount: number;
   readonly runtimeStarterTemplates: readonly AgentWorkspaceRuntimeStarterTemplateItem[];
-  readonly configProfileCount: number;
   readonly setupChecklist: readonly AgentWorkspaceSetupChecklistItem[];
   readonly warnings: readonly string[];
 }

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

@@ -101,7 +101,7 @@ export function formatAgentOperatorBriefing(ctx: CommandContext): string {
     `  skills: ${snapshot.enabledSkillCount}/${snapshot.localSkillCount} enabled; bundles ${snapshot.enabledSkillBundleCount}/${snapshot.localSkillBundleCount}; active ${snapshot.activeSkillCount}`,
     `  routines: ${snapshot.enabledRoutineCount}/${snapshot.localRoutineCount} enabled`,
     `  channels: ${readyChannels}/${snapshot.channels.length} ready; ${enabledChannels} enabled`,
-    `  voice/media: ${snapshot.voiceProviderCount} voice, ${snapshot.mediaProviderCount} media; browser surface ${snapshot.browserSurfaceEnabled ? 'enabled' : 'disabled'}`,
+    `  voice/media: ${snapshot.voiceProviderCount} voice, ${snapshot.mediaProviderCount} media; browser tools ${snapshot.voiceMediaReadiness.browserToolState}`,
     formatWorkPlanLine(workPlan.total, workPlan.counts),
     `  schedules: ${enabledJobs}/${jobs.length} visible jobs enabled`,
     '',

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

@@ -1,47 +1,409 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
+import type { CommandContext } from '../command-registry.ts';
+import type { AgentWorkspaceChannelStatus } from '../agent-workspace-channels.ts';
 import { buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
 
+type ChannelFilter = 'all' | 'ready' | 'attention';
+type JsonRecord = Record<string, unknown>;
+
+interface ChannelDaemonConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly tokenPath: string;
+}
+
+interface ChannelRouteSuccess {
+  readonly ok: true;
+  readonly route: string;
+  readonly body: unknown;
+}
+
+interface ChannelRouteFailure {
+  readonly ok: false;
+  readonly route: string;
+  readonly kind: 'auth_required' | 'daemon_unavailable' | 'route_unavailable' | 'daemon_error';
+  readonly message: string;
+}
+
+type ChannelRouteResult = ChannelRouteSuccess | ChannelRouteFailure;
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(record: JsonRecord, key: string, fallback = ''): string {
+  const value = record[key];
+  return typeof value === 'string' ? value : fallback;
+}
+
+function readBoolean(record: JsonRecord, key: string, fallback = false): boolean {
+  const value = record[key];
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function readRecordArray(record: JsonRecord, key: string): readonly JsonRecord[] {
+  const value = record[key];
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+
+function resolveChannelDaemonConnection(context: CommandContext): ChannelDaemonConnection {
+  const hostValue = context.platform?.configManager?.get('controlPlane.host');
+  const portValue = context.platform?.configManager?.get('controlPlane.port');
+  const host = typeof hostValue === 'string' && hostValue.trim().length > 0 ? hostValue.trim() : '127.0.0.1';
+  const port = typeof portValue === 'number' && Number.isFinite(portValue) ? portValue : 3421;
+  const homeDirectory = context.workspace?.shellPaths?.homeDirectory ?? process.env.HOME ?? '';
+  const tokenPath = join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  if (!existsSync(tokenPath)) return { baseUrl: `http://${host}:${port}`, token: null, tokenPath };
+  try {
+    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
+    return { baseUrl: `http://${host}:${port}`, token, tokenPath };
+  } catch {
+    return { baseUrl: `http://${host}:${port}`, token: null, tokenPath };
+  }
+}
+
+async function fetchChannelRoute(context: CommandContext, route: string): Promise<ChannelRouteResult> {
+  const connection = resolveChannelDaemonConnection(context);
+  if (!connection.token) {
+    return {
+      ok: false,
+      route,
+      kind: 'auth_required',
+      message: `No runtime operator token found at ${connection.tokenPath}`,
+    };
+  }
+
+  try {
+    const response = await fetch(`${connection.baseUrl}${route}`, {
+      headers: { authorization: `Bearer ${connection.token}` },
+    });
+    const text = await response.text();
+    let body: unknown = text;
+    if (text.trim().length > 0) {
+      try {
+        body = JSON.parse(text) as unknown;
+      } catch {
+        body = text;
+      }
+    }
+    if (!response.ok) {
+      const detail = isRecord(body) && typeof body.error === 'string' ? body.error : text;
+      return {
+        ok: false,
+        route,
+        kind: response.status === 401 || response.status === 403
+          ? 'auth_required'
+          : response.status === 404
+            ? 'route_unavailable'
+            : 'daemon_error',
+        message: `HTTP ${response.status}${detail ? `: ${detail}` : ''}`,
+      };
+    }
+    return { ok: true, route, body };
+  } catch (error) {
+    return {
+      ok: false,
+      route,
+      kind: 'daemon_unavailable',
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function formatChannelRouteFailure(title: string, failure: ChannelRouteFailure): string {
+  return [
+    `${title}: unavailable`,
+    `  kind: ${failure.kind}`,
+    `  route: ${failure.route}`,
+    `  error: ${failure.message}`,
+    '  policy: read-only; no channel send/action route was called',
+  ].join('\n');
+}
+
+function formatChannelLine(channel: AgentWorkspaceChannelStatus): string {
+  const missing = channel.missingRequiredKeys.length > 0
+    ? ` missing=${channel.missingRequiredKeys.join('|')}`
+    : '';
+  const target = channel.configuredDefaultTargetKeys.length > 0
+    ? ` target=${channel.configuredDefaultTargetKeys.join('|')}`
+    : channel.defaultTargetKeys.length > 0
+      ? ` target=missing(${channel.defaultTargetKeys.join('|')})`
+      : ' target=not-required';
+  return [
+    `  ${channel.label}: ${channel.setupState}`,
+    `ready=${channel.ready ? 'yes' : 'no'}`,
+    `delivery=${channel.delivery}`,
+    `risk=${channel.risk}`,
+    target,
+    missing,
+  ].join(' ');
+}
+
+function filterChannels(
+  channels: readonly AgentWorkspaceChannelStatus[],
+  filter: ChannelFilter,
+): readonly AgentWorkspaceChannelStatus[] {
+  if (filter === 'ready') return channels.filter((channel) => channel.ready);
+  if (filter === 'attention') return channels.filter((channel) => channel.enabled && channel.setupState !== 'ready');
+  return channels;
+}
+
+function printChannelSummary(
+  print: (message: string) => void,
+  channels: readonly AgentWorkspaceChannelStatus[],
+  filter: ChannelFilter,
+): void {
+  const ready = channels.filter((channel) => channel.ready);
+  const enabled = channels.filter((channel) => channel.enabled);
+  const needsTarget = channels.filter((channel) => channel.setupState === 'needs-target');
+  const needsConfig = channels.filter((channel) => channel.setupState === 'needs-config');
+  const filtered = filterChannels(channels, filter);
+  const title = filter === 'ready'
+    ? 'Channel Readiness: Ready'
+    : filter === 'attention'
+      ? 'Channel Readiness: Needs Attention'
+      : 'Channel Readiness';
+  const lines: string[] = [
+    title,
+    `  ready: ${ready.length}/${channels.length}`,
+    `  enabled: ${enabled.length}/${channels.length}`,
+    `  needs target: ${needsTarget.length}`,
+    `  needs config: ${needsConfig.length}`,
+    '  policy: read-only inspection; sends require explicit user action and Agent policy',
+    '  details: /channels show <id>',
+    '',
+    ...(filtered.length > 0
+      ? filtered.map(formatChannelLine)
+      : [`  No ${filter === 'ready' ? 'ready' : 'attention'} channels matched.`]),
+  ];
+  print(lines.join('\n'));
+}
+
+function printChannelDetail(
+  print: (message: string) => void,
+  channel: AgentWorkspaceChannelStatus,
+): void {
+  print([
+    `Channel: ${channel.label} (${channel.id})`,
+    `  state: ${channel.setupState}`,
+    `  enabled: ${channel.enabled ? 'yes' : 'no'}`,
+    `  ready: ${channel.ready ? 'yes' : 'no'}`,
+    `  delivery: ${channel.delivery}`,
+    `  risk: ${channel.risk} (${channel.riskLabel})`,
+    `  required config keys: ${channel.requiredKeys.join(', ') || 'none'}`,
+    `  missing config keys: ${channel.missingRequiredKeys.join(', ') || 'none'}`,
+    `  default target keys: ${channel.defaultTargetKeys.join(', ') || 'not required'}`,
+    `  configured target keys: ${channel.configuredDefaultTargetKeys.join(', ') || 'none'}`,
+    `  next: ${channel.nextStep}`,
+    '  policy: this command never prints secret values and never sends messages',
+  ].join('\n'));
+}
+
+function formatChannelAccounts(body: unknown): string {
+  const root = isRecord(body) ? body : {};
+  const accounts = readRecordArray(root, 'accounts');
+  const lines = [
+    'Channel Accounts',
+    `  accounts: ${accounts.length}`,
+    '  policy: read-only account posture; secret values are never shown',
+    '',
+  ];
+  if (accounts.length === 0) return [...lines, '  No channel accounts reported by connected services.'].join('\n');
+  for (const account of accounts.slice(0, 20)) {
+    const surface = readString(account, 'surface', 'unknown');
+    const accountId = readString(account, 'accountId', '');
+    const authState = readString(account, 'authState', readString(account, 'state', 'unknown'));
+    const configured = readBoolean(account, 'configured') ? 'configured' : 'not-configured';
+    const linked = readBoolean(account, 'linked') ? 'linked' : 'not-linked';
+    const secrets = readRecordArray(account, 'secrets')
+      .map((secret) => `${readString(secret, 'field', 'secret')}:${readString(secret, 'source', 'configured')}`)
+      .join(', ') || 'none';
+    lines.push(`  ${surface}${accountId ? `/${accountId}` : ''}: ${configured}; ${linked}; auth=${authState}; secret refs=${secrets}`);
+  }
+  if (accounts.length > 20) lines.push(`  ${accounts.length - 20} more account(s) omitted.`);
+  return lines.join('\n');
+}
+
+function formatChannelPolicies(body: unknown): string {
+  const root = isRecord(body) ? body : {};
+  const policies = readRecordArray(root, 'policies');
+  const lines = [
+    'Channel Policies',
+    `  policies: ${policies.length}`,
+    '  policy: read-only policy posture; use exact confirmed commands for changes',
+    '',
+  ];
+  if (policies.length === 0) return [...lines, '  No channel policies reported by connected services.'].join('\n');
+  for (const policy of policies.slice(0, 20)) {
+    const surface = readString(policy, 'surface', 'unknown');
+    const direct = readBoolean(policy, 'allowDirectMessages') ? 'direct=yes' : 'direct=no';
+    const users = Array.isArray(policy.allowlistUserIds) ? policy.allowlistUserIds.length : 0;
+    const groups = Array.isArray(policy.allowlistGroupIds) ? policy.allowlistGroupIds.length : 0;
+    const groupPolicies = readRecordArray(policy, 'groupPolicies').length;
+    lines.push(`  ${surface}: ${direct}; allowlist users=${users}; groups=${groups}; group policies=${groupPolicies}`);
+  }
+  if (policies.length > 20) lines.push(`  ${policies.length - 20} more policy record(s) omitted.`);
+  return lines.join('\n');
+}
+
+function formatChannelStatus(body: unknown): string {
+  const root = isRecord(body) ? body : {};
+  const channels = readRecordArray(root, 'channels');
+  const lines = [
+    'Connected Channel Status',
+    `  channels: ${channels.length}`,
+    '  policy: read-only connected-service status',
+    '',
+  ];
+  if (channels.length === 0) return [...lines, '  No connected channel status reported.'].join('\n');
+  for (const channel of channels.slice(0, 20)) {
+    const surface = readString(channel, 'surface', 'unknown');
+    const state = readString(channel, 'state', readString(channel, 'status', 'unknown'));
+    const enabled = readBoolean(channel, 'enabled') ? 'enabled' : 'disabled';
+    const ready = readBoolean(channel, 'ready') ? 'ready' : 'not-ready';
+    lines.push(`  ${surface}: ${enabled}; ${ready}; state=${state}`);
+  }
+  if (channels.length > 20) lines.push(`  ${channels.length - 20} more channel(s) omitted.`);
+  return lines.join('\n');
+}
+
+function formatChannelDoctor(surface: string, body: unknown): string {
+  const root = isRecord(body) ? body : {};
+  const checks = readRecordArray(root, 'checks');
+  const repairActions = readRecordArray(root, 'repairActions');
+  const lines = [
+    `Channel Doctor: ${readString(root, 'surface', surface)}`,
+    `  checks: ${checks.length}`,
+    `  repair actions: ${repairActions.length}`,
+    '  policy: read-only doctor report; repair actions are not run here',
+    '',
+  ];
+  if (checks.length === 0) lines.push('  No doctor checks reported.');
+  for (const check of checks.slice(0, 20)) {
+    lines.push(`  ${readString(check, 'id', 'check')}: ${readString(check, 'status', 'unknown')}`);
+  }
+  if (repairActions.length > 0) {
+    lines.push('', '  Available repair action ids:');
+    for (const action of repairActions.slice(0, 12)) lines.push(`  - ${readString(action, 'id', 'action')}`);
+  }
+  return lines.join('\n');
+}
+
+function formatChannelSetup(surface: string, body: unknown): string {
+  const root = isRecord(body) ? body : {};
+  const fields = readRecordArray(root, 'fields');
+  const secretTargets = readRecordArray(root, 'secretTargets');
+  const lines = [
+    `Channel Setup Schema: ${readString(root, 'surface', surface)}`,
+    `  version: ${typeof root.version === 'number' ? root.version : 'unknown'}`,
+    `  fields: ${fields.length}`,
+    `  secret targets: ${secretTargets.length}`,
+    '  policy: read-only setup schema; no credentials or values are printed',
+    '',
+  ];
+  if (fields.length > 0) {
+    lines.push('  Fields:');
+    for (const field of fields.slice(0, 20)) lines.push(`  - ${readString(field, 'id', 'field')}`);
+  }
+  if (secretTargets.length > 0) {
+    lines.push('', '  Secret targets:');
+    for (const target of secretTargets.slice(0, 12)) {
+      const required = readBoolean(target, 'required') ? 'required' : 'optional';
+      lines.push(`  - ${readString(target, 'id', 'secret')} (${required})`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function printReadOnlyChannelRoute(
+  context: CommandContext,
+  title: string,
+  route: string,
+  format: (body: unknown) => string,
+): Promise<void> {
+  const result = await fetchChannelRoute(context, route);
+  if (!result.ok) {
+    context.print(formatChannelRouteFailure(title, result));
+    return;
+  }
+  context.print(format(result.body));
+}
+
 export function registerChannelsRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'channels',
     aliases: ['channel'],
     description: 'Inspect Agent channel readiness without sending messages',
-    usage: '[list|readiness]',
-    argsHint: 'list|readiness',
-    handler(_args, ctx) {
+    usage: '[list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]',
+    argsHint: 'list|readiness|ready|attention|show|accounts|policies|status|doctor|setup',
+    async handler(args, ctx) {
       const channels = buildAgentWorkspaceChannels(ctx);
-      const ready = channels.filter((channel) => channel.ready);
-      const enabled = channels.filter((channel) => channel.enabled);
-      const needsTarget = channels.filter((channel) => channel.setupState === 'needs-target');
-      const needsConfig = channels.filter((channel) => channel.setupState === 'needs-config');
-      const lines: string[] = [
-        'Channel Readiness',
-        `  ready: ${ready.length}/${channels.length}`,
-        `  enabled: ${enabled.length}/${channels.length}`,
-        `  needs target: ${needsTarget.length}`,
-        `  needs config: ${needsConfig.length}`,
-        '  policy: read-only inspection; sends require explicit user action and Agent policy',
-        '',
-        ...channels.map((channel) => {
-          const missing = channel.missingRequiredKeys.length > 0
-            ? ` missing=${channel.missingRequiredKeys.join('|')}`
-            : '';
-          const target = channel.configuredDefaultTargetKeys.length > 0
-            ? ` target=${channel.configuredDefaultTargetKeys.join('|')}`
-            : channel.defaultTargetKeys.length > 0
-              ? ` target=missing(${channel.defaultTargetKeys.join('|')})`
-              : ' target=not-required';
-          return [
-            `  ${channel.label}: ${channel.setupState}`,
-            `ready=${channel.ready ? 'yes' : 'no'}`,
-            `delivery=${channel.delivery}`,
-            `risk=${channel.risk}`,
-            target,
-            missing,
-          ].join(' ');
-        }),
-      ];
-      ctx.print(lines.join('\n'));
+      const subcommand = (args[0] ?? 'readiness').trim().toLowerCase();
+
+      if (subcommand === 'list' || subcommand === 'readiness') {
+        printChannelSummary(ctx.print, channels, 'all');
+        return;
+      }
+
+      if (subcommand === 'ready') {
+        printChannelSummary(ctx.print, channels, 'ready');
+        return;
+      }
+
+      if (subcommand === 'attention' || subcommand === 'issues') {
+        printChannelSummary(ctx.print, channels, 'attention');
+        return;
+      }
+
+      if (subcommand === 'show') {
+        const channelId = args[1]?.trim().toLowerCase();
+        if (!channelId) {
+          ctx.print('Usage: /channels show <id>');
+          return;
+        }
+        const channel = channels.find((entry) => entry.id.toLowerCase() === channelId || entry.label.toLowerCase() === channelId);
+        if (!channel) {
+          ctx.print(`Unknown channel: ${channelId}\nUse /channels list to see available channel ids.`);
+          return;
+        }
+        printChannelDetail(ctx.print, channel);
+        return;
+      }
+
+      if (subcommand === 'accounts') {
+        await printReadOnlyChannelRoute(ctx, 'Channel accounts', '/api/channels/accounts', formatChannelAccounts);
+        return;
+      }
+
+      if (subcommand === 'policies') {
+        await printReadOnlyChannelRoute(ctx, 'Channel policies', '/api/channels/policies', formatChannelPolicies);
+        return;
+      }
+
+      if (subcommand === 'status') {
+        await printReadOnlyChannelRoute(ctx, 'Channel status', '/api/channels/status', formatChannelStatus);
+        return;
+      }
+
+      if (subcommand === 'doctor' || subcommand === 'setup') {
+        const channelId = args[1]?.trim().toLowerCase();
+        if (!channelId) {
+          ctx.print(`Usage: /channels ${subcommand} <id>`);
+          return;
+        }
+        const encoded = encodeURIComponent(channelId);
+        if (subcommand === 'doctor') {
+          await printReadOnlyChannelRoute(ctx, 'Channel doctor', `/api/channels/doctor/${encoded}`, (body) => formatChannelDoctor(channelId, body));
+          return;
+        }
+        await printReadOnlyChannelRoute(ctx, 'Channel setup', `/api/channels/setup/${encoded}`, (body) => formatChannelSetup(channelId, body));
+        return;
+      }
+
+      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]');
     },
   });
 }

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

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
-import { requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { requireShellPaths } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 interface VoiceBundle {
@@ -29,12 +29,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
     async handler(args, ctx) {
       const sub = (args[0] ?? 'matrix').toLowerCase();
       if (sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('approval');
-        else {
-          const panelManager = requirePanelManager(ctx);
-          panelManager.open('approval');
-          panelManager.show();
-        }
+        ctx.print('Approval panels are not part of the Agent workspace. Use /approval matrix.');
         return;
       }
       const matrix = [
@@ -64,11 +59,11 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ctx.print([
           `Approval Review: ${entry[0]}`,
           `  ${entry[1]}`,
-          '  Related workspaces: /security, /policy preflight, /trust, /mcp',
+          '  Related workspaces: /security, /trust, /mcp',
         ].join('\n'));
         return;
       }
-      ctx.print('Usage: /approval [open|matrix|review <kind>]');
+      ctx.print('Usage: /approval [matrix|review <kind>]');
     },
   });