ethagent 3.2.0 → 3.3.0

package/README.md

@@ -5,8 +5,8 @@ A privacy-first AI agent with a portable Ethereum identity.
 Switch providers or machines and the AI agent you customized stays behind. `ethagent` ties the agent to a wallet you own, so its soul, memory, and skills follow you across providers, machines, and models.
 
 - **Portable.** The ERC-8004 token is the agent's durable identity. Use the ENS name as a readable handle, or the token ID plus chain as the permanent reference, to restore the same agent anywhere.
-- **Private.** Soul and memory are encrypted before they are pinned to IPFS. The wallet signature used to unlock them stays local and never submits a transaction, spends funds, or grants token approval.
-- **Public.** The agent URI points to plain JSON for the Agent Card and public skills, so other agents can discover capabilities through ERC-8004 and IPFS.
+- **Private.** Soul, memory, and skills are encrypted before they are pinned to IPFS. The wallet signature used to unlock them stays local and never submits a transaction, spends funds, or grants token approval.
+- **Public.** The agent URI points to a public metadata payload on IPFS that includes the Agent Card, so other agents can discover the agent's capabilities through ERC-8004.
 
 <details>
 <summary><strong>Glossary</strong> (click to expand)</summary>
@@ -16,9 +16,9 @@ Switch providers or machines and the AI agent you customized stays behind. `etha
 | Owner Wallet | Holds and controls the ERC-8004 agent token. Signs custody changes and, in Simple custody, every URI rotation. |
 | Operator Wallet | Additional wallet authorized to rotate the onchain URI on behalf of the owner. Used in Advanced custody. Never receives token approval. |
 | Vault | Immutable per-agent custody contract used in Advanced custody. Holds at most one ERC-8004 token. |
-| Snapshot | Encrypted bundle of SOUL.md, MEMORY.md, and session state. Pinned to IPFS; decrypts only against the owner wallet's signature. |
-| Agent URI | IPFS URI stored in the ERC-8004 `tokenURI`. Resolves to the agent's published metadata. |
-| Agent Card | Public JSON describing the agent: name, description, capabilities, and skills. Other agents fetch it for discovery. |
+| Snapshot | Encrypted bundle of SOUL.md, MEMORY.md, the skills/ tree, and session state. Pinned to IPFS; decrypts only against the owner wallet's signature. |
+| Agent URI | IPFS URI stored in the ERC-8004 `tokenURI`. Resolves to a public metadata payload that references the Agent Card. |
+| Agent Card | Public JSON describing the agent: name, description, capabilities, and skills. Pinned on IPFS and linked from the agent URI; other agents fetch it for discovery. |
 
 </details>
 
@@ -48,12 +48,12 @@ Once running:
 
 The Identity Hub manages everything portable about the agent:
 
-- **Public Profile** edits name, description, icon, and the Agent Card.
+- **Public Profile** edits name, description, and icon: what other agents see in the Agent Card.
 - **ENS Name** links the agent to a subdomain under a parent name the owner wallet controls.
 - **Custody Mode** switches between Simple and Advanced by depositing the token into its Vault or unwrapping it back out.
-- **Prepare Transfer** stages a dual-wallet snapshot before sending the token externally.
+- **Prepare Transfer** stages a dual-wallet snapshot so the receiver can restore the agent after the token moves externally.
 - **Refetch Latest** pulls the most recent published snapshot back to local files.
-- **Load Agent** accepts either an ENS name or a bare token ID, and loads any agent owned by or linked to the connected wallet.
+- **Switch Agent** accepts either an ENS name or a bare token ID, and loads any agent owned by or linked to the connected wallet.
 
 The menu surfaces drift automatically. Token ownership, vault state, ENS record alignment, and pending URI rotations are checked against the live chain when the menu opens.
 
@@ -61,16 +61,15 @@ Every agent has a continuity directory at `~/.ethagent/continuity`.
 
 ## Continuity
 
-Each agent's continuity directory holds a small set of files. Private files are encrypted before they ever reach IPFS; public files are plain JSON so other agents can discover what the agent does.
+Each agent's continuity directory holds a small set of private files. They are encrypted before they ever reach IPFS.
 
 | File | Visibility | Purpose |
 | --- | --- | --- |
 | `SOUL.md` | Private | Soul, boundaries, standing instructions, and identity framing. |
 | `MEMORY.md` | Private | Durable preferences, project context, decisions, and operating notes. |
-| `skills/` | Private | Skill folders. The SKILL.md body never leaves your machine. The visibility flag only controls whether the skill's name and description get indexed in `skills.json`. New skills default to public. |
-| `skills.json` | Public | Machine-readable capabilities derived from public skills. |
+| `skills/` | Private | Skill folders. The SKILL.md body never leaves your machine. The visibility flag only controls whether the skill's name and description get listed in the Agent Card. New skills default to public. |
 
-`SOUL.md`, `MEMORY.md`, and each `SKILL.md` are plain Markdown you edit through the Identity Hub under Continuity. Skill frontmatter (name, description, when_to_use, visibility, tags) tells the agent when to load it. The body stays local; `visibility: public` indexes the name and description in `skills.json` and the Agent Card.
+`SOUL.md`, `MEMORY.md`, and each `SKILL.md` are plain Markdown you edit through the Identity Hub under Continuity. Skill frontmatter (name, description, when_to_use, visibility, tags) tells the agent when to load it. The body stays local; `visibility: public` lists the name and description in the Agent Card.
 
 - **Save Snapshot Now** encrypts the private files, pins them to IPFS, and rotates the onchain pointer to the new CID.
 - **Refetch Latest** reads the pointer back, signs the decrypt challenge with your wallet, and overwrites local files from the snapshot.
@@ -103,7 +102,7 @@ Save the token ID + network somewhere safe. ENS records can be cleared and rebui
 - Sender signs snapshot access, receiver signs restore access.
 - Sender publishes the snapshot pointer to the agent URI.
 - The actual transfer happens externally afterwards, in whichever wallet UI you prefer.
-- Once the token has moved, the receiver opens **Load Agent** with the receiving wallet and restores the same agent from the published snapshot.
+- Once the token has moved, the receiver opens **Switch Agent** with the receiving wallet and restores the same agent from the published snapshot.
 
 The token transfer flow prepares decrypt access and agent URI pointers only. It does not initiate the transfer and does not request approval over the token.
 
@@ -136,8 +135,8 @@ Vision support is available on:
 
 ## Privacy
 
-- **Public:** token ownership, the agent URI payload, public discovery files, and IPFS CIDs.
-- **Private:** plaintext `SOUL.md`, plaintext `MEMORY.md`, sessions, prompt history, API keys, local permissions, and the wallet signatures used for decryption.
+- **Public:** token ownership, the agent URI, the Agent Card it references, and IPFS CIDs.
+- **Private:** plaintext `SOUL.md`, plaintext `MEMORY.md`, the local skills/ tree, sessions, prompt history, API keys, local permissions, and the wallet signatures used for decryption.
 - Snapshots use a wallet signature as unlock material. The signature does not submit a transaction, spend funds, or grant token approval.
 - The transfer flow writes a snapshot pointer and stops; it never approves or moves the token.
 - `ethagent reset` deletes local ethagent data from the current machine while preserving installed local model assets. It does not burn or transfer tokens, remove public IPFS content, or mutate the onchain agent URI. Run **Save Snapshot Now** before resetting if local edits should become the recoverable state.
@@ -150,7 +149,7 @@ Vision support is available on:
 | Model | Cloud provider or local GGUF runner. |
 | Identity | ERC-8004 token owned by the wallet. |
 | Continuity | Private files encrypted before IPFS pinning. |
-| Discovery | Public `skills.json`, Agent Card, services, and the current agent URI payload. |
+| Discovery | The agent URI and the Agent Card it points to. |
 | Recovery | Refetch the current agent URI, decrypt the latest snapshot, and restore local files. |
 
 The ERC-8004 token is the durable handle. The machine, model, and local session all change around it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethagent",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "A privacy-first AI agent with a portable Ethereum identity",
   "type": "module",
   "main": "bin/ethagent.js",

package/src/identity/continuity/history.ts

@@ -6,7 +6,7 @@ import type { ContinuityFiles } from './envelope.js'
 import {
   continuityVaultRef,
   ensureContinuityVault,
-  writePublicSkillsFile,
+  writeAgentCardFile,
   writeContinuityFiles,
   type PrivateContinuityFile,
 } from './storage.js'
@@ -20,7 +20,7 @@ type PrivateContinuityHistorySnapshot = {
   existedBefore: boolean
   previousContent: string
   previousFiles?: ContinuityFiles
-  previousPublicSkills?: string
+  previousAgentCard?: string
   changeSummary: string
   identity: {
     address: string
@@ -42,7 +42,7 @@ type RecordPrivateContinuityHistoryInput = {
   existedBefore: boolean
   previousContent: string
   previousFiles?: ContinuityFiles
-  previousPublicSkills?: string
+  previousAgentCard?: string
   changeSummary: string
   createdAt?: string
   sessionId?: string
@@ -69,7 +69,7 @@ export async function recordPrivateContinuityHistorySnapshot(
     existedBefore: input.existedBefore,
     previousContent: input.previousContent,
     ...(input.previousFiles ? { previousFiles: input.previousFiles } : {}),
-    ...(input.previousPublicSkills !== undefined ? { previousPublicSkills: input.previousPublicSkills } : {}),
+    ...(input.previousAgentCard !== undefined ? { previousAgentCard: input.previousAgentCard } : {}),
     changeSummary: input.changeSummary,
     identity: {
       address: input.identity.address,
@@ -125,8 +125,8 @@ export async function restorePrivateContinuityHistorySnapshot(
 
   if (snapshot.previousFiles) {
     await writeContinuityFiles(identity, snapshot.previousFiles)
-    if (snapshot.previousPublicSkills !== undefined) {
-      await writePublicSkillsFile(identity, snapshot.previousPublicSkills)
+    if (snapshot.previousAgentCard !== undefined) {
+      await writeAgentCardFile(identity, snapshot.previousAgentCard)
     }
     return snapshot
   }
@@ -137,8 +137,8 @@ export async function restorePrivateContinuityHistorySnapshot(
   } else {
     await fs.rm(snapshot.filePath, { force: true })
   }
-  if (snapshot.previousPublicSkills !== undefined) {
-    await writePublicSkillsFile(identity, snapshot.previousPublicSkills)
+  if (snapshot.previousAgentCard !== undefined) {
+    await writeAgentCardFile(identity, snapshot.previousAgentCard)
   }
   return snapshot
 }

package/src/identity/continuity/publicSkills.ts

@@ -68,29 +68,7 @@ export function defaultPublicSkillsProfile(identity: EthagentIdentity): PublicSk
     version: '1.0.0',
     ...(agentWallet ? { agentWallet } : {}),
     ...(imageUrl ? { imageUrl } : {}),
-    skills: [
-      {
-        id: 'software-engineering',
-        name: 'Software engineering',
-        description: 'Read code, plan implementations, debug failures, refactor safely, and run focused tests.',
-        inputModes: ['text/markdown'],
-        outputModes: ['text/markdown'],
-      },
-      {
-        id: 'workspace-tools',
-        name: 'Workspace tools',
-        description: 'Use permissioned local file, shell, clipboard, and MCP tools for project work.',
-        inputModes: ['text/markdown'],
-        outputModes: ['text/markdown', 'application/json'],
-      },
-      {
-        id: 'ethereum-identity',
-        name: 'Ethereum identity',
-        description: 'Represent a portable ERC-8004 agent identity controlled by the owner wallet.',
-        inputModes: ['text/markdown'],
-        outputModes: ['text/markdown', 'application/json'],
-      },
-    ],
+    skills: [],
   }
 }
 
@@ -129,61 +107,6 @@ function uniqueSkillId(base: string, used: Set<string>): string {
   return `${slug}-${i}`
 }
 
-export function renderPublicSkillsJson(profile: PublicSkillsProfile): string {
-  const inputModes = unique(profile.skills.flatMap(skill => skill.inputModes))
-  const outputModes = unique(profile.skills.flatMap(skill => skill.outputModes))
-  const summary = {
-    schema: 'ethagent.public-skills.v1',
-    producer: ETHAGENT_PRODUCER,
-    ...(profile.agentWallet ? { agent_wallet: profile.agentWallet } : {}),
-    visibility: 'public',
-    name: profile.name,
-    description: profile.description,
-    version: profile.version,
-    ...(profile.imageUrl ? { imageUrl: profile.imageUrl } : {}),
-    inputModes,
-    outputModes,
-    boundary: 'Public discovery only. This is not executable code, private memory, or a skill installation manifest.',
-    capabilities: {
-      softwareEngineering: true,
-      workspaceTools: 'permissioned',
-      mcp: true,
-      streaming: true,
-      ethereumIdentity: 'ERC-8004',
-      encryptedContinuity: true,
-    },
-    delegation: {
-      bestFor: [
-        'code reading',
-        'implementation planning',
-        'debugging',
-        'refactors',
-        'tests',
-        'workspace automation',
-      ],
-      requiresApprovalFor: [
-        'workspace edits',
-        'shell commands',
-        'private continuity changes',
-      ],
-    },
-    privacy: {
-      publicOnly: true,
-      includesPrivateMemory: false,
-      includesExecutableCode: false,
-      includesSecrets: false,
-    },
-    skills: profile.skills.map(skill => ({
-      id: skill.id,
-      name: skill.name,
-      description: skill.description,
-      inputModes: skill.inputModes,
-      outputModes: skill.outputModes,
-    })),
-  }
-  return `${JSON.stringify(summary, null, 2)}\n`
-}
-
 export function createAgentCard(profile: PublicSkillsProfile, url?: string): AgentCard {
   const inputModes = unique(profile.skills.flatMap(skill => skill.inputModes))
   const outputModes = unique(profile.skills.flatMap(skill => skill.outputModes))
@@ -192,7 +115,7 @@ export function createAgentCard(profile: PublicSkillsProfile, url?: string): Age
     description: profile.description,
     version: profile.version,
     ...(profile.agentWallet ? { agent_wallet: profile.agentWallet } : {}),
-    protocolVersion: '0.2.6',
+    protocolVersion: '0.3.0',
     ...(url ? { url } : {}),
     ...(profile.imageUrl ? { image: profile.imageUrl } : {}),
     defaultInputModes: inputModes.length ? inputModes : ['text/markdown'],

package/src/identity/continuity/skills/publicSkillsSync.ts

@@ -2,8 +2,9 @@ import { atomicWriteText } from '../../../storage/atomicWrite.js'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import {
   appendPublicSkillEntries,
+  createAgentCard,
   defaultPublicSkillsProfile,
-  renderPublicSkillsJson,
+  serializeAgentCard,
 } from '../publicSkills.js'
 import { ensureContinuityVault, ensureTrailingNewline, readOrDefault } from '../storage/files.js'
 import { listSkills } from './loadSkills.js'
@@ -14,19 +15,19 @@ export async function derivePublicSkillEntries(identity: EthagentIdentity): Prom
   return entries.filter(entry => entry.visibility === 'public')
 }
 
-export async function renderPublicSkillsJsonForIdentity(identity: EthagentIdentity): Promise<string> {
+export async function renderAgentCardJsonForIdentity(identity: EthagentIdentity): Promise<string> {
   const publicEntries = await derivePublicSkillEntries(identity)
   const profile = appendPublicSkillEntries(defaultPublicSkillsProfile(identity), publicEntries)
-  return renderPublicSkillsJson(profile)
+  return serializeAgentCard(createAgentCard(profile))
 }
 
-export async function syncPublicSkillsManifest(identity: EthagentIdentity): Promise<string> {
+export async function syncAgentCardManifest(identity: EthagentIdentity): Promise<string> {
   const ref = await ensureContinuityVault(identity)
-  const next = await renderPublicSkillsJsonForIdentity(identity)
-  const current = await readOrDefault(ref.publicSkillsPath, '')
+  const next = await renderAgentCardJsonForIdentity(identity)
+  const current = await readOrDefault(ref.agentCardPath, '')
   if (current === ensureTrailingNewline(next) || current === next) {
     return current
   }
-  await atomicWriteText(ref.publicSkillsPath, ensureTrailingNewline(next), { mode: 0o644 })
+  await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(next), { mode: 0o644 })
   return next
 }

package/src/identity/continuity/snapshots.ts

@@ -17,7 +17,6 @@ type PublishedContinuitySnapshot = {
   metadataCid?: string
   agentUri?: string
   txHash?: string
-  publicSkillsCid?: string
   agentCardCid?: string
   contentHashes?: ContinuitySnapshotContentHashes
   label: string
@@ -55,8 +54,7 @@ export async function recordPublishedContinuitySnapshot(
     ...(backup.metadataCid ? { metadataCid: backup.metadataCid } : {}),
     ...(backup.agentUri ? { agentUri: backup.agentUri } : {}),
     ...(backup.txHash ? { txHash: backup.txHash } : {}),
-    ...(input.identity.publicSkills?.cid ? { publicSkillsCid: input.identity.publicSkills.cid } : {}),
-    ...(input.identity.publicSkills?.agentCardCid ? { agentCardCid: input.identity.publicSkills.agentCardCid } : {}),
+    ...(input.identity.agentCard?.cid ? { agentCardCid: input.identity.agentCard.cid } : {}),
     ...(contentHashes ? { contentHashes } : {}),
     label: input.label ?? 'published encrypted snapshot',
     identity: {
@@ -129,7 +127,6 @@ function enrichPublishedSnapshot(
     ...(snapshot.metadataCid ? {} : current.metadataCid ? { metadataCid: current.metadataCid } : {}),
     ...(snapshot.agentUri ? {} : current.agentUri ? { agentUri: current.agentUri } : {}),
     ...(snapshot.txHash ? {} : current.txHash ? { txHash: current.txHash } : {}),
-    ...(snapshot.publicSkillsCid ? {} : current.publicSkillsCid ? { publicSkillsCid: current.publicSkillsCid } : {}),
     ...(snapshot.agentCardCid ? {} : current.agentCardCid ? { agentCardCid: current.agentCardCid } : {}),
     ...(snapshot.contentHashes ? {} : current.contentHashes ? { contentHashes: current.contentHashes } : {}),
   }
@@ -141,8 +138,7 @@ function refreshPublishedSnapshotSidecars(
 ): PublishedContinuitySnapshot {
   return {
     ...snapshot,
-    ...(identity.publicSkills?.cid ? { publicSkillsCid: identity.publicSkills.cid } : {}),
-    ...(identity.publicSkills?.agentCardCid ? { agentCardCid: identity.publicSkills.agentCardCid } : {}),
+    ...(identity.agentCard?.cid ? { agentCardCid: identity.agentCard.cid } : {}),
   }
 }
 
@@ -180,8 +176,7 @@ function currentPublishedSnapshot(identity: EthagentIdentity): PublishedContinui
     ...(backup.metadataCid ? { metadataCid: backup.metadataCid } : {}),
     ...(backup.agentUri ? { agentUri: backup.agentUri } : {}),
     ...(backup.txHash ? { txHash: backup.txHash } : {}),
-    ...(identity.publicSkills?.cid ? { publicSkillsCid: identity.publicSkills.cid } : {}),
-    ...(identity.publicSkills?.agentCardCid ? { agentCardCid: identity.publicSkills.agentCardCid } : {}),
+    ...(identity.agentCard?.cid ? { agentCardCid: identity.agentCard.cid } : {}),
     label: 'current published snapshot',
     identity: {
       address: identity.address,

package/src/identity/continuity/storage/defaults.ts

@@ -1,6 +1,6 @@
 import type { EthagentIdentity } from '../../../storage/config.js'
 import type { ContinuityAgentSnapshot, ContinuityFiles } from '../envelope.js'
-import { defaultPublicSkillsProfile, renderPublicSkillsJson } from '../publicSkills.js'
+import { createAgentCard, defaultPublicSkillsProfile, serializeAgentCard } from '../publicSkills.js'
 import { renderPrivateIdentityBlock } from './markdown.js'
 
 export function continuityAgentSnapshot(identity: EthagentIdentity): ContinuityAgentSnapshot {
@@ -87,6 +87,6 @@ export function defaultContinuityFiles(identity: EthagentIdentity, _now = new Da
   }
 }
 
-export function defaultPublicSkillsJson(identity: EthagentIdentity): string {
-  return renderPublicSkillsJson(defaultPublicSkillsProfile(identity))
+export function defaultAgentCardJson(identity: EthagentIdentity): string {
+  return serializeAgentCard(createAgentCard(defaultPublicSkillsProfile(identity)))
 }

package/src/identity/continuity/storage/paths.ts

@@ -8,7 +8,7 @@ export function continuityVaultRef(identity: Pick<EthagentIdentity, 'chainId' |
     dir,
     soulPath: path.join(dir, 'SOUL.md'),
     memoryPath: path.join(dir, 'MEMORY.md'),
-    publicSkillsPath: path.join(dir, 'skills.json'),
+    agentCardPath: path.join(dir, 'agent-card.json'),
     skillsDir: path.join(dir, 'skills'),
   }
 }

package/src/identity/continuity/storage/scaffold.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import { atomicWriteText } from '../../../storage/atomicWrite.js'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import type { ContinuityFiles, ContinuitySkillsTree } from '../envelope.js'
@@ -6,10 +8,10 @@ import {
   materializeSkillsTree,
 } from '../skills/loadSkills.js'
 import {
-  renderPublicSkillsJsonForIdentity,
-  syncPublicSkillsManifest,
+  renderAgentCardJsonForIdentity,
+  syncAgentCardManifest,
 } from '../skills/publicSkillsSync.js'
-import { defaultContinuityFiles, defaultPublicSkillsJson } from './defaults.js'
+import { defaultContinuityFiles, defaultAgentCardJson } from './defaults.js'
 import {
   ensureContinuityFiles,
   ensureContinuityVault,
@@ -24,14 +26,14 @@ import type { ContinuityVaultRef, IdentityMarkdownScaffold } from './types.js'
 
 export async function ensureIdentityMarkdownScaffold(
   identity: EthagentIdentity,
-  options: { publicSkillsFallback?: string | (() => Promise<string>) } = {},
+  options: { agentCardFallback?: string | (() => Promise<string>) } = {},
 ): Promise<IdentityMarkdownScaffold> {
   const privateFiles = await ensureContinuityFiles(identity)
-  const publicSkills = await ensurePublicSkillsFile(identity, { fallback: options.publicSkillsFallback })
-  const syncedPublic = await syncPublicSkillsManifest(identity).catch(() => publicSkills)
+  const agentCard = await ensureAgentCardFile(identity, { fallback: options.agentCardFallback })
+  const syncedCard = await syncAgentCardManifest(identity).catch(() => agentCard)
   return {
     ...privateFiles,
-    'skills.json': syncedPublic,
+    'agent-card.json': syncedCard,
   }
 }
 
@@ -43,7 +45,7 @@ export async function writeIdentityMarkdownScaffold(
     'SOUL.md': files['SOUL.md'],
     'MEMORY.md': files['MEMORY.md'],
   })
-  await writePublicSkillsFile(identity, files['skills.json'])
+  await writeAgentCardFile(identity, files['agent-card.json'])
   return ref
 }
 
@@ -57,7 +59,7 @@ export async function prepareSyncedIdentityMarkdownScaffold(identity: EthagentId
   await ensureIdentityMarkdownScaffold(identity)
   const privateFiles = await readContinuityFiles(identity)
   const privateDefaults = defaultContinuityFiles(identity)
-  const publicDefault = await renderPublicSkillsJsonForIdentity(identity)
+  const agentCardDefault = await renderAgentCardJsonForIdentity(identity)
   return {
     'SOUL.md': syncGeneratedMarkdown(privateFiles['SOUL.md'], privateDefaults['SOUL.md'], [
       { marker: 'identity' },
@@ -65,13 +67,13 @@ export async function prepareSyncedIdentityMarkdownScaffold(identity: EthagentId
     'MEMORY.md': syncGeneratedMarkdown(privateFiles['MEMORY.md'], privateDefaults['MEMORY.md'], [
       { marker: 'identity' },
     ]),
-    'skills.json': publicDefault,
+    'agent-card.json': agentCardDefault,
   }
 }
 
-export async function prepareSyncedPublicSkillsJson(identity: EthagentIdentity): Promise<string> {
-  await ensurePublicSkillsFile(identity)
-  return renderPublicSkillsJsonForIdentity(identity)
+export async function prepareSyncedAgentCardJson(identity: EthagentIdentity): Promise<string> {
+  await ensureAgentCardFile(identity)
+  return renderAgentCardJsonForIdentity(identity)
 }
 
 export async function prepareSyncedSkillsTree(identity: EthagentIdentity): Promise<ContinuitySkillsTree> {
@@ -87,30 +89,40 @@ export async function restoreSkillsTree(
 }
 
 
-export async function ensurePublicSkillsFile(
+export async function ensureAgentCardFile(
   identity: EthagentIdentity,
   options: { fallback?: string | (() => Promise<string>) } = {},
 ): Promise<string> {
   const ref = await ensureContinuityVault(identity)
-  if (await exists(ref.publicSkillsPath)) return readPublicSkillsFile(identity)
+  if (await exists(ref.agentCardPath)) return readAgentCardFile(identity)
 
-  const fallback = await resolvePublicSkillsFallback(identity, options.fallback)
-  await atomicWriteText(ref.publicSkillsPath, ensureTrailingNewline(fallback), { mode: 0o644 })
-  return readPublicSkillsFile(identity)
+  const legacyPath = path.join(ref.dir, 'skills.json')
+  if (await exists(legacyPath)) {
+    const legacyContent = await readOrDefault(legacyPath, '')
+    if (legacyContent) {
+      await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(legacyContent), { mode: 0o644 })
+    }
+    await fs.rm(legacyPath, { force: true })
+    if (await exists(ref.agentCardPath)) return readAgentCardFile(identity)
+  }
+
+  const fallback = await resolveAgentCardFallback(identity, options.fallback)
+  await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(fallback), { mode: 0o644 })
+  return readAgentCardFile(identity)
 }
 
-export async function readPublicSkillsFile(identity: EthagentIdentity): Promise<string> {
+export async function readAgentCardFile(identity: EthagentIdentity): Promise<string> {
   const ref = await ensureContinuityVault(identity)
-  return readOrDefault(ref.publicSkillsPath, defaultPublicSkillsJson(identity))
+  return readOrDefault(ref.agentCardPath, defaultAgentCardJson(identity))
 }
 
-export async function writePublicSkillsFile(identity: EthagentIdentity, content: string): Promise<ContinuityVaultRef> {
+export async function writeAgentCardFile(identity: EthagentIdentity, content: string): Promise<ContinuityVaultRef> {
   const ref = await ensureContinuityVault(identity)
-  await atomicWriteText(ref.publicSkillsPath, ensureTrailingNewline(content), { mode: 0o644 })
+  await atomicWriteText(ref.agentCardPath, ensureTrailingNewline(content), { mode: 0o644 })
   return ref
 }
 
-async function resolvePublicSkillsFallback(
+async function resolveAgentCardFallback(
   identity: EthagentIdentity,
   fallback: string | (() => Promise<string>) | undefined,
 ): Promise<string> {
@@ -119,8 +131,8 @@ async function resolvePublicSkillsFallback(
     try {
       return await fallback()
     } catch {
-      return defaultPublicSkillsJson(identity)
+      return defaultAgentCardJson(identity)
     }
   }
-  return defaultPublicSkillsJson(identity)
+  return defaultAgentCardJson(identity)
 }

package/src/identity/continuity/storage/status.ts

@@ -2,10 +2,10 @@ import { createHash } from 'node:crypto'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import type { ContinuityFiles, ContinuitySkillsTree } from '../envelope.js'
 import { loadSkillsTree } from '../skills/loadSkills.js'
-import { syncPublicSkillsManifest } from '../skills/publicSkillsSync.js'
+import { syncAgentCardManifest } from '../skills/publicSkillsSync.js'
 import { continuityVaultRef } from './paths.js'
 import { exists, readContinuityFiles, statIfExists } from './files.js'
-import { readPublicSkillsFile } from './scaffold.js'
+import { readAgentCardFile } from './scaffold.js'
 import type { ContinuityPublishState, ContinuitySnapshotContentHashes, ContinuityVaultRef, ContinuityWorkingTreeStatus } from './types.js'
 
 export async function continuityVaultStatus(identity: EthagentIdentity): Promise<{ ready: boolean; files: ContinuityVaultRef }> {
@@ -22,7 +22,7 @@ export async function continuityWorkingTreeStatus(
   const stats = await Promise.all([
     statIfExists(ref.soulPath),
     statIfExists(ref.memoryPath),
-    statIfExists(ref.publicSkillsPath),
+    statIfExists(ref.agentCardPath),
   ])
   const newestMs = Math.max(0, ...stats.flatMap(stat => stat ? [stat.mtimeMs] : []))
   const ready = Boolean(stats[0] && stats[1])
@@ -54,30 +54,30 @@ export async function localContinuitySnapshotContentHashes(
   identity: EthagentIdentity,
 ): Promise<ContinuitySnapshotContentHashes> {
   const privateFiles = await readContinuityFiles(identity)
-  await syncPublicSkillsManifest(identity).catch(() => undefined)
-  const publicSkills = await readPublicSkillsFile(identity)
+  await syncAgentCardManifest(identity).catch(() => undefined)
+  const agentCard = await readAgentCardFile(identity)
   const skills = await loadSkillsTree(identity).catch(() => ({} as ContinuitySkillsTree))
-  return continuitySnapshotContentHashes(privateFiles, publicSkills, skills)
+  return continuitySnapshotContentHashes(privateFiles, agentCard, skills)
 }
 
 export function continuitySnapshotContentHashesFromSources(args: {
   privateFiles: ContinuityFiles
-  publicSkills: string
+  agentCard: string
   skills: ContinuitySkillsTree
 }): ContinuitySnapshotContentHashes {
-  return continuitySnapshotContentHashes(args.privateFiles, args.publicSkills, args.skills)
+  return continuitySnapshotContentHashes(args.privateFiles, args.agentCard, args.skills)
 }
 
 function continuitySnapshotContentHashes(
   privateFiles: ContinuityFiles,
-  publicSkills: string,
+  agentCard: string,
   skills: ContinuitySkillsTree,
 ): ContinuitySnapshotContentHashes {
   const skillsHash = hashSkillsTree(skills)
   return {
     'SOUL.md': hashContinuitySnapshotContent(privateFiles['SOUL.md']),
     'MEMORY.md': hashContinuitySnapshotContent(privateFiles['MEMORY.md']),
-    'skills.json': hashContinuitySnapshotContent(publicSkills),
+    'agent-card.json': hashContinuitySnapshotContent(agentCard),
     ...(skillsHash ? { 'private-skills': skillsHash } : {}),
   }
 }
@@ -101,7 +101,7 @@ function equalContinuitySnapshotHashes(
 ): boolean {
   if (a['SOUL.md'] !== b['SOUL.md']) return false
   if (a['MEMORY.md'] !== b['MEMORY.md']) return false
-  if (a['skills.json'] !== b['skills.json']) return false
+  if (a['agent-card.json'] !== b['agent-card.json']) return false
   return a['private-skills'] === b['private-skills']
 }
 

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

@@ -7,16 +7,16 @@ export type ContinuityVaultRef = {
   dir: string
   soulPath: string
   memoryPath: string
-  publicSkillsPath: string
+  agentCardPath: string
   skillsDir: string
 }
 
 export type IdentityMarkdownScaffold = ContinuityFiles & {
-  'skills.json': string
+  'agent-card.json': string
 }
 
-export type ContinuitySnapshotFile = PrivateContinuityFile | 'skills.json' | 'private-skills'
-export type ContinuitySnapshotContentHashes = Partial<Record<ContinuitySnapshotFile, string>> & Record<PrivateContinuityFile | 'skills.json', string>
+export type ContinuitySnapshotFile = PrivateContinuityFile | 'agent-card.json' | 'private-skills'
+export type ContinuitySnapshotContentHashes = Partial<Record<ContinuitySnapshotFile, string>> & Record<PrivateContinuityFile | 'agent-card.json', string>
 export type ContinuityPublishState = 'not-restored' | 'not-published' | 'verify-needed' | 'local-changes' | 'published'
 export type ContinuityWorkingTreeStatus = {
   ready: boolean

package/src/identity/continuity/storage.ts

@@ -17,15 +17,15 @@ export {
 export { continuityAgentSnapshot, defaultContinuityFiles } from './storage/defaults.js'
 export {
   ensureIdentityMarkdownScaffold,
-  ensurePublicSkillsFile,
+  ensureAgentCardFile,
   prepareSyncedIdentityMarkdownScaffold,
   prepareSyncedSkillsTree,
-  prepareSyncedPublicSkillsJson,
-  readPublicSkillsFile,
+  prepareSyncedAgentCardJson,
+  readAgentCardFile,
   restoreSkillsTree,
   syncIdentityMarkdownScaffold,
   writeIdentityMarkdownScaffold,
-  writePublicSkillsFile,
+  writeAgentCardFile,
 } from './storage/scaffold.js'
 export {
   continuityVaultStatus,