@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/input/agent-workspace-skill-bundle-command-editor-submission.ts

@@ -0,0 +1,101 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceSkillBundleCommandEditorKind } from './agent-workspace-skill-bundle-command-editors.ts';
+import { isAgentWorkspaceSkillBundleCommandEditorKind } from './agent-workspace-skill-bundle-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceSkillBundleCommandEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+export function isAgentWorkspaceSkillBundleCommandSubmissionKind(kind: string): kind is AgentWorkspaceSkillBundleCommandEditorKind {
+  return isAgentWorkspaceSkillBundleCommandEditorKind(kind as AgentWorkspaceSkillBundleCommandEditorKind);
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceSkillBundleCommandEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status: message,
+  };
+}
+
+function dispatch(command: string, title: string, detail: string, safety: AgentWorkspaceActionResult['safety']): AgentWorkspaceSkillBundleCommandEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: { kind: 'dispatched', title, detail, command, safety },
+  };
+}
+
+export function buildAgentWorkspaceSkillBundleCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceSkillBundleCommandEditorSubmission {
+  if (editor.kind === 'skill-bundle-search') {
+    const query = readField('query').trim();
+    const command = query.length > 0 ? `/skills bundle search ${quoteSlashCommandArg(query)}` : '/skills bundle search';
+    return dispatch(command, 'Opening skill bundle search', 'The workspace handed a read-only skill bundle search command to the shell-owned command router.', 'read-only');
+  }
+  if (editor.kind === 'skill-bundle-show') {
+    return dispatch(
+      `/skills bundle show ${quoteSlashCommandArg(readField('id'))}`,
+      'Opening skill bundle detail',
+      'The workspace handed a read-only skill bundle detail command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'skill-bundle-update') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Skill bundle update not confirmed. Type yes, then press Enter.');
+    const parts = ['/skills', 'bundle', 'update', quoteSlashCommandArg(readField('id'))];
+    const name = readField('name');
+    const description = readField('description');
+    const skills = readField('skills');
+    if (name.length > 0) parts.push('--name', quoteSlashCommandArg(name));
+    if (description.length > 0) parts.push('--description', quoteSlashCommandArg(description));
+    if (skills.length > 0) parts.push('--skills', quoteSlashCommandArg(skills));
+    return dispatch(parts.join(' '), 'Opening skill bundle update', 'The workspace handed a confirmed skill bundle update command to the shell-owned command router.', 'safe');
+  }
+  if (editor.kind === 'skill-bundle-enable' || editor.kind === 'skill-bundle-disable' || editor.kind === 'skill-bundle-review') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Skill bundle action not confirmed. Type yes, then press Enter.');
+    const verb = editor.kind.replace('skill-bundle-', '');
+    return dispatch(
+      `/skills bundle ${verb} ${quoteSlashCommandArg(readField('id'))}`,
+      `Opening skill bundle ${verb}`,
+      `The workspace handed a confirmed skill bundle ${verb} command to the shell-owned command router.`,
+      'safe',
+    );
+  }
+  if (editor.kind === 'skill-bundle-stale') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Skill bundle stale action not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/skills bundle stale ${quoteSlashCommandArg(readField('id'))} ${quoteSlashCommandArg(readField('reason'))}`,
+      'Opening skill bundle stale review',
+      'The workspace handed a confirmed skill bundle stale command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Skill bundle delete not confirmed. Type yes, then press Enter.');
+  return dispatch(
+    `/skills bundle delete ${quoteSlashCommandArg(readField('id'))} --yes`,
+    'Opening skill bundle delete',
+    'The workspace handed a confirmed skill bundle delete command to the shell-owned command router.',
+    'safe',
+  );
+}

package/src/input/agent-workspace-skill-bundle-command-editors.ts

@@ -0,0 +1,110 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceSkillBundleCommandEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'skill-bundle-search'
+  | 'skill-bundle-show'
+  | 'skill-bundle-update'
+  | 'skill-bundle-enable'
+  | 'skill-bundle-disable'
+  | 'skill-bundle-review'
+  | 'skill-bundle-stale'
+  | 'skill-bundle-delete'
+>;
+
+export function isAgentWorkspaceSkillBundleCommandEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceSkillBundleCommandEditorKind {
+  return kind === 'skill-bundle-search'
+    || kind === 'skill-bundle-show'
+    || kind === 'skill-bundle-update'
+    || kind === 'skill-bundle-enable'
+    || kind === 'skill-bundle-disable'
+    || kind === 'skill-bundle-review'
+    || kind === 'skill-bundle-stale'
+    || kind === 'skill-bundle-delete';
+}
+
+export function createAgentWorkspaceSkillBundleCommandEditor(kind: AgentWorkspaceSkillBundleCommandEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'skill-bundle-search') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Search Skill Bundles',
+      selectedFieldIndex: 0,
+      message: 'Search Agent-local skill bundles by name, description, or member skill.',
+      fields: [
+        { id: 'query', label: 'Search query', value: '', required: false, multiline: false, hint: 'Optional text query. Blank lists every bundle.' },
+      ],
+    };
+  }
+  if (kind === 'skill-bundle-show') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Skill Bundle',
+      selectedFieldIndex: 0,
+      message: 'Show one Agent-local skill bundle with readiness and member skills.',
+      fields: [
+        { id: 'id', label: 'Bundle id', value: '', required: true, multiline: false, hint: 'Existing local skill bundle id.' },
+      ],
+    };
+  }
+  if (kind === 'skill-bundle-update') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Update Skill Bundle',
+      selectedFieldIndex: 0,
+      message: 'Update one Agent-local skill bundle. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'id', label: 'Bundle id', value: '', required: true, multiline: false, hint: 'Existing local skill bundle id.' },
+        { id: 'name', label: 'Name', value: '', required: false, multiline: false, hint: 'Optional replacement name.' },
+        { id: 'description', label: 'Description', value: '', required: false, multiline: false, hint: 'Optional replacement one-line description.' },
+        { id: 'skills', label: 'Skill ids', value: '', required: false, multiline: false, hint: 'Optional replacement comma-separated local skill ids.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /skills bundle update.' },
+      ],
+    };
+  }
+  if (kind === 'skill-bundle-stale') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Mark Skill Bundle Stale',
+      selectedFieldIndex: 0,
+      message: 'Mark one Agent-local skill bundle stale with a review reason. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'id', label: 'Bundle id', value: '', required: true, multiline: false, hint: 'Existing local skill bundle id.' },
+        { id: 'reason', label: 'Reason', value: '', required: true, multiline: true, hint: 'Why this bundle needs review. Ctrl-J inserts a new line.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /skills bundle stale.' },
+      ],
+    };
+  }
+  if (kind === 'skill-bundle-delete') {
+    return {
+      kind,
+      mode: 'delete',
+      title: 'Delete Skill Bundle',
+      selectedFieldIndex: 0,
+      message: 'Delete one Agent-local skill bundle. This does not delete member skills. Type yes to confirm.',
+      fields: [
+        { id: 'id', label: 'Bundle id', value: '', required: true, multiline: false, hint: 'Existing local skill bundle id.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /skills bundle delete with --yes.' },
+      ],
+    };
+  }
+  const verb = kind === 'skill-bundle-enable'
+    ? 'Enable'
+    : kind === 'skill-bundle-disable'
+      ? 'Disable'
+      : 'Review';
+  return {
+    kind,
+    mode: 'update',
+    title: `${verb} Skill Bundle`,
+    selectedFieldIndex: 0,
+    message: `${verb} one Agent-local skill bundle. Type yes on the final field to confirm.`,
+    fields: [
+      { id: 'id', label: 'Bundle id', value: '', required: true, multiline: false, hint: 'Existing local skill bundle id.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: `Type yes to run /skills bundle ${verb.toLowerCase()}.` },
+    ],
+  };
+}

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

@@ -1,29 +1,39 @@
 import { basename, sep } from 'node:path';
 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';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
-import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
-import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { formatAgentRecordOrigin } from '../agent/record-labels.ts';
+import { AgentRoutineRegistry, evaluateAgentRoutineReadiness, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import {
+  AgentSkillRegistry,
+  evaluateAgentSkillBundleReadiness,
+  evaluateAgentSkillReadiness,
+  formatAgentSkillRequirement,
+  type AgentSkillBundleRecord,
+  type AgentSkillRecord,
+} from '../agent/skill-registry.ts';
 import { summarizeAgentBehaviorDiscovery } from '../agent/behavior-discovery-summary.ts';
 import { isPromptActiveMemory } from '../agent/memory-prompt.ts';
-import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
+import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates, readAgentRuntimeProfileSelection } from '../agent/runtime-profile.ts';
+import { RoutineScheduleReceiptStore } from '../agent/routine-schedule-receipts.ts';
+import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../config/surface.ts';
+import { connectedHostOperatorTokenFingerprint, readConnectedHostOperatorToken, type ConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
+import { getAgentWorkspaceConfigReader } from './agent-workspace-config-reader.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
 import { buildAgentWorkspaceVoiceMediaReadiness, type AgentWorkspaceVoiceMediaProviderDescriptor } from './agent-workspace-voice-media.ts';
 import type {
   AgentWorkspaceLocalLibraryItem,
+  AgentWorkspaceRoutineScheduleReceiptSummary,
   AgentWorkspaceRuntimeProfileItem,
   AgentWorkspaceRuntimeSnapshot,
   AgentWorkspaceRuntimeStarterTemplateItem,
 } from './agent-workspace-types.ts';
 
-type AgentWorkspaceConfigReader = {
-  get(key: string): unknown;
-};
-
 function readConfigString(context: CommandContext, key: string, fallback: string): string {
   try {
-    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
+    const configManager = getAgentWorkspaceConfigReader(context);
     const value = configManager?.get(key);
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback;
   } catch {
@@ -33,7 +43,7 @@ function readConfigString(context: CommandContext, key: string, fallback: string
 
 function readConfigNumber(context: CommandContext, key: string, fallback: number): number {
   try {
-    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
+    const configManager = getAgentWorkspaceConfigReader(context);
     const value = configManager?.get(key);
     const numberValue = typeof value === 'number' ? value : Number(value);
     return Number.isFinite(numberValue) ? numberValue : fallback;
@@ -44,7 +54,7 @@ function readConfigNumber(context: CommandContext, key: string, fallback: number
 
 function readConfigBoolean(context: CommandContext, key: string, fallback: boolean): boolean {
   try {
-    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
+    const configManager = getAgentWorkspaceConfigReader(context);
     const value = configManager?.get(key);
     if (typeof value === 'boolean') return value;
     if (typeof value === 'string') {
@@ -63,13 +73,19 @@ function inferActiveRuntimeProfile(homeDirectory: string): string {
   return homeDirectory.includes(marker) ? basename(homeDirectory) : '(default home)';
 }
 
+function inferRuntimeProfileBaseHome(homeDirectory: string): string {
+  const marker = `${sep}.goodvibes${sep}agent${sep}profile-homes${sep}`;
+  const markerIndex = homeDirectory.indexOf(marker);
+  return markerIndex >= 0 ? homeDirectory.slice(0, markerIndex) : homeDirectory;
+}
+
 function summarizePersonaItem(persona: AgentPersonaRecord, activePersonaId: string | null): AgentWorkspaceLocalLibraryItem {
   return {
     id: persona.id,
     name: persona.name,
     description: persona.description,
     reviewState: persona.reviewState,
-    source: persona.source,
+    source: formatAgentRecordOrigin(persona.source, persona.provenance),
     tags: persona.tags,
     triggers: persona.triggers,
     active: persona.id === activePersonaId,
@@ -77,45 +93,76 @@ function summarizePersonaItem(persona: AgentPersonaRecord, activePersonaId: stri
 }
 
 function summarizeSkillItem(skill: AgentSkillRecord): AgentWorkspaceLocalLibraryItem {
+  const readiness = evaluateAgentSkillReadiness(skill);
   return {
     id: skill.id,
     name: skill.name,
     description: skill.description,
     reviewState: skill.reviewState,
-    source: skill.source,
+    source: formatAgentRecordOrigin(skill.source, skill.provenance),
     tags: skill.tags,
     triggers: skill.triggers,
     enabled: skill.enabled,
+    requirementCount: skill.requirements.length,
+    missingRequirementCount: readiness.missing.length,
+    missingRequirements: readiness.missing.map(formatAgentSkillRequirement),
   };
 }
 
-function summarizeSkillBundleItem(bundle: AgentSkillBundleRecord): AgentWorkspaceLocalLibraryItem {
+function summarizeSkillBundleItem(bundle: AgentSkillBundleRecord, skills: readonly AgentSkillRecord[]): AgentWorkspaceLocalLibraryItem {
+  const readiness = evaluateAgentSkillBundleReadiness(bundle, skills);
+  const missing = [
+    ...readiness.missingRequirements.map(formatAgentSkillRequirement),
+    ...readiness.missingSkillIds.map((skillId) => `skill:${skillId}`),
+  ];
   return {
     id: bundle.id,
     name: bundle.name,
     description: `${bundle.description} Skills: ${bundle.skillIds.join(', ')}`,
     reviewState: bundle.reviewState,
-    source: bundle.source,
+    source: formatAgentRecordOrigin(bundle.source, bundle.provenance),
     tags: bundle.skillIds,
     triggers: [],
     enabled: bundle.enabled,
+    requirementCount: readiness.includedSkills.reduce((total, skill) => total + skill.requirements.length, 0) + readiness.missingSkillIds.length,
+    missingRequirementCount: missing.length,
+    missingRequirements: missing,
   };
 }
 
 function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalLibraryItem {
+  const readiness = evaluateAgentRoutineReadiness(routine);
   return {
     id: routine.id,
     name: routine.name,
     description: routine.description,
     reviewState: routine.reviewState,
-    source: routine.source,
+    source: formatAgentRecordOrigin(routine.source, routine.provenance),
     tags: routine.tags,
     triggers: routine.triggers,
     enabled: routine.enabled,
+    requirementCount: routine.requirements.length,
+    missingRequirementCount: readiness.missing.length,
+    missingRequirements: readiness.missing.map(formatAgentSkillRequirement),
     startCount: routine.startCount,
   };
 }
 
+function summarizeRoutineScheduleReceipt(
+  receipt: ReturnType<RoutineScheduleReceiptStore['snapshot']>['receipts'][number],
+): AgentWorkspaceRoutineScheduleReceiptSummary {
+  return {
+    id: receipt.id,
+    status: receipt.status,
+    routineId: receipt.routineId,
+    routineName: receipt.routineName,
+    scheduleName: receipt.scheduleName,
+    scheduleKind: receipt.scheduleKind,
+    scheduleValue: receipt.scheduleValue,
+    createdAt: receipt.createdAt,
+  };
+}
+
 function summarizeMemoryItem(record: MemoryRecord): AgentWorkspaceLocalLibraryItem {
   const detail = record.detail?.trim();
   return {
@@ -123,7 +170,7 @@ function summarizeMemoryItem(record: MemoryRecord): AgentWorkspaceLocalLibraryIt
     name: record.summary,
     description: detail && detail.length > 0 ? detail : `${record.scope}/${record.cls}`,
     reviewState: record.reviewState,
-    source: 'agent-memory',
+    source: 'Agent memory',
     tags: record.tags,
     triggers: [],
     scope: record.scope,
@@ -132,6 +179,22 @@ function summarizeMemoryItem(record: MemoryRecord): AgentWorkspaceLocalLibraryIt
   };
 }
 
+function summarizeNoteItem(note: AgentNoteRecord): AgentWorkspaceLocalLibraryItem {
+  const preview = note.body.replace(/\s+/g, ' ').trim();
+  const description = note.sourceUrl
+    ? `${preview.slice(0, 160)}${preview.length > 160 ? '...' : ''} Origin URL ${note.sourceUrl}`
+    : preview;
+  return {
+    id: note.id,
+    name: note.title,
+    description,
+    reviewState: note.reviewState,
+    source: formatAgentRecordOrigin(note.source, note.provenance),
+    tags: note.tags,
+    triggers: [],
+  };
+}
+
 function summarizeRuntimeProfile(profile: ReturnType<typeof listAgentRuntimeProfiles>[number]): AgentWorkspaceRuntimeProfileItem {
   return {
     id: profile.id,
@@ -202,6 +265,20 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return { count: 0, activeName: '(unavailable)', items: [] };
     }
   })();
+  const noteSnapshot = (() => {
+    try {
+      const shellPaths = context.workspace?.shellPaths;
+      if (!shellPaths) return { count: 0, reviewQueueCount: 0, items: [] };
+      const snapshot = AgentNoteRegistry.fromShellPaths(shellPaths).snapshot();
+      return {
+        count: snapshot.notes.length,
+        reviewQueueCount: snapshot.reviewQueue.length,
+        items: snapshot.notes.map(summarizeNoteItem),
+      };
+    } catch {
+      return { count: 0, reviewQueueCount: 0, items: [] };
+    }
+  })();
   const skillSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
@@ -214,7 +291,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
         bundleCount: snapshot.bundles.length,
         enabledBundleCount: snapshot.enabledBundles.length,
         items: snapshot.skills.map(summarizeSkillItem),
-        bundleItems: snapshot.bundles.map(summarizeSkillBundleItem),
+        bundleItems: snapshot.bundles.map((bundle) => summarizeSkillBundleItem(bundle, snapshot.skills)),
       };
     } catch {
       return { count: 0, enabled: 0, active: 0, bundleCount: 0, enabledBundleCount: 0, items: [], bundleItems: [] };
@@ -234,21 +311,44 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return { count: 0, enabled: 0, items: [] };
     }
   })();
+  const routineScheduleReceipts = (() => {
+    try {
+      const shellPaths = context.workspace?.shellPaths;
+      if (!shellPaths) return { count: 0, successful: 0, failed: 0, latest: null };
+      const receipts = RoutineScheduleReceiptStore.fromShellPaths(shellPaths).snapshot().receipts;
+      return {
+        count: receipts.length,
+        successful: receipts.filter((receipt) => receipt.status === 'created').length,
+        failed: receipts.filter((receipt) => receipt.status === 'failed').length,
+        latest: receipts[0] ? summarizeRoutineScheduleReceipt(receipts[0]) : null,
+      };
+    } catch {
+      return { count: 0, successful: 0, failed: 0, latest: null };
+    }
+  })();
   const discoveredBehavior = summarizeAgentBehaviorDiscovery(context.workspace?.shellPaths);
+  const profileBaseHome = inferRuntimeProfileBaseHome(context.workspace?.shellPaths?.homeDirectory ?? '');
   const runtimeProfiles = (() => {
     try {
-      return listAgentRuntimeProfiles(context.workspace?.shellPaths?.homeDirectory ?? '');
+      return listAgentRuntimeProfiles(profileBaseHome);
     } catch {
       return [];
     }
   })();
   const runtimeStarterTemplates = (() => {
     try {
-      return listAgentRuntimeProfileTemplates(context.workspace?.shellPaths?.homeDirectory ?? '');
+      return listAgentRuntimeProfileTemplates(profileBaseHome);
     } catch {
       return [];
     }
   })();
+  const selectedRuntimeProfile = (() => {
+    try {
+      return readAgentRuntimeProfileSelection(profileBaseHome);
+    } catch {
+      return null;
+    }
+  })();
   const voiceProviders = (() => {
     try {
       return context.platform?.voiceProviderRegistry?.list?.() ?? [];
@@ -299,6 +399,32 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const ttsLlmProvider = readConfigString(context, 'tts.llmProvider', '');
   const ttsLlmModel = readConfigString(context, 'tts.llmModel', '');
   const runtimeBaseUrl = `http://${host}:${port}`;
+  const companionAccess = (() => {
+    const homeDirectory = context.workspace?.shellPaths?.homeDirectory ?? '';
+    const tokenRecord: ConnectedHostOperatorToken = homeDirectory.length > 0
+      ? readConnectedHostOperatorToken(homeDirectory)
+      : { path: '(Agent home unavailable)', present: false, token: null };
+    const tokenFingerprint = tokenRecord.token ? connectedHostOperatorTokenFingerprint(tokenRecord.token) : null;
+    const pairingReady = Boolean(tokenRecord.token);
+    const nextStep = tokenRecord.error
+      ? 'Repair the connected-host operator token file through the owning GoodVibes host, then rerun /pair.'
+      : pairingReady
+        ? 'Use /pair to scan the QR code. Manual token display stays hidden unless /pair --show-token --yes is used.'
+        : 'Pair or provision connected-host access through the owning GoodVibes host, then rerun /pair.';
+    return {
+      surface: GOODVIBES_AGENT_PAIRING_SURFACE,
+      hostUrl: runtimeBaseUrl,
+      tokenPath: tokenRecord.path,
+      tokenPresent: tokenRecord.present,
+      tokenReadable: Boolean(tokenRecord.token),
+      tokenFingerprint,
+      tokenError: tokenRecord.error ?? null,
+      pairingReady,
+      qrCommand: '/pair',
+      manualTokenCommand: '/pair --show-token --yes',
+      nextStep,
+    } as const;
+  })();
   const channels = buildAgentWorkspaceChannels(context);
   const voiceMediaReadiness = buildAgentWorkspaceVoiceMediaReadiness({
     context,
@@ -312,12 +438,16 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionMemoryCount,
     localMemoryCount: memorySnapshot.count,
     localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
+    localNoteCount: noteSnapshot.count,
+    localNoteReviewQueueCount: noteSnapshot.reviewQueueCount,
     routineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
+    missingRoutineRequirementCount: routineSnapshot.items.reduce((total, item) => total + (item.missingRequirementCount ?? 0), 0),
     skillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
     skillBundleCount: skillSnapshot.bundleCount,
     enabledSkillBundleCount: skillSnapshot.enabledBundleCount,
+    missingSkillRequirementCount: skillSnapshot.items.reduce((total, item) => total + (item.missingRequirementCount ?? 0), 0),
     activePersonaName: personaSnapshot.activeName,
     discoveredPersonas: discoveredBehavior.personas,
     discoveredSkills: discoveredBehavior.skills,
@@ -343,9 +473,16 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     localMemoryReviewQueueCount: memorySnapshot.reviewQueueCount,
     localMemoryPromptActiveCount: memorySnapshot.promptActiveCount,
     localMemories: memorySnapshot.items,
+    localNoteCount: noteSnapshot.count,
+    localNoteReviewQueueCount: noteSnapshot.reviewQueueCount,
+    localNotes: noteSnapshot.items,
     localRoutineCount: routineSnapshot.count,
     enabledRoutineCount: routineSnapshot.enabled,
     localRoutines: routineSnapshot.items,
+    routineScheduleReceiptCount: routineScheduleReceipts.count,
+    successfulRoutineScheduleReceiptCount: routineScheduleReceipts.successful,
+    failedRoutineScheduleReceiptCount: routineScheduleReceipts.failed,
+    latestRoutineScheduleReceipt: routineScheduleReceipts.latest,
     localSkillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
     localSkillBundleCount: skillSnapshot.bundleCount,
@@ -360,7 +497,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     knowledgeRoute: '/api/goodvibes-agent/knowledge',
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',
-    wrfcPolicy: 'explicit-build-delegation-only',
+    delegatedReviewPolicy: 'explicit-build-delegation-only',
+    companionAccess,
     channels,
     voiceProviderCount: voiceProviders.length,
     voiceStreamingProviderCount: voiceProviders.filter((entry) => entry.capabilities.includes('tts-stream')).length,
@@ -381,9 +519,12 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     browserToolExposureEnabled: readConfigBoolean(context, 'web.enabled', false),
     browserToolPublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),
+    selectedRuntimeProfile: selectedRuntimeProfile?.id ?? null,
+    selectedRuntimeProfileExists: selectedRuntimeProfile?.exists ?? false,
+    selectedRuntimeProfileSelectedAt: selectedRuntimeProfile?.selectedAt ?? null,
     runtimeProfileCount: runtimeProfiles.length,
     runtimeProfiles: runtimeProfiles.map(summarizeRuntimeProfile),
-    runtimeProfileRoot: getAgentRuntimeProfilesRoot(context.workspace?.shellPaths?.homeDirectory ?? ''),
+    runtimeProfileRoot: getAgentRuntimeProfilesRoot(profileBaseHome),
     runtimeStarterTemplateCount: runtimeStarterTemplates.length,
     localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
     runtimeStarterTemplates: runtimeStarterTemplates.map(summarizeStarterTemplate),

package/src/input/agent-workspace-task-command-editor-submission.ts

@@ -0,0 +1,61 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceTaskCommandEditorKind } from './agent-workspace-task-command-editors.ts';
+import { isAgentWorkspaceTaskCommandEditorKind } from './agent-workspace-task-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceTaskCommandEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+export function isAgentWorkspaceTaskCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceTaskCommandEditorKind {
+  return isAgentWorkspaceTaskCommandEditorKind(kind);
+}
+
+export function buildAgentWorkspaceTaskCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceTaskCommandEditorSubmission {
+  if (editor.kind === 'task-list-filter') {
+    const filter = readField('filter');
+    const command = filter.length > 0 ? `/tasks list ${quoteSlashCommandArg(filter)}` : '/tasks list';
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening filtered task list.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening filtered task list',
+        detail: 'The workspace handed read-only connected-host task listing to the shell-owned command router.',
+        command,
+        safety: 'read-only',
+      },
+    };
+  }
+  const subcommand = editor.kind === 'task-output' ? 'output' : 'show';
+  const command = `/tasks ${subcommand} ${quoteSlashCommandArg(readField('taskId'))}`;
+  const title = editor.kind === 'task-output' ? 'Opening task output' : 'Opening task inspection';
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail: 'The workspace handed read-only connected-host task inspection to the shell-owned command router.',
+      command,
+      safety: 'read-only',
+    },
+  };
+}