ethagent 2.4.0 → 3.0.1

package/src/identity/hub/shared/components/menuFlagsFromReconciliation.ts

@@ -25,9 +25,9 @@ export function menuFlagsFromReconciliation(r: AgentReconciliation, perspective:
 
   let prepareTransferReason: string | undefined
   if (isOperator) {
-    prepareTransferReason = 'Operators cannot transfer the token.'
+    prepareTransferReason = 'Owner-only action'
   } else if (!unlinked && (r.custody === 'advanced' || r.custody === 'mid-flow-uri-pending')) {
-    prepareTransferReason = 'Token is in the vault. Withdraw it first in Custody Mode.'
+    prepareTransferReason = 'Withdraw from vault first'
   }
 
   const custodyAsterisk = r.custody === 'mid-flow-uri-pending' || r.vault === 'missing'
@@ -35,17 +35,13 @@ export function menuFlagsFromReconciliation(r: AgentReconciliation, perspective:
   if (isOperator) {
     custodyHint = undefined
   } else if (r.custody === 'mid-flow-uri-pending') {
-    custodyHint = 'Advanced setup pending. Open to finish.'
+    custodyHint = 'Setup pending, open to finish'
   } else if (r.vault === 'missing') {
-    custodyHint = 'Vault contract not found. Open to redeploy.'
+    custodyHint = 'Vault missing, open to redeploy'
   }
 
-  const custodyModeReason = isOperator
-    ? 'Operators cannot change custody, withdraw the token, or manage operators.'
-    : undefined
-  const ensNameReason = isOperator
-    ? 'Operators cannot change the ENS subdomain or its records.'
-    : undefined
+  const custodyModeReason = isOperator ? 'Owner-only action' : undefined
+  const ensNameReason = isOperator ? 'Owner-only action' : undefined
 
   return {
     prepareTransferDisabled: unlinked || inVault || isOperator,
@@ -56,11 +52,11 @@ export function menuFlagsFromReconciliation(r: AgentReconciliation, perspective:
     ...(ensNameReason ? { ensNameReason } : {}),
     saveSnapshotDisabled: unlinked,
     refetchLatestDisabled: unlinked,
-    ...(unlinked ? { tokenValuesUnlinkedNote: 'Token no longer linked to this wallet, values retained for reference' } : {}),
+    ...(unlinked ? { tokenValuesUnlinkedNote: 'Unlinked, retained for reference' } : {}),
 
     custodyAsterisk: custodyAsterisk && !isOperator,
     ...(custodyHint ? { custodyHint } : {}),
     saveSnapshotAsterisk: r.agentUri === 'local-newer',
-    ...(r.agentUri === 'local-newer' ? { saveSnapshotHint: 'Local state newer than chain. Save to publish the latest agentURI.' } : {}),
+    ...(r.agentUri === 'local-newer' ? { saveSnapshotHint: 'Local newer than onchain' } : {}),
   }
 }

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

@@ -16,7 +16,11 @@ import {
 } from '../reconciliation/index.js'
 import { normalizeApprovedOperatorWallets } from '../operatorWallets.js'
 import { readOwnerAddressField } from '../../../identityCompat.js'
-import { localContinuitySnapshotContentHashes } from '../../../continuity/storage.js'
+import {
+  continuitySnapshotContentHashesFromSources,
+  localContinuitySnapshotContentHashes,
+} from '../../../continuity/storage.js'
+import type { ContinuityFiles, ContinuitySkillsTree } from '../../../continuity/envelope.js'
 import { updatePublishedContinuitySnapshotContentHashes } from '../../../continuity/snapshots.js'
 import type { EffectCallbacks } from './types.js'
 import { awaitConfirmedReceipt } from './receipts.js'
@@ -141,9 +145,18 @@ export async function syncVaultMetadataOperatorsAfterOwnerSave(args: {
   }
 }
 
-export async function markCurrentContinuityFilesPublished(identity: EthagentIdentity): Promise<void> {
+export async function markCurrentContinuityFilesPublished(
+  identity: EthagentIdentity,
+  publishedSources?: {
+    privateFiles: ContinuityFiles
+    publicSkills: string
+    skills: ContinuitySkillsTree
+  },
+): Promise<void> {
   const cid = identity.backup?.cid
   if (!cid) return
-  const contentHashes = await localContinuitySnapshotContentHashes(identity)
+  const contentHashes = publishedSources
+    ? continuitySnapshotContentHashesFromSources(publishedSources)
+    : await localContinuitySnapshotContentHashes(identity)
   await updatePublishedContinuitySnapshotContentHashes(identity, cid, contentHashes).catch(() => null)
 }

package/src/identity/hub/shared/model/copy.ts

@@ -28,8 +28,6 @@ export function copyableIdentityFields(identity?: EthagentIdentity, config?: Eth
   return fields
 }
 
-export function identityValuesCopyHint(identity?: EthagentIdentity): string {
-  return readIdentityStateString(identity?.state, 'ensName')
-    ? 'Copy token, ENS, and token URI pointers'
-    : 'Copy token and token URI pointers'
+export function identityValuesCopyHint(_identity?: EthagentIdentity): string {
+  return 'Copy token and pointers'
 }

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

@@ -9,15 +9,21 @@ import {
 import {
   continuityAgentSnapshot,
   continuityVaultStatus,
+  prepareSyncedSkillsTree,
   readContinuityFiles,
   readPublicSkillsFile,
   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 {
@@ -161,16 +167,22 @@ export async function runTokenTransferSigning(
   }
   const nextIdentityForFiles: EthagentIdentity = { ...step.identity, state }
   const continuityFiles = await readContinuityFiles(nextIdentityForFiles)
-  const publicSkillsJson = 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 = createTransferContinuitySnapshotEnvelope({
     ownerAddress,
     ownerWalletSignature: senderSignature.signature,
@@ -181,6 +193,7 @@ export async function runTokenTransferSigning(
     payload: {
       agent: continuityAgentSnapshot(nextIdentityForFiles),
       files: continuityFiles,
+      ...(Object.keys(skillsTree).length > 0 ? { skills: skillsTree } : {}),
       transcript: [],
       state,
     },

package/src/identity/hub/useIdentityHubContinuity.ts

@@ -2,15 +2,23 @@ import { useEffect, useState } from 'react'
 import type { EthagentIdentity } from '../../storage/config.js'
 import { catFromIpfs, DEFAULT_IPFS_API_URL } from '../storage/ipfs.js'
 import {
-  continuityVaultRef,
   continuityVaultStatus,
   continuityWorkingTreeStatus,
   ensurePublicSkillsFile,
   type ContinuityWorkingTreeStatus,
 } from '../continuity/storage.js'
-import { openFileInEditor } from '../continuity/editor.js'
-import { exportLocalBackup } from '../continuity/localBackup.js'
+import { openFileInEditor, openInFileManager } from '../continuity/editor.js'
 import { listPublishedContinuitySnapshots } from '../continuity/snapshots.js'
+import {
+  createSkillFile,
+  deleteSkillEntry,
+  invalidateSkillsCache,
+  readSkillByRelativePath,
+  setSkillVisibility as setSkillVisibilityStorage,
+} from '../continuity/skills/loadSkills.js'
+import type { SkillVisibility } from '../continuity/skills/types.js'
+import { syncPublicSkillsManifest } from '../continuity/skills/publicSkillsSync.js'
+import { continuityVaultRef } from '../continuity/storage.js'
 import type { Step } from './identityHubReducer.js'
 
 type UseIdentityHubContinuityArgs = {
@@ -30,7 +38,11 @@ export function useIdentityHubContinuity({
   setContinuityReady: (ready: boolean) => void
   workingStatus: ContinuityWorkingTreeStatus | null
   openContinuityFile: (kind: 'soul' | 'memory' | 'skills') => Promise<void>
-  exportLocalBackupZip: () => Promise<void>
+  openSkillFile: (relativePath: string) => Promise<void>
+  openSkillsFolder: () => Promise<void>
+  createSkill: (name: string, visibility: SkillVisibility) => Promise<void>
+  deleteSkill: (relativePath: string) => Promise<void>
+  setSkillVisibility: (relativePath: string, visibility: SkillVisibility) => Promise<void>
 } {
   const [continuityReady, setContinuityReady] = useState<boolean>(false)
   const [workingStatus, setWorkingStatus] = useState<ContinuityWorkingTreeStatus | null>(null)
@@ -55,6 +67,7 @@ export function useIdentityHubContinuity({
       step.kind !== 'menu'
       && step.kind !== 'continuity-private'
       && step.kind !== 'continuity-public'
+      && step.kind !== 'continuity-skills-tree'
       && step.kind !== 'save-prompt'
       && step.kind !== 'rebackup-confirm'
     ) return
@@ -78,8 +91,39 @@ export function useIdentityHubContinuity({
     }
   }, [identity, step.kind])
 
+  const requireReadyVault = async (): Promise<EthagentIdentity> => {
+    if (!identity) throw new Error('No active identity')
+    const status = await continuityVaultStatus(identity)
+    if (!status.ready) {
+      throw new Error('Restore local continuity files before editing the skills tree')
+    }
+    return identity
+  }
+
+  const mutateSkillsTree = async (args: {
+    backStep: Step
+    run: (id: EthagentIdentity) => Promise<string>
+    successStep?: (notice: string) => Step
+  }): Promise<void> => {
+    try {
+      const id = await requireReadyVault()
+      const notice = await args.run(id)
+      invalidateSkillsCache(id)
+      await syncPublicSkillsManifest(id)
+      const next = args.successStep
+        ? args.successStep(notice)
+        : { kind: 'continuity-skills-tree' as const, notice }
+      setStep(next)
+    } catch (err: unknown) {
+      handleStepError(err, args.backStep)
+    }
+  }
+
   const openContinuityFile = async (kind: 'soul' | 'memory' | 'skills'): Promise<void> => {
     if (!identity) return
+    const returnKind: 'continuity-private' | 'continuity-skills-tree' = kind === 'skills'
+      ? 'continuity-skills-tree'
+      : 'continuity-private'
     try {
       if (kind === 'skills') {
         await ensurePublicSkillsFile(identity, {
@@ -89,43 +133,121 @@ export function useIdentityHubContinuity({
       const ref = continuityVaultRef(identity)
       const file = kind === 'soul' ? ref.soulPath : kind === 'memory' ? ref.memoryPath : ref.publicSkillsPath
       const result = await openFileInEditor(file)
-      const displayName = kind === 'soul' ? 'SOUL.md' : kind === 'memory' ? 'MEMORY.md' : 'skills.json'
-      const message = result.ok
-        ? `opened ${displayName} with ${result.method}.`
-        : `open failed: ${result.error}`
-      setStep({ kind: 'continuity-private', notice: message, editorOpened: result.ok })
+      if (result.ok) {
+        setStep({ kind: returnKind, editorOpened: true })
+      } else {
+        setStep({ kind: returnKind, notice: `open failed: ${result.error}`, editorOpened: false })
+      }
     } catch (err: unknown) {
-      handleStepError(err, { kind: 'continuity-private' })
+      handleStepError(err, { kind: returnKind })
     }
   }
 
-  const exportLocalBackupZip = async (): Promise<void> => {
+  const openSkillFile = async (relativePath: string): Promise<void> => {
     if (!identity) return
     try {
-      await ensurePublicSkillsFile(identity, {
-        fallback: () => readPublishedPublicSkills(identity),
-      })
-      const result = await exportLocalBackup(identity)
-      const message = result.ok
-        ? `Saved local backup to ${result.path}`
-        : result.cancelled
-          ? 'Backup cancelled'
-          : `Backup failed: ${result.error}`
-      setStep({ kind: 'continuity-private', notice: message })
+      const skill = await readSkillByRelativePath(identity, relativePath)
+      const result = await openFileInEditor(skill.absolutePath)
+      invalidateSkillsCache(identity)
+      try {
+        await syncPublicSkillsManifest(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 })
+        return
+      }
+      if (result.ok) {
+        setStep({ kind: 'continuity-skills-tree', editorOpened: true })
+      } else {
+        setStep({ kind: 'continuity-skills-tree', notice: `open failed: ${result.error}`, editorOpened: false })
+      }
     } catch (err: unknown) {
-      handleStepError(err, { kind: 'continuity-private' })
+      handleStepError(err, { kind: 'continuity-skills-tree' })
     }
   }
 
+  const openSkillsFolder = async (): Promise<void> => {
+    if (!identity) return
+    try {
+      const ref = continuityVaultRef(identity)
+      const result = await openInFileManager(ref.skillsDir)
+      if (result.ok) {
+        setStep({ kind: 'continuity-skills-tree', editorOpened: true })
+      } else {
+        setStep({ kind: 'continuity-skills-tree', notice: `open failed: ${result.error}`, editorOpened: false })
+      }
+    } catch (err: unknown) {
+      handleStepError(err, { kind: 'continuity-skills-tree' })
+    }
+  }
+
+  const createSkill = async (name: string, visibility: SkillVisibility): Promise<void> => {
+    const normalizedName = sanitizeSkillSegment(name)
+    if (!normalizedName) {
+      handleStepError(
+        new Error('Folder name must contain only letters, numbers, dashes, underscores, or dots'),
+        { kind: 'continuity-skill-new' },
+      )
+      return
+    }
+    try {
+      const id = await requireReadyVault()
+      const created = await createSkillFile(id, { name: normalizedName, visibility })
+      invalidateSkillsCache(id)
+      await syncPublicSkillsManifest(id)
+      const result = await openFileInEditor(created.absolutePath)
+      if (result.ok) {
+        setStep({ kind: 'continuity-skills-tree', editorOpened: true })
+      } else {
+        setStep({ kind: 'continuity-skills-tree', notice: `created ${created.relativePath}; open failed: ${result.error}`, editorOpened: false })
+      }
+    } catch (err: unknown) {
+      handleStepError(err, { kind: 'continuity-skill-new' })
+    }
+  }
+
+  const deleteSkill = async (relativePath: string): Promise<void> => {
+    await mutateSkillsTree({
+      backStep: { kind: 'continuity-skills-tree' },
+      run: async id => {
+        await deleteSkillEntry(id, relativePath)
+        return `deleted ${relativePath}`
+      },
+    })
+  }
+
+  const setSkillVisibility = async (
+    relativePath: string,
+    visibility: SkillVisibility,
+  ): Promise<void> => {
+    await mutateSkillsTree({
+      backStep: { kind: 'continuity-skill-actions', relativePath },
+      successStep: notice => ({ kind: 'continuity-skill-actions', relativePath, notice }),
+      run: async id => {
+        await setSkillVisibilityStorage(id, relativePath, visibility)
+        const display = relativePath.split('/')[0] ?? relativePath
+        return `${display} now ${visibility}`
+      },
+    })
+  }
+
   return {
     continuityReady,
     setContinuityReady,
     workingStatus,
     openContinuityFile,
-    exportLocalBackupZip,
+    openSkillFile,
+    openSkillsFolder,
+    createSkill,
+    deleteSkill,
+    setSkillVisibility,
   }
 }
 
+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')

package/src/identity/hub/useIdentityHubController.ts

@@ -389,7 +389,11 @@ export function useIdentityHubController({
     openTokenTransferFlow,
     openPublicProfileEdit,
     openContinuityFile: continuity.openContinuityFile,
-    exportLocalBackupZip: continuity.exportLocalBackupZip,
+    openSkillFile: continuity.openSkillFile,
+    openSkillsFolder: continuity.openSkillsFolder,
+    createSkill: continuity.createSkill,
+    deleteSkill: continuity.deleteSkill,
+    setSkillVisibility: continuity.setSkillVisibility,
   }
 }
 

package/src/identity/hub/useIdentityHubSideEffects.ts

@@ -20,10 +20,8 @@ import {
   runEnsSetupRecordsTransaction,
   runEnsSetupRegistryTransaction,
   runUpdateEnsRecords,
-} from './ens/index.js'
-import {
-  runRecoveryRefetch,
-} from './restore/index.js'
+} from './ens/transactions.js'
+import { runRecoveryRefetch } from './restore/recovery.js'
 import type { EffectCallbacks } from './shared/effects/types.js'
 import { useRestoreEffects } from './restore/useRestoreEffects.js'
 import {