ethagent 3.2.0 → 3.3.0

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

@@ -14,7 +14,6 @@ import {
 import {
   createAgentCard,
   defaultPublicSkillsProfile,
-  renderPublicSkillsJson,
   serializeAgentCard,
 } from '../../continuity/publicSkills.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
@@ -43,17 +42,17 @@ import { awaitConfirmedReceipt } from '../shared/effects/receipts.js'
 import { assertVerifiedPin } from '../shared/effects/profilePrep.js'
 
 type BackupMetadata = NonNullable<EthagentIdentity['backup']>
-type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type AgentCardMetadata = NonNullable<EthagentIdentity['agentCard']>
 
 type CreatePreparedTransaction = {
   ownerAddress: Address
   agentUri: string
   metadataCid: string
   backup: BackupMetadata
-  publicSkills: PublicSkillsMetadata
+  agentCard: AgentCardMetadata
   state: Record<string, unknown>
   continuityFiles: ReturnType<typeof defaultContinuityFiles>
-  publicSkillsJson: string
+  agentCardJson: string
 }
 
 export async function runCreatePreflight(
@@ -139,10 +138,8 @@ export async function runCreateSigning(
       })
       const continuityFiles = defaultContinuityFiles(draftIdentity)
       const publicProfile = defaultPublicSkillsProfile(draftIdentity)
-      const publicSkillsJson = renderPublicSkillsJson(publicProfile)
-      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(publicProfile)), fetch, { pinataJwt: step.pinataJwt })
+      const agentCardJson = serializeAgentCard(createAgentCard(publicProfile))
+      const agentCardPin = await addToIpfs(DEFAULT_IPFS_API_URL, agentCardJson, fetch, { pinataJwt: step.pinataJwt })
       assertVerifiedPin(agentCardPin)
       const envelope = createContinuitySnapshotEnvelope({
         ownerAddress: wallet.account,
@@ -168,9 +165,8 @@ export async function runCreateSigning(
         rpcUrl: step.registry.rpcUrl,
         identityRegistryAddress: step.registry.identityRegistryAddress,
       }
-      const publicSkills: PublicSkillsMetadata = {
-        cid: publicSkillsPin.cid,
-        agentCardCid: agentCardPin.cid,
+      const agentCard: AgentCardMetadata = {
+        cid: agentCardPin.cid,
         updatedAt: envelope.createdAt,
         status: 'pinned',
       }
@@ -181,7 +177,7 @@ export async function runCreateSigning(
         ...(typeof state.imageUrl === 'string' ? { image: state.imageUrl } : {}),
       }, {
         backup: { 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 },
         ownerAddress: wallet.account,
       })
@@ -197,10 +193,10 @@ export async function runCreateSigning(
           agentUri,
           metadataCid,
           backup: { ...backup, metadataCid, agentUri },
-          publicSkills,
+          agentCard,
           state,
           continuityFiles,
-          publicSkillsJson,
+          agentCardJson,
         },
       }
     },
@@ -233,11 +229,11 @@ export async function runCreateSigning(
     metadataCid: result.prepared.metadataCid,
     state: result.prepared.state,
     backup,
-    publicSkills: result.prepared.publicSkills,
+    agentCard: result.prepared.agentCard,
   }
   await writeIdentityMarkdownScaffold(nextIdentity, {
     ...defaultContinuityFiles(nextIdentity),
-    'skills.json': result.prepared.publicSkillsJson,
+    'agent-card.json': result.prepared.agentCardJson,
   })
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'initial published snapshot' }).catch(() => null)
   await callbacks.onIdentityComplete(nextIdentity, `ERC-8004 agent registered · #${registered.agentId.toString()}`, 'create')

package/src/identity/hub/ens/EnsEditFlow.tsx

@@ -2,8 +2,8 @@ import React from 'react'
 import { getAddress, type Address } from 'viem'
 import type { BrowserWalletReady } from '../../wallet/browserWallet.js'
 import {
-  AGENT_RECORD_READ_KEY_LIST,
   buildAgentEnsRecords,
+  buildEnsip25Key,
   diffRecords,
   recordsFromTextMap,
 } from '../../ens/agentRecords.js'
@@ -137,8 +137,15 @@ export const EnsEditFlow: React.FC<EnsEditProps> = ({
     setPhase({ kind: 'validating', fullName, mode, ownerAddress: phaseOwnerAddress, operatorWallet })
     try {
       const validation = await validateAgentEnsLink(fullName, ownerAddress)
-      const currentText = validation.ok
-        ? await readEthagentTextRecords(fullName, AGENT_RECORD_READ_KEY_LIST)
+      const readKeys = identity.agentId
+        ? [buildEnsip25Key({
+            chainId: registry.chainId,
+            identityRegistryAddress: registry.identityRegistryAddress,
+            agentId: identity.agentId,
+          })]
+        : []
+      const currentText = validation.ok && readKeys.length > 0
+        ? await readEthagentTextRecords(fullName, readKeys)
         : {}
       const current = recordsFromTextMap(currentText)
       const next = buildAgentEnsRecords({
@@ -252,7 +259,14 @@ export const EnsEditFlow: React.FC<EnsEditProps> = ({
   const runUnlinkEnsLoading = React.useCallback((fullName: string): void => {
     setValidationError(null)
     setPhase({ kind: 'unlink-loading', fullName })
-    readEthagentTextRecords(fullName, AGENT_RECORD_READ_KEY_LIST)
+    const readKeys = identity.agentId
+      ? [buildEnsip25Key({
+          chainId: registry.chainId,
+          identityRegistryAddress: registry.identityRegistryAddress,
+          agentId: identity.agentId,
+        })]
+      : []
+    readEthagentTextRecords(fullName, readKeys)
       .then(currentText => {
         const currentRecords = recordsFromTextMap(currentText)
         setPhase({
@@ -266,7 +280,7 @@ export const EnsEditFlow: React.FC<EnsEditProps> = ({
         setValidationError(err instanceof Error ? err.message : String(err))
         setPhase({ kind: 'mode-select' })
       })
-  }, [])
+  }, [identity.agentId, registry.chainId, registry.identityRegistryAddress])
 
   const maintenanceScreen = renderEnsMaintenancePhase({
     phase,

package/src/identity/hub/ens/EnsEditReviewScreens.tsx

@@ -4,11 +4,9 @@ import { getAddress, type Address } from 'viem'
 import { Surface } from '../../../ui/Surface.js'
 import { Select, type SelectOption } from '../../../ui/Select.js'
 import { theme } from '../../../ui/theme.js'
-import {
-  formatRecordValue,
-  recordLabel,
-  type AgentEnsRecords,
-  type AgentRecordDiff,
+import type {
+  AgentEnsRecords,
+  AgentRecordDiff,
 } from '../../ens/agentRecords.js'
 import type { EnsValidation } from '../../ens/ensLookup.js'
 import type {
@@ -194,7 +192,9 @@ export const EnsSetupBlockedScreen: React.FC<EnsSetupBlockedScreenProps> = ({
           {isSimple
             ? <EnsSetupRow label="Wallet" value={fallback.ownerAddress ? shortAddress(fallback.ownerAddress) : shortAddress(fallback.operatorAddress)} />
             : (fallback.ownerAddress ? <EnsSetupRow label="Owner wallet" value={shortAddress(fallback.ownerAddress)} /> : null)}
-          {fallback.nextRecords?.token ? <EnsSetupRow label="Token link" value={fallback.nextRecords.token} /> : null}
+          {fallback.nextRecords && Object.keys(fallback.nextRecords).length > 0
+            ? <EnsSetupRow label="Attestation" value="ENSIP-25 agent-registration record" />
+            : null}
           <EnsSetupRow label="Address" value={`Set the subdomain address record to the ${isSimple ? 'connected wallet' : 'owner wallet'}.`} />
           {!isSimple
             ? (
@@ -271,7 +271,7 @@ export const UnlinkEnsReviewScreen: React.FC<UnlinkEnsReviewScreenProps> = ({
             {changedDiffs.map(diff => (
               <Text key={diff.key}>
                 <Text color={theme.dim}>{`  ${diff.key}  `}</Text>
-                <Text color={theme.accentPeriwinkle}>{formatRecordValue(diff.field, diff.current)}</Text>
+                <Text color={theme.accentPeriwinkle}>{diff.current}</Text>
               </Text>
             ))}
           </Box>
@@ -420,16 +420,16 @@ export const ReviewScreen: React.FC<ReviewScreenProps> = ({
           : null}
         {recordsDiff.map(diff => (
           <Text key={diff.key}>
-            <Text color={theme.dim}>{`- ${recordLabel(diff.field)}: `}</Text>
+            <Text color={theme.dim}>{`- ${diff.key}: `}</Text>
             {diff.changed
               ? (
                 <>
-                  {renderRecordValue(diff.field, diff.current)}
+                  {renderRecordValue(diff.current)}
                   <Text color={theme.dim}>{' → '}</Text>
-                  {renderRecordValue(diff.field, diff.next)}
+                  {renderRecordValue(diff.next)}
                 </>
               )
-              : renderRecordValue(diff.field, diff.next)}
+              : renderRecordValue(diff.next)}
           </Text>
         ))}
         {!hasRecordChanges

package/src/identity/hub/ens/EnsEditShared.tsx

@@ -4,10 +4,6 @@ import type { Address } from 'viem'
 import { Surface } from '../../../ui/Surface.js'
 import { TextInput } from '../../../ui/TextInput.js'
 import { theme } from '../../../ui/theme.js'
-import {
-  formatRecordValue,
-  type AgentEnsRecordState,
-} from '../../ens/agentRecords.js'
 import {
   isEthDomain,
   sanitizeSubdomainPrefix,
@@ -24,9 +20,9 @@ import type { EnsEditProps } from './types.js'
 
 export const footerHint = (hint: string) => <Text color={theme.dim}>{hint}</Text>
 
-export const renderRecordValue = (field: keyof AgentEnsRecordState, value: string) =>
+export const renderRecordValue = (value: string) =>
   value
-    ? <Text color={theme.accentPeriwinkle}>{formatRecordValue(field, value)}</Text>
+    ? <Text color={theme.accentPeriwinkle}>{value}</Text>
     : <Text color={theme.dim}>Unset</Text>
 
 export function rootErrorMessage(

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

@@ -18,7 +18,7 @@ export function recordsHaveCurrentValues(recordsDiff: AgentRecordDiff[]): boolea
 }
 
 export function emptyAgentEnsRecords(): AgentEnsRecords {
-  return { token: '' }
+  return {}
 }
 
 export function unlinkEnsLinkOptions(savedCustodyMode: CustodyMode | undefined, savedOwnerAddress: string): EnsLinkOptions {
@@ -84,8 +84,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/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,
   }