ethagent 3.3.3 → 4.0.0

package/src/identity/continuity/privateEdit/types.ts

@@ -1,28 +0,0 @@
-import type { EthagentIdentity } from '../../../storage/config.js'
-import type { PrivateContinuityFile } from '../storage.js'
-
-export type PrivateContinuityEditInput = {
-  file: PrivateContinuityFile
-  oldText?: string
-  newText?: string
-  appendToSection?: string
-  appendText?: string
-  replaceAll?: boolean
-  replaceWholeFile?: boolean
-}
-
-export type PreparedPrivateContinuityEdit = {
-  identity: EthagentIdentity
-  file: PrivateContinuityFile
-  fullPath: string
-  relativePath: string
-  directoryPath: string
-  existedBefore: boolean
-  previousContent: string
-  before: string
-  after: string
-  previewBefore: string
-  previewAfter: string
-  changeSummary: string
-  diff: string
-}

package/src/identity/continuity/privateEdit.ts

@@ -1,46 +0,0 @@
-import path from 'node:path'
-import { atomicWriteText } from '../../storage/atomicWrite.js'
-import type { EthagentConfig } from '../../storage/config.js'
-import { ensureContinuityVault } from './storage.js'
-import { ensureTrailingNewline } from './storage/files.js'
-import { applyPrivateContinuityEdit } from './privateEdit/apply.js'
-import { renderPrivateContinuityDiff } from './privateEdit/diff.js'
-import { privateContinuityPath, readPrivateContinuityFile } from './privateEdit/files.js'
-import type { PreparedPrivateContinuityEdit, PrivateContinuityEditInput } from './privateEdit/types.js'
-
-export type { PreparedPrivateContinuityEdit, PrivateContinuityEditInput } from './privateEdit/types.js'
-
-export async function preparePrivateContinuityEdit(
-  input: PrivateContinuityEditInput,
-  config: EthagentConfig | undefined,
-): Promise<PreparedPrivateContinuityEdit> {
-  const identity = config?.identity
-  if (!identity) {
-    throw new Error('No active identity; create or load an identity before proposing private continuity edits')
-  }
-
-  const fullPath = privateContinuityPath(identity, input.file)
-  const existing = await readPrivateContinuityFile(identity, input.file, fullPath)
-  const applied = applyPrivateContinuityEdit(input, existing.content, identity)
-
-  return {
-    identity,
-    file: input.file,
-    fullPath,
-    relativePath: 'identity-vault/' + input.file,
-    directoryPath: path.dirname(fullPath),
-    existedBefore: existing.existedBefore,
-    previousContent: existing.existedBefore ? existing.content : '',
-    before: existing.content,
-    after: applied.after,
-    previewBefore: applied.previewBefore,
-    previewAfter: applied.previewAfter,
-    changeSummary: applied.summary,
-    diff: renderPrivateContinuityDiff(input.file, applied.before, applied.after),
-  }
-}
-
-export async function writePreparedPrivateContinuityEdit(edit: PreparedPrivateContinuityEdit): Promise<void> {
-  await ensureContinuityVault(edit.identity)
-  await atomicWriteText(edit.fullPath, ensureTrailingNewline(edit.after), { mode: 0o600 })
-}

package/src/identity/hub/IdentityHub.tsx

@@ -1,14 +0,0 @@
-import React from 'react'
-import { IdentityHubRoutes } from './Routes.js'
-import type { IdentityHubProps } from './types.js'
-import { useIdentityHubController } from './useIdentityHubController.js'
-
-export type {
-  IdentityHubInitialAction,
-  IdentityHubResult,
-} from './types.js'
-
-export const IdentityHub: React.FC<IdentityHubProps> = props => {
-  const controller = useIdentityHubController(props)
-  return <IdentityHubRoutes controller={controller} />
-}

package/src/identity/hub/continuity/RecoveryConfirmScreen.tsx

@@ -1,104 +0,0 @@
-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 { localChangeStatusView, type LocalChangeStatusView } from './state.js'
-
-import type { ContinuityWorkingTreeStatus } from '../../continuity/storage.js'
-
-type RecoveryConfirmMode = 'publish' | 'refetch'
-
-interface RecoveryConfirmScreenProps {
-  mode: RecoveryConfirmMode
-  workingStatus?: ContinuityWorkingTreeStatus | null
-  pendingPublish?: boolean
-  footer: React.ReactNode
-  onConfirm: () => void
-  onBack: () => void
-}
-
-export const RecoveryConfirmScreen: React.FC<RecoveryConfirmScreenProps> = ({ mode, workingStatus, pendingPublish, footer, onConfirm, onBack }) => {
-  const isPublish = mode === 'publish'
-  const title = isPublish ? 'Save Snapshot?' : 'Refetch Latest From Onchain?'
-  const subtitle = isPublish
-    ? 'Saves SOUL.md, MEMORY.md, skills, and profile changes.'
-    : 'This overwrites local files with the onchain version.'
-
-  const headlineColor = theme.accentPeriwinkle
-  const headline = isPublish
-    ? 'Saving updates the onchain pointer for this agent.'
-    : 'Refetching replaces SOUL.md, MEMORY.md, and skills with what is onchain.'
-  const detail = isPublish
-    ? 'Your local continuity files and profile edits become the saved state. The previous snapshot pointer is overwritten.'
-    : 'Unsaved local edits will be lost. Use this when local files are missing or out of sync with the latest saved snapshot.'
-
-  const localChangeStatus = localChangeStatusView(workingStatus)
-
-  return (
-    <Surface title={title} subtitle={subtitle} footer={footer} tone="primary">
-      <Box flexDirection="column">
-        <Text color={headlineColor}>{headline}</Text>
-        <Text color={theme.textSubtle}>{detail}</Text>
-        {isPublish && (
-          <Box marginTop={1}>
-            <SaveSnapshotStatusLine status={localChangeStatus} />
-          </Box>
-        )}
-        {!isPublish && pendingPublish ? (
-          <Box marginTop={1} flexDirection="column">
-            <Text color={theme.accentError} bold>Local snapshot is ahead of onchain.</Text>
-            <Text color={theme.textSubtle}>Local edits have not yet been rotated to the onchain pointer. Refetching discards them and reverts to the last published snapshot.</Text>
-          </Box>
-        ) : null}
-        {!isPublish && (
-          <Box marginTop={1}>
-            <Text color={theme.accentPeriwinkle}>Overwrite your local files?</Text>
-          </Box>
-        )}
-      </Box>
-      <Box marginTop={1}>
-        <Select<'confirm' | 'back'>
-          options={[
-            { value: 'confirm', role: 'section', label: isPublish ? 'Save' : 'Refetch' },
-            {
-              value: 'confirm',
-              label: isPublish ? 'Yes, Save Snapshot Now' : 'Yes, Refetch From Onchain',
-              hint: isPublish ? 'Sign and save the encrypted snapshot' : 'Wallet decrypts and overwrites local files',
-            },
-            { value: 'back', role: 'section', label: 'Navigation' },
-            {
-              value: 'back',
-              label: 'No, Go Back',
-              hint: isPublish ? 'Return without saving anything' : 'Return without changing anything',
-              role: 'utility',
-            },
-          ]}
-          hintLayout="inline"
-          onSubmit={choice => {
-            if (choice === 'confirm') return onConfirm()
-            return onBack()
-          }}
-          onCancel={onBack}
-        />
-      </Box>
-    </Surface>
-  )
-}
-
-const SaveSnapshotStatusLine: React.FC<{ status: LocalChangeStatusView }> = ({ status }) => {
-  if (status.hasLocalChanges) {
-    return (
-      <Text>
-        <Text color={theme.textSubtle}>Local changes detected: </Text>
-        <Text color={theme.accentError} bold>{status.files.length > 0 ? status.files.join(', ') : 'local files differ from saved snapshot'}</Text>
-      </Text>
-    )
-  }
-
-  if (!status.detail) return null
-
-  const color = status.tone === 'ok' || status.tone === 'warn' ? theme.accentPeriwinkle : theme.dim
-  const label = status.detail === 'None detected' ? 'No local changes detected.' : status.detail
-  return <Text color={color}>{label}</Text>
-}

package/src/identity/hub/ens/effects.ts

@@ -1,218 +0,0 @@
-import type { Address, PublicClient } from 'viem'
-import type { EthagentIdentity } from '../../../storage/config.js'
-import type { AgentEnsRecordState, AgentEnsRecords } from '../../ens/agentRecords.js'
-import type { Erc8004RegistryConfig } from '../../registry/erc8004.js'
-import {
-  openBrowserWalletSession,
-  type WalletPurpose,
-} from '../../wallet/browserWallet.js'
-import type { ProfileUpdates, Step } from '../identityHubReducer.js'
-import type { EffectCallbacks, EnsClearProgress, EnsLinkProgress, EnsUpdateProgress } from '../shared/effects/types.js'
-import {
-  runEnsSetupRecordsTransaction,
-  runEnsSetupRegistryTransaction,
-  runUpdateEnsRecords,
-} from './transactions.js'
-import { runRebackupSigningInSession } from '../continuity/effects.js'
-
-type EnsRecordsFlowArgs = {
-  identity: EthagentIdentity
-  registry: Erc8004RegistryConfig
-  fullName: string
-  ownerAddress: Address
-  records: AgentEnsRecords
-  currentRecords?: AgentEnsRecordState
-  pinataJwt?: string
-  publicClient?: PublicClient
-}
-
-async function runEnsRecordsThenSnapshot(args: {
-  flowId: 'ens-clear' | 'ens-update' | 'ens-link'
-  flow: EnsRecordsFlowArgs
-  clearRecords: boolean
-  recordsPurpose: WalletPurpose
-  callbacks: EffectCallbacks
-  reportProgress: (phase: 'records-tx' | 'records-confirming' | 'snapshot-sign' | 'snapshot-tx' | 'snapshot-confirming') => void
-  preRecordsSteps?: number
-  totalSteps: number
-}): Promise<void> {
-  const { flow } = args
-  const session = await openBrowserWalletSession({ onReady: args.callbacks.onWalletReady })
-  try {
-    args.reportProgress('records-tx')
-    const recordsStepIndex = (args.preRecordsSteps ?? 0) + 1
-    await runUpdateEnsRecords({
-      fullName: flow.fullName,
-      ownerAddress: flow.ownerAddress,
-      records: flow.records,
-      ...(flow.currentRecords ? { currentRecords: flow.currentRecords } : {}),
-      callbacks: args.callbacks,
-      purpose: args.recordsPurpose,
-      clearRecords: args.clearRecords,
-      ...(flow.publicClient ? { publicClient: flow.publicClient } : {}),
-      tokenChainId: flow.registry.chainId,
-      session,
-      flowId: args.flowId,
-      flowStep: recordsStepIndex,
-    })
-    args.reportProgress('records-confirming')
-    args.reportProgress('snapshot-sign')
-    const snapshotStepIndex = recordsStepIndex + 1
-    const nextEnsName = args.clearRecords ? '' : flow.fullName
-    const profileUpdates: ProfileUpdates = { ensName: nextEnsName }
-    const rebackupStep: Extract<Step, { kind: 'rebackup-signing' }> = {
-      kind: 'rebackup-signing',
-      identity: flow.identity,
-      registry: flow.registry,
-      profileUpdates,
-      ...(flow.pinataJwt ? { pinataJwt: flow.pinataJwt } : {}),
-    }
-    args.reportProgress('snapshot-tx')
-    await runRebackupSigningInSession(rebackupStep, args.callbacks, session, {
-      flowId: args.flowId,
-      flowStep: snapshotStepIndex,
-    })
-    args.reportProgress('snapshot-confirming')
-  } finally {
-    await session.close().catch(() => null)
-    args.callbacks.onWalletReady(null)
-  }
-}
-
-export async function runEnsUnlinkFlow(
-  step: Extract<Step, { kind: 'ens-clear-flow-running' }>,
-  callbacks: EffectCallbacks,
-): Promise<void> {
-  await runEnsRecordsThenSnapshot({
-    flowId: 'ens-clear',
-    clearRecords: true,
-    recordsPurpose: 'clear-ens-records',
-    flow: {
-      identity: step.identity,
-      registry: step.registry,
-      fullName: step.fullName,
-      ownerAddress: step.ownerAddress,
-      records: step.records,
-      ...(step.currentRecords ? { currentRecords: step.currentRecords } : {}),
-      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
-    },
-    callbacks,
-    reportProgress: phase => callbacks.onEnsClearProgress?.({ phase, label: ensClearLabelFor(phase) }),
-    totalSteps: 2,
-  })
-  callbacks.onEnsClearProgress?.(null)
-}
-
-export async function runEnsUpdateFlow(
-  step: Extract<Step, { kind: 'ens-update-flow-running' }>,
-  callbacks: EffectCallbacks,
-): Promise<void> {
-  await runEnsRecordsThenSnapshot({
-    flowId: 'ens-update',
-    clearRecords: false,
-    recordsPurpose: 'update-ens-records',
-    flow: {
-      identity: step.identity,
-      registry: step.registry,
-      fullName: step.fullName,
-      ownerAddress: step.ownerAddress,
-      records: step.records,
-      ...(step.currentRecords ? { currentRecords: step.currentRecords } : {}),
-      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
-    },
-    callbacks,
-    reportProgress: phase => callbacks.onEnsUpdateProgress?.({ phase, label: ensUpdateLabelFor(phase) }),
-    totalSteps: 2,
-  })
-  callbacks.onEnsUpdateProgress?.(null)
-}
-
-function ensClearLabelFor(phase: EnsClearProgress['phase']): string {
-  switch (phase) {
-    case 'records-tx': return 'Clearing ENS records on Ethereum Mainnet...'
-    case 'records-confirming': return 'Waiting for ENS clear confirmation...'
-    case 'snapshot-sign': return 'Sign to save the cleared snapshot...'
-    case 'snapshot-tx': return 'Publishing cleared snapshot to the agent token URI...'
-    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
-  }
-}
-
-function ensUpdateLabelFor(phase: EnsUpdateProgress['phase']): string {
-  switch (phase) {
-    case 'records-tx': return 'Updating ENS records on Ethereum Mainnet...'
-    case 'records-confirming': return 'Waiting for ENS records confirmation...'
-    case 'snapshot-sign': return 'Sign to save the updated snapshot...'
-    case 'snapshot-tx': return 'Publishing updated snapshot to the agent token URI...'
-    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
-  }
-}
-
-function ensLinkLabelFor(phase: EnsLinkProgress['phase']): string {
-  switch (phase) {
-    case 'registry-tx': return 'Creating ENS subdomain on Ethereum Mainnet...'
-    case 'registry-confirming': return 'Waiting for subdomain creation confirmation...'
-    case 'records-tx': return 'Setting ENS records on Ethereum Mainnet...'
-    case 'records-confirming': return 'Waiting for ENS records confirmation...'
-    case 'snapshot-sign': return 'Sign to save the linked snapshot...'
-    case 'snapshot-tx': return 'Publishing linked snapshot to the agent token URI...'
-    case 'snapshot-confirming': return 'Waiting for snapshot publish confirmation...'
-  }
-}
-
-export async function runEnsLinkFlow(
-  step: Extract<Step, { kind: 'ens-link-flow-running' }>,
-  callbacks: EffectCallbacks,
-): Promise<void> {
-  const session = await openBrowserWalletSession({ onReady: callbacks.onWalletReady })
-  const report = (phase: EnsLinkProgress['phase']): void => {
-    callbacks.onEnsLinkProgress?.({ phase, label: ensLinkLabelFor(phase) })
-  }
-  try {
-    let stepIndex = 0
-    const willRunRegistry = step.setup.registryAction !== 'none'
-    if (willRunRegistry) {
-      stepIndex += 1
-      report('registry-tx')
-      await runEnsSetupRegistryTransaction({
-        setup: step.setup,
-        callbacks,
-        tokenChainId: step.registry.chainId,
-        session,
-        flowId: 'ens-link',
-        flowStep: stepIndex,
-      })
-      report('registry-confirming')
-    }
-    stepIndex += 1
-    report('records-tx')
-    await runEnsSetupRecordsTransaction({
-      setup: step.setup,
-      callbacks,
-      tokenChainId: step.registry.chainId,
-      session,
-      flowId: 'ens-link',
-      flowStep: stepIndex,
-    })
-    report('records-confirming')
-    stepIndex += 1
-    report('snapshot-sign')
-    const profileUpdates: ProfileUpdates = { ensName: step.setup.fullName }
-    const rebackupStep: Extract<Step, { kind: 'rebackup-signing' }> = {
-      kind: 'rebackup-signing',
-      identity: step.identity,
-      registry: step.registry,
-      profileUpdates,
-      ...(step.pinataJwt ? { pinataJwt: step.pinataJwt } : {}),
-    }
-    report('snapshot-tx')
-    await runRebackupSigningInSession(rebackupStep, callbacks, session, {
-      flowId: 'ens-link',
-      flowStep: stepIndex,
-    })
-    report('snapshot-confirming')
-  } finally {
-    await session.close().catch(() => null)
-    callbacks.onWalletReady(null)
-    callbacks.onEnsLinkProgress?.(null)
-  }
-}

package/src/identity/hub/shared/components/MenuScreen.tsx

@@ -1,241 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { Surface } from '../../../../ui/Surface.js'
-import { Select, type SelectOption } from '../../../../ui/Select.js'
-import { theme } from '../../../../ui/theme.js'
-import { FirstRunTimeline } from '../../../../app/FirstRunTimeline.js'
-import type { EthagentConfig, EthagentIdentity } from '../../../../storage/config.js'
-import type { ContinuityWorkingTreeStatus } from '../../../continuity/storage.js'
-import { identityPerspective, readCustodyMode } from '../../custody/state.js'
-import { identityValuesCopyHint } from '../model/copy.js'
-import { transferSnapshotView } from '../../transfer/state.js'
-import { IdentitySummary } from './IdentitySummary.js'
-import type { AgentReconciliation } from '../reconciliation/index.js'
-import { menuFlagsFromReconciliation } from './menuFlagsFromReconciliation.js'
-
-type MenuScreenProps = {
-  mode: 'first-run' | 'manage'
-  config?: EthagentConfig
-  identity?: EthagentIdentity
-  workingStatus?: ContinuityWorkingTreeStatus | null
-  canRebackup: boolean
-  reconciliation?: AgentReconciliation
-  footer: React.ReactNode
-  onCreate: () => void
-  onLoad: () => void
-  onBackupNow: () => void
-  onRefetchLatest: () => void
-  onPublicProfile: () => void
-  onEnsName: () => void
-  onWalletSetup: () => void
-  onContinuity: () => void
-  onSkillsTree: () => void
-  onIdentityValues: () => void
-  onPrepareTransfer: () => void
-  onStorage: () => void
-  onSkip: () => void
-  onCancel: () => void
-}
-
-type Action =
-  | 'public-profile'
-  | 'ens-name'
-  | 'wallet-setup'
-  | 'continuity'
-  | 'skills-tree'
-  | 'backup'
-  | 'refetch'
-  | 'identity-values'
-  | 'prepare-transfer'
-  | 'storage'
-  | 'create'
-  | 'load'
-  | 'skip'
-  | 'cancel'
-
-export const MenuScreen: React.FC<MenuScreenProps> = ({
-  mode,
-  config,
-  identity,
-  workingStatus,
-  canRebackup,
-  reconciliation,
-  footer,
-  onCreate,
-  onLoad,
-  onBackupNow,
-  onRefetchLatest,
-  onPublicProfile,
-  onEnsName,
-  onWalletSetup,
-  onContinuity,
-  onSkillsTree,
-  onIdentityValues,
-  onPrepareTransfer,
-  onStorage,
-  onSkip,
-  onCancel,
-}) => {
-  const isFirstRun = mode === 'first-run'
-  const title = isFirstRun ? 'Set Up Agent Identity' : 'Identity Hub'
-  const subtitle: React.ReactNode = isFirstRun
-    ? <FirstRunTimeline current={2} />
-    : 'Manage agent identity, custody, encrypted continuity, and recovery.'
-
-  const canRefetch = Boolean(canRebackup && identity?.backup?.cid)
-  const custodyMode = identity ? readCustodyMode(identity.state) : undefined
-
-  const perspective = identityPerspective(identity)
-  const flags = reconciliation
-    ? menuFlagsFromReconciliation(reconciliation, perspective)
-    : (perspective === 'operator'
-      ? menuFlagsFromReconciliation({
-          token: 'unknown', custody: 'unknown', agentUri: 'unknown',
-          vault: 'unknown', workingTree: 'unknown', rpc: 'reachable', driftCount: 0, lastCheckedAt: '',
-        }, perspective)
-      : null)
-
-  const walletSetupBaseHint = custodyMode === 'advanced'
-    ? 'Owner wallet, vault, operators'
-    : 'Simple mode, switch for vault delegation'
-
-  const walletSetupLabel = flags?.custodyAsterisk ? 'Custody Mode *' : 'Custody Mode'
-  const walletSetupHint = flags?.custodyModeReason ?? flags?.custodyHint ?? walletSetupBaseHint
-
-  const saveSnapshotLabel = flags?.saveSnapshotAsterisk ? 'Save Snapshot *' : 'Save Snapshot'
-  const saveSnapshotHint = flags?.saveSnapshotHint ?? 'Publish encrypted snapshot'
-
-  const ensNameHint = flags?.ensNameReason ?? 'Public name or subdomain'
-
-  const prepareTransferHint = flags?.prepareTransferReason ?? 'Hand off this agent'
-
-  const tokenValuesHint = flags?.tokenValuesUnlinkedNote ?? identityValuesCopyHint(identity)
-
-  const options: Array<SelectOption<Action>> = identity
-    ? [
-        { value: 'public-profile', role: 'section', label: 'Public Identity' },
-        { value: 'public-profile', label: 'Public Profile', hint: 'Agent card and profile fields' },
-        { value: 'ens-name', label: 'ENS Name', hint: ensNameHint, disabled: flags?.ensNameDisabled ?? false },
-        { value: 'continuity', role: 'section', label: 'Continuity' },
-        { value: 'continuity', label: 'Soul & Memory', hint: 'Edit SOUL.md and MEMORY.md' },
-        { value: 'skills-tree', label: 'Skills', hint: 'Browse and edit SKILL.md files' },
-        { value: 'backup', label: saveSnapshotLabel, hint: saveSnapshotHint, disabled: !canRebackup || (flags?.saveSnapshotDisabled ?? false) },
-        { value: 'refetch', label: 'Refetch Snapshot', hint: 'Restore latest snapshot', disabled: !canRefetch || (flags?.refetchLatestDisabled ?? false) },
-        { value: 'wallet-setup', role: 'section', label: 'Custody' },
-        { value: 'wallet-setup', label: walletSetupLabel, hint: walletSetupHint, disabled: !identity.agentId || (flags?.custodyModeDisabled ?? false) },
-        { value: 'prepare-transfer', label: 'Prepare Transfer', hint: prepareTransferHint, disabled: flags?.prepareTransferDisabled ?? false },
-        { value: 'identity-values', role: 'section', label: 'Token' },
-        { value: 'identity-values', label: 'Token Values', hint: tokenValuesHint },
-        { value: 'load', label: 'Switch Agent', hint: 'Switch agent or wallet' },
-        { value: 'create', label: 'New Agent', hint: 'Mint another agent' },
-        { value: 'storage', label: 'IPFS Storage', hint: 'Publishing credentials' },
-        { value: 'cancel', role: 'section', label: 'Exit' },
-        { value: 'cancel', label: 'Close Identity Hub', hint: 'Return to chat', role: 'utility' },
-      ]
-    : [
-        { value: 'create', role: 'section', label: 'Setup' },
-        { value: 'create', label: 'Create New Agent', hint: 'Mint a wallet-owned token for this machine' },
-        { value: 'load', label: 'Load Existing Agent', hint: 'Find a token owned by this wallet or linked to it' },
-        ...(mode === 'first-run'
-          ? [
-              { value: 'skip' as Action, label: 'Skip For Now', hint: 'Continue now, use /identity later', role: 'utility' as const },
-            ]
-          : [
-              { value: 'cancel' as Action, label: 'Close Identity Hub', hint: 'Return to chat without changing identity', role: 'utility' as const },
-            ]),
-      ]
-
-  const reconciliationBanner = identity && reconciliation
-    ? renderReconciliationBanner(reconciliation, identity)
-    : null
-
-  return (
-    <Surface title={title} subtitle={subtitle} footer={footer}>
-      <IdentitySummary
-        identity={identity}
-        config={config}
-        workingStatus={workingStatus}
-        tokenLinked={reconciliation ? reconciliation.token === 'linked' : true}
-        {...(reconciliation?.onChainOwner ? { onchainOwner: reconciliation.onChainOwner } : {})}
-      />
-      {reconciliationBanner ? (
-        <Box marginTop={1} flexDirection="column">
-          {reconciliationBanner}
-        </Box>
-      ) : null}
-      <Box marginTop={1}>
-        <Select<Action>
-          options={options}
-          hintLayout="inline"
-          onSubmit={choice => {
-            if (choice === 'skip') return onSkip()
-            if (choice === 'cancel') return onCancel()
-            if (choice === 'public-profile') return onPublicProfile()
-            if (choice === 'ens-name') return onEnsName()
-            if (choice === 'wallet-setup') return onWalletSetup()
-            if (choice === 'continuity') return onContinuity()
-            if (choice === 'skills-tree') return onSkillsTree()
-            if (choice === 'backup') return onBackupNow()
-            if (choice === 'refetch') return onRefetchLatest()
-            if (choice === 'identity-values') return onIdentityValues()
-            if (choice === 'prepare-transfer') return onPrepareTransfer()
-            if (choice === 'storage') return onStorage()
-            if (choice === 'load') return onLoad()
-            if (choice === 'create') return onCreate()
-          }}
-          onCancel={mode === 'first-run' ? undefined : onCancel}
-        />
-      </Box>
-    </Surface>
-  )
-}
-
-function renderReconciliationBanner(r: AgentReconciliation, identity: EthagentIdentity): React.ReactNode {
-  if (r.token === 'no-agent') return null
-  if (r.token === 'unlinked') {
-    const tokenLabel = r.tokenAgentId ? `Token #${r.tokenAgentId}` : 'Token'
-    const transferSnapshot = transferSnapshotView(identity)
-    if (transferSnapshot) {
-      return (
-        <>
-          <Text color={theme.accentError} bold>Agent Unlinked</Text>
-          <Text color={theme.textSubtle}>{tokenLabel} was transferred. Local SOUL.md, MEMORY.md, and skills remain. Back them up before this directory is reused.</Text>
-          <Text color={theme.textSubtle}>Use Switch Agent or New Agent to re-enable disabled actions.</Text>
-        </>
-      )
-    }
-    return (
-      <>
-        <Text color={theme.accentError} bold>Agent Unlinked</Text>
-        <Text color={theme.textSubtle}>{tokenLabel} left without Prepare Transfer. Back up local SOUL.md, MEMORY.md, and skills before loading another agent.</Text>
-        <Text color={theme.textSubtle}>For continuity handoff: ask the new holder to return the token, then run Prepare Transfer before re-sending.</Text>
-        <Text color={theme.textSubtle}>Use Switch Agent or New Agent to re-enable disabled actions.</Text>
-      </>
-    )
-  }
-  if (r.token === 'unknown') {
-    return (
-      <>
-        <Text color={theme.dim}>Ownership Check Failed (RPC?)</Text>
-        {r.tokenDetail ? <Text color={theme.dim}>{r.tokenDetail}</Text> : null}
-      </>
-    )
-  }
-  if (r.driftCount === 0) {
-    return null
-  }
-  const lines: string[] = []
-  if (r.custody === 'mid-flow-uri-pending') lines.push('Advanced setup pending. Open Custody Mode to finish.')
-  if (r.agentUri === 'local-newer') lines.push('Local state newer than onchain. Save Snapshot Now to publish.')
-  if (r.agentUri === 'chain-newer') lines.push('Onchain agentURI is newer than local. Refetch Latest.')
-  if (r.vault === 'missing') lines.push('Recorded vault address has no contract at it. Open Custody Mode to redeploy.')
-  if (r.workingTree === 'dirty') lines.push('Local edits pending. Save Snapshot Now to publish.')
-  return (
-    <>
-      <Text color={theme.accentPeriwinkle} bold>Agent Linked. {lines.length} item{lines.length === 1 ? '' : 's'} need attention</Text>
-      {lines.map((line, i) => (
-        <Text key={i} color={theme.textSubtle}>· {line}</Text>
-      ))}
-    </>
-  )
-}