ethagent 0.2.1 → 1.0.1

package/src/identity/hub/identityHubModel.ts

@@ -0,0 +1,291 @@
+import type { EthagentConfig, EthagentIdentity, SelectableNetwork } from '../../storage/config.js'
+import {
+  RegisterAgentPreflightError,
+  supportedErc8004ChainForId,
+  type Erc8004AgentCandidate,
+} from '../registry/erc8004.js'
+import { AgentStateOwnerMismatchError } from '../crypto/backupEnvelope.js'
+import { ContinuitySnapshotOwnerMismatchError } from '../continuity/envelope.js'
+import { resolveSelectedNetwork } from '../registry/registryConfig.js'
+
+export const PREFLIGHT_AGENT_URI = 'ipfs://bafybeigdyrztma2dbfczw7q6ooozbxlqzyw5r7w4f3qw2axvvxqg3w6y7q'
+
+export type IdentityHubErrorView = {
+  title: string
+  detail?: string
+  hint?: string
+}
+
+export function initialAgentState(name: string, description: string, ownerAddress: string): Record<string, unknown> {
+  return {
+    version: 1,
+    name,
+    description,
+    ownerAddress,
+    createdAt: new Date().toISOString(),
+    preferences: {},
+    memory: {},
+  }
+}
+
+export function identityHubErrorView(err: unknown): IdentityHubErrorView {
+  if (err instanceof RegisterAgentPreflightError) {
+    return {
+      title: err.title,
+      detail: err.detail,
+      hint: err.hint,
+    }
+  }
+  if (err instanceof AgentStateOwnerMismatchError) {
+    return {
+      title: 'backup locked to another wallet',
+      detail: `wallet ${shortAddress(err.currentOwner)} cannot read state encrypted for ${shortAddress(err.backupOwner)}.`,
+      hint: 'Use the wallet that created this backup.',
+    }
+  }
+  if (err instanceof ContinuitySnapshotOwnerMismatchError) {
+    return {
+      title: 'continuity locked to another wallet',
+      detail: `wallet ${shortAddress(err.currentOwner)} cannot read SOUL.md or MEMORY.md encrypted for ${shortAddress(err.snapshotOwner)}.`,
+      hint: 'Use the wallet that created this continuity snapshot.',
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err)
+  if (message === 'fetch failed') {
+    return {
+      title: 'storage unavailable',
+      detail: 'could not reach storage.',
+      hint: 'check the connection, then try again.',
+    }
+  }
+  return {
+    title: 'identity error',
+    detail: message,
+  }
+}
+
+export function pinataErrorText(err: unknown): string {
+  const view = identityHubErrorView(err)
+  return view.detail ?? view.title
+}
+
+export function isRegistrationPreflightError(err: unknown): boolean {
+  return err instanceof RegisterAgentPreflightError
+}
+
+export function shortCid(cid: string): string {
+  if (cid.length <= 18) return cid
+  return `${cid.slice(0, 10)}...${cid.slice(-6)}`
+}
+
+export function shortAddress(address: string): string {
+  if (address.length <= 14) return address
+  return `${address.slice(0, 6)}...${address.slice(-4)}`
+}
+
+export function shortHash(value: string): string {
+  if (value.length <= 18) return value
+  return `${value.slice(0, 8)}...${value.slice(-6)}`
+}
+
+export function tokenLabel(candidate: Erc8004AgentCandidate): string {
+  return tokenCandidateLabel(candidate)
+}
+
+export function tokenCandidateLabel(candidate: Erc8004AgentCandidate): string {
+  return candidate.name?.trim() || `agent token #${candidate.agentId.toString()}`
+}
+
+export function tokenCandidateSelectLabel(
+  candidate: Erc8004AgentCandidate,
+  current = false,
+): string {
+  return `${tokenCandidateLabel(candidate)}${current ? '  *' : ''}`
+}
+
+export function tokenCandidateHint(candidate: Erc8004AgentCandidate): string {
+  const chain = supportedErc8004ChainForId(candidate.chainId)
+  const network = chain?.network ? networkLabel(chain.network) : chain?.name ?? `chain ${candidate.chainId}`
+  const parts = [
+    candidate.name?.trim() ? `token #${candidate.agentId.toString()}` : null,
+    network,
+    candidate.backup?.createdAt ? `backup ${formatDate(candidate.backup.createdAt)}` : null,
+  ].filter((part): part is string => Boolean(part))
+  return parts.join(' · ')
+}
+
+export function isCurrentAgentCandidate(
+  identity: EthagentIdentity | undefined,
+  candidate: Erc8004AgentCandidate,
+): boolean {
+  if (!identity?.agentId) return false
+  if (identity.agentId !== candidate.agentId.toString()) return false
+
+  const owner = identity.ownerAddress ?? identity.address
+  if (owner && owner.toLowerCase() !== candidate.ownerAddress.toLowerCase()) return false
+  if (identity.chainId !== undefined && identity.chainId !== candidate.chainId) return false
+  if (
+    identity.identityRegistryAddress
+    && identity.identityRegistryAddress.toLowerCase() !== candidate.identityRegistryAddress.toLowerCase()
+  ) {
+    return false
+  }
+  return true
+}
+
+export function storageLabel(apiUrl: string): string {
+  void apiUrl
+  return 'IPFS'
+}
+
+const NETWORK_LABELS: Record<SelectableNetwork, string> = {
+  mainnet:  'ethereum mainnet',
+  arbitrum: 'arbitrum one',
+  base:     'base',
+  optimism: 'optimism',
+  polygon:  'polygon',
+}
+
+export function networkLabel(network: SelectableNetwork): string {
+  return NETWORK_LABELS[network]
+}
+
+const NETWORK_SUBTITLES: Record<SelectableNetwork, string> = {
+  mainnet:  'agent tokens on ethereum mainnet.',
+  arbitrum: 'agent tokens on arbitrum one.',
+  base:     'agent tokens on base.',
+  optimism: 'agent tokens on optimism.',
+  polygon:  'agent tokens on polygon.',
+}
+
+export function networkSubtitle(network: SelectableNetwork): string {
+  return NETWORK_SUBTITLES[network]
+}
+
+export function networkMenuTagline(): string {
+  return 'choose where your agent token is created or found.'
+}
+
+export function currentNetworkLine(config?: EthagentConfig): string {
+  return networkLabel(resolveSelectedNetwork(config))
+}
+
+export function chainSummaryRow(config?: EthagentConfig, identity?: EthagentIdentity): {
+  label: string
+  value: string
+  tone: 'ok' | 'dim'
+} {
+  const network = resolveSelectedNetwork(config)
+  const fromIdentity = identity?.chainId ? supportedErc8004ChainForId(identity.chainId)?.name.toLowerCase() : undefined
+  const value = fromIdentity ?? networkLabel(network)
+  return { label: 'chain', value, tone: identity?.chainId ? 'ok' : 'dim' }
+}
+
+export function lastBackupLabel(identity?: EthagentIdentity): string {
+  const created = identity?.backup?.createdAt
+  return created ? formatDate(created) : 'never'
+}
+
+export function identitySummaryRows(
+  identity: EthagentIdentity | undefined,
+  config?: EthagentConfig,
+): Array<{
+  label: string
+  value: string
+  tone: 'ok' | 'dim'
+}> {
+  const backup = identity?.backup
+  const owner = identity?.ownerAddress ?? identity?.address
+  const ownerValue = owner ? shortAddress(owner) : 'not connected'
+  const tokenValue = identity?.agentId ? `#${identity.agentId}` : 'not created'
+  const chain = chainSummaryRow(config, identity)
+  const stateValue = backup?.cid ? shortCid(backup.cid) : 'not saved yet'
+  const skillsValue = identity?.publicSkills?.cid ? shortCid(identity.publicSkills.cid) : 'not published'
+  const cardValue = identity?.publicSkills?.agentCardCid ? shortCid(identity.publicSkills.agentCardCid) : 'not published'
+  const imageValue = typeof identity?.state?.imageUrl === 'string' && identity.state.imageUrl.trim() ? 'attached' : 'not attached'
+  return [
+    { label: 'owner', value: ownerValue, tone: identity ? 'ok' : 'dim' },
+    { label: 'token', value: tokenValue, tone: identity?.agentId ? 'ok' : 'dim' },
+    { label: 'network', value: chain.value, tone: chain.tone },
+    { label: 'state', value: stateValue, tone: backup ? 'ok' : 'dim' },
+    { label: 'skills', value: skillsValue, tone: identity?.publicSkills?.cid ? 'ok' : 'dim' },
+    { label: 'card', value: cardValue, tone: identity?.publicSkills?.agentCardCid ? 'ok' : 'dim' },
+    { label: 'image', value: imageValue, tone: imageValue === 'attached' ? 'ok' : 'dim' },
+  ]
+}
+
+export type IdentityDetailSection = {
+  title: string
+  rows: Array<{
+    label: string
+    value: string
+    tone: 'ok' | 'dim'
+  }>
+}
+
+export function identityDetailSections(
+  identity: EthagentIdentity | undefined,
+  config?: EthagentConfig,
+): IdentityDetailSection[] {
+  const backup = identity?.backup
+  const owner = identity?.ownerAddress ?? identity?.address
+  const chain = chainSummaryRow(config, identity)
+  const stateCid = backup?.cid ?? 'not saved yet'
+  const registrationCid = identity?.metadataCid ?? 'not saved yet'
+  const publicSkillsCid = identity?.publicSkills?.cid ?? 'not published'
+  const agentCardCid = identity?.publicSkills?.agentCardCid ?? 'not published'
+
+  return [
+    {
+      title: 'Agent',
+      rows: [
+        { label: 'token', value: identity?.agentId ? `#${identity.agentId}` : 'not created', tone: identity?.agentId ? 'ok' : 'dim' },
+        { label: 'network', value: chain.value, tone: chain.tone },
+        { label: 'registration', value: registrationCid, tone: identity?.metadataCid ? 'ok' : 'dim' },
+      ],
+    },
+    {
+      title: 'Owner',
+      rows: [
+        { label: 'wallet', value: owner ?? 'not connected', tone: owner ? 'ok' : 'dim' },
+      ],
+    },
+    {
+      title: 'Recovery',
+      rows: [
+        { label: 'state CID', value: stateCid, tone: backup?.cid ? 'ok' : 'dim' },
+        { label: 'skills CID', value: publicSkillsCid, tone: identity?.publicSkills?.cid ? 'ok' : 'dim' },
+        { label: 'agent card CID', value: agentCardCid, tone: identity?.publicSkills?.agentCardCid ? 'ok' : 'dim' },
+        { label: 'storage', value: backup?.ipfsApiUrl ? storageLabel(backup.ipfsApiUrl) : 'not saved yet', tone: backup?.ipfsApiUrl ? 'ok' : 'dim' },
+        { label: 'created', value: identity?.createdAt ? formatDate(identity.createdAt) : 'not created', tone: identity?.createdAt ? 'ok' : 'dim' },
+        { label: 'last backup', value: backup?.createdAt ? formatDate(backup.createdAt) : 'never', tone: backup?.createdAt ? 'ok' : 'dim' },
+        { label: 'status', value: backup?.status ?? 'unknown', tone: backup?.status ? 'ok' : 'dim' },
+      ],
+    },
+  ]
+}
+
+export type CopyableField = {
+  label: string
+  value: string
+}
+
+export function copyableIdentityFields(identity?: EthagentIdentity): CopyableField[] {
+  if (!identity) return []
+  const fields: CopyableField[] = []
+  if (identity.backup?.cid) fields.push({ label: 'state CID', value: identity.backup.cid })
+  if (identity.publicSkills?.cid) fields.push({ label: 'skills CID', value: identity.publicSkills.cid })
+  if (identity.publicSkills?.agentCardCid) fields.push({ label: 'agent card CID', value: identity.publicSkills.agentCardCid })
+  if (identity.metadataCid) fields.push({ label: 'registration CID', value: identity.metadataCid })
+  if (identity.agentUri) fields.push({ label: 'agent URI', value: identity.agentUri })
+  const owner = identity.ownerAddress ?? identity.address
+  if (owner) fields.push({ label: 'owner address', value: owner })
+  if (identity.agentId) fields.push({ label: 'token id', value: identity.agentId })
+  return fields
+}
+
+function formatDate(input: string): string {
+  const date = new Date(input)
+  if (Number.isNaN(date.getTime())) return input
+  return date.toISOString().slice(0, 10)
+}

package/src/identity/hub/identityHubReducer.ts

@@ -0,0 +1,209 @@
+import type { EthagentConfig, EthagentIdentity, SelectableNetwork } from '../../storage/config.js'
+import type { Erc8004AgentCandidate, Erc8004RegistryConfig } from '../registry/erc8004.js'
+import type { RegistryResolution } from '../registry/registryConfig.js'
+import type { AgentStateBackupEnvelope } from '../crypto/backupEnvelope.js'
+import type { ContinuitySnapshotEnvelope } from '../continuity/envelope.js'
+import type { IdentityHubErrorView } from './identityHubModel.js'
+
+export type RestorePurpose = 'restore' | 'switch'
+export type DetailsView = Extract<Step, { kind: 'details' }>
+export type ProfileUpdates = { name?: string; description?: string; imagePath?: string }
+export type RestorableBackupEnvelope = AgentStateBackupEnvelope | ContinuitySnapshotEnvelope
+
+export type Step =
+  | { kind: 'menu' }
+  | { kind: 'replace-confirm'; next: 'create' | 'restore' }
+  | { kind: 'create-name'; error?: string }
+  | { kind: 'create-description'; name: string }
+  | { kind: 'create-network'; name: string; description: string }
+  | { kind: 'create-preflight'; name: string; description: string; network?: SelectableNetwork }
+  | { kind: 'create-registry'; name: string; description: string; resolution: RegistryResolution; error?: string }
+  | { kind: 'create-signing'; name: string; description: string; registry: Erc8004RegistryConfig; pinataJwt?: string }
+  | { kind: 'create-storage'; name: string; description: string; registry: Erc8004RegistryConfig; error?: string; pinataJwt?: string }
+  | { kind: 'restore-owner'; purpose?: RestorePurpose }
+  | { kind: 'restore-wallet'; purpose?: RestorePurpose }
+  | { kind: 'restore-network'; ownerHandle: string; purpose?: RestorePurpose }
+  | { kind: 'restore-registry'; ownerHandle: string; error?: string; purpose?: RestorePurpose }
+  | { kind: 'restore-discovering'; ownerHandle: string; registry: Erc8004RegistryConfig; purpose?: RestorePurpose }
+  | { kind: 'restore-token-id'; ownerHandle: string; registry: Erc8004RegistryConfig; error?: string; purpose?: RestorePurpose }
+  | { kind: 'restore-select-token'; ownerHandle: string; registry: Erc8004RegistryConfig; candidates: Erc8004AgentCandidate[]; purpose?: RestorePurpose }
+  | { kind: 'restore-fetching'; cid: string; apiUrl: string; candidate: Erc8004AgentCandidate; purpose?: RestorePurpose }
+  | { kind: 'restore-authorizing'; cid: string; apiUrl: string; envelope: RestorableBackupEnvelope; candidate: Erc8004AgentCandidate; purpose?: RestorePurpose }
+  | { kind: 'rebackup-signing'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; pinataJwt?: string; profileUpdates?: ProfileUpdates; returnTo?: Step }
+  | { kind: 'rebackup-storage'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; error?: string; pinataJwt?: string; profileUpdates?: ProfileUpdates; returnTo?: Step }
+  | { kind: 'public-profile-signing'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; pinataJwt?: string; profileUpdates?: ProfileUpdates; returnTo?: Step }
+  | { kind: 'public-profile-storage'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; error?: string; pinataJwt?: string; profileUpdates?: ProfileUpdates; returnTo?: Step }
+  | { kind: 'continuity-private'; notice?: string }
+  | { kind: 'continuity-public'; notice?: string }
+  | { kind: 'rebackup-confirm' }
+  | { kind: 'recovery-refetch-confirm' }
+  | { kind: 'recovery-refetching'; identity: EthagentIdentity; registry: Erc8004RegistryConfig }
+  | { kind: 'rebackup-start'; back: Step }
+  | { kind: 'edit-profile-name'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; returnTo?: Step }
+  | { kind: 'edit-profile-description'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; name: string; returnTo?: Step }
+  | { kind: 'edit-profile-image'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; name: string; description: string; error?: string; returnTo?: Step }
+  | { kind: 'storage-credential' }
+  | { kind: 'storage-credential-input'; error?: string }
+  | { kind: 'storage-credential-forget-confirm' }
+  | { kind: 'details' }
+  | { kind: 'busy'; label: string }
+  | { kind: 'error'; error: IdentityHubErrorView; back: Step }
+
+export type Action =
+  | { type: 'goMenu' }
+  | { type: 'startCreate'; hasIdentity: boolean }
+  | { type: 'confirmReplace' }
+  | { type: 'cancelReplace' }
+  | { type: 'nameSubmitted'; name: string }
+  | { type: 'descriptionSubmitted'; name: string; description: string }
+  | { type: 'preflightResolved'; step: Step }
+  | { type: 'registrySubmitted'; step: Step }
+  | { type: 'storageSubmitted'; step: Step }
+  | { type: 'walletSigned'; step: Step }
+  | { type: 'pinned'; step: Step }
+  | { type: 'registered'; step: Step }
+  | { type: 'startRestore' }
+  | { type: 'ownerSubmitted'; step: Step }
+  | { type: 'restoreRegistrySubmitted'; step: Step }
+  | { type: 'discovered'; step: Step }
+  | { type: 'tokenSelected'; step: Step }
+  | { type: 'fetched'; step: Step }
+  | { type: 'authorized' }
+  | { type: 'openDetails' }
+  | { type: 'openCopyPicker' }
+  | { type: 'closeCopyPicker' }
+  | { type: 'error'; error: IdentityHubErrorView; back: Step }
+  | { type: 'back'; from: Step }
+
+export function identityHubReducer(state: Step, action: Action): Step {
+  switch (action.type) {
+    case 'goMenu':
+      return { kind: 'menu' }
+    case 'startCreate':
+      if (action.hasIdentity) return { kind: 'replace-confirm', next: 'create' }
+      return { kind: 'create-name' }
+    case 'confirmReplace':
+      return { kind: 'create-name' }
+    case 'cancelReplace':
+      return { kind: 'menu' }
+    case 'nameSubmitted':
+      return { kind: 'create-description', name: action.name }
+    case 'descriptionSubmitted':
+      return { kind: 'create-network', name: action.name, description: action.description }
+    case 'preflightResolved':
+    case 'registrySubmitted':
+    case 'storageSubmitted':
+    case 'walletSigned':
+    case 'pinned':
+    case 'registered':
+    case 'ownerSubmitted':
+    case 'restoreRegistrySubmitted':
+    case 'discovered':
+    case 'tokenSelected':
+    case 'fetched':
+      return action.step
+    case 'startRestore':
+      return { kind: 'restore-wallet' }
+    case 'openDetails':
+      return { kind: 'details' }
+    case 'openCopyPicker':
+      if (state.kind === 'details') return { kind: 'details' }
+      return state
+    case 'closeCopyPicker':
+      if (state.kind === 'details') return { kind: 'details' }
+      return state
+    case 'error':
+      return { kind: 'error', error: action.error, back: action.back }
+    case 'back':
+      return backStep(action.from)
+    default:
+      return state
+  }
+}
+
+function backStep(from: Step): Step {
+  switch (from.kind) {
+    case 'create-name':
+      return { kind: 'menu' }
+    case 'create-description':
+      return { kind: 'create-name' }
+    case 'create-network':
+      return { kind: 'create-description', name: from.name }
+    case 'create-preflight':
+      return { kind: 'create-network', name: from.name, description: from.description }
+    case 'create-registry':
+      return { kind: 'create-network', name: from.name, description: from.description }
+    case 'create-signing':
+      return { kind: 'create-network', name: from.name, description: from.description }
+    case 'create-storage':
+      return { kind: 'create-network', name: from.name, description: from.description }
+    case 'restore-owner':
+      return { kind: 'menu' }
+    case 'restore-wallet':
+      return { kind: 'restore-owner', purpose: from.purpose }
+    case 'restore-network':
+      return { kind: 'restore-owner', purpose: from.purpose }
+    case 'restore-registry':
+      return { kind: 'restore-network', ownerHandle: from.ownerHandle, purpose: from.purpose }
+    case 'restore-discovering':
+      return { kind: 'restore-network', ownerHandle: from.ownerHandle, purpose: from.purpose }
+    case 'restore-token-id':
+      return { kind: 'restore-network', ownerHandle: from.ownerHandle, purpose: from.purpose }
+    case 'restore-select-token':
+      return { kind: 'restore-network', ownerHandle: from.ownerHandle, purpose: from.purpose }
+    case 'restore-fetching':
+      return { kind: 'restore-network', ownerHandle: from.candidate.ownerAddress, purpose: from.purpose }
+    case 'restore-authorizing':
+      return { kind: 'restore-network', ownerHandle: from.candidate.ownerAddress, purpose: from.purpose }
+    case 'details':
+      return { kind: 'menu' }
+    case 'rebackup-signing':
+    case 'rebackup-storage':
+    case 'rebackup-start':
+      return from.kind === 'rebackup-start' ? from.back : from.returnTo ?? { kind: 'menu' }
+    case 'public-profile-signing':
+    case 'public-profile-storage':
+      return from.returnTo ?? { kind: 'continuity-public' }
+    case 'continuity-private':
+    case 'continuity-public':
+      return { kind: 'menu' }
+    case 'rebackup-confirm':
+    case 'recovery-refetch-confirm':
+    case 'recovery-refetching':
+      return { kind: 'menu' }
+    case 'edit-profile-name':
+      return from.returnTo ?? { kind: 'continuity-public' }
+    case 'edit-profile-description':
+      return { kind: 'edit-profile-name', identity: from.identity, registry: from.registry, returnTo: from.returnTo }
+    case 'edit-profile-image':
+      return { kind: 'edit-profile-description', identity: from.identity, registry: from.registry, name: from.name, returnTo: from.returnTo }
+    case 'storage-credential':
+    case 'storage-credential-input':
+    case 'storage-credential-forget-confirm':
+      return { kind: 'menu' }
+    case 'error':
+      return from.back
+    default:
+      return { kind: 'menu' }
+  }
+}
+
+export const CREATE_STEP_LABELS = ['name', 'describe', 'network', 'create']
+
+export function createStepNumber(step: Step): number {
+  switch (step.kind) {
+    case 'create-name':
+      return 1
+    case 'create-description':
+      return 2
+    case 'create-network':
+      return 3
+    case 'create-preflight':
+    case 'create-storage':
+    case 'create-registry':
+    case 'create-signing':
+      return 4
+    default:
+      return 0
+  }
+}

package/src/identity/hub/screens/BusyScreen.tsx

@@ -0,0 +1,26 @@
+import React from 'react'
+import { Text } from 'ink'
+import { Surface } from '../../../ui/Surface.js'
+import { Spinner } from '../../../ui/Spinner.js'
+import { theme } from '../../../ui/theme.js'
+import { useAppInput } from '../../../app/input/AppInputProvider.js'
+
+type BusyScreenProps = {
+  title: string
+  subtitle?: React.ReactNode
+  label: string
+  footer?: React.ReactNode
+  onCancel?: () => void
+}
+
+export const BusyScreen: React.FC<BusyScreenProps> = ({ title, subtitle, label, footer, onCancel }) => {
+  useAppInput((_input, key) => {
+    if (key.escape && onCancel) onCancel()
+  }, { isActive: Boolean(onCancel) })
+  const resolvedFooter = footer ?? (onCancel ? <Text color={theme.dim}>esc cancels</Text> : undefined)
+  return (
+    <Surface title={title} subtitle={subtitle} footer={resolvedFooter}>
+      <Spinner label={label} />
+    </Surface>
+  )
+}

package/src/identity/hub/screens/ContinuityDashboardScreen.tsx

@@ -0,0 +1,139 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../../../ui/Surface.js'
+import { Select } from '../../../ui/Select.js'
+import { theme } from '../../../ui/theme.js'
+import type { EthagentConfig, EthagentIdentity } from '../../../storage/config.js'
+import { IdentitySummary } from './IdentitySummary.js'
+import { shortCid } from '../identityHubModel.js'
+
+type PrivateAction = 'soul' | 'memory' | 'backup' | 'back'
+type PublicAction = 'edit' | 'skills' | 'publish' | 'back'
+
+type CommonProps = {
+  identity?: EthagentIdentity
+  config?: EthagentConfig
+  ready: boolean
+  notice?: string
+  footer: React.ReactNode
+  onBack: () => void
+}
+
+export const PrivateContinuityScreen: React.FC<CommonProps & {
+  canBackup: boolean
+  onOpenSoul: () => void
+  onOpenMemory: () => void
+  onBackup: () => void
+}> = ({
+  identity,
+  config,
+  ready,
+  notice,
+  footer,
+  canBackup,
+  onOpenSoul,
+  onOpenMemory,
+  onBackup,
+  onBack,
+}) => (
+  <Surface title="Private Memory Files" subtitle={notice ?? privateSubtitle(ready)} footer={footer}>
+    <IdentitySummary identity={identity} config={config} compact />
+    <PrivateRows identity={identity} ready={ready} />
+    <Box marginTop={1}>
+      <Select<PrivateAction>
+        options={[
+          { value: 'soul', role: 'section', prefix: '--', label: 'Open local files' },
+          { value: 'soul', label: 'open SOUL.md', hint: 'edit persona and operating preferences', disabled: !ready },
+          { value: 'memory', label: 'open MEMORY.md', hint: 'edit private working memory for this agent', disabled: !ready },
+          { value: 'backup', role: 'section', prefix: '--', label: 'Publish' },
+          { value: 'backup', label: 'save snapshot', hint: 'save editor changes first; then encrypt and pin', disabled: !ready || !canBackup },
+          { value: 'back', role: 'section', prefix: '--', label: 'Navigation' },
+          { value: 'back', label: 'back to identity hub', hint: 'return without changing private files', role: 'utility' },
+        ]}
+        hintLayout="inline"
+        onSubmit={choice => {
+          if (choice === 'soul') return onOpenSoul()
+          if (choice === 'memory') return onOpenMemory()
+          if (choice === 'backup') return onBackup()
+          return onBack()
+        }}
+        onCancel={onBack}
+      />
+    </Box>
+  </Surface>
+)
+
+export const PublicSkillsScreen: React.FC<CommonProps & {
+  canPublish: boolean
+  onEditProfile: () => void
+  onOpenSkills: () => void
+  onPublish: () => void
+}> = ({ identity, config, notice, footer, canPublish, onEditProfile, onOpenSkills, onPublish, onBack }) => (
+  <Surface title="Public Profile" subtitle={notice ?? 'Public token metadata only. Private SOUL.md and MEMORY.md are not touched here.'} footer={footer}>
+    <IdentitySummary identity={identity} config={config} compact />
+    <PublicProfileRows identity={identity} />
+    <Box marginTop={1}>
+      <Select<PublicAction>
+        options={[
+          { value: 'edit', role: 'section', prefix: '--', label: 'Profile' },
+          { value: 'edit', label: 'edit name, description, image', hint: 'upload a local image to IPFS automatically' },
+          { value: 'skills', role: 'section', prefix: '--', label: 'Capabilities' },
+          { value: 'skills', label: 'open skills.json', hint: 'edit public capabilities and notes' },
+          { value: 'publish', role: 'section', prefix: '--', label: 'Publish' },
+          { value: 'publish', label: 'publish public profile', hint: 'save skills.json first; pins metadata and updates tokenURI', disabled: !canPublish },
+          { value: 'back', role: 'section', prefix: '--', label: 'Navigation' },
+          { value: 'back', label: 'back to identity hub', hint: 'return without changing public metadata', role: 'utility' },
+        ]}
+        hintLayout="inline"
+        onSubmit={choice => {
+          if (choice === 'edit') return onEditProfile()
+          if (choice === 'skills') return onOpenSkills()
+          if (choice === 'publish') return onPublish()
+          return onBack()
+        }}
+        onCancel={onBack}
+      />
+    </Box>
+  </Surface>
+)
+
+const PrivateRows: React.FC<{ identity?: EthagentIdentity; ready: boolean }> = ({ identity, ready }) => (
+  <Box flexDirection="column" marginTop={1}>
+    <Text>
+      <Text color={theme.dim}>{'local files'.padEnd(13)}</Text>
+      <Text color={ready ? theme.text : theme.dim}>{ready ? 'SOUL.md and MEMORY.md ready' : 'missing local working files'}</Text>
+    </Text>
+    <Text>
+      <Text color={theme.dim}>{'snapshot'.padEnd(13)}</Text>
+      <Text color={identity?.backup?.cid ? theme.text : theme.dim}>{identity?.backup?.cid ? shortCid(identity.backup.cid) : 'not saved yet'}</Text>
+    </Text>
+  </Box>
+)
+
+const PublicProfileRows: React.FC<{ identity?: EthagentIdentity }> = ({ identity }) => (
+  <Box flexDirection="column" marginTop={1}>
+    <Text>
+      <Text color={theme.dim}>{'skills.json'.padEnd(13)}</Text>
+      <Text color={identity?.publicSkills?.cid ? theme.text : theme.dim}>{identity?.publicSkills?.cid ? shortCid(identity.publicSkills.cid) : 'not published'}</Text>
+    </Text>
+    <Text>
+      <Text color={theme.dim}>{'agent card'.padEnd(13)}</Text>
+      <Text color={identity?.publicSkills?.agentCardCid ? theme.text : theme.dim}>{identity?.publicSkills?.agentCardCid ? shortCid(identity.publicSkills.agentCardCid) : 'not published'}</Text>
+    </Text>
+    <Text>
+      <Text color={theme.dim}>{'image'.padEnd(13)}</Text>
+      <Text color={readStateString(identity?.state, 'imageUrl') ? theme.text : theme.dim}>{readStateString(identity?.state, 'imageUrl') ? 'attached' : 'not attached'}</Text>
+    </Text>
+  </Box>
+)
+
+function privateSubtitle(ready: boolean): string {
+  return ready
+    ? 'SOUL.md and MEMORY.md are private local files on this machine.'
+    : 'Use "refetch latest snapshot" from the hub menu to recover files.'
+}
+
+function readStateString(state: Record<string, unknown> | undefined, key: string): string {
+  const value = state?.[key]
+  return typeof value === 'string' ? value.trim() : ''
+}