ethagent 2.4.0 → 3.0.0

package/src/identity/hub/continuity/skills/SkillsTreeScreen.tsx

@@ -0,0 +1,213 @@
+import React, { useEffect, useState } from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../../../../ui/Surface.js'
+import { Select, type SelectOption } from '../../../../ui/Select.js'
+import { theme } from '../../../../ui/theme.js'
+import type { EthagentConfig, EthagentIdentity } from '../../../../storage/config.js'
+import {
+  listSkillsTree,
+  type SkillsTreeView,
+} from '../../../continuity/skills/loadSkills.js'
+import type { SkillIndexEntry } from '../../../continuity/skills/types.js'
+import { IdentitySummary } from '../../shared/components/IdentitySummary.js'
+import type { ContinuityWorkingTreeStatus } from '../../../continuity/storage.js'
+
+type SkillsTreeAction =
+  | { kind: 'skill'; relativePath: string }
+  | { kind: 'new' }
+  | { kind: 'delete' }
+  | { kind: 'visibility' }
+  | { kind: 'view-manifest' }
+  | { kind: 'open-folder' }
+  | { kind: 'noop' }
+  | { kind: 'back' }
+
+interface SkillsTreeScreenProps {
+  identity?: EthagentIdentity
+  config?: EthagentConfig
+  workingStatus?: ContinuityWorkingTreeStatus | null
+  notice?: string
+  editorOpened?: boolean
+  footer: React.ReactNode
+  onOpenSkill: (relativePath: string) => void
+  onNewSkill: () => void
+  onDelete: () => void
+  onVisibility: () => void
+  onViewPublicManifest: () => void
+  onOpenFolder: () => void
+  onBack: () => void
+}
+
+export const SkillsTreeScreen: React.FC<SkillsTreeScreenProps> = ({
+  identity,
+  config,
+  workingStatus,
+  notice,
+  editorOpened,
+  footer,
+  onOpenSkill,
+  onNewSkill,
+  onDelete,
+  onVisibility,
+  onViewPublicManifest,
+  onOpenFolder,
+  onBack,
+}) => {
+  const [tree, setTree] = useState<SkillsTreeView | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) {
+      setTree({ skills: [], supportingCounts: {} })
+      return () => { cancelled = true }
+    }
+    const refresh = (): Promise<void> => listSkillsTree(identity)
+      .then(view => {
+        if (cancelled) return
+        setTree(view)
+        setError(null)
+      })
+      .catch(err => {
+        if (cancelled) return
+        setTree({ skills: [], supportingCounts: {} })
+        setError(String((err as Error).message ?? err))
+      })
+    void refresh()
+    if (!editorOpened) return () => { cancelled = true }
+    const interval = setInterval(() => { void refresh() }, 1500)
+    return () => {
+      cancelled = true
+      clearInterval(interval)
+    }
+  }, [identity, editorOpened])
+
+  const subtitle = notice ?? 'Open a skill, create one, or remove one.'
+  const isLoading = tree === null
+  const skills = tree?.skills ?? []
+  const supportingCounts = tree?.supportingCounts ?? {}
+  const hasAny = skills.length > 0
+
+  const options = buildOptions(skills, supportingCounts, isLoading, hasAny)
+
+  return (
+    <Surface title="Skills" subtitle={subtitle} footer={footer}>
+      <IdentitySummary identity={identity} config={config} workingStatus={workingStatus} />
+      {error && (
+        <Box marginTop={1}>
+          <Text color={theme.accentError}>{error}</Text>
+        </Box>
+      )}
+      {editorOpened && (
+        <Box marginTop={1}>
+          <Text color={theme.accentPeriwinkle}>Save with ctrl+s in your editor</Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Select<SkillsTreeAction>
+          options={options}
+          hintLayout="inline"
+          onSubmit={choice => {
+            if (choice.kind === 'skill') return onOpenSkill(choice.relativePath)
+            if (choice.kind === 'new') return onNewSkill()
+            if (choice.kind === 'delete') return onDelete()
+            if (choice.kind === 'visibility') return onVisibility()
+            if (choice.kind === 'view-manifest') return onViewPublicManifest()
+            if (choice.kind === 'open-folder') return onOpenFolder()
+            if (choice.kind === 'back') return onBack()
+          }}
+          onCancel={onBack}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+function buildOptions(
+  entries: SkillIndexEntry[],
+  supportingCounts: Record<string, number>,
+  isLoading: boolean,
+  hasAny: boolean,
+): Array<SelectOption<SkillsTreeAction>> {
+  const rows: Array<SelectOption<SkillsTreeAction>> = []
+  const noopValue: SkillsTreeAction = { kind: 'noop' }
+
+  if (isLoading) {
+    rows.push({
+      value: noopValue,
+      role: 'notice',
+      label: 'Loading...',
+      labelColor: theme.dim,
+      indent: 0,
+    })
+  } else if (!hasAny) {
+    rows.push({ value: noopValue, role: 'section', label: 'Catalog' })
+    rows.push({ value: noopValue, role: 'notice', label: 'skills/', labelColor: theme.dim, indent: 3 })
+    rows.push({ value: noopValue, role: 'notice', label: '└── <skill>/', labelColor: theme.dim, indent: 3 })
+    rows.push({ value: noopValue, role: 'notice', label: '    └── SKILL.md', labelColor: theme.dim, indent: 3 })
+  } else {
+    rows.push({ value: noopValue, role: 'section', label: 'Catalog' })
+    rows.push({ value: noopValue, role: 'notice', label: 'skills/', labelColor: theme.dim, indent: 3 })
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name))
+    for (let i = 0; i < sorted.length; i++) {
+      const skill = sorted[i]
+      if (!skill) continue
+      const isLast = i === sorted.length - 1
+      const branch = isLast ? '└── ' : '├── '
+      const supportCount = supportingCounts[skill.name] ?? 0
+      const meta = [capitalize(skill.visibility)]
+      if (supportCount > 0) meta.push(`${supportCount + 1} files`)
+      rows.push({
+        value: { kind: 'skill', relativePath: skill.relativePath },
+        label: `${branch}${skill.name}/SKILL.md`,
+        hint: meta.join('  ·  '),
+        indent: 3,
+      })
+    }
+  }
+
+  rows.push({ value: noopValue, role: 'notice', label: '' })
+  rows.push({ value: noopValue, role: 'section', label: 'Manage' })
+  rows.push({
+    value: { kind: 'new' },
+    label: 'New Skill',
+    hint: 'Scaffold a new skill folder with SKILL.md',
+  })
+  if (hasAny) {
+    rows.push({
+      value: { kind: 'delete' },
+      label: 'Delete Skill',
+      hint: 'Remove a skill folder and all its supporting files',
+    })
+    rows.push({
+      value: { kind: 'visibility' },
+      label: 'Change Visibility',
+      hint: 'Toggle public, discoverable, or private',
+    })
+  }
+  rows.push({ value: noopValue, role: 'section', label: 'Inspect' })
+  rows.push({
+    value: { kind: 'view-manifest' },
+    label: 'Edit skills.json',
+    hint: 'Open skills.json in your editor',
+  })
+  rows.push({
+    value: { kind: 'open-folder' },
+    label: 'Open Skills Folder',
+    hint: 'Reveal skills/ in your file manager',
+  })
+  rows.push({ value: noopValue, role: 'section', label: 'Navigation' })
+  rows.push({
+    value: { kind: 'back' },
+    label: 'Back',
+    hint: 'Return to Identity Hub menu',
+    role: 'utility',
+  })
+
+  return rows
+}
+
+function capitalize(value: string): string {
+  if (!value) return value
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}

package/src/identity/hub/continuity/snapshot.ts

@@ -12,6 +12,7 @@ import {
   continuityAgentSnapshot,
   defaultContinuityFiles,
 } from '../../continuity/storage.js'
+import type { ContinuitySkillsTree } from '../../continuity/envelope.js'
 import type { Erc8004RegistryConfig, EthagentOperatorsPointer } from '../../registry/erc8004.js'
 import { readOwnerAddressField } from '../../identityCompat.js'
 import { readCustodyMode } from '../custody/state.js'
@@ -206,6 +207,7 @@ export function createContinuityEnvelopeForSave(args: {
   walletSignature: string
   state: Record<string, unknown>
   files: ReturnType<typeof defaultContinuityFiles>
+  skills?: ContinuitySkillsTree
   walletAccess: WalletRestoreAccessContext
   challengePurpose?: WalletChallengePurpose
 }): ContinuitySnapshotEnvelope {
@@ -259,6 +261,7 @@ export function createContinuityEnvelopeForSave(args: {
     payload: {
       agent: continuityAgentSnapshot(args.identity),
       files: args.files,
+      ...(args.skills && Object.keys(args.skills).length > 0 ? { skills: args.skills } : {}),
       transcript: [],
       state: args.state,
     },

package/src/identity/hub/continuity/state.ts

@@ -20,13 +20,14 @@ export function changedContinuitySnapshotFiles(
   workingStatus?: ContinuityWorkingTreeStatus | null,
 ): string[] {
   if (!workingStatus?.localContentHashes || !workingStatus.publishedContentHashes) return []
-  const files: Array<keyof typeof workingStatus.localContentHashes> = ['SOUL.md', 'MEMORY.md', 'skills.json']
+  const files: Array<keyof typeof workingStatus.localContentHashes> = ['SOUL.md', 'MEMORY.md', 'skills.json', 'private-skills']
   return files
-    .filter(file => workingStatus.localContentHashes?.[file] !== workingStatus.publishedContentHashes?.[file])
+    .filter(file => (workingStatus.localContentHashes?.[file] ?? '') !== (workingStatus.publishedContentHashes?.[file] ?? ''))
     .map(displayContinuitySnapshotFile)
 }
 
 function displayContinuitySnapshotFile(file: keyof NonNullable<ContinuityWorkingTreeStatus['localContentHashes']>): string {
+  if (file === 'private-skills') return 'skills/'
   return file
 }
 

package/src/identity/hub/continuity/vault.ts

@@ -2,6 +2,7 @@ import { getAddress, type Address, type Hex } from 'viem'
 import type { EthagentIdentity } from '../../../storage/config.js'
 import {
   prepareSyncedIdentityMarkdownScaffold,
+  prepareSyncedSkillsTree,
   readContinuityFiles,
   readPublicSkillsFile,
   writeIdentityMarkdownScaffold,
@@ -10,13 +11,20 @@ import {
 import {
   createWalletRestoreAccessChallenge,
   serializeContinuitySnapshotEnvelope,
+  type ContinuityFiles,
+  type ContinuitySkillsTree,
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
+  appendPublicSkillEntries,
   createAgentCard,
   defaultPublicSkillsProfile,
   serializeAgentCard,
 } from '../../continuity/publicSkills.js'
+import {
+  derivePublicSkillEntries,
+  syncPublicSkillsManifest,
+} from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL } from '../../storage/ipfs.js'
 import {
@@ -58,6 +66,11 @@ type VaultPublishPrepared = {
   nextIdentity: EthagentIdentity
   markdownScaffold?: IdentityMarkdownScaffold
   completionMessage: string
+  publishedSources: {
+    privateFiles: ContinuityFiles
+    publicSkills: string
+    skills: ContinuitySkillsTree
+  }
 }
 
 export async function runOperatorWalletRebackup(args: {
@@ -129,18 +142,22 @@ export async function runOperatorWalletRebackup(args: {
   const continuityFiles = markdownScaffold
     ? { 'SOUL.md': markdownScaffold['SOUL.md'], 'MEMORY.md': markdownScaffold['MEMORY.md'] }
     : await readContinuityFiles(nextIdentityForFiles)
-  const publicSkillsJson = markdownScaffold
-    ? markdownScaffold['skills.json']
-    : await readPublicSkillsFile(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(defaultPublicSkillsProfile(nextIdentityForFiles))),
+    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
     fetch,
     { pinataJwt: step.pinataJwt },
   )
   assertVerifiedPin(agentCardPin)
+  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
   const envelope = createContinuityEnvelopeForSave({
     identity: nextIdentityForFiles,
     registry: step.registry,
@@ -149,6 +166,7 @@ export async function runOperatorWalletRebackup(args: {
     walletSignature: wallet.signature,
     state,
     files: continuityFiles,
+    skills: skillsTree,
     walletAccess,
     ...(challengePurpose ? { challengePurpose } : {}),
   })
@@ -185,7 +203,11 @@ export async function runOperatorWalletRebackup(args: {
     await writeIdentityMarkdownScaffold(nextIdentity, markdownScaffold)
   }
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'local operator-wallet snapshot' }).catch(() => null)
-  await markCurrentContinuityFilesPublished(nextIdentity).catch(() => null)
+  await markCurrentContinuityFilesPublished(nextIdentity, {
+    privateFiles: continuityFiles,
+    publicSkills: publicSkillsJson,
+    skills: skillsTree,
+  }).catch(() => null)
   const completionMessage = nextEnsName !== undefined && nextEnsName !== ((step.identity.state as Record<string, unknown> | undefined)?.ensName as string | undefined)
     ? 'Snapshot saved locally. Owner wallet still needs to publish to make ENS changes discoverable.'
     : uploadedImageUri !== undefined
@@ -262,18 +284,22 @@ async function runOperatorWalletVaultPublish(args: {
       const continuityFiles = markdownScaffold
         ? { 'SOUL.md': markdownScaffold['SOUL.md'], 'MEMORY.md': markdownScaffold['MEMORY.md'] }
         : await readContinuityFiles(nextIdentityForFiles)
-      const publicSkillsJson = markdownScaffold
-        ? markdownScaffold['skills.json']
-        : await readPublicSkillsFile(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(defaultPublicSkillsProfile(nextIdentityForFiles))),
+        serializeAgentCard(createAgentCard(augmentedPublicProfile)),
         fetch,
         { pinataJwt: step.pinataJwt },
       )
       assertVerifiedPin(agentCardPin)
+      const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
       const envelope = createContinuityEnvelopeForSave({
         identity: nextIdentityForFiles,
         registry: step.registry,
@@ -282,6 +308,7 @@ async function runOperatorWalletVaultPublish(args: {
         walletSignature: wallet.signature,
         state,
         files: continuityFiles,
+        skills: skillsTree,
         walletAccess,
         ...(challengePurpose ? { challengePurpose } : {}),
       })
@@ -354,6 +381,11 @@ async function runOperatorWalletVaultPublish(args: {
           nextIdentity,
           ...(markdownScaffold ? { markdownScaffold } : {}),
           completionMessage,
+          publishedSources: {
+            privateFiles: continuityFiles,
+            publicSkills: publicSkillsJson,
+            skills: skillsTree,
+          },
         },
       }
     },
@@ -373,6 +405,6 @@ async function runOperatorWalletVaultPublish(args: {
     await writeIdentityMarkdownScaffold(nextIdentity, result.prepared.markdownScaffold)
   }
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'operator-published snapshot' }).catch(() => null)
-  await markCurrentContinuityFilesPublished(nextIdentity).catch(() => null)
+  await markCurrentContinuityFilesPublished(nextIdentity, result.prepared.publishedSources).catch(() => null)
   await callbacks.onIdentityComplete(nextIdentity, result.prepared.completionMessage, 'update')
 }

package/src/identity/hub/custody/CustodyEditFlow.tsx

@@ -214,7 +214,7 @@ export const CustodyEditFlow: React.FC<CustodyEditFlowProps> = ({
       <Surface
         title="Switch to Advanced"
         subtitle="Move this token into its own Vault so authorized operator wallets can update this agent onchain without your signature each time."
-        footer={footerHint('enter confirm, esc back')}
+        footer={footerHint('enter confirm · esc back')}
       >
         <Box flexDirection="column">
           <Row label="Token" value={tokenLabel} />
@@ -236,7 +236,7 @@ export const CustodyEditFlow: React.FC<CustodyEditFlowProps> = ({
               { value: 'confirm', label: 'Yes, Switch to Advanced', hint: `Sign with ${shortAddress(ownerAddress || tokenOwner)} to deposit this token into its Vault` },
               { value: 'transfer', role: 'section', label: 'Move Token First' },
               { value: 'transfer', label: 'Prepare Token Transfer', hint: 'Move the token to a different wallet first, with snapshot handoff' },
-              { value: 'back', role: 'section', label: 'Cancel' },
+              { value: 'back', role: 'section', label: 'Navigation' },
               { value: 'back', label: 'No, Go Back', hint: 'Return without changing custody', role: 'utility' },
             ]}
             hintLayout="inline"
@@ -278,7 +278,7 @@ export const CustodyEditFlow: React.FC<CustodyEditFlowProps> = ({
           options={[
             { value: 'confirm', role: 'section', label: 'Confirm' },
             { value: 'confirm', label: 'Yes, Switch to Simple', hint: `Sign with the owner wallet to unwrap ${tokenLabel} from its Vault` },
-            { value: 'back', role: 'section', label: 'Cancel' },
+            { value: 'back', role: 'section', label: 'Navigation' },
             { value: 'back', label: 'No, Go Back', hint: 'Return without changing custody', role: 'utility' },
           ]}
           hintLayout="inline"

package/src/identity/hub/identityHubReducer.ts

@@ -59,6 +59,13 @@ export type Step =
   | { kind: 'public-profile-storage'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; error?: string; pinataJwt?: string; profileUpdates?: ProfileUpdates; returnTo?: Step; vaultAddress?: `0x${string}` }
   | { kind: 'continuity-private'; notice?: string; editorOpened?: boolean }
   | { kind: 'continuity-public'; notice?: string; editorOpened?: boolean }
+  | { kind: 'continuity-skills-tree'; notice?: string; editorOpened?: boolean }
+  | { kind: 'continuity-skill-new'; error?: string }
+  | { kind: 'continuity-skill-new-visibility'; name: string; error?: string }
+  | { kind: 'continuity-skill-delete'; notice?: string }
+  | { kind: 'continuity-skill-delete-confirm'; target: { kind: 'skill'; relativePath: string } }
+  | { kind: 'continuity-skill-visibility'; notice?: string }
+  | { kind: 'continuity-skill-visibility-pick'; relativePath: string }
   | { kind: 'rebackup-confirm'; back: Step }
   | { kind: 'recovery-refetch-confirm'; back: Step }
   | { kind: 'recovery-refetching'; identity: EthagentIdentity; registry: Erc8004RegistryConfig; back: Step }
@@ -173,6 +180,20 @@ function backStep(from: Step): Step {
     case 'continuity-private':
     case 'continuity-public':
       return { kind: 'menu' }
+    case 'continuity-skills-tree':
+      return { kind: 'menu' }
+    case 'continuity-skill-new':
+      return { kind: 'continuity-skills-tree' }
+    case 'continuity-skill-new-visibility':
+      return { kind: 'continuity-skill-new' }
+    case 'continuity-skill-delete':
+      return { kind: 'continuity-skills-tree' }
+    case 'continuity-skill-delete-confirm':
+      return { kind: 'continuity-skill-delete' }
+    case 'continuity-skill-visibility':
+      return { kind: 'continuity-skills-tree' }
+    case 'continuity-skill-visibility-pick':
+      return { kind: 'continuity-skill-visibility' }
     case 'rebackup-confirm':
     case 'recovery-refetch-confirm':
     case 'recovery-refetching':

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

@@ -6,15 +6,21 @@ import {
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
+  prepareSyncedSkillsTree,
   prepareSyncedPublicSkillsJson,
   readContinuityFiles,
   writePublicSkillsFile,
 } from '../../continuity/storage.js'
 import {
+  appendPublicSkillEntries,
   createAgentCard,
   defaultPublicSkillsProfile,
   serializeAgentCard,
 } from '../../continuity/publicSkills.js'
+import {
+  derivePublicSkillEntries,
+  syncPublicSkillsManifest,
+} from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { addToIpfs, DEFAULT_IPFS_API_URL, isPinataUploadUrl } from '../../storage/ipfs.js'
 import {
@@ -151,7 +157,7 @@ async function runPublicProfileSigningInner(
         includeLastBackedUpAt: false,
       })
       const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
-      const publicSkillsJson = await prepareSyncedPublicSkillsJson(nextIdentityForFiles)
+      const publicSkillsJson = await syncPublicSkillsManifest(nextIdentityForFiles)
       const publicSkillsPin = await addToIpfs(DEFAULT_IPFS_API_URL, publicSkillsJson, fetch, { pinataJwt: step.pinataJwt })
       assertVerifiedPin(publicSkillsPin)
       const agentCardPin = await addToIpfs(
@@ -395,18 +401,24 @@ async function prepareOperatorProfileArtifacts(args: {
   })
   const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
 
-  const publicSkillsJson = await prepareSyncedPublicSkillsJson(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(defaultPublicSkillsProfile(nextIdentityForFiles))),
+    serializeAgentCard(createAgentCard(augmentedPublicProfile)),
     fetch,
     { pinataJwt: step.pinataJwt },
   )
   assertVerifiedPin(agentCardPin)
 
   const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
+  const skillsTree = await prepareSyncedSkillsTree(nextIdentityForFiles)
   const envelope = createContinuityEnvelopeForSave({
     identity: nextIdentityForFiles,
     registry: step.registry,
@@ -415,6 +427,7 @@ async function prepareOperatorProfileArtifacts(args: {
     walletSignature: wallet.signature,
     state,
     files: continuityFiles,
+    skills: skillsTree,
     walletAccess,
     challengePurpose,
   })

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

@@ -1,8 +1,9 @@
 import React from 'react'
-import { Text } from 'ink'
+import { Box, Text } from 'ink'
 import { Surface } from '../../../ui/Surface.js'
 import { Select } from '../../../ui/Select.js'
 import { TextInput } from '../../../ui/TextInput.js'
+import { Spinner } from '../../../ui/Spinner.js'
 import { theme } from '../../../ui/theme.js'
 import { normalizeErc8004RegistryConfig } from '../../registry/erc8004.js'
 import {
@@ -18,7 +19,7 @@ import { WalletApprovalScreen } from '../shared/components/WalletApprovalScreen.
 import { BusyScreen } from '../shared/components/BusyScreen.js'
 import type { BrowserWalletReady } from '../../wallet/browserWallet.js'
 import type { EthagentConfig } from '../../../storage/config.js'
-import { restoreSignatureRequestForStep } from './index.js'
+import { restoreSignatureRequestForStep } from './auth.js'
 import type { RestoreProgress } from '../shared/effects/types.js'
 
 type RestoreStep = Exclude<Extract<Step, { kind: `restore-${string}` }>, { kind: 'restore-wallet' | 'restore-network' }>
@@ -122,11 +123,24 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
   }
 
   if (step.kind === 'restore-ens-input') {
+    if (step.busy) {
+      return (
+        <Surface
+          title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+          subtitle="Looking up the agent onchain."
+          footer={footerHint('esc cancels')}
+        >
+          <Box marginTop={1}>
+            <Spinner label="looking up ENS name onchain..." />
+          </Box>
+        </Surface>
+      )
+    }
     return (
       <Surface
         title={isSwitch ? 'Load Agent' : 'Restore Agent'}
         subtitle="Enter the agent's ENS name to decrypt with an authorized operator wallet."
-        footer={footerHint(step.busy ? 'Looking up...' : 'enter continue · esc back')}
+        footer={footerHint('enter continue · esc back')}
       >
         <Text color={theme.dim}>The full agent subdomain, e.g. agent.example.eth.</Text>
         <TextInput
@@ -134,17 +148,35 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
           onSubmit={value => onEnsSubmit(value.trim())}
           onCancel={onBack}
         />
-        {step.error ? <Text color={theme.accentError}>{step.error}</Text> : null}
+        {step.error ? (
+          <Box marginTop={1} flexDirection="column">
+            <Text color={theme.accentError}>Could not resolve ENS name</Text>
+            <Text color={theme.textSubtle}>{step.error}</Text>
+          </Box>
+        ) : null}
       </Surface>
     )
   }
 
   if (step.kind === 'restore-token-id-input') {
+    if (step.busy) {
+      return (
+        <Surface
+          title={isSwitch ? 'Load Agent' : 'Restore Agent'}
+          subtitle="Looking up the agent onchain."
+          footer={footerHint('esc cancels')}
+        >
+          <Box marginTop={1}>
+            <Spinner label="looking up token onchain..." />
+          </Box>
+        </Surface>
+      )
+    }
     return (
       <Surface
         title={isSwitch ? 'Load Agent' : 'Restore Agent'}
         subtitle={`Enter the ERC-8004 token ID on ${networkLabelForRegistry(step.registry)}.`}
-        footer={footerHint(step.busy ? 'Looking up...' : 'enter continue · esc back')}
+        footer={footerHint('enter continue · esc back')}
       >
         <Text color={theme.dim}>The integer token ID assigned at mint.</Text>
         <TextInput
@@ -152,7 +184,12 @@ export const RestoreFlow: React.FC<RestoreFlowProps> = ({
           onSubmit={value => onTokenIdSubmit(value.trim())}
           onCancel={onBack}
         />
-        {step.error ? <Text color={theme.accentError}>{step.error}</Text> : null}
+        {step.error ? (
+          <Box marginTop={1} flexDirection="column">
+            <Text color={theme.accentError}>Could not resolve token</Text>
+            <Text color={theme.textSubtle}>{step.error}</Text>
+          </Box>
+        ) : null}
       </Surface>
     )
   }

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

@@ -5,7 +5,12 @@ import {
   restoreContinuitySnapshotEnvelope,
   transferSnapshotMetadataFromEnvelope,
 } from '../../continuity/envelope.js'
-import { ensureIdentityMarkdownScaffold, writeContinuityFiles } from '../../continuity/storage.js'
+import {
+  ensureIdentityMarkdownScaffold,
+  restoreSkillsTree,
+  writeContinuityFiles,
+} from '../../continuity/storage.js'
+import { syncPublicSkillsManifest } from '../../continuity/skills/publicSkillsSync.js'
 import { recordPublishedContinuitySnapshot } from '../../continuity/snapshots.js'
 import { requestBrowserWalletSignature } from '../../wallet/browserWallet.js'
 import { setVaultAddressField } from '../../identityCompat.js'
@@ -31,6 +36,7 @@ export async function runRestoreAuthorize(
   callbacks.onRestoreProgress?.({ phase: 'decrypting', label: 'signature received · decrypting encrypted snapshot...' })
   let restored: ReturnType<typeof restoreAgentStateBackupEnvelope> | ReturnType<typeof restoreContinuitySnapshotEnvelope>
   let continuityFiles: ReturnType<typeof restoreContinuitySnapshotEnvelope>['files'] | undefined
+  let continuitySkills: ReturnType<typeof restoreContinuitySnapshotEnvelope>['skills']
   if (isContinuitySnapshotEnvelope(step.envelope)) {
     const payload = restoreContinuitySnapshotEnvelope({
       envelope: step.envelope,
@@ -39,6 +45,7 @@ export async function runRestoreAuthorize(
     })
     restored = payload
     continuityFiles = payload.files
+    continuitySkills = payload.skills
   } else {
     restored = restoreAgentStateBackupEnvelope({
       envelope: step.envelope,
@@ -104,9 +111,13 @@ export async function runRestoreAuthorize(
   if (continuityFiles) {
     await writeContinuityFiles(nextIdentity, continuityFiles)
   }
+  if (continuitySkills) {
+    await restoreSkillsTree(nextIdentity, continuitySkills)
+  }
   callbacks.onRestoreProgress?.({ phase: 'finishing', label: 'finalizing restored identity...' })
   await restorePublishedPublicSkills(nextIdentity, step.apiUrl, step.candidate.publicDiscovery?.skillsCid)
   await ensureIdentityMarkdownScaffold(nextIdentity)
+  await syncPublicSkillsManifest(nextIdentity).catch(() => null)
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'restored from agent backup' }).catch(() => null)
   await callbacks.onIdentityComplete(nextIdentity, `ERC-8004 agent restored · #${step.candidate.agentId.toString()}`, 'restore')
 }