ethagent 3.2.0 → 3.3.1

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

@@ -7,7 +7,7 @@ import {
   type Erc8004RegistryConfig,
 } from '../../registry/erc8004.js'
 import { parseAgentTokenReference, readEthagentTextRecords } from '../../ens/ensLookup.js'
-import { AGENT_RECORD_KEYS } from '../../ens/agentRecords.js'
+import { AGENT_TOKEN_RECORD_KEY } from '../../ens/agentRecords.js'
 
 const ETH_NAME_PATTERN = /^([a-z0-9-]+\.)+eth$/i
 
@@ -22,26 +22,28 @@ export async function resolveAgentEnsToCandidate(
   const trimmed = ensName.trim()
   if (!trimmed) return { ok: false, message: 'Enter an agent ENS name (e.g. agent.example.eth).' }
   if (!ETH_NAME_PATTERN.test(trimmed)) return { ok: false, message: 'Enter a valid .eth name.' }
+
   let records: Record<string, string>
   try {
-    records = await readEthagentTextRecords(trimmed, [AGENT_RECORD_KEYS.token])
+    records = await readEthagentTextRecords(trimmed, [AGENT_TOKEN_RECORD_KEY])
   } catch (err: unknown) {
-    return { ok: false, message: `Could not reach Ethereum mainnet to resolve ${trimmed}: ${err instanceof Error ? err.message : String(err)}` }
+    return { ok: false, message: `Could not reach Ethereum Mainnet to resolve ${trimmed}: ${err instanceof Error ? err.message : String(err)}` }
   }
-  const tokenValue = records[AGENT_RECORD_KEYS.token]
-  if (!tokenValue) return { ok: false, message: `${trimmed} has no org.ethagent.token record.` }
+  const tokenValue = records[AGENT_TOKEN_RECORD_KEY]
+  if (!tokenValue) return { ok: false, message: `${trimmed} has no agent discovery record. Use token-ID restore instead, or re-link this ENS name to refresh its records.` }
   const tokenRef = parseAgentTokenReference(tokenValue)
-  if (!tokenRef) return { ok: false, message: `${trimmed}'s org.ethagent.token record is not a valid eip155 reference.` }
+  if (!tokenRef) return { ok: false, message: `${trimmed}'s agent discovery record is not a valid eip155 reference.` }
   if (tokenRef.chainId !== registry.chainId) {
     return { ok: false, message: `${trimmed}'s agent token is onchain ${tokenRef.chainId}, not the network you selected.` }
   }
   const finalRegistry: Erc8004RegistryConfig = registry.identityRegistryAddress.toLowerCase() === tokenRef.identityRegistryAddress.toLowerCase()
     ? registry
     : { ...registry, identityRegistryAddress: tokenRef.identityRegistryAddress }
-  let owner: Address
+
+  let onchainOwner: Address
   try {
     const publicClient = createErc8004PublicClient(finalRegistry)
-    owner = await publicClient.readContract({
+    onchainOwner = await publicClient.readContract({
       address: finalRegistry.identityRegistryAddress,
       abi: [{ inputs: [{ name: 'tokenId', type: 'uint256' }], name: 'ownerOf', outputs: [{ name: '', type: 'address' }], stateMutability: 'view', type: 'function' }] as const,
       functionName: 'ownerOf',
@@ -53,7 +55,7 @@ export async function resolveAgentEnsToCandidate(
   try {
     const candidate = await discoverOwnedAgentBackupByTokenId({
       ...finalRegistry,
-      ownerHandle: owner,
+      ownerHandle: onchainOwner,
       ipfsApiUrl: DEFAULT_IPFS_API_URL,
       tokenId: tokenRef.agentId,
     })

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

@@ -124,7 +124,7 @@ export const MenuScreen: React.FC<MenuScreenProps> = ({
         { 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: 'Load Agent', hint: 'Refresh or load another agent' },
+        { 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' },
@@ -198,7 +198,7 @@ function renderReconciliationBanner(r: AgentReconciliation, identity: EthagentId
         <>
           <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 Load Agent or New Agent to re-enable disabled actions.</Text>
+          <Text color={theme.textSubtle}>Use Switch Agent or New Agent to re-enable disabled actions.</Text>
         </>
       )
     }
@@ -207,7 +207,7 @@ function renderReconciliationBanner(r: AgentReconciliation, identity: EthagentId
         <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 Load Agent or New Agent to re-enable disabled actions.</Text>
+        <Text color={theme.textSubtle}>Use Switch Agent or New Agent to re-enable disabled actions.</Text>
       </>
     )
   }

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

@@ -26,8 +26,8 @@ export const UnlinkedIdentityScreen: React.FC<UnlinkedIdentityScreenProps> = ({
   onCancel,
 }) => {
   const options: Array<{ value: Action; label: string; hint?: string; role?: 'section' | 'utility' }> = [
-    { value: 'load-agent', role: 'section', label: 'Load Agent' },
-    { value: 'load-agent', label: 'Load Agent', hint: 'Reconnect this token by signing with the current owner wallet, or load a different one' },
+    { value: 'load-agent', role: 'section', label: 'Switch Agent' },
+    { value: 'load-agent', label: 'Switch Agent', hint: 'Reconnect this token by signing with the current owner wallet, or switch to a different one' },
     { value: 'open-menu', role: 'section', label: 'Identity Hub' },
     { value: 'open-menu', label: 'Open Identity Hub', hint: 'Browse local identity, continuity files, and settings without reconnecting' },
   ]

package/src/identity/hub/shared/effects/sync.ts

@@ -149,7 +149,7 @@ export async function markCurrentContinuityFilesPublished(
   identity: EthagentIdentity,
   publishedSources?: {
     privateFiles: ContinuityFiles
-    publicSkills: string
+    agentCard: string
     skills: ContinuitySkillsTree
   },
 ): Promise<void> {

package/src/identity/hub/transfer/TokenTransferScreens.tsx

@@ -192,7 +192,7 @@ export const TokenTransferReadyScreen: React.FC<TokenTransferReadyScreenProps> =
       <Box marginTop={1} flexDirection="column">
         <Text color={theme.textSubtle}>Use this process for every ERC-8004 token transfer.</Text>
         <Text color={theme.textSubtle}>Both sender and receiver signatures can decrypt this snapshot.</Text>
-        <Text color={theme.textSubtle}>After transfer, use Load Agent with the receiver wallet.</Text>
+        <Text color={theme.textSubtle}>After transfer, use Switch Agent with the receiver wallet.</Text>
         <Text color={theme.textSubtle}>{APPROVAL_GUARDRAIL}</Text>
       </Box>
       <Box marginTop={1}>

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

@@ -11,18 +11,10 @@ import {
   continuityVaultStatus,
   prepareSyncedSkillsTree,
   readContinuityFiles,
-  readPublicSkillsFile,
-  writePublicSkillsFile,
+  writeAgentCardFile,
 } from '../../continuity/storage.js'
 import {
-  appendPublicSkillEntries,
-  createAgentCard,
-  defaultPublicSkillsProfile,
-  serializeAgentCard,
-} from '../../continuity/publicSkills.js'
-import {
-  derivePublicSkillEntries,
-  syncPublicSkillsManifest,
+  syncAgentCardManifest,
 } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
@@ -47,7 +39,7 @@ import { tokenTransferProgressForPhase } from './progress.js'
 import { assertTokenNotInVault } from '../custody/preflight.js'
 
 type BackupMetadata = NonNullable<EthagentIdentity['backup']>
-type PublicSkillsMetadata = NonNullable<EthagentIdentity['publicSkills']>
+type AgentCardMetadata = NonNullable<EthagentIdentity['agentCard']>
 
 type TokenTransferResult = {
   identity: EthagentIdentity
@@ -167,20 +159,8 @@ export async function runTokenTransferSigning(
   }
   const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
   const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
-  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 skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
   const envelope = createTransferContinuitySnapshotEnvelope({
@@ -215,9 +195,8 @@ export async function runTokenTransferSigning(
     agentId: transferAgentId,
     ...(transferSnapshot ? { transferSnapshot } : {}),
   }
-  const publicSkills: PublicSkillsMetadata = {
-    cid: publicSkillsPin.cid,
-    agentCardCid: agentCardPin.cid,
+  const agentCard: AgentCardMetadata = {
+    cid: agentCardPin.cid,
     updatedAt: envelope.createdAt,
     status: 'pinned',
   }
@@ -232,7 +211,7 @@ export async function runTokenTransferSigning(
     ...(uploadedImageUri ? { image: uploadedImageUri } : {}),
   }, {
     backup: { cid: snapshotCid, envelopeVersion: envelope.envelopeVersion, createdAt: envelope.createdAt, ...(transferSnapshot ? { transferSnapshot } : {}) },
-    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: transferAgentId },
     ensName: nextEnsName,
     operators: operatorsPointerFromState(state, nextEnsName),
@@ -273,10 +252,10 @@ export async function runTokenTransferSigning(
     agentUri,
     metadataCid,
     backup: { ...backup, metadataCid, agentUri, txHash: tx.txHash },
-    publicSkills,
+    agentCard,
     state,
   }
-  await writePublicSkillsFile(nextIdentity, publicSkillsJson)
+  await writeAgentCardFile(nextIdentity, agentCardJson)
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'published transfer snapshot' }).catch(() => null)
   callbacks.onTokenTransferProgress?.(null)
   return {

package/src/identity/hub/useIdentityHubContinuity.ts

@@ -4,7 +4,7 @@ import { catFromIpfs, DEFAULT_IPFS_API_URL } from '../storage/ipfs.js'
 import {
   continuityVaultStatus,
   continuityWorkingTreeStatus,
-  ensurePublicSkillsFile,
+  ensureAgentCardFile,
   type ContinuityWorkingTreeStatus,
 } from '../continuity/storage.js'
 import { openFileInEditor, openInFileManager } from '../continuity/editor.js'
@@ -17,7 +17,7 @@ import {
   setSkillVisibility as setSkillVisibilityStorage,
 } from '../continuity/skills/loadSkills.js'
 import type { SkillVisibility } from '../continuity/skills/types.js'
-import { syncPublicSkillsManifest } from '../continuity/skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../continuity/skills/publicSkillsSync.js'
 import { continuityVaultRef } from '../continuity/storage.js'
 import type { Step } from './identityHubReducer.js'
 
@@ -109,7 +109,7 @@ export function useIdentityHubContinuity({
       const id = await requireReadyVault()
       const notice = await args.run(id)
       invalidateSkillsCache(id)
-      await syncPublicSkillsManifest(id)
+      await syncAgentCardManifest(id)
       const next = args.successStep
         ? args.successStep(notice)
         : { kind: 'continuity-skills-tree' as const, notice }
@@ -126,12 +126,12 @@ export function useIdentityHubContinuity({
       : 'continuity-private'
     try {
       if (kind === 'skills') {
-        await ensurePublicSkillsFile(identity, {
-          fallback: () => readPublishedPublicSkills(identity),
+        await ensureAgentCardFile(identity, {
+          fallback: () => readPublishedAgentCard(identity),
         })
       }
       const ref = continuityVaultRef(identity)
-      const file = kind === 'soul' ? ref.soulPath : kind === 'memory' ? ref.memoryPath : ref.publicSkillsPath
+      const file = kind === 'soul' ? ref.soulPath : kind === 'memory' ? ref.memoryPath : ref.agentCardPath
       const result = await openFileInEditor(file)
       if (result.ok) {
         setStep({ kind: returnKind, editorOpened: true })
@@ -150,10 +150,10 @@ export function useIdentityHubContinuity({
       const result = await openFileInEditor(skill.absolutePath)
       invalidateSkillsCache(identity)
       try {
-        await syncPublicSkillsManifest(identity)
+        await syncAgentCardManifest(identity)
       } catch (syncErr: unknown) {
         const failPrefix = result.ok ? '' : `open failed: ${result.error}; `
-        setStep({ kind: 'continuity-skills-tree', notice: `${failPrefix}public manifest sync failed: ${(syncErr as Error).message}`, editorOpened: result.ok })
+        setStep({ kind: 'continuity-skills-tree', notice: `${failPrefix}agent card update failed: ${(syncErr as Error).message}`, editorOpened: result.ok })
         return
       }
       if (result.ok) {
@@ -194,7 +194,7 @@ export function useIdentityHubContinuity({
       const id = await requireReadyVault()
       const created = await createSkillFile(id, { name: normalizedName, visibility })
       invalidateSkillsCache(id)
-      await syncPublicSkillsManifest(id)
+      await syncAgentCardManifest(id)
       const result = await openFileInEditor(created.absolutePath)
       if (result.ok) {
         setStep({ kind: 'continuity-skills-tree', editorOpened: true })
@@ -248,9 +248,9 @@ export function sanitizeSkillSegment(value: string): string {
   return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60)
 }
 
-async function readPublishedPublicSkills(identity: EthagentIdentity): Promise<string> {
-  const cid = identity.publicSkills?.cid
-  if (!cid) throw new Error('No saved public skills CID')
+async function readPublishedAgentCard(identity: EthagentIdentity): Promise<string> {
+  const cid = identity.agentCard?.cid
+  if (!cid) throw new Error('No saved Agent Card CID')
   return new TextDecoder().decode(await catFromIpfs(
     identity.backup?.ipfsApiUrl ?? DEFAULT_IPFS_API_URL,
     cid,

package/src/identity/hub/useIdentityHubController.ts

@@ -240,9 +240,14 @@ export function useIdentityHubController({
       handleStepError(new Error('no agent registry configured for this identity'), backStep)
       return
     }
+    const isAdvanced = readCustodyMode(identity.state as Record<string, unknown> | undefined) === 'advanced'
     const vaultAddress = options?.useVault === false
       ? undefined
-      : options?.vaultAddress ?? resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
+      : options?.vaultAddress != null
+        ? options.vaultAddress
+        : isAdvanced
+          ? resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
+          : undefined
     ;(async () => {
       const role: 'token-holder' | 'vault-level-owner' = vaultAddress ? 'vault-level-owner' : 'token-holder'
       const allowed = await guardOwnership(identity, registry, role, backStep)
@@ -260,8 +265,12 @@ export function useIdentityHubController({
       return
     }
     ;(async () => {
-      const vaultAddress = resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
-      const allowed = await guardOwnership(identity, registry, 'vault-level-owner', backStep)
+      const isAdvanced = readCustodyMode(identity.state as Record<string, unknown> | undefined) === 'advanced'
+      const vaultAddress = isAdvanced
+        ? resolveVaultAddress(identity, config?.erc8004?.operatorVaults)
+        : undefined
+      const role: 'token-holder' | 'vault-level-owner' = vaultAddress ? 'vault-level-owner' : 'token-holder'
+      const allowed = await guardOwnership(identity, registry, role, backStep)
       if (!allowed) return
       runPublicProfilePreflight(identity, registry, callbacks, profileUpdates, backStep, vaultAddress)
         .catch((err: unknown) => handleStepError(err, backStep))

package/src/identity/registry/erc8004/metadata.ts

@@ -62,16 +62,15 @@ function parseTransferSnapshotMetadata(input: Record<string, unknown> | null): T
 export function parseEthagentPublicDiscoveryPointer(registration: Record<string, unknown> | null): EthagentPublicDiscoveryPointer | null {
   if (!registration) return null
   const ext = objectField(registration, 'x-ethagent') ?? objectField(registration, 'ethagent')
-  const publicSkills = ext ? objectField(ext, 'publicSkills') : null
   const agentCard = ext ? objectField(ext, 'agentCard') : null
-  const skillsCid = publicSkills ? stringField(publicSkills, 'cid') : undefined
-  const agentCardCid = agentCard ? stringField(agentCard, 'cid') : undefined
-  const updatedAt = (publicSkills ? stringField(publicSkills, 'updatedAt') : undefined)
-    ?? (agentCard ? stringField(agentCard, 'updatedAt') : undefined)
-  if (!skillsCid && !agentCardCid) return null
+  const legacyPublicSkills = ext ? objectField(ext, 'publicSkills') : null
+  const agentCardCid = (agentCard ? stringField(agentCard, 'cid') : undefined)
+    ?? (legacyPublicSkills ? stringField(legacyPublicSkills, 'cid') : undefined)
+  const updatedAt = (agentCard ? stringField(agentCard, 'updatedAt') : undefined)
+    ?? (legacyPublicSkills ? stringField(legacyPublicSkills, 'updatedAt') : undefined)
+  if (!agentCardCid) return null
   return {
-    ...(skillsCid ? { skillsCid } : {}),
-    ...(agentCardCid ? { agentCardCid } : {}),
+    agentCardCid,
     ...(updatedAt ? { updatedAt } : {}),
   }
 }
@@ -166,7 +165,6 @@ function serializeOperatorsPointer(pointer: EthagentOperatorsPointer): Record<st
   return {
     approvedOperatorWallets: pointer.approvedOperatorWallets.map(record => ({
       address: getAddress(record.address),
-      ...(record.challenge ? { challenge: record.challenge } : {}),
       ...(record.verifiedAt ? { verifiedAt: record.verifiedAt } : {}),
       ...(record.restoreAccessKey ? { restoreAccessKey: serializeRestoreAccessKey(record.restoreAccessKey) } : {}),
     })),
@@ -229,13 +227,6 @@ export function withEthagentPointers(
         ...(backup.transferSnapshot ? { transferSnapshot: serializeTransferSnapshotMetadata(backup.transferSnapshot) } : {}),
       },
     } : {}),
-    ...(publicDiscovery?.skillsCid ? {
-      publicSkills: {
-        cid: publicDiscovery.skillsCid,
-        format: 'application/json',
-        ...(updatedAt ? { updatedAt } : {}),
-      },
-    } : {}),
     ...(publicDiscovery?.agentCardCid ? {
       agentCard: {
         cid: publicDiscovery.agentCardCid,
@@ -285,17 +276,9 @@ function withEthagentServices(
   if (publicDiscovery?.agentCardCid) {
     const endpoint = `ipfs://${publicDiscovery.agentCardCid}`
     pushUniqueService(services, {
-      type: 'a2a',
+      type: 'A2A',
       name: 'agent-card',
-      endpoint,
-      url: endpoint,
-    })
-  }
-  if (publicDiscovery?.skillsCid) {
-    const endpoint = `ipfs://${publicDiscovery.skillsCid}`
-    pushUniqueService(services, {
-      type: 'A2A-skills',
-      name: 'public-skills',
+      version: '0.3.0',
       endpoint,
       url: endpoint,
     })
@@ -322,7 +305,7 @@ function isEthagentManagedService(item: unknown): boolean {
   const name = obj.name
   if (name === 'agentWallet') return true
   if (name === 'ENS') return true
-  if (type === 'a2a' && (name === undefined || name === 'agent-card')) return true
+  if ((type === 'A2A' || type === 'a2a') && (name === undefined || name === 'agent-card')) return true
   return (type === 'A2A-skills' || type === 'ipfs') && name === 'public-skills'
 }
 

package/src/identity/registry/erc8004/types.ts

@@ -21,7 +21,6 @@ export type EthagentBackupPointer = {
 }
 
 export type EthagentPublicDiscoveryPointer = {
-  skillsCid?: string
   agentCardCid?: string
   updatedAt?: string
 }

package/src/storage/config.ts

@@ -51,9 +51,8 @@ const IdentitySchema = z.object({
       createdAt: z.string(),
     })).optional(),
   }).optional(),
-  publicSkills: z.object({
+  agentCard: z.object({
     cid: z.string().min(1).optional(),
-    agentCardCid: z.string().min(1).optional(),
     updatedAt: z.string().optional(),
     status: z.enum(['pinned', 'failed', 'unknown']).optional(),
   }).optional(),

package/src/storage/identity.ts

@@ -18,7 +18,7 @@ export type IdentityStatus = {
   createdAt: string
   backend: KeyBackend | 'browser-wallet'
   backup?: EthagentIdentity['backup']
-  publicSkills?: EthagentIdentity['publicSkills']
+  agentCard?: EthagentIdentity['agentCard']
   source?: EthagentIdentity['source']
   agentId?: string
   chainId?: number
@@ -33,7 +33,7 @@ export async function getIdentityStatus(config?: EthagentConfig): Promise<Identi
       createdAt: resolved.identity.createdAt,
       backend: 'browser-wallet',
       backup: resolved.identity.backup,
-      publicSkills: resolved.identity.publicSkills,
+      agentCard: resolved.identity.agentCard,
       source: resolved.identity.source,
       agentId: resolved.identity.agentId,
       chainId: resolved.identity.chainId,
@@ -47,7 +47,7 @@ export async function getIdentityStatus(config?: EthagentConfig): Promise<Identi
     createdAt: resolved.identity.createdAt,
     backend,
     backup: resolved.identity.backup,
-    publicSkills: resolved.identity.publicSkills,
+    agentCard: resolved.identity.agentCard,
     source: resolved.identity.source,
     chainId: resolved.identity.chainId,
   }

package/src/storage/rewind.ts

@@ -257,7 +257,7 @@ function isIdentityMarkdownSnapshot(snapshot: RewindSnapshot): boolean {
   )
 }
 
-const IDENTITY_MARKDOWN_FILES = new Set(['soul.md', 'memory.md', 'skills.json'])
+const IDENTITY_MARKDOWN_FILES = new Set(['soul.md', 'memory.md', 'agent-card.json'])
 
 function normalizeSnippet(input?: string): string {
   const normalized = (input ?? '').replace(/\s+/g, ' ').trim()

package/src/tools/privateContinuityEditTool.ts

@@ -4,7 +4,7 @@ import {
   writePreparedPrivateContinuityEdit,
 } from '../identity/continuity/privateEdit.js'
 import { recordPrivateContinuityHistorySnapshot } from '../identity/continuity/history.js'
-import { readContinuityFiles, readPublicSkillsFile } from '../identity/continuity/storage.js'
+import { readContinuityFiles, readAgentCardFile } from '../identity/continuity/storage.js'
 import type { Tool } from './contracts.js'
 import { formatFileChangeResult } from './fileDiff.js'
 
@@ -120,9 +120,9 @@ export const privateContinuityEditTool: Tool<typeof schema> = {
   },
   async execute(input, context) {
     const prepared = await preparePrivateContinuityEdit(input, context.config)
-    const [previousFiles, previousPublicSkills] = await Promise.all([
+    const [previousFiles, previousAgentCard] = await Promise.all([
       readContinuityFiles(prepared.identity),
-      readPublicSkillsFile(prepared.identity),
+      readAgentCardFile(prepared.identity),
     ])
     await recordPrivateContinuityHistorySnapshot({
       identity: prepared.identity,
@@ -131,7 +131,7 @@ export const privateContinuityEditTool: Tool<typeof schema> = {
       existedBefore: prepared.existedBefore,
       previousContent: prepared.previousContent,
       previousFiles,
-      previousPublicSkills,
+      previousAgentCard,
       changeSummary: prepared.changeSummary,
       sessionId: context.checkpoint?.sessionId,
       turnId: context.checkpoint?.turnId,

package/src/utils/withRetry.ts

@@ -220,7 +220,7 @@ export async function fetchWithRetry(
         && options.parseRetryHintFromBody
       ) {
         let bodyText = ''
-        try { bodyText = await response.text() } catch { /* ignore */ }
+        try { bodyText = await response.text() } catch {}
         bufferedResponse = new Response(bodyText, {
           status: response.status,
           statusText: response.statusText,
@@ -240,7 +240,7 @@ export async function fetchWithRetry(
       if (!classification.retryable || attempt > policy.maxRetries) return bufferedResponse ?? response
 
       if (!bufferedResponse) {
-        try { await response.body?.cancel() } catch { /* ignore */ }
+        try { await response.body?.cancel() } catch {}
       }
       const delayMs = computeBackoffMs(
         attempt,