@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/cli/status.ts

@@ -1,11 +1,12 @@
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { OnboardingCheckMarkersState } from '../runtime/onboarding/index.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
-import { isNetworkFacing } from './network-posture.ts';
 import type { GoodVibesCliOutputFormat } from './types.ts';
 import type { CliServicePosture } from './service-posture.ts';
 import type { CliExternalRuntimeSnapshot } from './external-runtime.ts';
 import { getProviderIdFromModel } from '../config/provider-model.ts';
+import { formatAgentRecordSource } from '../agent/record-labels.ts';
+import { formatAgentKnowledgeFailureKind } from './agent-knowledge-format.ts';
 
 export interface CliStatusOptions {
   readonly configManager: Pick<ConfigManager, 'get'>;
@@ -30,7 +31,7 @@ export interface CliAuthStatus {
 
 export interface CliDoctorFinding {
   readonly id: string;
-  readonly area: 'auth' | 'network' | 'onboarding' | 'runtime' | 'security' | 'secrets';
+  readonly area: 'auth' | 'onboarding' | 'runtime' | 'security' | 'secrets';
   readonly severity: 'warning' | 'risk';
   readonly summary: string;
   readonly cause: string;
@@ -92,29 +93,11 @@ function secretPolicyLabel(policy: unknown): string {
   return String(policy ?? 'unknown');
 }
 
-function bindLine(label: string, enabled: unknown, binding: { readonly hostMode: string; readonly host: string; readonly port: number }): string {
-  return `  ${label}: ${yesNo(enabled)} (${binding.hostMode} ${binding.host}:${binding.port})`;
-}
-
 export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliDoctorFinding[] {
   const config = options.configManager;
-  const serviceEnabled = config.get('service.enabled') === true;
-  const daemonEnabled = config.get('danger.daemon') === true;
-  const listenerEnabled = config.get('danger.httpListener') === true;
-  const webEnabled = config.get('web.enabled') === true;
-  const controlPlaneEnabled = config.get('controlPlane.enabled') === true;
-  const controlPlaneBinding = resolveRuntimeEndpointBinding(config, 'controlPlane');
-  const httpListenerBinding = resolveRuntimeEndpointBinding(config, 'httpListener');
-  const webBinding = resolveRuntimeEndpointBinding(config, 'web');
   const permissionMode = config.get('permissions.mode');
   const secretPolicy = config.get('storage.secretPolicy');
   const marker = options.onboardingMarkers?.effective;
-  const serverBackedEnabled = daemonEnabled || controlPlaneEnabled || listenerEnabled || webEnabled;
-  const networkFacingSurfaces = [
-    ['runtime connection', controlPlaneEnabled, controlPlaneBinding],
-    ['inbound events endpoint', listenerEnabled, httpListenerBinding],
-    ['browser companion route', webEnabled, webBinding],
-  ].filter(([, enabled, binding]) => isNetworkFacing(enabled, binding as typeof controlPlaneBinding));
 
   const findings: CliDoctorFinding[] = [];
 
@@ -124,18 +107,18 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-unreachable',
         area: 'runtime',
         severity: 'warning',
-        summary: 'Connected GoodVibes services are not reachable.',
+        summary: 'Connected GoodVibes host is not reachable.',
         cause: `Agent could not reach ${options.externalRuntime.baseUrl}${options.externalRuntime.error ? `: ${options.externalRuntime.error}` : '.'}`,
-        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until connected GoodVibes services are available.',
-        action: 'Start or repair the owning GoodVibes host, then rerun goodvibes-agent status.',
+        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until the connected GoodVibes host is available.',
+        action: 'Make the owning GoodVibes host available, then rerun goodvibes-agent status.',
       });
     } else if (!options.externalRuntime.compatible) {
       findings.push({
         id: 'external-runtime-version-mismatch',
         area: 'runtime',
         severity: 'warning',
-        summary: 'Connected GoodVibes service SDK version does not match Agent.',
-        cause: `Connected service reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
+        summary: 'Connected GoodVibes host SDK version does not match Agent.',
+        cause: `Connected host reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
         impact: 'Agent-only routes, especially isolated Agent Knowledge, may be missing or incompatible.',
         action: 'Update the owning GoodVibes host so /status matches this Agent package SDK pin.',
       });
@@ -146,9 +129,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-token-missing',
         area: 'auth',
         severity: 'warning',
-        summary: 'Connected-service operator token is missing.',
+        summary: 'Connected-host operator token is missing.',
         cause: `No operator token was found at ${options.externalRuntime.operatorToken.path}.`,
-        impact: 'Agent can inspect only unauthenticated routes and cannot use protected connected-service APIs.',
+        impact: 'Agent can inspect only unauthenticated routes and cannot use protected connected-host APIs.',
         action: 'Pair or provision access through the owning GoodVibes host, then rerun goodvibes-agent auth.',
       });
     }
@@ -160,24 +143,12 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         severity: 'warning',
         summary: 'Isolated Agent Knowledge route is not ready.',
         cause: `${options.externalRuntime.agentKnowledge.route} returned ${options.externalRuntime.agentKnowledge.kind}${options.externalRuntime.agentKnowledge.statusCode === null ? '' : ` (${options.externalRuntime.agentKnowledge.statusCode})`}.`,
-        impact: 'Agent Knowledge ask/search will not use any fallback wiki or non-Agent knowledge segment; it will fail closed until the Agent route is available.',
-        action: 'Update the connected GoodVibes services to the Agent-compatible SDK and verify goodvibes-agent compat.',
+        impact: 'Agent Knowledge ask/search will not use default or non-Agent knowledge fallback; it will fail closed until the Agent route is available.',
+        action: 'Update the connected GoodVibes host to the Agent-compatible SDK and verify goodvibes-agent compat.',
       });
     }
   }
 
-  if (serverBackedEnabled && !serviceEnabled) {
-    findings.push({
-      id: 'runtime-ownership-external',
-      area: 'runtime',
-      severity: 'warning',
-      summary: 'Connected-service settings are present while Agent service ownership is disabled by design.',
-      cause: 'One or more connected API, inbound events, or browser companion settings are enabled while service.enabled is false.',
-      impact: 'The owning GoodVibes host must provide availability for those endpoints; Agent will not start or enable them.',
-      action: 'Manage connected-service availability from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
-    });
-  }
-
   if (options.service) {
     for (const issue of options.service.issues) {
       if (findings.some((finding) => finding.summary === issue)) continue;
@@ -186,9 +157,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         area: 'runtime',
         severity: 'warning',
         summary: issue,
-        cause: 'The connected-service inspection found a mismatch between configured endpoint state and observed host state.',
-        impact: 'Connected API, listener, or web availability may not match the configuration.',
-        action: 'Use Agent status and doctor diagnostics here, then manage connected services outside Agent.',
+        cause: 'The connected-host inspection found a mismatch between configured endpoint state and observed host state.',
+        impact: 'Companion chat, Agent Knowledge, approvals, automation status, or build delegation may be unavailable.',
+        action: 'Use Agent status and doctor diagnostics here, then repair the connected GoodVibes host outside Agent.',
       });
     }
   }
@@ -198,37 +169,13 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'onboarding-incomplete',
       area: 'onboarding',
       severity: 'warning',
-      summary: 'Agent setup has not been shown for this user.',
-      cause: 'No global user setup check marker was found.',
-      impact: 'Important connected-service, network, provider, auth, or permission choices may still be implicit defaults.',
+      summary: 'Agent setup has not been applied for this user.',
+      cause: 'No global user setup completion marker was found.',
+      impact: 'Provider/model, Agent Knowledge, local behavior, channel, and permission choices may still be implicit defaults.',
       action: 'Run /setup in GoodVibes Agent or goodvibes-agent setup status to review setup state.',
     });
   }
 
-  if (networkFacingSurfaces.length > 0 && options.auth?.userStorePresent !== true) {
-    findings.push({
-      id: 'network-endpoint-without-runtime-auth-signal',
-      area: 'auth',
-      severity: 'risk',
-      summary: 'Network-facing connected-service endpoints are enabled without a visible auth signal.',
-      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see connected-service auth state from its local compatibility files.`,
-      impact: 'Remote access paths may be unusable or unsafe unless the owning host configured auth.',
-      action: 'Review connected-service auth outside Agent; Agent will not create local service users.',
-    });
-  }
-
-  if (networkFacingSurfaces.length > 0 && options.auth?.bootstrapCredentialPresent === true) {
-    findings.push({
-      id: 'network-endpoint-with-bootstrap-credential',
-      area: 'auth',
-      severity: 'risk',
-      summary: 'A bootstrap credential is still present while network-facing surfaces are enabled.',
-      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound and auth-bootstrap.txt exists.`,
-      impact: 'Bootstrap credentials should be treated as temporary setup material, not long-lived network access credentials.',
-      action: 'Replace bootstrap auth and retire the bootstrap credential outside Agent.',
-    });
-  }
-
   if (permissionMode === 'allow-all') {
     findings.push({
       id: 'allow-all-permissions',
@@ -253,18 +200,6 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
     });
   }
 
-  if (listenerEnabled && isNetworkFacing(listenerEnabled, httpListenerBinding)) {
-    findings.push({
-      id: 'network-http-listener-enabled',
-      area: 'network',
-      severity: 'warning',
-      summary: 'The inbound events endpoint is reachable beyond loopback.',
-      cause: `Inbound events endpoint is enabled on ${httpListenerBinding.host}:${httpListenerBinding.port} with ${httpListenerBinding.hostMode} binding.`,
-      impact: 'External tools and devices may be able to reach incoming event endpoints.',
-      action: 'Keep inbound-event secrets/signature checks configured for every enabled endpoint.',
-    });
-  }
-
   return findings;
 }
 
@@ -315,13 +250,6 @@ export function buildCliStatusSnapshot(options: CliStatusOptions): CliStatusSnap
 export function renderCliStatus(options: CliStatusOptions): string {
   const config = options.configManager;
   const snapshot = buildCliStatusSnapshot(options);
-  const serviceEnabled = snapshot.runtimeConnection.enabled;
-  const controlPlaneEnabled = snapshot.runtimeEndpoints.controlPlane.enabled;
-  const listenerEnabled = snapshot.runtimeEndpoints.httpListener.enabled;
-  const webEnabled = snapshot.runtimeEndpoints.web.enabled;
-  const controlPlaneBinding = snapshot.runtimeEndpoints.controlPlane;
-  const httpListenerBinding = snapshot.runtimeEndpoints.httpListener;
-  const webBinding = snapshot.runtimeEndpoints.web;
   const marker = options.onboardingMarkers?.effective;
   const findings = snapshot.findings;
   const externalRuntime = snapshot.externalRuntime;
@@ -330,70 +258,63 @@ export function renderCliStatus(options: CliStatusOptions): string {
 
   const lines = [
     snapshot.title,
-    `  workingDir: ${options.workingDirectory}`,
-    `  homeDir: ${options.homeDirectory}`,
+    `  working directory ${options.workingDirectory}`,
+    `  home directory ${options.homeDirectory}`,
     '',
-    'Provider:',
-    `  provider: ${getProviderIdFromModel(config.get('provider.model'))}`,
-    `  model: ${String(config.get('provider.model'))}`,
-    `  reasoning: ${String(config.get('provider.reasoningEffort'))}`,
+    'Provider',
+    `  provider ${getProviderIdFromModel(config.get('provider.model'))}`,
+    `  model ${String(config.get('provider.model'))}`,
+    `  reasoning ${String(config.get('provider.reasoningEffort'))}`,
     '',
-    'Auth:',
+    'Auth',
     `  permissions: ${permissionModeLabel(config.get('permissions.mode'))} (${String(config.get('permissions.mode'))})`,
     `  secretPolicy: ${secretPolicyLabel(config.get('storage.secretPolicy'))} (${String(config.get('storage.secretPolicy'))})`,
     options.auth
-      ? `  runtimeAuthSignal: ${options.auth.userStorePresent ? 'present' : 'missing'} (${options.auth.userStorePath})`
-      : '  runtimeAuthSignal: unknown',
+      ? `  local auth store ${options.auth.userStorePresent ? 'present' : 'missing'} (${options.auth.userStorePath})`
+      : '  local auth store unknown',
     options.auth
-      ? `  bootstrapCredential: ${options.auth.bootstrapCredentialPresent ? 'present' : 'missing'} (${options.auth.bootstrapCredentialPath})`
-      : '  bootstrapCredential: unknown',
+      ? `  setup credential ${options.auth.bootstrapCredentialPresent ? 'present' : 'missing'} (${options.auth.bootstrapCredentialPath})`
+      : '  setup credential unknown',
     options.auth
-      ? `  operatorTokens: ${options.auth.operatorTokenPresent ? 'present' : 'missing'} (${options.auth.operatorTokenPath})`
-      : '  operatorTokens: unknown',
+      ? `  connected host token ${options.auth.operatorTokenPresent ? 'present' : 'missing'} (${options.auth.operatorTokenPath})`
+      : '  connected host token unknown',
     '',
-    'Connected GoodVibes API:',
+    'Connected GoodVibes host:',
     ...(externalRuntime ? [
       `  baseUrl: ${externalRuntime.baseUrl}`,
       `  reachable: ${yesNo(externalRuntime.reachable)}${externalRuntime.statusCode === null ? '' : ` (HTTP ${externalRuntime.statusCode})`}`,
       `  sdk: ${externalRuntime.version} expected ${externalRuntime.expectedVersion}`,
       `  compatible: ${yesNo(externalRuntime.compatible)}`,
-      `  operatorToken: ${externalRuntime.operatorToken.present ? 'present' : 'missing'} (${externalRuntime.operatorToken.path})`,
-      `  Agent Knowledge: ${externalRuntime.agentKnowledge.ready ? 'ready' : `not ready (${externalRuntime.agentKnowledge.kind})`}`,
+      `  access token: ${externalRuntime.operatorToken.present ? 'present' : 'missing'} (${externalRuntime.operatorToken.path})`,
+      `  Agent Knowledge: ${externalRuntime.agentKnowledge.ready ? 'ready' : `not ready (${formatAgentKnowledgeFailureKind(externalRuntime.agentKnowledge.kind)})`}`,
       ...(externalRuntime.error ? [`  error: ${externalRuntime.error}`] : []),
     ] : [
-      '  live check: unavailable',
+      '  live check unavailable',
     ]),
     '',
-    'Connected GoodVibes Services:',
-    '  Agent role: client/operator TUI only',
-    '  service ownership: outside Agent',
-    '  Agent starts services: no',
+    'Agent role:',
+    '  product: interactive operator TUI',
+    '  host lifecycle: external',
+    '  starts or exposes host: no',
     ...(options.service ? [
-      `  platform: ${options.service.managed.platform}`,
-      `  installed: ${yesNo(options.service.managed.installed)}`,
-      `  running: ${yesNo(options.service.managed.running)}`,
-      `  definition: ${options.service.managed.path}`,
-      `  log: ${options.service.log.path ?? 'n/a'} (${options.service.log.exists ? 'present' : 'missing'})`,
+      `  host log signal ${options.service.log.path ?? 'n/a'} (${options.service.log.exists ? 'present' : 'missing'})`,
     ] : []),
-    'Onboarding:',
-    `  checked: ${marker?.exists ? 'yes' : 'no'}`,
-    `  scope: ${marker?.scope ?? 'none'}`,
-    `  updatedAt: ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
+    'Onboarding',
+    `  checked ${marker?.exists ? 'yes' : 'no'}`,
+    `  scope ${marker?.scope ?? 'none'}`,
+    `  updated ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
   ];
 
   if (options.doctor) {
     lines.push(
       '',
-      'Connected-Service Config Signals:',
-      `  host config present: ${yesNo(serviceEnabled)}`,
-      '  lifecycle config: external to Agent',
-      '',
-      'Endpoint Diagnostics:',
-      bindLine('runtimeApi', controlPlaneEnabled, controlPlaneBinding),
-      bindLine('incomingWebhook', listenerEnabled, httpListenerBinding),
-      bindLine('browserCompanion', webEnabled, webBinding),
+      'Readiness Checks:',
+      '  companion chat route',
+      '  isolated Agent Knowledge route',
+      '  approvals and automation status routes',
+      '  explicit build delegation route',
     );
-    lines.push('', 'Warnings:');
+    lines.push('', 'Warnings');
     if (findings.length === 0) {
       lines.push('  none');
     } else {
@@ -415,11 +336,11 @@ export function renderOnboardingCliStatus(options: CliStatusOptions): string {
   const marker = options.onboardingMarkers?.effective;
   return [
     'GoodVibes Agent setup status',
-    `  checked: ${marker?.exists ? 'yes' : 'no'}`,
-    `  scope: ${marker?.scope ?? 'none'}`,
-    `  source: ${marker?.payload?.source ?? 'n/a'}`,
-    `  mode: ${marker?.payload?.mode ?? 'n/a'}`,
-    `  updatedAt: ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
-    `  workingDir: ${options.workingDirectory}`,
+    `  checked ${marker?.exists ? 'yes' : 'no'}`,
+    `  scope ${marker?.scope ?? 'none'}`,
+    `  origin ${marker?.payload?.source ? formatAgentRecordSource(marker.payload.source) : 'n/a'}`,
+    `  mode ${marker?.payload?.mode ?? 'n/a'}`,
+    `  updated ${marker?.payload ? new Date(marker.payload.updatedAt).toISOString() : 'n/a'}`,
+    `  working directory ${options.workingDirectory}`,
   ].join('\n');
 }

package/src/core/conversation-message-snapshot.ts

@@ -0,0 +1,131 @@
+import type { ConversationMessageSnapshot, TokenUsage } from './conversation.ts';
+import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ToolCall } from '@pellux/goodvibes-sdk/platform/types';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function readContentPart(value: unknown): ContentPart | null {
+  if (!isRecord(value)) return null;
+  if (value.type === 'text' && typeof value.text === 'string') {
+    return { type: 'text', text: value.text };
+  }
+  if (value.type === 'image' && typeof value.data === 'string' && typeof value.mediaType === 'string') {
+    return { type: 'image', data: value.data, mediaType: value.mediaType };
+  }
+  return null;
+}
+
+function readContent(value: unknown): string | ContentPart[] | null {
+  if (typeof value === 'string') return value;
+  if (!Array.isArray(value)) return null;
+  const parts: ContentPart[] = [];
+  for (const entry of value) {
+    const part = readContentPart(entry);
+    if (!part) return null;
+    parts.push(part);
+  }
+  return parts;
+}
+
+function readTokenUsage(value: unknown): TokenUsage | undefined {
+  if (!isRecord(value) || typeof value.inputTokens !== 'number' || typeof value.outputTokens !== 'number') return undefined;
+  return {
+    inputTokens: value.inputTokens,
+    outputTokens: value.outputTokens,
+    ...(typeof value.cacheReadTokens === 'number' ? { cacheReadTokens: value.cacheReadTokens } : {}),
+    ...(typeof value.cacheWriteTokens === 'number' ? { cacheWriteTokens: value.cacheWriteTokens } : {}),
+  };
+}
+
+function readToolCalls(value: unknown): ToolCall[] | null {
+  if (!Array.isArray(value)) return null;
+  const calls: ToolCall[] = [];
+  for (const entry of value) {
+    if (!isRecord(entry) || typeof entry.id !== 'string' || typeof entry.name !== 'string' || !isRecord(entry.arguments)) return null;
+    calls.push({ id: entry.id, name: entry.name, arguments: entry.arguments });
+  }
+  return calls;
+}
+
+function hasOwn(record: Record<string, unknown>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+
+function readConversationMessageSnapshot(value: unknown): ConversationMessageSnapshot | null {
+  if (!isRecord(value)) return null;
+  if (value.role === 'user') {
+    const content = readContent(value.content);
+    if (content === null) return null;
+    const cancelled = hasOwn(value, 'cancelled') ? readBoolean(value.cancelled) : undefined;
+    if (hasOwn(value, 'cancelled') && cancelled === undefined) return null;
+    return {
+      role: 'user',
+      content,
+      ...(cancelled !== undefined ? { cancelled } : {}),
+    };
+  }
+  if (value.role === 'assistant') {
+    const content = readString(value.content);
+    if (content === undefined) return null;
+    const toolCalls = hasOwn(value, 'toolCalls') ? readToolCalls(value.toolCalls) : undefined;
+    if (toolCalls === null) return null;
+    const reasoningContent = hasOwn(value, 'reasoningContent') ? readString(value.reasoningContent) : undefined;
+    if (hasOwn(value, 'reasoningContent') && reasoningContent === undefined) return null;
+    const reasoningSummary = hasOwn(value, 'reasoningSummary') ? readString(value.reasoningSummary) : undefined;
+    if (hasOwn(value, 'reasoningSummary') && reasoningSummary === undefined) return null;
+    const usage = hasOwn(value, 'usage') ? readTokenUsage(value.usage) : undefined;
+    if (hasOwn(value, 'usage') && usage === undefined) return null;
+    const model = hasOwn(value, 'model') ? readString(value.model) : undefined;
+    if (hasOwn(value, 'model') && model === undefined) return null;
+    const provider = hasOwn(value, 'provider') ? readString(value.provider) : undefined;
+    if (hasOwn(value, 'provider') && provider === undefined) return null;
+    return {
+      role: 'assistant',
+      content,
+      ...(toolCalls !== undefined ? { toolCalls } : {}),
+      ...(reasoningContent !== undefined ? { reasoningContent } : {}),
+      ...(reasoningSummary !== undefined ? { reasoningSummary } : {}),
+      ...(usage !== undefined ? { usage } : {}),
+      ...(model !== undefined ? { model } : {}),
+      ...(provider !== undefined ? { provider } : {}),
+    };
+  }
+  if (value.role === 'system' && typeof value.content === 'string') {
+    return { role: 'system', content: value.content };
+  }
+  if (value.role === 'tool' && typeof value.callId === 'string' && typeof value.content === 'string') {
+    const toolName = hasOwn(value, 'toolName') ? readString(value.toolName) : undefined;
+    if (hasOwn(value, 'toolName') && toolName === undefined) return null;
+    return {
+      role: 'tool',
+      callId: value.callId,
+      content: value.content,
+      ...(toolName !== undefined ? { toolName } : {}),
+    };
+  }
+  return null;
+}
+
+export function readConversationMessageSnapshots(messages: readonly object[]): ConversationMessageSnapshot[] {
+  const snapshots: ConversationMessageSnapshot[] = [];
+  for (const [index, message] of messages.entries()) {
+    const snapshot = readConversationMessageSnapshot(message);
+    if (!snapshot) throw new Error(`Invalid saved conversation message at index ${index}.`);
+    snapshots.push(snapshot);
+  }
+  return snapshots;
+}
+
+export function conversationMessagesAsSessionRecords(messages: readonly ConversationMessageSnapshot[]): Array<Record<string, unknown>> {
+  return messages.map((message) => ({ ...message }));
+}

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

@@ -0,0 +1,149 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceAccessCommandEditorKind } from './agent-workspace-access-command-editors.ts';
+import { isAgentWorkspaceAccessCommandEditorKind } from './agent-workspace-access-command-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceAccessCommandEditorSubmission =
+  | {
+    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 isAgentWorkspaceAccessCommandSubmissionKind(kind: string): kind is AgentWorkspaceAccessCommandEditorKind {
+  return isAgentWorkspaceAccessCommandEditorKind(kind as AgentWorkspaceAccessCommandEditorKind);
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceAccessCommandEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status: message,
+  };
+}
+
+function dispatch(command: string, title: string, detail: string, safety: AgentWorkspaceActionResult['safety']): AgentWorkspaceAccessCommandEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status: `${title}.`,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail,
+      command,
+      safety,
+    },
+  };
+}
+
+export function buildAgentWorkspaceAccessCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceAccessCommandEditorSubmission {
+  if (editor.kind === 'auth-show') {
+    return dispatch(
+      `/auth show ${quoteSlashCommandArg(readField('provider'))}`,
+      'Opening provider auth inspection',
+      'The workspace handed a read-only provider auth inspection command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'auth-repair') {
+    return dispatch(
+      `/auth repair ${quoteSlashCommandArg(readField('provider'))}`,
+      'Opening provider auth repair review',
+      'The workspace handed a read-only provider auth repair review command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'auth-bundle-export') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Auth review bundle export not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/auth bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
+      'Opening auth review bundle export',
+      'The workspace handed a confirmed auth review bundle export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  if (editor.kind === 'auth-bundle-inspect') {
+    return dispatch(
+      `/auth bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+      'Opening auth review bundle inspection',
+      'The workspace handed a read-only auth review bundle inspect command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'trust-bundle-export') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Trust bundle export not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/trust bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
+      'Opening trust bundle export',
+      'The workspace handed a confirmed trust bundle export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  if (editor.kind === 'trust-bundle-inspect') {
+    return dispatch(
+      `/trust bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+      'Opening trust bundle inspection',
+      'The workspace handed a read-only trust bundle inspect command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'subscription-bundle-export') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Subscription bundle export not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/subscription bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
+      'Opening subscription bundle export',
+      'The workspace handed a confirmed subscription bundle export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  if (editor.kind === 'subscription-bundle-inspect') {
+    return dispatch(
+      `/subscription bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+      'Opening subscription bundle inspection',
+      'The workspace handed a read-only subscription bundle inspect command to the shell-owned command router.',
+      'read-only',
+    );
+  }
+  if (editor.kind === 'voice-enable' || editor.kind === 'voice-disable') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, `Voice interaction ${editor.kind === 'voice-enable' ? 'enable' : 'disable'} not confirmed. Type yes, then press Enter.`);
+    const mode = editor.kind === 'voice-enable' ? 'enable' : 'disable';
+    return dispatch(
+      `/voice ${mode} --yes`,
+      `Opening voice interaction ${mode}`,
+      `The workspace handed a confirmed voice ${mode} command to the shell-owned command router.`,
+      'safe',
+    );
+  }
+  if (editor.kind === 'voice-bundle-export') {
+    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Voice bundle export not confirmed. Type yes, then press Enter.');
+    return dispatch(
+      `/voice bundle export ${quoteSlashCommandArg(readField('path'))} --yes`,
+      'Opening voice bundle export',
+      'The workspace handed a confirmed voice bundle export command to the shell-owned command router.',
+      'safe',
+    );
+  }
+  return dispatch(
+    `/voice bundle inspect ${quoteSlashCommandArg(readField('path'))}`,
+    'Opening voice bundle inspection',
+    'The workspace handed a read-only voice bundle inspect command to the shell-owned command router.',
+    'read-only',
+  );
+}