ethagent 2.4.0 → 3.0.1

package/src/identity/hub/continuity/RecoveryConfirmScreen.tsx

@@ -20,15 +20,15 @@ interface RecoveryConfirmScreenProps {
 
 export const RecoveryConfirmScreen: React.FC<RecoveryConfirmScreenProps> = ({ mode, workingStatus, pendingPublish, footer, onConfirm, onBack }) => {
   const isPublish = mode === 'publish'
-  const title = isPublish ? 'Save Snapshot?' : 'Refetch Latest From Chain?'
+  const title = isPublish ? 'Save Snapshot?' : 'Refetch Latest From Onchain?'
   const subtitle = isPublish
-    ? 'Saves SOUL.md, MEMORY.md, skills.json, and profile changes.'
+    ? 'Saves SOUL.md, MEMORY.md, skills, and profile changes.'
     : 'This overwrites local files with the onchain version.'
 
   const headlineColor = theme.accentPeriwinkle
   const headline = isPublish
     ? 'Saving updates the onchain pointer for this agent.'
-    : 'Refetching replaces SOUL.md, MEMORY.md, and skills.json with what is onchain.'
+    : 'Refetching replaces SOUL.md, MEMORY.md, and skills with what is onchain.'
   const detail = isPublish
     ? 'Your local continuity files and profile edits become the saved state. The previous snapshot pointer is overwritten.'
     : 'Unsaved local edits will be lost. Use this when local files are missing or out of sync with the latest saved snapshot.'
@@ -47,7 +47,7 @@ export const RecoveryConfirmScreen: React.FC<RecoveryConfirmScreenProps> = ({ mo
         )}
         {!isPublish && pendingPublish ? (
           <Box marginTop={1} flexDirection="column">
-            <Text color={theme.accentError} bold>Local snapshot is ahead of chain.</Text>
+            <Text color={theme.accentError} bold>Local snapshot is ahead of onchain.</Text>
             <Text color={theme.textSubtle}>Local edits have not yet been rotated to the onchain pointer. Refetching discards them and reverts to the last published snapshot.</Text>
           </Box>
         ) : null}
@@ -63,10 +63,10 @@ export const RecoveryConfirmScreen: React.FC<RecoveryConfirmScreenProps> = ({ mo
             { value: 'confirm', role: 'section', label: isPublish ? 'Save' : 'Refetch' },
             {
               value: 'confirm',
-              label: isPublish ? 'Yes, Save Snapshot Now' : 'Yes, Refetch From Chain',
+              label: isPublish ? 'Yes, Save Snapshot Now' : 'Yes, Refetch From Onchain',
               hint: isPublish ? 'Sign and save the encrypted snapshot' : 'Wallet decrypts and overwrites local files',
             },
-            { value: 'back', role: 'section', label: 'Cancel' },
+            { value: 'back', role: 'section', label: 'Navigation' },
             {
               value: 'back',
               label: 'No, Go Back',

package/src/identity/hub/continuity/SavePromptScreen.tsx

@@ -35,9 +35,8 @@ export const SavePromptScreen: React.FC<SavePromptScreenProps> = ({ workingStatu
       <Box marginTop={1}>
         <Select<SavePromptAction>
           options={[
-            { value: 'save-now', role: 'section', label: 'Save' },
             { value: 'save-now', label: 'Save now', hint: 'Sign once and save the encrypted snapshot' },
-            { value: 'later', label: 'Not now', hint: 'Ask again on the next ethagent launch', role: 'utility' },
+            { value: 'later', label: 'Not now', hint: 'Ask again on the next launch', role: 'utility' },
           ]}
           hintLayout="inline"
           onSubmit={onSelect}

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

@@ -4,14 +4,25 @@ import type { EthagentIdentity } from '../../../storage/config.js'
 import {
   continuityVaultStatus,
   prepareSyncedIdentityMarkdownScaffold,
+  prepareSyncedSkillsTree,
   readContinuityFiles,
   readPublicSkillsFile,
   writeIdentityMarkdownScaffold,
   type IdentityMarkdownScaffold,
 } from '../../continuity/storage.js'
+import {
+  appendPublicSkillEntries,
+  defaultPublicSkillsProfile as basePublicSkillsProfile,
+} from '../../continuity/publicSkills.js'
+import {
+  derivePublicSkillEntries,
+  syncPublicSkillsManifest,
+} from '../../continuity/skills/publicSkillsSync.js'
 import {
   createWalletRestoreAccessChallenge,
   serializeContinuitySnapshotEnvelope,
+  type ContinuityFiles,
+  type ContinuitySkillsTree,
   type WalletChallengePurpose,
 } from '../../continuity/envelope.js'
 import {
@@ -78,6 +89,11 @@ type RebackupPreparedTransaction = {
   publicSkills: PublicSkillsMetadata
   identity: EthagentIdentity
   markdownScaffold?: IdentityMarkdownScaffold
+  publishedSources: {
+    privateFiles: ContinuityFiles
+    publicSkills: string
+    skills: ContinuitySkillsTree
+  }
 }
 
 export async function runRebackupPreflight(
@@ -224,18 +240,22 @@ async function runRebackupSigningInner(
       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(
+        basePublicSkillsProfile(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,
@@ -244,6 +264,7 @@ async function runRebackupSigningInner(
         walletSignature: wallet.signature,
         state,
         files: continuityFiles,
+        skills: skillsTree,
         walletAccess,
         ...(challengePurpose ? { challengePurpose } : {}),
       })
@@ -310,6 +331,11 @@ async function runRebackupSigningInner(
             publicSkills,
             identity: { ...step.identity, state },
             ...(markdownScaffold ? { markdownScaffold } : {}),
+            publishedSources: {
+              privateFiles: continuityFiles,
+              publicSkills: publicSkillsJson,
+              skills: skillsTree,
+            },
           },
         }
       }
@@ -330,6 +356,11 @@ async function runRebackupSigningInner(
           publicSkills,
           identity: { ...step.identity, state },
           ...(markdownScaffold ? { markdownScaffold } : {}),
+          publishedSources: {
+            privateFiles: continuityFiles,
+            publicSkills: publicSkillsJson,
+            skills: skillsTree,
+          },
         },
       }
     },
@@ -359,7 +390,7 @@ async function runRebackupSigningInner(
     await writeIdentityMarkdownScaffold(nextIdentity, result.prepared.markdownScaffold)
   }
   await recordPublishedContinuitySnapshot({ identity: nextIdentity, label: 'published encrypted snapshot' }).catch(() => null)
-  await markCurrentContinuityFilesPublished(nextIdentity).catch(() => null)
+  await markCurrentContinuityFilesPublished(nextIdentity, result.prepared.publishedSources).catch(() => null)
   const resolverSyncWarning = await syncVaultOperatorsAfterOwnerSave({
     beforeIdentity: step.identity,
     afterIdentity: nextIdentity,

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

@@ -0,0 +1,112 @@
+import React, { useEffect, useState } from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../../../../ui/Surface.js'
+import { Select } from '../../../../ui/Select.js'
+import { theme } from '../../../../ui/theme.js'
+import type { EthagentIdentity } from '../../../../storage/config.js'
+import {
+  listSkills,
+  listSkillFiles,
+  type SkillFileEntry,
+} from '../../../continuity/skills/loadSkills.js'
+import { continuityVaultRef } from '../../../continuity/storage.js'
+import type { SkillIndexEntry } from '../../../continuity/skills/types.js'
+
+type ConfirmChoice = 'delete' | 'cancel'
+
+type DeleteTarget = { kind: 'skill'; relativePath: string }
+
+interface DeleteSkillConfirmScreenProps {
+  identity?: EthagentIdentity
+  target: DeleteTarget
+  footer: React.ReactNode
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+const MAX_LISTED_FILES = 10
+
+export const DeleteSkillConfirmScreen: React.FC<DeleteSkillConfirmScreenProps> = ({
+  identity,
+  target,
+  footer,
+  onConfirm,
+  onCancel,
+}) => {
+  const [entries, setEntries] = useState<SkillIndexEntry[] | null>(null)
+  const [files, setFiles] = useState<SkillFileEntry[] | null>(null)
+  const skillName = target.relativePath.split('/')[0] ?? ''
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) { setEntries([]); setFiles([]); return () => { cancelled = true } }
+    setEntries(null)
+    setFiles(null)
+    listSkills(identity)
+      .then(result => { if (!cancelled) setEntries(result) })
+      .catch(() => { if (!cancelled) setEntries([]) })
+    listSkillFiles(identity, skillName)
+      .then(result => { if (!cancelled) setFiles(result) })
+      .catch(() => { if (!cancelled) setFiles([]) })
+    return () => { cancelled = true }
+  }, [identity, target.relativePath, skillName])
+
+  const ref = identity ? continuityVaultRef(identity) : undefined
+  const skillMissing = entries !== null && !entries.some(entry => entry.relativePath === target.relativePath)
+  const supportingCount = (files ?? []).filter(f => f.relativePath !== 'SKILL.md').length
+  const subtitle = skillMissing
+    ? `Skill ${skillName} was already removed elsewhere. Cancel and refresh.`
+    : supportingCount > 0
+      ? `Removes ${skillName}/ and ${supportingCount} supporting file${supportingCount === 1 ? '' : 's'}. This cannot be undone.`
+      : `Removes ${skillName}/. This cannot be undone.`
+
+  return (
+    <Surface title={`Delete ${skillName}?`} subtitle={subtitle} footer={footer} tone="error">
+      <Box marginTop={1} flexDirection="column">
+        <Text color={theme.dim}>This will remove:</Text>
+        {ref && (
+          <Box marginLeft={2} flexDirection="column">
+            <Text color={theme.text}>{ref.skillsDir}/{skillName}/</Text>
+            {files === null ? (
+              <Text color={theme.dim}>(loading folder contents...)</Text>
+            ) : (
+              <FolderContents files={files} />
+            )}
+          </Box>
+        )}
+      </Box>
+      <Box marginTop={1}>
+        <Select<ConfirmChoice>
+          options={[
+            { value: 'delete', label: 'Yes, delete', hint: skillMissing ? 'Skill already missing on disk' : 'Permanent. Will be reflected in the next snapshot.', bold: true, disabled: skillMissing },
+            { value: 'cancel', label: 'No, back', hint: 'Return to the delete picker', role: 'utility' },
+          ]}
+          hintLayout="inline"
+          initialIndex={1}
+          onSubmit={choice => {
+            if (choice === 'delete') return onConfirm()
+            return onCancel()
+          }}
+          onCancel={onCancel}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+const FolderContents: React.FC<{ files: SkillFileEntry[] }> = ({ files }) => {
+  if (files.length === 0) {
+    return <Text color={theme.dim}>(empty folder)</Text>
+  }
+  const shown = files.slice(0, MAX_LISTED_FILES)
+  const extra = files.length - shown.length
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Text color={theme.dim}>Files to be removed:</Text>
+      {shown.map(f => (
+        <Text key={f.relativePath} color={theme.text}>  · {f.relativePath}</Text>
+      ))}
+      {extra > 0 && <Text color={theme.dim}>  · ...and {extra} more</Text>}
+    </Box>
+  )
+}

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

@@ -0,0 +1,57 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../../../../ui/Surface.js'
+import { TextInput } from '../../../../ui/TextInput.js'
+import { theme } from '../../../../ui/theme.js'
+
+interface NewSkillScreenProps {
+  error?: string
+  footer: React.ReactNode
+  onSubmit: (name: string) => void
+  onCancel: () => void
+}
+
+export const NewSkillScreen: React.FC<NewSkillScreenProps> = ({
+  error,
+  footer,
+  onSubmit,
+  onCancel,
+}) => (
+  <Surface
+    title="New Skill"
+    subtitle="Folder name. The skill activates by this name."
+    footer={footer}
+  >
+    <Box marginTop={1} flexDirection="column">
+      <TextInput
+        label="Folder name"
+        placeholder="<folder>"
+        validate={value => validateSegment(value)}
+        onSubmit={raw => {
+          const trimmed = raw.trim()
+          if (validateSegment(trimmed) === null) onSubmit(trimmed)
+        }}
+        onCancel={onCancel}
+      />
+      <Box marginTop={1}>
+        <Text color={theme.dim}>
+          Saved as skills/&lt;folder&gt;/SKILL.md. Add supporting files later by dropping them into the same folder.
+        </Text>
+      </Box>
+      {error && (
+        <Box marginTop={1}>
+          <Text color={theme.accentError}>{error}</Text>
+        </Box>
+      )}
+    </Box>
+  </Surface>
+)
+
+export function validateSegment(value: string): string | null {
+  const trimmed = value.trim()
+  if (!trimmed) return 'Enter a name.'
+  if (trimmed.includes('/') || trimmed.includes('\\')) return 'One segment only, no slashes.'
+  if (trimmed === '.' || trimmed === '..') return 'Reserved name.'
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) return 'Only letters, digits, dashes, underscores, dots.'
+  return null
+}

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

@@ -0,0 +1,52 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { Surface } from '../../../../ui/Surface.js'
+import { Select } from '../../../../ui/Select.js'
+import { theme } from '../../../../ui/theme.js'
+import type { SkillVisibility } from '../../../continuity/skills/types.js'
+
+interface NewSkillVisibilityScreenProps {
+  name: string
+  error?: string
+  footer: React.ReactNode
+  onSelect: (visibility: SkillVisibility) => void
+  onCancel: () => void
+}
+
+export const NewSkillVisibilityScreen: React.FC<NewSkillVisibilityScreenProps> = ({
+  name,
+  error,
+  footer,
+  onSelect,
+  onCancel,
+}) => (
+  <Surface
+    title={`Visibility · ${name}`}
+    subtitle="Discoverable is the default. You can change it later from Change Visibility."
+    footer={footer}
+  >
+    {error && (
+      <Box marginTop={1}>
+        <Text color={theme.accentError}>{error}</Text>
+      </Box>
+    )}
+    <Box marginTop={1}>
+      <Select<SkillVisibility | 'back'>
+        options={[
+          { value: 'private', label: 'Private', hint: 'Local-only. Not in skills.json.' },
+          { value: 'discoverable', label: 'Discoverable', hint: 'Default. Indexed in skills.json with description.' },
+          { value: 'public', label: 'Public', hint: 'Indexed in skills.json and Agent Card.' },
+          { value: 'back', role: 'section', label: 'Navigation' },
+          { value: 'back', label: 'Back', hint: 'Return to the name step', role: 'utility' },
+        ]}
+        hintLayout="inline"
+        initialIndex={1}
+        onSubmit={choice => {
+          if (choice === 'back') return onCancel()
+          return onSelect(choice)
+        }}
+        onCancel={onCancel}
+      />
+    </Box>
+  </Surface>
+)

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

@@ -0,0 +1,151 @@
+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 { EthagentIdentity } from '../../../../storage/config.js'
+import { listSkills, listSkillFiles } from '../../../continuity/skills/loadSkills.js'
+import type { SkillIndexEntry, SkillVisibility } from '../../../continuity/skills/types.js'
+
+type SkillAction =
+  | { kind: 'open' }
+  | { kind: 'set-visibility'; visibility: SkillVisibility }
+  | { kind: 'delete' }
+  | { kind: 'back' }
+  | { kind: 'noop' }
+
+interface SkillActionsScreenProps {
+  identity?: EthagentIdentity
+  relativePath: string
+  notice?: string
+  footer: React.ReactNode
+  onOpenSkill: (relativePath: string) => void
+  onSetVisibility: (relativePath: string, visibility: SkillVisibility) => void
+  onDelete: (relativePath: string) => void
+  onBack: () => void
+}
+
+export const SkillActionsScreen: React.FC<SkillActionsScreenProps> = ({
+  identity,
+  relativePath,
+  notice,
+  footer,
+  onOpenSkill,
+  onSetVisibility,
+  onDelete,
+  onBack,
+}) => {
+  const [entry, setEntry] = useState<SkillIndexEntry | null>(null)
+  const [supportingCount, setSupportingCount] = useState<number | null>(null)
+  const skillName = relativePath.split('/')[0] ?? ''
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) return () => { cancelled = true }
+    listSkills(identity)
+      .then(list => {
+        if (cancelled) return
+        const match = list.find(item => item.relativePath === relativePath)
+        setEntry(match ?? null)
+      })
+      .catch(() => { if (!cancelled) setEntry(null) })
+    listSkillFiles(identity, skillName)
+      .then(files => {
+        if (cancelled) return
+        setSupportingCount(files.filter(f => f.relativePath !== 'SKILL.md').length)
+      })
+      .catch(() => { if (!cancelled) setSupportingCount(null) })
+    return () => { cancelled = true }
+  }, [identity, relativePath, skillName, notice])
+
+  const displayName = entry?.displayName ?? entry?.name ?? skillName
+  const visibility = entry?.visibility
+  const subtitle = notice ?? 'Open, change visibility, or delete this skill.'
+
+  const options: Array<SelectOption<SkillAction>> = []
+  const noop: SkillAction = { kind: 'noop' }
+
+  options.push({ value: noop, role: 'section', label: 'Open' })
+  options.push({
+    value: { kind: 'open' },
+    label: 'Open SKILL.md',
+    hint: 'View or edit this skill',
+  })
+
+  options.push({ value: noop, role: 'section', label: 'Visibility' })
+  options.push(visibilityOption('private', visibility))
+  options.push(visibilityOption('discoverable', visibility))
+  options.push(visibilityOption('public', visibility))
+
+  options.push({ value: noop, role: 'section', label: 'Manage' })
+  options.push({
+    value: { kind: 'delete' },
+    label: 'Delete',
+    hint: 'Remove this skill folder and its supporting files',
+  })
+  options.push({
+    value: { kind: 'back' },
+    label: 'Back',
+    hint: 'Return to Skills',
+    role: 'utility',
+  })
+
+  const leafMeta = formatLeafMeta(visibility, supportingCount)
+
+  return (
+    <Surface title={`Skill · ${displayName}`} subtitle={subtitle} footer={footer}>
+      <Box flexDirection="column" marginTop={1}>
+        <Text color={theme.dim}>skills/</Text>
+        <Text>
+          <Text color={theme.dim}>└── </Text>
+          <Text color={theme.accentPeriwinkle} bold>{`${skillName}/SKILL.md`}</Text>
+          {leafMeta ? <Text color={theme.dim}>{`   ${leafMeta}`}</Text> : null}
+        </Text>
+      </Box>
+      <Box marginTop={1}>
+        <Select<SkillAction>
+          options={options}
+          hintLayout="inline"
+          onSubmit={choice => {
+            if (choice.kind === 'open') return onOpenSkill(relativePath)
+            if (choice.kind === 'set-visibility') return onSetVisibility(relativePath, choice.visibility)
+            if (choice.kind === 'delete') return onDelete(relativePath)
+            if (choice.kind === 'back') return onBack()
+          }}
+          onCancel={onBack}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+function formatLeafMeta(visibility: SkillVisibility | undefined, supportingCount: number | null): string {
+  if (!visibility) return ''
+  const fileLabel = supportingCount === null
+    ? null
+    : supportingCount === 0 ? '1 file' : `${supportingCount + 1} files`
+  return fileLabel ? `${capitalize(visibility)} · ${fileLabel}` : capitalize(visibility)
+}
+
+function visibilityOption(level: SkillVisibility, current?: SkillVisibility): SelectOption<SkillAction> {
+  const isCurrent = current === level
+  const hint = visibilityHint(level) + (isCurrent ? '  ·  current' : '')
+  const base: SelectOption<SkillAction> = {
+    value: { kind: 'set-visibility', visibility: level },
+    label: `Set ${capitalize(level)}`,
+    hint,
+  }
+  if (isCurrent) base.labelColor = theme.accentPeriwinkle
+  return base
+}
+
+function visibilityHint(level: SkillVisibility): string {
+  if (level === 'private') return 'Local-only. Not in skills.json.'
+  if (level === 'discoverable') return 'Default. Indexed with description.'
+  return 'Indexed with description and Agent Card link.'
+}
+
+function capitalize(value: string): string {
+  if (!value) return value
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}