ethagent 3.2.0 → 3.3.1

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

@@ -3,6 +3,12 @@ import type { AgentEnsRecords, AgentRecordDiff } from '../../ens/agentRecords.js
 import type { EnsRegistryAction, EnsSetupBlockedPlan } from '../../ens/ensAutomation.js'
 import type { CustodyMode } from '../custody/state.js'
 
+export function abbreviateHexBlobs(input: string): string {
+  return input.replace(/0x([0-9a-fA-F]{20,})/g, (_match, hex) => {
+    return `0x${hex.slice(0, 8)}...${hex.slice(-8)}`
+  })
+}
+
 export type EnsLinkOptions = {
   mode: 'simple' | 'advanced'
   ownerAddress?: Address
@@ -18,7 +24,7 @@ export function recordsHaveCurrentValues(recordsDiff: AgentRecordDiff[]): boolea
 }
 
 export function emptyAgentEnsRecords(): AgentEnsRecords {
-  return { token: '' }
+  return {}
 }
 
 export function unlinkEnsLinkOptions(savedCustodyMode: CustodyMode | undefined, savedOwnerAddress: string): EnsLinkOptions {
@@ -46,18 +52,6 @@ export function modeSwitchHeading(
   return 'Automation'
 }
 
-export function setupSwitchNotice(
-  currentEnsName: string,
-  currentMode: CustodyMode | undefined,
-  nextEnsName: string,
-  nextMode: 'simple' | 'advanced',
-): string | null {
-  if (!currentEnsName && !currentMode) return null
-  const currentTopology = currentMode === 'advanced' ? 'advanced' : currentMode === 'simple' ? 'simple' : undefined
-  if (currentEnsName === nextEnsName && currentTopology === nextMode) return null
-  return 'This replaces the saved ENS setup directly. Reset is only for clearing the current link.'
-}
-
 export function advancedSubdomainStatusText(action: EnsRegistryAction): string {
   switch (action) {
     case 'create-subdomain':
@@ -84,8 +78,6 @@ export function manualReasonTitle(reason: EnsSetupBlockedPlan['reason']): string
     case 'wrapped-parent':
     case 'subdomain-wrapped':
       return 'ENS NameWrapper ownership could not be verified'
-    case 'token-record-collision':
-      return 'Subdomain already points to another token'
     case 'token-owner-mismatch':
       return 'Owner wallet does not own this ERC-8004 token'
     case 'token-owner-lookup-failed':

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

@@ -5,10 +5,11 @@ import {
   createErc8004PublicClient,
   supportedErc8004ChainForId,
 } from '../../registry/erc8004.js'
-import { encodeSetEthagentTextRecords } from '../../ens/ensLookup.js'
-import { encodeEnsRecordsTransaction, encodeEnsRegistryTransaction, type EnsSetupPlan } from '../../ens/ensAutomation.js'
-import type { AgentEnsRecordState, AgentEnsRecords } from '../../ens/agentRecords.js'
-import { changedRecords } from '../../ens/agentRecords.js'
+import { encodeSetEnsip25TextRecord, readEthagentTextRecords } from '../../ens/ensLookup.js'
+import { encodeEnsRecordsTransaction, encodeEnsRegistryTransaction, readAddressRecord, type EnsSetupPlan } from '../../ens/ensAutomation.js'
+import type { AgentEnsRecordState, AgentEnsRecords, AgentRecordDiff } from '../../ens/agentRecords.js'
+import { changedRecords, clearedRecords, diffRecords } from '../../ens/agentRecords.js'
+import { namehash, getAddress } from 'viem'
 import { sendBrowserWalletTransaction, type BrowserWalletSession, type WalletPurpose } from '../../wallet/browserWallet.js'
 import type { EffectCallbacks } from '../shared/effects/types.js'
 function chainLabel(chainId: number): string {
@@ -32,17 +33,29 @@ export async function runUpdateEnsRecords(args: {
   session?: BrowserWalletSession
   flowId?: string
   flowStep?: number
-}): Promise<{ txHash: string }> {
+}): Promise<{ txHash: string } | { skipped: true }> {
+  const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
+  const queryKeys = Array.from(new Set([
+    ...Object.keys(args.records ?? {}),
+    ...Object.keys(args.currentRecords ?? {}),
+  ]))
+  let freshCurrent: AgentEnsRecordState = args.currentRecords ?? {}
+  if (queryKeys.length > 0) {
+    try {
+      freshCurrent = await readEthagentTextRecords(args.fullName, queryKeys, { publicClient })
+    } catch {
+      freshCurrent = args.currentRecords ?? {}
+    }
+  }
   const next = ensRecordWritesForUpdate({
     records: args.records,
-    currentRecords: args.currentRecords,
+    currentRecords: freshCurrent,
     clearRecords: args.clearRecords,
   })
   if (Object.keys(next).length === 0) {
-    throw new Error('No ENS records to update')
+    return { skipped: true }
   }
-  const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
-  const encoded = await encodeSetEthagentTextRecords(args.fullName, next, { publicClient })
+  const encoded = await encodeSetEnsip25TextRecord(args.fullName, next, { publicClient })
   await preflightEnsRecordTransaction({
     fullName: args.fullName,
     account: args.ownerAddress,
@@ -83,10 +96,11 @@ export function ensRecordWritesForUpdate(args: {
   currentRecords?: AgentEnsRecordState
   clearRecords?: boolean
 }): Record<string, string> {
+  const current = args.currentRecords ?? {}
   if (args.clearRecords) {
-    return changedRecords(args.currentRecords ?? {}, { token: '' })
+    return changedRecords(current, clearedRecords(current))
   }
-  return changedRecords(args.currentRecords ?? { token: '' }, args.records)
+  return changedRecords(current, args.records)
 }
 
 export async function runEnsSetupRegistryTransaction(args: {
@@ -148,13 +162,14 @@ export async function runEnsSetupRecordsTransaction(args: {
   flowId?: string
   flowStep?: number
 }): Promise<{ txHash: string } | null> {
-  const encoded = encodeEnsRecordsTransaction(args.setup)
-  if (!encoded) return null
   const publicClient = args.publicClient ?? createMainnetEnsPublicClient()
-  const purpose: WalletPurpose = args.setup.mode === 'simple' ? 'set-simple-ens-records' : 'set-agent-ens-records'
+  const freshSetup = await refreshEnsSetupAgainstChain(args.setup, publicClient)
+  const encoded = encodeEnsRecordsTransaction(freshSetup)
+  if (!encoded) return null
+  const purpose: WalletPurpose = freshSetup.mode === 'simple' ? 'set-simple-ens-records' : 'set-agent-ens-records'
   await preflightEnsRecordTransaction({
-    fullName: args.setup.fullName,
-    account: args.setup.ownerAddress,
+    fullName: freshSetup.fullName,
+    account: freshSetup.ownerAddress,
     to: encoded.to,
     data: encoded.data,
     publicClient,
@@ -164,7 +179,7 @@ export async function runEnsSetupRecordsTransaction(args: {
   if (args.session) {
     const result = await args.session.sendTransaction({
       chainId: 1,
-      expectedAccount: args.setup.ownerAddress,
+      expectedAccount: freshSetup.ownerAddress,
       to: encoded.to,
       data: encoded.data,
       purpose,
@@ -176,7 +191,7 @@ export async function runEnsSetupRecordsTransaction(args: {
   }
   const result = await sendBrowserWalletTransaction({
     chainId: 1,
-    expectedAccount: args.setup.ownerAddress,
+    expectedAccount: freshSetup.ownerAddress,
     to: encoded.to,
     data: encoded.data,
     purpose,
@@ -187,6 +202,40 @@ export async function runEnsSetupRecordsTransaction(args: {
   return { txHash: result.txHash }
 }
 
+async function refreshEnsSetupAgainstChain(setup: EnsSetupPlan, publicClient: PublicClient): Promise<EnsSetupPlan> {
+  if (setup.registryAction !== 'none' && !setup.recordDiffs.length && !setup.addressRecord.changed) {
+    return setup
+  }
+  const node = namehash(setup.fullName)
+  const keys = Array.from(new Set(setup.recordDiffs.map(diff => diff.key)))
+  let freshCurrent: AgentEnsRecordState = setup.currentRecords
+  if (keys.length > 0) {
+    try {
+      freshCurrent = await readEthagentTextRecords(setup.fullName, keys, { publicClient })
+    } catch {
+      freshCurrent = setup.currentRecords
+    }
+  }
+  let freshAddress = setup.addressRecord.current
+  try {
+    freshAddress = await readAddressRecord(publicClient, setup.resolverAddress, node)
+  } catch {
+    freshAddress = setup.addressRecord.current
+  }
+  const addressChanged = !freshAddress || getAddress(freshAddress).toLowerCase() !== getAddress(setup.addressRecord.next).toLowerCase()
+  const recordDiffs: AgentRecordDiff[] = diffRecords(freshCurrent, setup.nextRecords)
+  return {
+    ...setup,
+    currentRecords: freshCurrent,
+    recordDiffs,
+    addressRecord: {
+      current: freshAddress,
+      next: setup.addressRecord.next,
+      changed: addressChanged,
+    },
+  }
+}
+
 export function createMainnetEnsPublicClient(): PublicClient {
   return createErc8004PublicClient({
     chainId: 1,

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

@@ -31,7 +31,6 @@ export type SimpleEnsPhase =
   | { kind: 'review'; fullName: string; validation: EnsValidation; recordsDiff: AgentRecordDiff[]; currentRecords: AgentEnsRecordState; nextRecords: AgentEnsRecords; mode: 'simple' | 'advanced'; ownerAddress?: Address; operatorWallet?: Address }
 
 export type AdvancedEnsPhase =
-  | { kind: 'advanced-transfer-check' }
   | { kind: 'advanced-root-check'; rootName: string }
   | { kind: 'advanced-subdomain'; rootName: string; label?: string; error?: string }
   | { kind: 'advanced-subdomain-check'; rootName: string; label: string }
@@ -71,7 +70,6 @@ export type EnsEditProps = {
   onEnsRecordsUpdate: (fullName: string, records: AgentEnsRecords, options: EnsLinkOptions, clearRecords?: boolean, currentRecords?: AgentEnsRecordState) => void
   onEnsSetup: (setup: EnsSetupPlan) => void
   onManageOperatorWalletAccess: () => void
-  onWithdrawToken: () => void
   initialView?: 'advanced'
   onBack: () => void
 }

package/src/identity/hub/profile/EditProfileFlow.tsx

@@ -26,7 +26,6 @@ type EditProfileFlowProps = {
   onEnsRecordsUpdate: (fullName: string, records: AgentEnsRecords, options: EnsLinkOptions, clearRecords?: boolean, currentRecords?: AgentEnsRecordState) => void
   onEnsSetup: (setup: EnsSetupPlan) => void
   onManageOperatorWalletAccess: () => void
-  onWithdrawToken: () => void
   onBack: () => void
   onMenu: () => void
 }
@@ -49,7 +48,6 @@ export const EditProfileFlow: React.FC<EditProfileFlowProps> = ({
   onEnsRecordsUpdate,
   onEnsSetup,
   onManageOperatorWalletAccess,
-  onWithdrawToken,
   onBack,
   onMenu,
 }) => {
@@ -101,7 +99,6 @@ export const EditProfileFlow: React.FC<EditProfileFlowProps> = ({
         onEnsRecordsUpdate={onEnsRecordsUpdate}
         onEnsSetup={onEnsSetup}
         onManageOperatorWalletAccess={onManageOperatorWalletAccess}
-        onWithdrawToken={onWithdrawToken}
         initialView={step.initialView}
         onBack={onBack}
       />

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

@@ -6,15 +6,9 @@ import {
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
-  prepareSyncedPublicSkillsJson,
-  writePublicSkillsFile,
+  writeAgentCardFile,
 } from '../../continuity/storage.js'
-import {
-  createAgentCard,
-  defaultPublicSkillsProfile,
-  serializeAgentCard,
-} from '../../continuity/publicSkills.js'
-import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
 import {
@@ -63,15 +57,15 @@ import {
   prepareOperatorProfileArtifacts,
 } from './operatorSave.js'
 
-type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type AgentCardMetadata = NonNullable<EthagentIdentity['agentCard']>
 
 type PublicProfilePreparedTransaction = {
   ownerAddress: Address
   agentUri: string
   metadataCid: string
-  publicSkills: PublicSkillsMetadata
+  agentCard: AgentCardMetadata
   identity: EthagentIdentity
-  publicSkillsJson: string
+  agentCardJson: string
 }
 
 export async function runPublicProfilePreflight(
@@ -151,20 +145,12 @@ async function runPublicProfileSigningInner(
         includeLastBackedUpAt: false,
       })
       const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
-      const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
-      const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
-      assertVerifiedPin(publicSkillsPin)
-      const agentCardPin = await addToIpfs(
-        DEFAULT_IPFS_API_URL,
-        serializeAgentCard(createAgentCard(defaultPublicSkillsProfile(nextIdentityForFiles))),
-        fetch,
-        { pinataJwt: step.pinataJwt },
-      )
+      const agentCardJson = await syncAgentCardManifest(nextIdentityForFiles)
+      const agentCardPin = await addToIpfs(DEFAULT_IPFS_API_URL, agentCardJson, fetch, { pinataJwt: step.pinataJwt })
       assertVerifiedPin(agentCardPin)
       const updatedAt = new Date().toISOString()
-      const publicSkills: PublicSkillsMetadata = {
-        cid: publicSkillsPin.cid,
-        agentCardCid: agentCardPin.cid,
+      const agentCard: AgentCardMetadata = {
+        cid: agentCardPin.cid,
         updatedAt,
         status: 'pinned',
       }
@@ -181,8 +167,7 @@ async function runPublicProfileSigningInner(
       }, {
         backup: existingBackup,
         publicDiscovery: {
-          skillsCid: publicSkills.cid,
-          agentCardCid: publicSkills.agentCardCid,
+          agentCardCid: agentCard.cid,
           updatedAt,
         },
         registration: {
@@ -212,9 +197,9 @@ async function runPublicProfileSigningInner(
           ownerAddress: snapshotOwner,
           agentUri,
           metadataCid,
-          publicSkills,
+          agentCard,
           identity: { ...step.identity, state },
-          publicSkillsJson,
+          agentCardJson,
         },
       }
     },
@@ -231,9 +216,9 @@ async function runPublicProfileSigningInner(
     identityRegistryAddress: step.registry.identityRegistryAddress,
     agentUri: result.prepared.agentUri,
     metadataCid: result.prepared.metadataCid,
-    publicSkills: result.prepared.publicSkills,
+    agentCard: result.prepared.agentCard,
   }
-  await writePublicSkillsFile(nextIdentity, result.prepared.publicSkillsJson)
+  await writeAgentCardFile(nextIdentity, result.prepared.agentCardJson)
   await markCurrentContinuityFilesPublished(nextIdentity)
   const resolverSyncWarning = await syncVaultOperatorsAfterOwnerSave({
     beforeIdentity: step.identity,
@@ -345,7 +330,7 @@ async function runOperatorWalletVaultPublicProfileSave(args: {
         ? { ...prepared.nextIdentity.backup, txHash: vaultTx.txHash }
         : prepared.nextIdentity.backup,
     }
-    await writePublicSkillsFile(nextIdentity, prepared.publicSkillsJson)
+    await writeAgentCardFile(nextIdentity, prepared.agentCardJson)
     await markCurrentContinuityFilesPublished(nextIdentity).catch(() => null)
     await recordPublishedContinuitySnapshot({
       identity: nextIdentity,

package/src/identity/hub/profile/identity.ts

@@ -74,16 +74,14 @@ export function identitySummaryRows(
   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 saved'
-  const cardValue = identity?.publicSkills?.agentCardCid ? shortCid(identity.publicSkills.agentCardCid) : 'not saved'
+  const cardValue = identity?.agentCard?.cid ? shortCid(identity.agentCard.cid) : 'not saved'
   const iconValue = typeof identity?.state?.imageUrl === 'string' && identity.state.imageUrl.trim() ? 'attached' : 'not attached'
   return [
     { label: 'owner wallet', 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: 'card', value: cardValue, tone: identity?.agentCard?.cid ? 'ok' : 'dim' },
     { label: 'icon', value: iconValue, tone: iconValue === 'attached' ? 'ok' : 'dim' },
   ]
 }

package/src/identity/hub/profile/operatorSave.ts

@@ -10,14 +10,7 @@ import {
   readContinuityFiles,
 } from '../../continuity/storage.js'
 import {
-  appendPublicSkillEntries,
-  createAgentCard,
-  defaultPublicSkillsProfile,
-  serializeAgentCard,
-} from '../../continuity/publicSkills.js'
-import {
-  derivePublicSkillEntries,
-  syncPublicSkillsManifest,
+  syncAgentCardManifest,
 } from '../../continuity/skills/publicSkillsSync.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
 import {
@@ -40,12 +33,12 @@ import {
 } from '../continuity/snapshot.js'
 
 type BackupMetadata = NonNullable<EthagentIdentity['backup']>
-type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type AgentCardMetadata = NonNullable<EthagentIdentity['agentCard']>
 type WalletAccessContext = NonNullable<ReturnType<typeof walletRestoreAccessContext>>
 
 export type OperatorProfileArtifacts = {
   nextIdentity: EthagentIdentity
-  publicSkillsJson: string
+  agentCardJson: string
   agentUri: string
   metadataCid: string
 }
@@ -75,20 +68,8 @@ export async function prepareOperatorProfileArtifacts(args: {
   })
   const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
 
-  const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
-  const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
-  assertVerifiedPin(publicSkillsPin)
-  const publicSkillEntries = await derivePublicSkillEntries(nextIdentityForFiles)
-  const augmentedPublicProfile = appendPublicSkillEntries(
-    defaultPublicSkillsProfile(nextIdentityForFiles),
-    publicSkillEntries,
-  )
-  const agentCardPin = await addToIpfs(
-    DEFAULT_IPFS_API_URL,
-    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
-    fetch,
-    { pinataJwt: step.pinataJwt },
-  )
+  const agentCardJson = await syncAgentCardManifest(nextIdentityForFiles)
+  const agentCardPin = await addToIpfs(DEFAULT_IPFS_API_URL, agentCardJson, fetch, { pinataJwt: step.pinataJwt })
   assertVerifiedPin(agentCardPin)
 
   const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
@@ -108,9 +89,8 @@ export async function prepareOperatorProfileArtifacts(args: {
   const statePin = await addToIpfs(DEFAULT_IPFS_API_URL, serializeContinuitySnapshotEnvelope(envelope), fetch, { pinataJwt: step.pinataJwt })
   assertVerifiedPin(statePin)
 
-  const publicSkills: PublicSkillsMetadata = {
-    cid: publicSkillsPin.cid,
-    agentCardCid: agentCardPin.cid,
+  const agentCard: AgentCardMetadata = {
+    cid: agentCardPin.cid,
     updatedAt: envelope.createdAt,
     status: 'pinned',
   }
@@ -134,7 +114,7 @@ export async function prepareOperatorProfileArtifacts(args: {
     ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
   }, {
     backup: { cid: statePin.cid, envelopeVersion: envelope.envelopeVersion, createdAt: envelope.createdAt },
-    publicDiscovery: { skillsCid: publicSkills.cid, agentCardCid: publicSkills.agentCardCid, updatedAt: publicSkills.updatedAt },
+    publicDiscovery: { agentCardCid: agentCard.cid, updatedAt: agentCard.updatedAt },
     registration: { chainId: step.registry.chainId, identityRegistryAddress: step.registry.identityRegistryAddress, agentId: step.identity.agentId },
     ensName: nextEnsName,
     operators: operatorsPointerFromState(state, nextEnsName),
@@ -149,14 +129,14 @@ export async function prepareOperatorProfileArtifacts(args: {
     ...step.identity,
     state,
     backup: { ...backup, metadataCid, agentUri },
-    publicSkills,
+    agentCard,
     agentUri,
     metadataCid,
   }
 
   return {
     nextIdentity,
-    publicSkillsJson,
+    agentCardJson,
     agentUri,
     metadataCid,
   }

package/src/identity/hub/restore/RestoreFlow.tsx

@@ -101,7 +101,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
   if (step.kind === 'restore-recovery-input') {
     return (
       <Surface
-        title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+        title={isSwitch ? 'Switch Agent' : 'Restore Agent'}
         subtitle="The connected wallet doesn't directly own an agent token on this network."
         footer={footerHint('enter select · esc back')}
       >
@@ -126,7 +126,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
     if (step.busy) {
       return (
         <Surface
-          title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+          title={isSwitch ? 'Switch Agent' : 'Restore Agent'}
           subtitle="Looking up the agent onchain."
           footer={footerHint('esc cancels')}
         >
@@ -138,7 +138,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
     }
     return (
       <Surface
-        title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+        title={isSwitch ? 'Switch Agent' : 'Restore Agent'}
         subtitle="Enter the agent's ENS name to decrypt with an authorized operator wallet."
         footer={footerHint('enter continue · esc back')}
       >
@@ -162,7 +162,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
     if (step.busy) {
       return (
         <Surface
-          title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+          title={isSwitch ? 'Switch Agent' : 'Restore Agent'}
           subtitle="Looking up the agent onchain."
           footer={footerHint('esc cancels')}
         >
@@ -174,7 +174,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
     }
     return (
       <Surface
-        title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+        title={isSwitch ? 'Switch Agent' : 'Restore Agent'}
         subtitle={`Enter the ERC-8004 token ID on ${networkLabelForRegistry(step.registry)}.`}
         footer={footerHint('enter continue · esc back')}
       >
@@ -223,7 +223,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
   if (step.kind === 'restore-select-token') {
     return (
       <Surface
-        title={isSwitch ? 'Load an Agent' : 'Choose Your Agent'}
+        title={isSwitch ? 'Switch Agent' : 'Choose Your Agent'}
         subtitle={step.ownerHandle}
         footer={footerHint('enter select · esc back')}
       >
@@ -260,7 +260,7 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
   if (step.kind === 'restore-fetching') {
     return (
       <BusyScreen
-        title={isSwitch ? 'Loading Agent' : 'Restoring Your Agent'}
+        title={isSwitch ? 'Switching Agent' : 'Restoring Your Agent'}
         subtitle="IPFS"
         label="opening encrypted state from IPFS..."
         onCancel={onBack}
@@ -348,7 +348,7 @@ function restoreAuthorizationView(
       title: 'Operator Wallet Required',
       subtitle: `Sign with the operator wallet ${shortAddress(requester)} to decrypt this snapshot.`,
       label: 'waiting for operator wallet signature...',
-      progressTitle: isSwitch ? 'Loading Agent' : 'Restoring Your Agent',
+      progressTitle: isSwitch ? 'Switching Agent' : 'Restoring Your Agent',
     }
   }
 
@@ -356,6 +356,6 @@ function restoreAuthorizationView(
     title: 'Owner Wallet Required',
     subtitle: `This encrypted snapshot requires the owner wallet ${shortAddress(owner)}.`,
     label: 'waiting for owner wallet signature...',
-    progressTitle: isSwitch ? 'Loading Agent' : 'Restoring Your Agent',
+    progressTitle: isSwitch ? 'Switching Agent' : 'Restoring Your Agent',
   }
 }

package/src/identity/hub/restore/apply.ts

@@ -10,7 +10,7 @@ import {
   restoreSkillsTree,
   writeContinuityFiles,
 } from '../../continuity/storage.js'
-import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { requestBrowserWalletSignature } from '../../wallet/browserWallet.js'
 import { setVaultAddressField } from '../../identityCompat.js'
@@ -18,7 +18,7 @@ import type { Step } from '../identityHubReducer.js'
 import type { EffectCallbacks } from '../shared/effects/types.js'
 import { isContinuitySnapshotEnvelope } from './envelopes.js'
 import { restoreSignatureRequestForStep } from './auth.js'
-import { type BackupMetadata, operatorStateFromCandidate, restorePublishedPublicSkills } from './helpers.js'
+import { type BackupMetadata, operatorStateFromCandidate, restorePublishedAgentCard } from './helpers.js'
 
 export async function runRestoreAuthorize(
   step: Extract<Step, { kind: 'restore-authorizing' }>,
@@ -99,10 +99,9 @@ export async function runRestoreAuthorize(
     metadataCid: step.candidate.metadataCid,
     state: restoredState,
     backup,
-    ...(step.candidate.publicDiscovery ? {
-      publicSkills: {
-        ...(step.candidate.publicDiscovery.skillsCid ? { cid: step.candidate.publicDiscovery.skillsCid } : {}),
-        ...(step.candidate.publicDiscovery.agentCardCid ? { agentCardCid: step.candidate.publicDiscovery.agentCardCid } : {}),
+    ...(step.candidate.publicDiscovery?.agentCardCid ? {
+      agentCard: {
+        cid: step.candidate.publicDiscovery.agentCardCid,
         ...(step.candidate.publicDiscovery.updatedAt ? { updatedAt: step.candidate.publicDiscovery.updatedAt } : {}),
         status: 'pinned',
       },
@@ -115,9 +114,9 @@ export async function runRestoreAuthorize(
     await restoreSkillsTree(nextIdentity, continuitySkills)
   }
   callbacks.onRestoreProgress?.({ phase: 'finishing', label: 'finalizing restored identity...' })
-  await restorePublishedPublicSkills(nextIdentity, step.apiUrl, step.candidate.publicDiscovery?.skillsCid)
+  await restorePublishedAgentCard(nextIdentity, step.apiUrl, step.candidate.publicDiscovery?.agentCardCid)
   await ensureIdentityMarkdownScaffold(nextIdentity)
-  await syncPublicSkillsManifest(nextIdentity).catch(() => null)
+  await syncAgentCardManifest(nextIdentity).catch(() => null)
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'restored from agent backup' }).catch(() => null)
   await callbacks.onIdentityComplete(nextIdentity, `ERC-8004 agent restored · #${step.candidate.agentId.toString()}`, 'restore')
 }

package/src/identity/hub/restore/helpers.ts

@@ -6,7 +6,7 @@ import {
 } from '../../continuity/envelope.js'
 import { catFromIpfs } from '../../storage/ipfs.js'
 import type { Erc8004AgentCandidate } from '../../registry/erc8004.js'
-import { writePublicSkillsFile } from '../../continuity/storage.js'
+import { writeAgentCardFile } from '../../continuity/storage.js'
 import { normalizeApprovedOperatorWallets } from '../shared/operatorWallets.js'
 
 export type BackupMetadata = NonNullable<EthagentIdentity['backup']>
@@ -75,7 +75,7 @@ export function operatorStateFromCandidate(candidate: Erc8004AgentCandidate): Re
   }
 }
 
-export async function restorePublishedPublicSkills(
+export async function restorePublishedAgentCard(
   identity: EthagentIdentity,
   apiUrl: string,
   cid: string | undefined,
@@ -83,7 +83,7 @@ export async function restorePublishedPublicSkills(
   if (!cid) return false
   try {
     const raw = await catFromIpfs(apiUrl, cid)
-    await writePublicSkillsFile(identity, new TextDecoder().decode(raw))
+    await writeAgentCardFile(identity, new TextDecoder().decode(raw))
     return true
   } catch {
     return false

package/src/identity/hub/restore/recovery.ts

@@ -12,7 +12,7 @@ import {
   restoreSkillsTree,
   writeContinuityFiles,
 } from '../../continuity/storage.js'
-import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot, updatePublishedContinuitySnapshotContentHashes } from '../../continuity/snapshots.js'
 import { catFromIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
 import {
@@ -24,7 +24,7 @@ import { setVaultAddressField } from '../../identityCompat.js'
 import type { EffectCallbacks } from '../shared/effects/types.js'
 import { isContinuitySnapshotEnvelope, parseRestorableEnvelope } from './envelopes.js'
 import { restoreMessageForWallet } from './auth.js'
-import { type BackupMetadata, operatorStateFromCandidate, restorePublishedPublicSkills } from './helpers.js'
+import { type BackupMetadata, operatorStateFromCandidate, restorePublishedAgentCard } from './helpers.js'
 
 export async function runRecoveryRefetch(
   identity: EthagentIdentity,
@@ -46,7 +46,7 @@ export async function runRecoveryRefetch(
   const raw = await catFromIpfs(apiUrl, candidate.backup.cid)
   const envelope = parseRestorableEnvelope(raw)
   if (!isContinuitySnapshotEnvelope(envelope)) {
-    throw new Error('This snapshot is in an unsupported envelope format and cannot be refetched here; use Load Agent')
+    throw new Error('This snapshot is in an unsupported envelope format and cannot be refetched here; use Switch Agent')
   }
   const eligibleAddresses: Address[] = [ownerAddress]
   if (isWalletContinuitySnapshotEnvelope(envelope)) {
@@ -119,10 +119,9 @@ export async function runRecoveryRefetch(
     metadataCid: candidate.metadataCid,
     state: refreshedState,
     backup: refreshedBackup,
-    ...(candidate.publicDiscovery ? {
-      publicSkills: {
-        ...(candidate.publicDiscovery.skillsCid ? { cid: candidate.publicDiscovery.skillsCid } : {}),
-        ...(candidate.publicDiscovery.agentCardCid ? { agentCardCid: candidate.publicDiscovery.agentCardCid } : {}),
+    ...(candidate.publicDiscovery?.agentCardCid ? {
+      agentCard: {
+        cid: candidate.publicDiscovery.agentCardCid,
         ...(candidate.publicDiscovery.updatedAt ? { updatedAt: candidate.publicDiscovery.updatedAt } : {}),
         status: 'pinned',
       },
@@ -133,11 +132,11 @@ export async function runRecoveryRefetch(
     await restoreSkillsTree(nextIdentity, payload.skills)
   }
   callbacks.onRestoreProgress?.({ phase: 'finishing', label: 'finalizing refreshed identity...' })
-  const publicSkillsRestored = await restorePublishedPublicSkills(nextIdentity, apiUrl, candidate.publicDiscovery?.skillsCid)
+  const agentCardRestored = await restorePublishedAgentCard(nextIdentity, apiUrl, candidate.publicDiscovery?.agentCardCid)
   await ensureIdentityMarkdownScaffold(nextIdentity)
-  await syncPublicSkillsManifest(nextIdentity).catch(() => null)
+  await syncAgentCardManifest(nextIdentity).catch(() => null)
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'Refetched Latest Snapshot From Onchain' }).catch(() => null)
-  if (publicSkillsRestored) {
+  if (agentCardRestored) {
     const contentHashes = await localContinuitySnapshotContentHashes(nextIdentity)
     await updatePublishedContinuitySnapshotContentHashes(nextIdentity, candidate.backup.cid, contentHashes).catch(() => null)
   }