@pellux/goodvibes-agent 0.1.76 → 0.1.78

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.78 - 2026-06-01
+
+- Expanded the Agent channel workspace into a concrete readiness matrix with setup state, missing runtime config keys, default-target posture, and safe next steps for each externally owned channel.
+- Kept channel setup read-only inside Agent: no runtime lifecycle ownership, no hidden sends, and no secret values rendered.
+
+## 0.1.77 - 2026-06-01
+
+- Added a first-class Agent profile creation form inside the fullscreen operator workspace instead of dispatching a placeholder command template.
+- Surfaced profile and starter-template summaries directly in the Profiles workspace so day-one setup can pick an isolated Agent home from the TUI.
+- Made Agent runtime profile creation refuse existing profile homes to protect local profile state across CLI, onboarding, and workspace flows.
+
 ## 0.1.76 - 2026-05-31
 
 - Added optional starter profile creation to first-run onboarding so setup can create an isolated Agent home seeded with persona, skill, and routine templates.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "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/agent/runtime-profile.ts

@@ -727,6 +727,9 @@ export function listAgentRuntimeProfiles(baseHomeDirectory: string): readonly Ag
 
 export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName: string, options: CreateAgentRuntimeProfileOptions = {}): AgentRuntimeProfileInfo {
   const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
+  if (existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile already exists: ${resolution.id}`);
+  }
   mkdirSync(resolution.homeDirectory, { recursive: true });
   const createdAt = new Date().toISOString();
   const appliedTemplate = options.templateId

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

@@ -98,7 +98,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'profile-sync-list', label: 'Profile sync list', detail: 'Inspect saved config profiles available for export/import.', command: '/profilesync list', kind: 'command', safety: 'read-only' },
       { id: 'profile-sync-export', label: 'Export profile sync', detail: 'Export config profiles to a portable bundle. Requires a real path and explicit --yes.', command: '/profilesync export <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'setup-transfer-export', label: 'Export setup transfer', detail: 'Export Agent setup transfer data from the current home. Requires a real path and explicit --yes.', command: '/setup transfer export <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'runtime-profile-create', label: 'Create Agent profile', detail: 'Create an isolated Agent profile from a built-in or local starter. Requires a real name and explicit --yes.', command: '/agent-profile create <name> --template <id> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-create', label: 'Create Agent profile', detail: 'Open an in-workspace form that creates an isolated Agent home from a built-in or local starter.', editorKind: 'profile', kind: 'editor', safety: 'safe' },
       { id: 'runtime-profile-template-edit', label: 'Customize starter', detail: 'Export a starter JSON file, edit it, import it as a local starter, then create a profile from it.', command: '/agent-profile template export <id> <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-switch', label: 'Switch Agent profile', detail: 'Launch goodvibes-agent --agent-profile <name> to use that isolated Agent home. This workspace cannot switch the current process home after startup.', kind: 'guidance', safety: 'safe' },
     ],

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

@@ -7,11 +7,17 @@ export interface AgentWorkspaceChannelStatus {
   readonly label: string;
   readonly enabled: boolean;
   readonly ready: boolean;
+  readonly requiredKeys: readonly string[];
+  readonly missingRequiredKeys: readonly string[];
   readonly missingConfigCount: number;
+  readonly defaultTargetKeys: readonly string[];
+  readonly configuredDefaultTargetKeys: readonly string[];
   readonly defaultTarget: 'configured' | 'missing' | 'not-required';
   readonly delivery: 'disabled' | 'blocked' | 'explicit-target' | 'default-ready';
   readonly risk: AgentWorkspaceChannelRisk;
   readonly riskLabel: string;
+  readonly setupState: 'disabled' | 'needs-config' | 'needs-target' | 'ready';
+  readonly nextStep: string;
 }
 
 interface AgentWorkspaceConfigReader {
@@ -182,10 +188,12 @@ function hasConfigValue(context: CommandContext, key: string): boolean {
 
 function buildChannelStatus(context: CommandContext, spec: AgentWorkspaceChannelSpec): AgentWorkspaceChannelStatus {
   const enabled = readConfigBoolean(context, spec.enabledKey, false);
-  const missingConfigCount = spec.requiredKeys.filter((key) => !hasConfigValue(context, key)).length;
+  const missingRequiredKeys = spec.requiredKeys.filter((key) => !hasConfigValue(context, key));
+  const configuredDefaultTargetKeys = spec.defaultTargetKeys.filter((key) => hasConfigValue(context, key));
+  const missingConfigCount = missingRequiredKeys.length;
   const defaultTarget = spec.defaultTargetKeys.length === 0
     ? 'not-required'
-    : spec.defaultTargetKeys.some((key) => hasConfigValue(context, key))
+    : configuredDefaultTargetKeys.length > 0
       ? 'configured'
       : 'missing';
   const ready = enabled && missingConfigCount === 0;
@@ -196,16 +204,36 @@ function buildChannelStatus(context: CommandContext, spec: AgentWorkspaceChannel
       : defaultTarget === 'configured'
         ? 'default-ready'
         : 'explicit-target';
+  const setupState = !enabled
+    ? 'disabled'
+    : missingConfigCount > 0
+      ? 'needs-config'
+      : defaultTarget === 'missing'
+        ? 'needs-target'
+        : 'ready';
+  const nextStep = setupState === 'disabled'
+    ? `Enable ${spec.label} in the owning GoodVibes runtime before Agent can use it.`
+    : setupState === 'needs-config'
+      ? `Configure ${missingRequiredKeys.join(', ')} in the owning runtime or secret manager.`
+      : setupState === 'needs-target'
+        ? `Provide an explicit delivery target per send, or configure one of ${spec.defaultTargetKeys.join(', ')}.`
+        : `Use explicit user action or runtime policy to send through ${spec.label}.`;
   return {
     id: spec.id,
     label: spec.label,
     enabled,
     ready,
+    requiredKeys: spec.requiredKeys,
+    missingRequiredKeys,
     missingConfigCount,
+    defaultTargetKeys: spec.defaultTargetKeys,
+    configuredDefaultTargetKeys,
     defaultTarget,
     delivery,
     risk: spec.risk,
     riskLabel: spec.riskLabel,
+    setupState,
+    nextStep,
   };
 }
 

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

@@ -1,9 +1,36 @@
 import type { AgentPersonaRecord } from '../agent/persona-registry.ts';
 import type { AgentRoutineRecord } from '../agent/routine-registry.ts';
 import type { AgentSkillRecord } from '../agent/skill-registry.ts';
-import type { AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem } from './agent-workspace-types.ts';
+import type {
+  AgentWorkspaceLocalEditor,
+  AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRuntimeStarterTemplateItem,
+} from './agent-workspace-types.ts';
+
+export function createProfileEditor(templates: readonly AgentWorkspaceRuntimeStarterTemplateItem[]): AgentWorkspaceLocalEditor {
+  const defaultTemplate = templates.find((template) => template.id === 'research')?.id ?? templates[0]?.id ?? 'none';
+  const preview = templates.length === 0
+    ? 'No starter templates found; use none to create an empty isolated profile.'
+    : templates
+      .slice(0, 6)
+      .map((template) => `${template.id} (${template.name})`)
+      .join(', ');
+  return {
+    kind: 'profile',
+    mode: 'create',
+    title: 'Create Agent Profile',
+    selectedFieldIndex: 0,
+    message: 'Create an isolated Agent home seeded with a persona, skills, and routines. The current process keeps using its existing home until relaunched with --agent-profile.',
+    fields: [
+      { id: 'name', label: 'Profile name', value: '', required: true, multiline: false, hint: 'Short profile name. It normalizes to lowercase letters, numbers, dots, underscores, and dashes.' },
+      { id: 'template', label: 'Starter template', value: defaultTemplate, required: false, multiline: false, hint: `Template id or none. Available: ${preview}.` },
+    ],
+  };
+}
 
 export function createLocalEditor(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'profile') return createProfileEditor([]);
   if (kind === 'persona') {
     return {
       kind,
@@ -137,6 +164,7 @@ export function isAffirmative(value: string): boolean {
 }
 
 export function editorCategoryId(kind: AgentWorkspaceLocalEditorKind): string {
+  if (kind === 'profile') return 'profiles';
   if (kind === 'persona') return 'personas';
   if (kind === 'skill') return 'skills';
   return 'routines';

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

@@ -6,7 +6,12 @@ import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-regist
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
-import type { AgentWorkspaceLocalLibraryItem, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
+import type {
+  AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRuntimeProfileItem,
+  AgentWorkspaceRuntimeSnapshot,
+  AgentWorkspaceRuntimeStarterTemplateItem,
+} from './agent-workspace-types.ts';
 
 type AgentWorkspaceConfigReader = {
   get(key: string): unknown;
@@ -94,6 +99,28 @@ function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalL
   };
 }
 
+function summarizeRuntimeProfile(profile: ReturnType<typeof listAgentRuntimeProfiles>[number]): AgentWorkspaceRuntimeProfileItem {
+  return {
+    id: profile.id,
+    homeDirectory: profile.homeDirectory,
+    createdAt: profile.createdAt,
+    starterTemplateId: profile.starterTemplateId,
+    starterTemplateName: profile.starterTemplateName,
+  };
+}
+
+function summarizeStarterTemplate(template: ReturnType<typeof listAgentRuntimeProfileTemplates>[number]): AgentWorkspaceRuntimeStarterTemplateItem {
+  return {
+    id: template.id,
+    name: template.name,
+    description: template.description,
+    personaName: template.personaName,
+    skillNames: template.skillNames,
+    routineNames: template.routineNames,
+    source: template.source,
+  };
+}
+
 export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): AgentWorkspaceRuntimeSnapshot {
   const host = readConfigString(context, 'controlPlane.host', '127.0.0.1');
   const port = readConfigNumber(context, 'controlPlane.port', 3421);
@@ -255,9 +282,11 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     browserSurfacePublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
     runtimeProfileCount: runtimeProfiles.length,
+    runtimeProfiles: runtimeProfiles.map(summarizeRuntimeProfile),
     runtimeProfileRoot: getAgentRuntimeProfilesRoot(context.workspace?.shellPaths?.homeDirectory ?? ''),
     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

@@ -7,7 +7,7 @@ export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 
 export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'local-selection' | 'local-operation';
 
-export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine';
+export type AgentWorkspaceLocalEditorKind = 'persona' | 'skill' | 'routine' | 'profile';
 
 export type AgentWorkspaceLocalOperation =
   | 'persona-edit'
@@ -94,6 +94,24 @@ export interface AgentWorkspaceLocalLibraryItem {
   readonly startCount?: number;
 }
 
+export interface AgentWorkspaceRuntimeProfileItem {
+  readonly id: string;
+  readonly homeDirectory: string;
+  readonly createdAt: string | null;
+  readonly starterTemplateId?: string;
+  readonly starterTemplateName?: string;
+}
+
+export interface AgentWorkspaceRuntimeStarterTemplateItem {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly personaName: string;
+  readonly skillNames: readonly string[];
+  readonly routineNames: readonly string[];
+  readonly source: string;
+}
+
 export interface AgentWorkspaceRuntimeSnapshot {
   readonly provider: string;
   readonly model: string;
@@ -133,9 +151,11 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly browserSurfacePublicBaseUrl: string;
   readonly activeRuntimeProfile: string;
   readonly runtimeProfileCount: number;
+  readonly runtimeProfiles: readonly AgentWorkspaceRuntimeProfileItem[];
   readonly runtimeProfileRoot: string;
   readonly runtimeStarterTemplateCount: number;
   readonly localStarterTemplateCount: number;
+  readonly runtimeStarterTemplates: readonly AgentWorkspaceRuntimeStarterTemplateItem[];
   readonly configProfileCount: number;
   readonly setupChecklist: readonly AgentWorkspaceSetupChecklistItem[];
   readonly warnings: readonly string[];

package/src/input/agent-workspace.ts

@@ -3,9 +3,10 @@ import type { ShellPathService } from '@/runtime/index.ts';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agent/runtime-profile.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { AGENT_WORKSPACE_CATEGORIES } from './agent-workspace-categories.ts';
-import { createDeleteEditor, createLocalEditor, createPersonaUpdateEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
+import { createDeleteEditor, createLocalEditor, createPersonaUpdateEditor, createProfileEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 
@@ -25,7 +26,6 @@ export type {
 } from './agent-workspace-types.ts';
 export { AGENT_WORKSPACE_MODAL_NAME } from './agent-workspace-types.ts';
 export { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
-
 function parseCommand(command: string): { readonly name: string; readonly args: readonly string[] } {
   const trimmed = command.trim().replace(/^\//, '');
   if (!trimmed) return { name: '', args: [] };
@@ -46,6 +46,7 @@ export class AgentWorkspace {
     persona: 0,
     skill: 0,
     routine: 0,
+    profile: 0,
   };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
@@ -228,7 +229,9 @@ export class AgentWorkspace {
     const action = this.selectedAction;
     if (!action) return;
     if (action.kind === 'editor' && action.editorKind) {
-      this.localEditor = createLocalEditor(action.editorKind);
+      this.localEditor = action.editorKind === 'profile'
+        ? createProfileEditor(this.runtimeSnapshot?.runtimeStarterTemplates ?? [])
+        : createLocalEditor(action.editorKind);
       this.status = `Editing ${this.localEditor.title}.`;
       this.lastActionResult = {
         kind: 'guidance',
@@ -347,6 +350,7 @@ export class AgentWorkspace {
   private localLibraryItems(kind: AgentWorkspaceLocalEditorKind): readonly AgentWorkspaceLocalLibraryItem[] {
     if (kind === 'persona') return this.runtimeSnapshot?.localPersonas ?? [];
     if (kind === 'skill') return this.runtimeSnapshot?.localSkills ?? [];
+    if (kind === 'profile') return [];
     return this.runtimeSnapshot?.localRoutines ?? [];
   }
 
@@ -564,7 +568,14 @@ export class AgentWorkspace {
         this.submitLocalDeleteEditor(shellPaths, editor);
         return;
       }
-      if (editor.kind === 'persona') {
+      if (editor.kind === 'profile') {
+        const template = this.editorField('template');
+        const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
+        const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, this.editorField('name'), {
+          ...(templateId ? { templateId } : {}),
+        });
+        this.finishProfileEditor(profile);
+      } else if (editor.kind === 'persona') {
         const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
         if (editor.mode === 'update' && editor.recordId) {
           const wasActive = registry.snapshot().activePersonaId === editor.recordId;
@@ -699,6 +710,26 @@ export class AgentWorkspace {
     this.clampSelection();
   }
 
+  private finishProfileEditor(profile: AgentRuntimeProfileInfo): void {
+    this.localEditor = null;
+    const categoryIndex = this.categories.findIndex((category) => category.id === 'profiles');
+    if (categoryIndex >= 0) {
+      this.selectedCategoryIndex = categoryIndex;
+      this.selectedActionIndex = this.categories[categoryIndex]?.actions.findIndex((action) => action.id === 'runtime-profile-create') ?? 0;
+      if (this.selectedActionIndex < 0) this.selectedActionIndex = 0;
+    }
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    const starter = profile.starterTemplateId ? ` from ${profile.starterTemplateId}` : '';
+    this.status = `Created Agent profile: ${profile.id}.`;
+    this.lastActionResult = {
+      kind: 'refreshed',
+      title: 'Created Agent profile',
+      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current TUI session was not switched.`,
+      safety: 'safe',
+    };
+    this.clampSelection();
+  }
+
   private finishLocalDelete(kind: AgentWorkspaceLocalEditorKind, id: string, name: string): void {
     this.localEditor = null;
     const categoryId = editorCategoryId(kind);

package/src/renderer/agent-workspace.ts

@@ -142,6 +142,47 @@ function localLibraryLines(
   return lines;
 }
 
+function profileLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: 'Agent Profiles', fg: PALETTE.title, bold: true },
+  ];
+  if (snapshot.runtimeProfiles.length === 0) {
+    lines.push({ text: 'No isolated Agent profiles yet. Use Create Agent profile in this workspace.', fg: PALETTE.warn });
+    return lines;
+  }
+  for (const profile of snapshot.runtimeProfiles.slice(0, 6)) {
+    const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : ' starter=none';
+    const created = profile.createdAt ? ` created=${profile.createdAt.slice(0, 10)}` : '';
+    lines.push({ text: `${profile.id}${starter}${created}`, fg: PALETTE.info, bold: profile.id === snapshot.activeRuntimeProfile });
+    lines.push({ text: `  home: ${profile.homeDirectory}`, fg: PALETTE.muted });
+  }
+  if (snapshot.runtimeProfiles.length > 6) {
+    lines.push({ text: `${snapshot.runtimeProfiles.length - 6} more profile(s).`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
+function starterTemplateLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const lines: ContextLine[] = [
+    { text: 'Starter Templates', fg: PALETTE.title, bold: true },
+  ];
+  for (const template of snapshot.runtimeStarterTemplates.slice(0, 6)) {
+    lines.push({
+      text: `${template.id}: ${template.name} [${template.source}]`,
+      fg: template.source === 'local' ? PALETTE.good : PALETTE.info,
+      bold: template.id === 'research',
+    });
+    lines.push({
+      text: `  ${template.description} Persona ${template.personaName}; skills ${template.skillNames.join(', ')}; routines ${template.routineNames.join(', ')}.`,
+      fg: PALETTE.muted,
+    });
+  }
+  if (snapshot.runtimeStarterTemplates.length > 6) {
+    lines.push({ text: `${snapshot.runtimeStarterTemplates.length - 6} more starter template(s).`, fg: PALETTE.dim });
+  }
+  return lines;
+}
+
 function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
   if (!snapshot) return [{ text: 'Runtime context is not loaded yet.', fg: PALETTE.warn }];
   const base: ContextLine[] = [{ text: 'Live Agent Context', fg: PALETTE.title, bold: true }];
@@ -164,23 +205,34 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     const enabledCount = snapshot.channels.filter((channel) => channel.enabled).length;
     const readyCount = snapshot.channels.filter((channel) => channel.ready).length;
     const configuredDefaults = snapshot.channels.filter((channel) => channel.defaultTarget === 'configured').length;
-    const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label).join(', ');
+    const readyChannels = snapshot.channels.filter((channel) => channel.ready).map((channel) => channel.label);
+    const needsTarget = snapshot.channels.filter((channel) => channel.setupState === 'needs-target');
+    const needsConfig = snapshot.channels.filter((channel) => channel.setupState === 'needs-config');
+    const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label);
+    const disabledPreview = disabledChannels.slice(0, 6).join(', ');
+    const disabledSuffix = disabledChannels.length > 6 ? `, +${disabledChannels.length - 6} more` : '';
+    const orderedChannels = [
+      ...snapshot.channels.filter((channel) => channel.enabled),
+      ...snapshot.channels.filter((channel) => !channel.enabled),
+    ].slice(0, 6);
     base.push(
       { text: `GoodVibes runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
       { text: `Readiness: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} default target(s) configured.`, fg: PALETTE.info },
-      { text: `Disabled channels: ${disabledChannels || 'none'}.`, fg: PALETTE.dim },
-      { text: 'Pairing: use /pair or /qrcode for companion setup.', fg: PALETTE.info },
-      { text: 'Channel posture: inspect via /communication and /setup review.', fg: PALETTE.muted },
-      { text: 'Safety: external delivery, unknown senders, and public exposure require explicit policy and user action.', fg: PALETTE.warn },
+      { text: `Ready channels: ${readyChannels.join(', ') || 'none'}.`, fg: readyChannels.length > 0 ? PALETTE.good : PALETTE.warn },
+      { text: `Needs default target: ${needsTarget.map((channel) => `${channel.label} -> ${channel.defaultTargetKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsTarget.length > 0 ? PALETTE.warn : PALETTE.muted },
+      { text: `Needs config: ${needsConfig.map((channel) => `${channel.label} -> ${channel.missingRequiredKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsConfig.length > 0 ? PALETTE.warn : PALETTE.muted },
+      { text: `Disabled channels: ${disabledPreview || 'none'}${disabledSuffix}.`, fg: PALETTE.dim },
+      { text: 'Safety: no secret values; sends and public exposure require explicit user action and runtime policy.', fg: PALETTE.warn },
     );
-    for (const channel of snapshot.channels) {
-      const enabled = channel.enabled ? 'enabled' : 'disabled';
+    for (const channel of orderedChannels) {
       const ready = channel.ready ? 'ready' : `${channel.missingConfigCount} missing`;
       base.push({
-        text: `${channel.label}: ${enabled}; ${ready}; default ${channel.defaultTarget}; delivery ${channel.delivery}; risk ${channel.riskLabel}.`,
+        text: `${channel.label}: ${channel.setupState}; ${ready}; target ${channel.defaultTarget}; delivery ${channel.delivery}; risk ${channel.risk}.`,
         fg: channel.ready ? PALETTE.good : channel.enabled ? PALETTE.warn : PALETTE.dim,
       });
     }
+    base.push({ text: 'Only config key names and readiness state are rendered here.', fg: PALETTE.muted });
+    base.push({ text: 'Pairing: use /pair or /qrcode; inspect routed activity with /communication and /setup review.', fg: PALETTE.info });
   } else if (category.id === 'knowledge') {
     base.push(
       { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },
@@ -206,8 +258,14 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: `Agent profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
       { text: `Starter templates: ${snapshot.runtimeStarterTemplateCount}; local custom: ${snapshot.localStarterTemplateCount}`, fg: PALETTE.info },
       { text: `Config profiles: ${snapshot.configProfileCount}`, fg: PALETTE.info },
+      { text: `Starter ids: ${snapshot.runtimeStarterTemplates.map((template) => template.id).join(', ') || 'none'}`, fg: PALETTE.info },
+      { text: '' },
+      ...profileLines(snapshot),
+      { text: '' },
+      ...starterTemplateLines(snapshot),
+      { text: '' },
       { text: 'Named Agent profiles isolate local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
-      { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace via /agent-profile.', fg: PALETTE.info },
+      { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace.', fg: PALETTE.info },
       { text: 'The external GoodVibes runtime remains shared unless the owning host is configured separately.', fg: PALETTE.warn },
       { text: 'Portable bundles require explicit export/import commands with real paths and --yes.', fg: PALETTE.muted },
     );

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.76';
+let _version = '0.1.78';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {