@pellux/goodvibes-agent 1.1.4 → 1.1.6

package/src/input/agent-workspace-host-category.ts

@@ -0,0 +1,57 @@
+import type { AgentWorkspaceCategory } from './agent-workspace-types.ts';
+
+export const AGENT_WORKSPACE_HOST_CATEGORY: AgentWorkspaceCategory = {
+  id: 'host',
+  group: 'OPERATIONS',
+  label: 'Connected Host',
+  summary: 'Connected-host health, tasks, sessions, channels, and automation.',
+  detail: 'Use this workspace to inspect the GoodVibes host surfaces that Agent can see: system health, remote routes, host tasks, sessions, channels, schedules, knowledge, media, MCP, provider auth, support bundles, and telemetry/config posture.',
+  actions: [
+    { id: 'host-overview', label: 'Host overview', detail: 'Review connected-host, provider, settings, continuity, and Agent health without starting or mutating host work.', command: '/health review', kind: 'command', safety: 'read-only' },
+    { id: 'host-services', label: 'Host services', detail: 'Inspect connected-host service readiness, credentials, and integration issues without changing them.', command: '/health host', kind: 'command', safety: 'read-only' },
+    { id: 'host-setup', label: 'Setup review', detail: 'Inspect setup issues that affect connected-host and Agent runtime readiness.', command: '/health setup', kind: 'command', safety: 'read-only' },
+    { id: 'host-remote', label: 'Remote routes', detail: 'Inspect remote build-host route health and recovery signals without starting build work.', command: '/health remote', kind: 'command', safety: 'read-only' },
+    { id: 'host-maintenance', label: 'Session maintenance', detail: 'Review continuity, compaction, and current-session maintenance posture.', command: '/health maintenance', kind: 'command', safety: 'read-only' },
+    { id: 'host-continuity', label: 'Continuity', detail: 'Inspect last-session pointer, recovery-file posture, and return-context state.', command: '/health continuity', kind: 'command', safety: 'read-only' },
+    { id: 'host-tasks', label: 'Host tasks', detail: 'Inspect connected-host task state without creating, retrying, or mutating tasks.', command: '/tasks list', kind: 'command', safety: 'read-only' },
+    { id: 'host-task-filter', label: 'Filter host tasks', detail: 'Open a status/type form for read-only connected-host task filtering.', editorKind: 'task-list-filter', kind: 'editor', safety: 'read-only' },
+    { id: 'host-task-show', label: 'Inspect host task', detail: 'Open a task-id form for read-only connected-host task metadata.', editorKind: 'task-show', kind: 'editor', safety: 'read-only' },
+    { id: 'host-task-output', label: 'Show task output', detail: 'Open a task-id form for read-only connected-host task output.', editorKind: 'task-output', kind: 'editor', safety: 'read-only' },
+    { id: 'host-sessions', label: 'Host session routes', detail: 'Browse saved Agent sessions and return-context posture exposed through the runtime session surface.', command: '/session list', kind: 'command', safety: 'read-only' },
+    { id: 'host-session-graph', label: 'Session graph', detail: 'Open a read-only form for cross-session graph inspection; graph mutation remains blocked in Agent.', editorKind: 'session-graph', kind: 'editor', safety: 'read-only' },
+    { id: 'host-channels-status', label: 'Channel status', detail: 'Inspect connected channel runtime status from the host without mutating delivery state.', command: '/channels status', kind: 'command', safety: 'read-only' },
+    { id: 'host-channel-accounts', label: 'Channel accounts', detail: 'Inspect connected channel accounts without printing secret values or sending messages.', command: '/channels accounts', kind: 'command', safety: 'read-only' },
+    { id: 'host-channel-policies', label: 'Channel policies', detail: 'Inspect channel delivery policy posture without changing routing.', command: '/channels policies', kind: 'command', safety: 'read-only' },
+    { id: 'host-channels', label: 'Open Channels', detail: 'Jump to the channel setup and delivery workspace.', targetCategoryId: 'channels', kind: 'workspace', safety: 'safe' },
+    { id: 'host-automation', label: 'Open Automation', detail: 'Jump to connected schedules, reminders, receipts, and explicit run controls.', targetCategoryId: 'automation', kind: 'workspace', safety: 'safe' },
+    { id: 'host-schedules', label: 'Schedule status', detail: 'Inspect schedules and run history without running or mutating them.', command: '/schedule list', kind: 'command', safety: 'read-only' },
+    { id: 'host-schedule-reconcile', label: 'Reconcile schedules', detail: 'Compare local promotion receipts with live connected schedules.', command: '/schedule reconcile', kind: 'command', safety: 'read-only' },
+    { id: 'host-knowledge', label: 'Knowledge route', detail: 'Inspect isolated Agent Knowledge route readiness and source counts.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
+    { id: 'host-knowledge-open', label: 'Open Knowledge', detail: 'Jump to Agent Knowledge source, graph, review, and ingest controls.', targetCategoryId: 'knowledge', kind: 'workspace', safety: 'safe' },
+    { id: 'host-media', label: 'Media providers', detail: 'Inspect configured media providers before generating media with confirmation.', command: '/media providers', kind: 'command', safety: 'read-only' },
+    { id: 'host-media-open', label: 'Open Voice and Media', detail: 'Jump to voice, TTS, image input, media provider, and browser-tool setup actions.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
+    { id: 'host-mcp-health', label: 'MCP health', detail: 'Inspect MCP lifecycle issues without changing trust posture or approving tool-definition review.', command: '/health mcp', kind: 'command', safety: 'read-only' },
+    { id: 'host-mcp-review', label: 'MCP review', detail: 'Inspect MCP server connection, trust, role, and review posture.', command: '/mcp review', kind: 'command', safety: 'read-only' },
+    { id: 'host-tools-open', label: 'Open Tools and MCP', detail: 'Jump to MCP server setup, tool inventory, secrets, and security review.', targetCategoryId: 'tools', kind: 'workspace', safety: 'safe' },
+    { id: 'host-provider-accounts', label: 'Provider accounts', detail: 'Review provider account routes, subscription windows, and billing-path safety.', command: '/accounts review', kind: 'command', safety: 'read-only' },
+    { id: 'host-provider-detail', label: 'Provider detail', detail: 'Open a provider-id form for account and provider configuration review.', editorKind: 'provider-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-provider-routes', label: 'Provider routes', detail: 'Open a provider-id form for account, subscription, and route inspection.', editorKind: 'provider-routes', kind: 'editor', safety: 'read-only' },
+    { id: 'host-provider-repair', label: 'Provider repair guidance', detail: 'Open a provider-id form for read-only provider repair guidance.', editorKind: 'provider-account-repair', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-owner', label: 'Connected-host auth owner', detail: 'Show that connected-host auth administration belongs to the owning GoodVibes host, not Agent.', command: '/auth local', kind: 'command', safety: 'read-only' },
+    { id: 'host-auth-review', label: 'Provider auth review', detail: 'Review provider auth posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
+    { id: 'host-auth-detail', label: 'Provider auth detail', detail: 'Open a provider-id form for read-only provider auth inspection.', editorKind: 'auth-show', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-repair', label: 'Provider auth repair', detail: 'Open a provider-id form for provider auth repair guidance.', editorKind: 'auth-repair', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-bundle-export', label: 'Export auth bundle', detail: 'Open a confirmed form that exports a redacted provider auth review bundle.', editorKind: 'auth-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-auth-bundle-inspect', label: 'Inspect auth bundle', detail: 'Open a form that inspects a provider auth review bundle before sharing or import.', editorKind: 'auth-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-subscription-bundle-export', label: 'Export subscription bundle', detail: 'Open a confirmed form that exports redacted provider subscription state for review.', editorKind: 'subscription-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-subscription-bundle-inspect', label: 'Inspect subscription bundle', detail: 'Open a form that inspects provider subscription state before sharing.', editorKind: 'subscription-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-security', label: 'Security review', detail: 'Inspect token posture, MCP attack paths, policy lint, plugin risk, and incident pressure.', command: '/security review', kind: 'command', safety: 'read-only' },
+    { id: 'host-trust', label: 'Trust review', detail: 'Review permission, secret, plugin, and MCP trust posture without exporting bundles or changing trust.', command: '/trust review', kind: 'command', safety: 'read-only' },
+    { id: 'host-support-bundle-export', label: 'Export support bundle', detail: 'Export a redacted Agent support bundle from the Host page.', editorKind: 'support-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-support-bundle-inspect', label: 'Inspect support bundle', detail: 'Inspect a support bundle before import or sharing.', editorKind: 'support-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-support-bundle-import', label: 'Import support bundle', detail: 'Import reviewed, non-redacted config values from a support bundle.', editorKind: 'support-bundle-import', kind: 'editor', safety: 'safe' },
+    { id: 'host-telemetry', label: 'Telemetry settings', detail: 'Open telemetry payload policy settings for connected-host and Agent observability review.', command: '/config telemetry', kind: 'command', safety: 'safe' },
+    { id: 'host-config', label: 'Control-plane settings', detail: 'Open configuration controls for service, channels, tools, automation, provider, and storage posture.', command: '/config', kind: 'command', safety: 'safe' },
+    { id: 'host-safety', label: 'Host mutation policy', detail: 'Agent may inspect connected-host surfaces and run explicit confirmed actions, but does not silently create tasks, send channel messages, mutate auth, or start automation.', kind: 'guidance', safety: 'blocked' },
+  ],
+};

package/src/input/agent-workspace-local-editor-submission.ts

@@ -0,0 +1,193 @@
+import type { ShellPathService } from '@/runtime/index.ts';
+import { AgentNoteRegistry } from '../agent/note-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 { createAgentWorkspaceLearnedBehavior } from './agent-workspace-learned-behavior.ts';
+import { buildAgentWorkspaceRequirements } from './agent-workspace-requirements.ts';
+import { isAffirmative, splitList } from './agent-workspace-editors.ts';
+import type { AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind } from './agent-workspace-types.ts';
+
+type LearnedBehaviorTarget = Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'note' | 'profile'>;
+
+export interface AgentWorkspaceLocalEditorSubmissionCallbacks {
+  readonly readField: (id: string) => string;
+  readonly learnedBehaviorTarget: () => LearnedBehaviorTarget;
+  readonly submitDeleteEditor: () => void;
+  readonly finishLocalEditor: (kind: AgentWorkspaceLocalEditorKind, id: string, name: string, verb: 'Created' | 'Updated') => void;
+  readonly finishProfileEditor: (profile: AgentRuntimeProfileInfo) => void;
+}
+
+export function submitAgentWorkspaceLocalRegistryEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  callbacks: AgentWorkspaceLocalEditorSubmissionCallbacks,
+): void {
+  const field = callbacks.readField;
+  if (editor.mode === 'delete') {
+    callbacks.submitDeleteEditor();
+    return;
+  }
+  if (editor.kind === 'learned-behavior') {
+    const created = createAgentWorkspaceLearnedBehavior(shellPaths, {
+      target: callbacks.learnedBehaviorTarget(),
+      name: field('name'),
+      description: field('description'),
+      notes: field('notes'),
+      tags: splitList(field('tags')),
+      triggers: splitList(field('triggers')),
+      enable: isAffirmative(field('enable')),
+    });
+    callbacks.finishLocalEditor(created.kind, created.id, created.name, 'Created');
+  } else if (editor.kind === 'profile') {
+    const template = field('template');
+    const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
+    const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, field('name'), {
+      ...(templateId ? { templateId } : {}),
+    });
+    callbacks.finishProfileEditor(profile);
+  } else if (editor.kind === 'note') {
+    submitNoteEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else if (editor.kind === 'persona') {
+    submitPersonaEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else if (editor.kind === 'skill') {
+    submitSkillEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else {
+    submitRoutineEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  }
+}
+
+function submitNoteEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentNoteRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      title: field('title'),
+      body: field('body'),
+      sourceUrl: field('sourceUrl'),
+      tags: splitList(field('tags')),
+      provenance: 'Workspace',
+    });
+    finish('note', updated.id, updated.title, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    title: field('title'),
+    body: field('body'),
+    sourceUrl: field('sourceUrl'),
+    tags: splitList(field('tags')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('note', created.id, created.title, 'Created');
+}
+
+function submitPersonaEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const wasActive = registry.snapshot().activePersonaId === editor.recordId;
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      body: field('body'),
+      tags: splitList(field('tags')),
+      triggers: splitList(field('triggers')),
+      provenance: 'Workspace',
+    });
+    if (isAffirmative(field('activate'))) registry.setActive(updated.id);
+    else if (wasActive) registry.clearActive();
+    finish('persona', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    body: field('body'),
+    tags: splitList(field('tags')),
+    triggers: splitList(field('triggers')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  if (isAffirmative(field('activate'))) registry.setActive(created.id);
+  finish('persona', created.id, created.name, 'Created');
+}
+
+function submitSkillEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      procedure: field('procedure'),
+      triggers: splitList(field('triggers')),
+      tags: splitList(field('tags')),
+      requirements: buildAgentWorkspaceRequirements(field),
+      provenance: 'Workspace',
+    });
+    registry.setEnabled(updated.id, isAffirmative(field('enabled')));
+    finish('skill', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    procedure: field('procedure'),
+    triggers: splitList(field('triggers')),
+    tags: splitList(field('tags')),
+    requirements: buildAgentWorkspaceRequirements(field),
+    enabled: isAffirmative(field('enabled')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('skill', created.id, created.name, 'Created');
+}
+
+function submitRoutineEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      steps: field('steps'),
+      triggers: splitList(field('triggers')),
+      tags: splitList(field('tags')),
+      requirements: buildAgentWorkspaceRequirements(field),
+      provenance: 'Workspace',
+    });
+    registry.setEnabled(updated.id, isAffirmative(field('enabled')));
+    finish('routine', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    steps: field('steps'),
+    triggers: splitList(field('triggers')),
+    tags: splitList(field('tags')),
+    requirements: buildAgentWorkspaceRequirements(field),
+    enabled: isAffirmative(field('enabled')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('routine', created.id, created.name, 'Created');
+}

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

@@ -40,6 +40,9 @@ export function searchAgentWorkspaceActions(
         action.command ?? '',
         action.editorKind ?? '',
         action.targetCategoryId ?? '',
+        action.modelPickerFlow ?? '',
+        action.modelPickerTarget ?? '',
+        action.settingsTarget ?? '',
         action.localOperation ?? '',
         action.safety,
       ].join(' ').toLowerCase();
@@ -80,6 +83,9 @@ function scoreActionSearchResult(
   score += scoreField(action.editorKind, terms, exactQuery, 85, 26);
   score += scoreField(action.command, terms, exactQuery, 75, 22);
   score += scoreField(action.label, terms, exactQuery, 65, 18);
+  score += scoreField(action.modelPickerTarget, terms, exactQuery, 58, 18);
+  score += scoreField(action.settingsTarget, terms, exactQuery, 58, 18);
+  score += scoreField(action.modelPickerFlow, terms, exactQuery, 54, 16);
   score += scoreField(action.localOperation, terms, exactQuery, 50, 16);
   score += scoreField(action.targetCategoryId, terms, exactQuery, 40, 12);
   score += scoreField(action.detail, terms, exactQuery, 24, 6);

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

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import type { ConfigKey, ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
+import type { PendingSubscriptionLogin, ProviderSubscription } from '@pellux/goodvibes-sdk/platform/config';
 import { setHarnessSetting } from '../agent/harness-control.ts';
 import { isExternalHostOwnedSettingKey } from '../config/agent-settings-policy.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
@@ -83,6 +84,83 @@ function valuesMatch(left: unknown, right: unknown): boolean {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function readRecordMap(record: Record<string, unknown>, key: string): readonly unknown[] {
+  const value = record[key];
+  return isRecord(value) ? Object.values(value) : [];
+}
+
+function isProviderSubscription(value: unknown): value is ProviderSubscription {
+  return isRecord(value)
+    && typeof value.provider === 'string'
+    && typeof value.accessToken === 'string'
+    && typeof value.tokenType === 'string'
+    && value.authMode === 'oauth'
+    && typeof value.overrideAmbientApiKeys === 'boolean'
+    && typeof value.createdAt === 'number'
+    && typeof value.updatedAt === 'number';
+}
+
+function isPendingSubscriptionLogin(value: unknown): value is PendingSubscriptionLogin {
+  return isRecord(value)
+    && typeof value.provider === 'string'
+    && typeof value.state === 'string'
+    && typeof value.verifier === 'string'
+    && typeof value.redirectUri === 'string'
+    && typeof value.createdAt === 'number';
+}
+
+function importTuiSubscriptions(context: CommandContext, parseErrors: string[]): {
+  readonly importedActive: string[];
+  readonly importedPending: string[];
+  readonly unchangedActive: string[];
+  readonly unchangedPending: string[];
+  readonly skipped: string[];
+} {
+  const shellPaths = context.workspace.shellPaths;
+  const manager = context.platform.subscriptionManager;
+  const result = {
+    importedActive: [] as string[],
+    importedPending: [] as string[],
+    unchangedActive: [] as string[],
+    unchangedPending: [] as string[],
+    skipped: [] as string[],
+  };
+  if (!shellPaths || !manager) return result;
+
+  const sourcePath = shellPaths.resolveUserPath(GOODVIBES_TUI_SURFACE_ROOT, 'subscriptions.json');
+  try {
+    const store = readJsonRecord(sourcePath);
+    if (!store) return result;
+    for (const entry of readRecordMap(store, 'subscriptions')) {
+      if (!isProviderSubscription(entry)) {
+        result.skipped.push('active subscription with invalid shape');
+        continue;
+      }
+      if (valuesMatch(manager.get(entry.provider), entry)) {
+        result.unchangedActive.push(entry.provider);
+        continue;
+      }
+      manager.saveSubscription(entry);
+      result.importedActive.push(entry.provider);
+    }
+    for (const entry of readRecordMap(store, 'pending')) {
+      if (!isPendingSubscriptionLogin(entry)) {
+        result.skipped.push('pending subscription with invalid shape');
+        continue;
+      }
+      if (valuesMatch(manager.getPending(entry.provider), entry)) {
+        result.unchangedPending.push(entry.provider);
+        continue;
+      }
+      manager.savePending(entry);
+      result.importedPending.push(entry.provider);
+    }
+  } catch (error) {
+    parseErrors.push(`subscriptions: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return result;
+}
+
 export function agentWorkspaceSettingSchema(context: CommandContext | null, key: string): ConfigSetting | null {
   return context?.platform?.configManager
     ?.getSchema()
@@ -200,7 +278,7 @@ export async function applyAgentWorkspaceSettingValue(
 export async function importAgentWorkspaceTuiSettings(context: CommandContext | null): Promise<TuiSettingsImportOutcome> {
   const shellPaths = context?.workspace?.shellPaths;
   const configManager = context?.platform?.configManager;
-  if (!shellPaths || !configManager) {
+  if (!context || !shellPaths || !configManager) {
     return {
       status: 'GoodVibes TUI settings import is unavailable in this runtime.',
       runtimeSnapshot: null,
@@ -232,11 +310,14 @@ export async function importAgentWorkspaceTuiSettings(context: CommandContext |
       parseErrors.push(`${source.label}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  const subscriptions = importTuiSubscriptions(context, parseErrors);
+  const subscriptionImports = subscriptions.importedActive.length + subscriptions.importedPending.length;
+  const subscriptionUnchanged = subscriptions.unchangedActive.length + subscriptions.unchangedPending.length;
 
-  if (values.size === 0) {
+  if (values.size === 0 && subscriptionImports === 0 && subscriptionUnchanged === 0 && subscriptions.skipped.length === 0) {
     const detail = parseErrors.length > 0
-      ? `No importable settings found. ${parseErrors.join('; ')}`
-      : 'No GoodVibes TUI settings file with importable Agent-owned settings was found.';
+      ? `No importable settings or subscriptions found. ${parseErrors.join('; ')}`
+      : 'No GoodVibes TUI settings or subscription store with importable Agent-owned state was found.';
     return {
       status: 'No GoodVibes TUI settings imported.',
       runtimeSnapshot: null,
@@ -266,16 +347,21 @@ export async function importAgentWorkspaceTuiSettings(context: CommandContext |
       skipped.push(`${setting.key}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  skipped.push(...subscriptions.skipped);
+  const changedCount = imported.length + subscriptionImports;
+  const unchangedCount = unchanged.length + subscriptionUnchanged;
 
   return {
-    status: imported.length > 0 ? `Imported ${imported.length} GoodVibes TUI setting(s).` : 'No GoodVibes TUI settings changed.',
+    status: changedCount > 0 ? `Imported ${changedCount} GoodVibes TUI item(s).` : 'No GoodVibes TUI settings changed.',
     runtimeSnapshot: context ? buildAgentWorkspaceRuntimeSnapshot(context) : null,
     result: {
-      kind: skipped.length > 0 && imported.length === 0 ? 'error' : imported.length > 0 ? 'refreshed' : 'guidance',
-      title: imported.length > 0 ? 'GoodVibes TUI settings imported' : 'No settings changed',
+      kind: skipped.length > 0 && changedCount === 0 ? 'error' : changedCount > 0 ? 'refreshed' : 'guidance',
+      title: changedCount > 0 ? 'GoodVibes TUI settings imported' : 'No settings changed',
       detail: [
         imported.length > 0 ? `Imported: ${imported.slice(0, 10).join(', ')}${imported.length > 10 ? `, +${imported.length - 10} more` : ''}.` : '',
-        unchanged.length > 0 ? `${unchanged.length} setting(s) already matched.` : '',
+        subscriptions.importedActive.length > 0 ? `Imported active subscription(s): ${subscriptions.importedActive.join(', ')}.` : '',
+        subscriptions.importedPending.length > 0 ? `Imported pending subscription(s): ${subscriptions.importedPending.join(', ')}.` : '',
+        unchangedCount > 0 ? `${unchangedCount} item(s) already matched.` : '',
         skipped.length > 0 ? `Skipped: ${skipped.slice(0, 5).join('; ')}${skipped.length > 5 ? `; +${skipped.length - 5} more` : ''}.` : '',
         parseErrors.length > 0 ? `Parse issues: ${parseErrors.join('; ')}.` : '',
       ].filter((line) => line.length > 0).join(' '),

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

@@ -14,6 +14,9 @@ export interface AgentWorkspaceSetupChecklistInput {
   readonly provider: string;
   readonly model: string;
   readonly runtimeBaseUrl: string;
+  readonly activeSubscriptionCount: number;
+  readonly pendingSubscriptionCount: number;
+  readonly availableSubscriptionProviderCount: number;
   readonly sessionMemoryCount: number;
   readonly localMemoryCount: number;
   readonly localMemoryReviewQueueCount: number;
@@ -69,6 +72,23 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
         : 'Choose a provider and model before relying on assistant turns.',
       command: 'Setup -> Provider and model',
     },
+    {
+      id: 'subscriptions',
+      label: 'Provider subscriptions',
+      status: input.activeSubscriptionCount > 0
+        ? 'ready'
+        : input.pendingSubscriptionCount > 0
+          ? 'recommended'
+          : input.availableSubscriptionProviderCount > 0 ? 'recommended' : 'optional',
+      detail: input.activeSubscriptionCount > 0
+        ? `${input.activeSubscriptionCount} provider subscription session(s) are active.`
+        : input.pendingSubscriptionCount > 0
+          ? `${input.pendingSubscriptionCount} provider subscription login(s) are pending completion.`
+          : input.availableSubscriptionProviderCount > 0
+            ? `${input.availableSubscriptionProviderCount} subscription-capable provider(s) are available. Start login if you want subscription routing.`
+            : 'No subscription-capable providers are available yet. Use API keys or add an OAuth provider service.',
+      command: 'Start -> Start subscription login',
+    },
     {
       id: 'agent-knowledge',
       label: 'Agent Knowledge',

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

@@ -1,4 +1,5 @@
 import { basename, sep } from 'node:path';
+import { listAvailableSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
 import type { CommandContext } from './command-registry.ts';
 import { AgentNoteRegistry, type AgentNoteRecord } from '../agent/note-registry.ts';
@@ -398,6 +399,41 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const ttsVoice = readConfigString(context, 'tts.voice', '(voice default)');
   const ttsLlmProvider = readConfigString(context, 'tts.llmProvider', '');
   const ttsLlmModel = readConfigString(context, 'tts.llmModel', '');
+  const embeddingProvider = readConfigString(context, 'provider.embeddingProvider', '(provider default)');
+  const reasoningEffort = readConfigString(context, 'provider.reasoningEffort', '(default)');
+  const helperEnabled = readConfigBoolean(context, 'helper.enabled', false);
+  const toolLlmEnabled = readConfigBoolean(context, 'tools.llmEnabled', false);
+  const providerFailureHints = readConfigBoolean(context, 'behavior.suggestAlternativeOnProviderFail', false);
+  const cacheEnabled = readConfigBoolean(context, 'cache.enabled', true);
+  const cacheStableTtl = readConfigString(context, 'cache.stableTtl', '(default)');
+  const cacheMonitorHitRate = readConfigBoolean(context, 'cache.monitorHitRate', true);
+  const cacheHitRateWarningThreshold = readConfigNumber(context, 'cache.hitRateWarningThreshold', 0.3);
+  const hitlMode = readConfigString(context, 'behavior.hitlMode', '(default)');
+  const guidanceMode = readConfigString(context, 'behavior.guidanceMode', '(default)');
+  const saveHistory = readConfigBoolean(context, 'behavior.saveHistory', true);
+  const autoApprove = readConfigBoolean(context, 'behavior.autoApprove', false);
+  const autoCompactThreshold = readConfigNumber(context, 'behavior.autoCompactThreshold', 0);
+  const staleContextWarnings = readConfigBoolean(context, 'behavior.staleContextWarnings', false);
+  const showThinking = readConfigBoolean(context, 'display.showThinking', false);
+  const showReasoningSummary = readConfigBoolean(context, 'display.showReasoningSummary', false);
+  const theme = readConfigString(context, 'display.theme', '(default)');
+  const stream = readConfigBoolean(context, 'display.stream', true);
+  const lineNumbers = readConfigString(context, 'display.lineNumbers', '(default)');
+  const operationalMessages = readConfigString(context, 'ui.operationalMessages', '(default)');
+  const systemMessages = readConfigString(context, 'ui.systemMessages', '(default)');
+  const releaseChannel = readConfigString(context, 'release.channel', '(default)');
+  const permissionMode = readConfigString(context, 'permissions.mode', '(default)');
+  const toolAutoHeal = readConfigBoolean(context, 'tools.autoHeal', false);
+  const toolsDefaultTokenBudget = readConfigNumber(context, 'tools.defaultTokenBudget', 5000);
+  const artifactMaxBytes = readConfigNumber(context, 'storage.artifacts.maxBytes', 512 * 1024 * 1024);
+  const rawPromptTelemetry = readConfigBoolean(context, 'telemetry.includeRawPrompts', false);
+  const automationEnabled = readConfigBoolean(context, 'automation.enabled', false);
+  const automationMaxConcurrentRuns = readConfigNumber(context, 'automation.maxConcurrentRuns', 4);
+  const automationRunHistoryLimit = readConfigNumber(context, 'automation.runHistoryLimit', 100);
+  const automationDefaultTimeoutMs = readConfigNumber(context, 'automation.defaultTimeoutMs', 15 * 60 * 1000);
+  const automationCatchUpWindowMinutes = readConfigNumber(context, 'automation.catchUpWindowMinutes', 30);
+  const automationFailureCooldownMs = readConfigNumber(context, 'automation.failureCooldownMs', 5 * 60 * 1000);
+  const automationDeleteAfterRun = readConfigBoolean(context, 'automation.deleteAfterRun', false);
   const runtimeBaseUrl = `http://${host}:${port}`;
   const companionAccess = (() => {
     const homeDirectory = context.workspace?.shellPaths?.homeDirectory ?? '';
@@ -425,6 +461,18 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       nextStep,
     } as const;
   })();
+  const subscriptionSnapshot = (() => {
+    try {
+      const manager = context.platform?.subscriptionManager;
+      const services = context.platform?.serviceRegistry;
+      const active = manager?.list?.().length ?? 0;
+      const pending = manager?.listPending?.().length ?? 0;
+      const available = services ? listAvailableSubscriptionProviders(services.getAll()).length : 0;
+      return { active, pending, available };
+    } catch {
+      return { active: 0, pending: 0, available: 0 };
+    }
+  })();
   const channels = buildAgentWorkspaceChannels(context);
   const voiceMediaReadiness = buildAgentWorkspaceVoiceMediaReadiness({
     context,
@@ -435,6 +483,9 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     provider,
     model,
     runtimeBaseUrl,
+    activeSubscriptionCount: subscriptionSnapshot.active,
+    pendingSubscriptionCount: subscriptionSnapshot.pending,
+    availableSubscriptionProviderCount: subscriptionSnapshot.available,
     sessionMemoryCount,
     localMemoryCount: memorySnapshot.count,
     localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
@@ -463,11 +514,49 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     provider,
     model,
     modelDisplayName: currentModel?.displayName ?? model,
+    embeddingProvider,
+    reasoningEffort,
+    helperEnabled,
+    toolLlmEnabled,
+    providerFailureHints,
+    cacheEnabled,
+    cacheStableTtl,
+    cacheMonitorHitRate,
+    cacheHitRateWarningThreshold,
+    hitlMode,
+    guidanceMode,
+    saveHistory,
+    autoApprove,
+    autoCompactThreshold,
+    staleContextWarnings,
+    showThinking,
+    showReasoningSummary,
+    theme,
+    stream,
+    lineNumbers,
+    operationalMessages,
+    systemMessages,
+    releaseChannel,
+    permissionMode,
+    toolAutoHeal,
+    toolsDefaultTokenBudget,
+    artifactMaxBytes,
+    rawPromptTelemetry,
+    automationEnabled,
+    automationMaxConcurrentRuns,
+    automationRunHistoryLimit,
+    automationDefaultTimeoutMs,
+    automationCatchUpWindowMinutes,
+    automationFailureCooldownMs,
+    automationDeleteAfterRun,
     sessionId: context.session?.runtime?.sessionId ?? 'unknown',
     workingDirectory: context.workspace?.shellPaths?.workingDirectory ?? 'unavailable',
     homeDirectory: context.workspace?.shellPaths?.homeDirectory ?? 'unavailable',
     runtimeBaseUrl,
     runtimeOwnership: 'external',
+    activeSubscriptionCount: subscriptionSnapshot.active,
+    pendingSubscriptionCount: subscriptionSnapshot.pending,
+    availableSubscriptionProviderCount: subscriptionSnapshot.available,
     sessionMemoryCount,
     localMemoryCount: memorySnapshot.count,
     localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,