ethagent 2.3.0 → 3.0.0

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

@@ -37,6 +37,7 @@ export const SavePromptScreen: React.FC<SavePromptScreenProps> = ({ workingStatu
           options={[
             { value: 'save-now', role: 'section', label: 'Save' },
             { value: 'save-now', label: 'Save now', hint: 'Sign once and save the encrypted snapshot' },
+            { value: 'later', role: 'section', label: 'Defer' },
             { value: 'later', label: 'Not now', hint: 'Ask again on the next ethagent launch', role: 'utility' },
           ]}
           hintLayout="inline"

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/DeleteSkillScreen.tsx

@@ -0,0 +1,123 @@
+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 } from '../../../continuity/skills/loadSkills.js'
+import type { SkillIndexEntry } from '../../../continuity/skills/types.js'
+
+type DeleteTarget =
+  | { kind: 'skill'; relativePath: string }
+  | { kind: 'cancel' }
+
+interface DeleteSkillScreenProps {
+  identity?: EthagentIdentity
+  notice?: string
+  footer: React.ReactNode
+  onPick: (target: { kind: 'skill'; relativePath: string }) => void
+  onCancel: () => void
+}
+
+export const DeleteSkillScreen: React.FC<DeleteSkillScreenProps> = ({
+  identity,
+  notice,
+  footer,
+  onPick,
+  onCancel,
+}) => {
+  const [entries, setEntries] = useState<SkillIndexEntry[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) {
+      setEntries([])
+      return () => { cancelled = true }
+    }
+    listSkills(identity)
+      .then(list => { if (!cancelled) { setEntries(list); setError(null) } })
+      .catch(err => {
+        if (cancelled) return
+        setEntries([])
+        setError(String((err as Error).message ?? err))
+      })
+    return () => { cancelled = true }
+  }, [identity])
+
+  const subtitle = notice ?? 'Pick a skill to delete. The whole folder will be removed.'
+  const isLoading = entries === null
+  const skills = entries ?? []
+  const hasAnything = skills.length > 0
+
+  const options = buildOptions(skills, isLoading)
+
+  return (
+    <Surface title="Delete Skill" subtitle={subtitle} footer={footer} tone="error">
+      {error && (
+        <Box marginTop={1}>
+          <Text color={theme.accentError}>{error}</Text>
+        </Box>
+      )}
+      {!isLoading && !hasAnything && (
+        <Box marginTop={1}>
+          <Text color={theme.dim}>Nothing to delete. The skills tree is empty.</Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Select<DeleteTarget>
+          options={options}
+          hintLayout="inline"
+          onSubmit={choice => {
+            if (choice.kind === 'cancel') return onCancel()
+            return onPick(choice)
+          }}
+          onCancel={onCancel}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+function buildOptions(
+  entries: SkillIndexEntry[],
+  isLoading: boolean,
+): Array<SelectOption<DeleteTarget>> {
+  const rows: Array<SelectOption<DeleteTarget>> = []
+  const noopValue: DeleteTarget = { kind: 'cancel' }
+
+  if (isLoading) {
+    rows.push({
+      value: noopValue,
+      role: 'notice',
+      label: 'Loading...',
+      labelColor: theme.dim,
+      indent: 0,
+    })
+  } else if (entries.length > 0) {
+    rows.push({ value: noopValue, role: 'section', label: 'Targets' })
+    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 ? '└── ' : '├── '
+      rows.push({
+        value: { kind: 'skill', relativePath: skill.relativePath },
+        label: `${branch}${skill.name}/`,
+        indent: 3,
+      })
+    }
+  }
+
+  rows.push({ value: noopValue, role: 'section', label: 'Navigation' })
+  rows.push({
+    value: { kind: 'cancel' },
+    label: 'Back',
+    hint: 'Return to Skills',
+    role: 'utility',
+  })
+
+  return rows
+}

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/SkillVisibilityScreen.tsx

@@ -0,0 +1,171 @@
+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 } from '../../../continuity/skills/loadSkills.js'
+import type { SkillIndexEntry, SkillVisibility } from '../../../continuity/skills/types.js'
+
+interface SkillVisibilityListProps {
+  identity?: EthagentIdentity
+  notice?: string
+  footer: React.ReactNode
+  onPick: (relativePath: string) => void
+  onCancel: () => void
+}
+
+type PickAction =
+  | { kind: 'skill'; relativePath: string }
+  | { kind: 'cancel' }
+
+export const SkillVisibilityListScreen: React.FC<SkillVisibilityListProps> = ({
+  identity,
+  notice,
+  footer,
+  onPick,
+  onCancel,
+}) => {
+  const [entries, setEntries] = useState<SkillIndexEntry[] | null>(null)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) {
+      setEntries([])
+      return () => { cancelled = true }
+    }
+    listSkills(identity)
+      .then(list => { if (!cancelled) { setEntries(list); setError(null) } })
+      .catch(err => {
+        if (cancelled) return
+        setEntries([])
+        setError(String((err as Error).message ?? err))
+      })
+    return () => { cancelled = true }
+  }, [identity])
+
+  const subtitle = notice ?? 'Pick a skill to change its visibility in the public manifest.'
+  const isLoading = entries === null
+  const skills = entries ?? []
+
+  const options: Array<SelectOption<PickAction>> = []
+  if (isLoading) {
+    options.push({ value: { kind: 'cancel' }, role: 'notice', label: 'Loading...', labelColor: theme.dim, indent: 0 })
+  } else if (skills.length === 0) {
+    options.push({ value: { kind: 'cancel' }, role: 'notice', label: 'No skills yet. Create one first.', labelColor: theme.dim, indent: 0 })
+  } else {
+    options.push({ value: { kind: 'cancel' }, role: 'section', label: 'Skills' })
+    for (const skill of skills) {
+      options.push({
+        value: { kind: 'skill', relativePath: skill.relativePath },
+        label: skill.displayName ?? skill.name,
+        hint: visibilityBadge(skill.visibility),
+        hintColor: visibilityColor(skill.visibility),
+      })
+    }
+  }
+  options.push({ value: { kind: 'cancel' }, role: 'section', label: 'Navigation' })
+  options.push({ value: { kind: 'cancel' }, label: 'Back', hint: 'Return to Skills', role: 'utility' })
+
+  return (
+    <Surface title="Skill Visibility" subtitle={subtitle} footer={footer}>
+      {error && (
+        <Box marginTop={1}>
+          <Text color={theme.accentError}>{error}</Text>
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Select<PickAction>
+          options={options}
+          hintLayout="inline"
+          onSubmit={choice => {
+            if (choice.kind === 'cancel') return onCancel()
+            return onPick(choice.relativePath)
+          }}
+          onCancel={onCancel}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+interface SkillVisibilityPickProps {
+  identity?: EthagentIdentity
+  relativePath: string
+  footer: React.ReactNode
+  onSelect: (visibility: SkillVisibility) => void
+  onCancel: () => void
+}
+
+export const SkillVisibilityPickScreen: React.FC<SkillVisibilityPickProps> = ({
+  identity,
+  relativePath,
+  footer,
+  onSelect,
+  onCancel,
+}) => {
+  const [current, setCurrent] = useState<SkillVisibility | null>(null)
+  const [displayName, setDisplayName] = useState<string>(relativePath)
+
+  useEffect(() => {
+    let cancelled = false
+    if (!identity) return () => { cancelled = true }
+    listSkills(identity)
+      .then(list => {
+        if (cancelled) return
+        const match = list.find(entry => entry.relativePath === relativePath)
+        if (match) {
+          setCurrent(match.visibility)
+          setDisplayName(match.displayName ?? match.name)
+        }
+      })
+      .catch(() => null)
+    return () => { cancelled = true }
+  }, [identity, relativePath])
+
+  const subtitle = current
+    ? `Current: ${current}. Pick a new value.`
+    : 'Pick a visibility level.'
+
+  return (
+    <Surface title={`Visibility · ${displayName}`} subtitle={subtitle} footer={footer}>
+      <Box marginTop={1}>
+        <Select<SkillVisibility | 'cancel'>
+          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: 'cancel', role: 'section', label: 'Navigation' },
+            { value: 'cancel', label: 'Back', hint: 'Return to skill list', role: 'utility' },
+          ]}
+          hintLayout="inline"
+          initialIndex={current ? indexForVisibility(current) : 0}
+          onSubmit={choice => {
+            if (choice === 'cancel') return onCancel()
+            return onSelect(choice)
+          }}
+          onCancel={onCancel}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+function visibilityBadge(visibility: SkillVisibility): string {
+  if (visibility === 'public') return '[public]'
+  if (visibility === 'discoverable') return '[discoverable]'
+  return '[private]'
+}
+
+function visibilityColor(visibility: SkillVisibility): string {
+  if (visibility === 'public') return theme.accentPeriwinkle
+  if (visibility === 'discoverable') return theme.textSubtle
+  return theme.dim
+}
+
+function indexForVisibility(visibility: SkillVisibility): number {
+  if (visibility === 'private') return 0
+  if (visibility === 'discoverable') return 1
+  return 2
+}