ethagent 3.1.2 → 3.3.0

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/models/llamacpp.ts

@@ -256,12 +256,68 @@ async function fetchServedModels(host: string = DEFAULT_LLAMA_HOST, timeoutMs =
   }
 }
 
+let cachedLlamaCppContextSize: number | null = null
+const llamaCppContextSizeListeners = new Set<(size: number) => void>()
+
+export async function fetchLlamaCppContextSize(
+  host: string = DEFAULT_LLAMA_HOST,
+  timeoutMs = 1500,
+): Promise<number | null> {
+  const response = await fetchWithTimeout(`${host.replace(/\/+$/, '')}/props`, timeoutMs)
+  if (!response || !response.ok) return null
+  try {
+    const data = await response.json() as {
+      n_ctx?: unknown
+      default_generation_settings?: { n_ctx?: unknown }
+    }
+    const raw = typeof data.n_ctx === 'number'
+      ? data.n_ctx
+      : typeof data.default_generation_settings?.n_ctx === 'number'
+        ? data.default_generation_settings.n_ctx
+        : null
+    if (typeof raw === 'number' && raw > 0) {
+      const changed = cachedLlamaCppContextSize !== raw
+      cachedLlamaCppContextSize = raw
+      if (changed) {
+        for (const listener of llamaCppContextSizeListeners) {
+          try { listener(raw) } catch { void 0 }
+        }
+      }
+      return raw
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+export function getCachedLlamaCppContextSize(): number | null {
+  return cachedLlamaCppContextSize
+}
+
+export function setCachedLlamaCppContextSize(size: number): void {
+  if (!(size > 0)) return
+  const changed = cachedLlamaCppContextSize !== size
+  cachedLlamaCppContextSize = size
+  if (changed) {
+    for (const listener of llamaCppContextSizeListeners) {
+      try { listener(size) } catch { void 0 }
+    }
+  }
+}
+
+export function onLlamaCppContextSizeChange(listener: (size: number) => void): () => void {
+  llamaCppContextSizeListeners.add(listener)
+  return () => { llamaCppContextSizeListeners.delete(listener) }
+}
+
 export async function detectLlamaCpp(host: string = DEFAULT_LLAMA_HOST): Promise<LlamaCppStatus> {
   const [binary, serverUp] = await Promise.all([
     detectLlamaCppServerBinary(),
     isLlamaCppServerUp(host),
   ])
   const servedModels = serverUp ? await listServedModels(host) : []
+  if (serverUp) void fetchLlamaCppContextSize(host)
   return {
     binaryPresent: binary.path !== null,
     binaryPath: binary.path,
@@ -298,6 +354,7 @@ export async function startLlamaCppServer(args: {
     }
   }
   if (initialStatus.state === 'ready') {
+    void fetchLlamaCppContextSize(host)
     return { ok: true, alreadyRunning: true }
   }
   if (initialStatus.state === 'different') {
@@ -377,7 +434,10 @@ export async function startLlamaCppServer(args: {
     pollMs: args.pollMs ?? 500,
     childFailure: () => childFailure,
   })
-  if (ready.ok) return { ok: true, alreadyRunning: false }
+  if (ready.ok) {
+    void fetchLlamaCppContextSize(host)
+    return { ok: true, alreadyRunning: false }
+  }
   if (ready.code === 'readiness-timeout') {
     return startFailure('readiness-timeout', { detail: capture() })
   }

package/src/models/llamacppPreflight.ts

@@ -1,4 +1,5 @@
 import {
+  fetchLlamaCppContextSize,
   startLlamaCppServer,
   stopLlamaCppServer,
   type LlamaCppStartFailureCode,
@@ -64,7 +65,10 @@ export async function ensureLlamaCppRunnerReady(
         servedModels: probe.models,
       }
     }
-    if (!local.mmprojPath) return { ok: true, alreadyRunning: true }
+    if (!local.mmprojPath) {
+      void fetchLlamaCppContextSize(llamaCppServerHostFromBaseUrl(baseUrl))
+      return { ok: true, alreadyRunning: true }
+    }
     await (deps.stopServer ?? stopLlamaCppServer)().catch(() => null)
   }
 

package/src/runtime/compaction.ts

@@ -1,6 +1,7 @@
 import type { Message, Provider } from '../providers/contracts.js'
 import { approximateTokens, messageTextContent } from '../utils/messages.js'
 import type { SessionMessage } from '../storage/sessions.js'
+import { getCachedLlamaCppContextSize } from '../models/llamacpp.js'
 
 const COMPACT_SYSTEM = `Create a continuation handoff for this coding-agent conversation.
 Keep it concise but complete. Preserve the current goal, user constraints, key decisions, relevant files, tool results, pending tasks, and known failures. Do not claim unverified work was completed. No preamble.`
@@ -17,8 +18,7 @@ const CLOUD_MESSAGE_CHAR_LIMIT = 2_000
 export type CompactionStage =
   | 'preparing transcript'
   | 'compressing long context'
-  | 'summarizing with local model'
-  | 'summarizing with provider'
+  | 'summarizing transcript'
 
 export type CompactTranscriptOptions = {
   signal?: AbortSignal
@@ -60,6 +60,12 @@ export function contextWindow(model: string): number {
 export function contextWindowInfo(provider: string, model: string): ContextWindowInfo {
   const lower = model.toLowerCase()
   const providerLower = provider.toLowerCase()
+  if (providerLower === 'llamacpp') {
+    const cached = getCachedLlamaCppContextSize()
+    if (cached) {
+      return { tokens: cached, confidence: 'exact', source: 'llama.cpp /props' }
+    }
+  }
   if (lower.startsWith('qwen3:4b') || lower.startsWith('qwen3:30b') || lower.startsWith('qwen3:235b')) {
     return { tokens: 256_000, confidence: 'inferred', source: 'qwen3 long-context tag' }
   }
@@ -138,7 +144,7 @@ export async function compactTranscript(
   const signal = options.signal ?? controller!.signal
   let summary = ''
   const local = isLocalProviderId(provider.id)
-  options.onStage?.(local ? 'summarizing with local model' : 'summarizing with provider')
+  options.onStage?.('summarizing transcript')
   try {
     for await (const ev of provider.complete(prompt, signal, {
       maxTokens: options.maxOutputTokens ?? (local ? LOCAL_COMPACTION_OUTPUT_TOKENS : CLOUD_COMPACTION_OUTPUT_TOKENS),
@@ -168,7 +174,7 @@ export function buildCompactionSource(
   const nonSystem = transcript.filter(m => m.role !== 'system')
   const local = isLocalProviderId(providerId)
   const tokenBudget = options.maxInputTokens ?? (local ? LOCAL_COMPACTION_INPUT_TOKENS : CLOUD_COMPACTION_INPUT_TOKENS)
-  const charBudget = Math.max(1_000, tokenBudget * 4)
+  const charBudget = Math.max(1_000, tokenBudget * 3)
   const recentMessageCount = local ? LOCAL_RECENT_MESSAGE_COUNT : CLOUD_RECENT_MESSAGE_COUNT
   const messageCharLimit = local ? LOCAL_MESSAGE_CHAR_LIMIT : CLOUD_MESSAGE_CHAR_LIMIT
   const rawTokenEstimate = approximateTokens(nonSystem)
@@ -385,5 +391,5 @@ function limitCompactionText(text: string, charBudget: number): string {
 }
 
 function approximateTextTokens(text: string): number {
-  return Math.ceil(text.length / 4)
+  return Math.ceil(text.length / 3)
 }

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/messages.ts

@@ -33,5 +33,5 @@ export function blocksToText(blocks: MessageContentBlock[]): string {
 export function approximateTokens(messages: Message[]): number {
   let chars = 0
   for (const m of messages) chars += messageTextContent(m).length
-  return Math.ceil(chars / 4)
+  return Math.ceil(chars / 3)
 }

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,