agent-facets 0.1.2 → 0.2.1

package/src/tui/editor.ts

@@ -0,0 +1,40 @@
+import { spawnSync } from 'node:child_process'
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+/**
+ * Opens the user's preferred terminal editor with the given content.
+ * Returns the edited content after the editor closes.
+ *
+ * This is synchronous — it blocks the event loop while the editor is open.
+ * Callers must ensure the TUI is in a safe state before calling.
+ *
+ * Uses $VISUAL, $EDITOR, or falls back to 'vi'.
+ */
+export function openInEditorSync(content: string, filename = 'description.md'): string | null {
+  const editor = process.env.VISUAL || process.env.EDITOR || 'vi'
+  const tmpFile = join(tmpdir(), `facet-${Date.now()}-${filename}`)
+
+  writeFileSync(tmpFile, content, 'utf-8')
+
+  // Split editor command to support args (e.g., "code --wait")
+  const [cmd, ...args] = editor.split(' ')
+  if (!cmd) return null
+
+  const result = spawnSync(cmd, [...args, tmpFile], {
+    stdio: 'inherit',
+  })
+
+  if (result.status !== 0) return null
+
+  const edited = readFileSync(tmpFile, 'utf-8')
+
+  try {
+    unlinkSync(tmpFile)
+  } catch {
+    // Ignore cleanup failures
+  }
+
+  return edited
+}

package/src/tui/views/build/build-view.tsx

@@ -1,6 +1,12 @@
-import { type BuildProgress, runBuildPipeline, writeBuildOutput } from '@agent-facets/core'
+import {
+  BUILD_STAGES,
+  type BuildProgress,
+  type BuildStage,
+  runBuildPipeline,
+  writeBuildOutput,
+} from '@agent-facets/core'
 import { Box, Text, useApp } from 'ink'
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
 import type { Stage } from '../../components/stage-row.tsx'
 import { StageRow } from '../../components/stage-row.tsx'
 import { THEME } from '../../theme.ts'
@@ -24,54 +30,61 @@ export function BuildView({
   onFailure?: (errorCount: number) => void
 }) {
   const { exit } = useApp()
-  const [stages, setStages] = useState<Stage[]>([
-    { label: 'Validating manifest', status: 'pending' },
-    { label: 'Assembling archive', status: 'pending' },
-    { label: 'Writing output', status: 'pending' },
-  ])
+  const [stages, setStages] = useState<Stage[]>(BUILD_STAGES.map((label) => ({ label, status: 'pending' as const })))
   const [result, setResult] = useState<BuildViewResult | null>(null)
-  const [errors, setErrors] = useState<string[]>([])
   const [warnings, setWarnings] = useState<string[]>([])
 
-  const updateStage = useCallback((index: number, update: Partial<Stage>) => {
-    setStages((prev) => prev.map((s, i) => (i === index ? { ...s, ...update } : s)))
-  }, [])
+  // Deferred exit: set this to an Error to exit after the next render cycle,
+  // ensuring error/stage state updates are painted before Ink unmounts.
+  const [pendingExit, setPendingExit] = useState<Error | null>(null)
 
   useEffect(() => {
-    async function run() {
-      // Stages 1 & 2: Validate and assemble archive (pipeline handles both, emits progress)
-      const stageIndexMap: Record<string, number> = {
-        'Validating manifest': 0,
-        'Assembling archive': 1,
+    if (pendingExit) {
+      exit(pendingExit)
+    }
+  }, [pendingExit, exit])
+
+  // Build a stable lookup from stage label to index
+  const stageIndexMap = useMemo(() => Object.fromEntries(BUILD_STAGES.map((label, i) => [label, i])), [])
+
+  const updateStage = useCallback(
+    (label: BuildStage, update: Partial<Stage>) => {
+      const index = stageIndexMap[label]
+      if (index !== undefined) {
+        setStages((prev) => prev.map((s, i) => (i === index ? { ...s, ...update } : s)))
       }
+    },
+    [stageIndexMap],
+  )
 
+  useEffect(() => {
+    async function run() {
       const pipelineResult = await runBuildPipeline(rootDir, (progress: BuildProgress) => {
-        const index = stageIndexMap[progress.stage]
-        if (index !== undefined) {
-          updateStage(index, {
-            status: progress.status === 'running' ? 'running' : progress.status === 'done' ? 'done' : 'failed',
-          })
-        }
+        updateStage(progress.stage, {
+          status: progress.status === 'running' ? 'running' : progress.status === 'done' ? 'done' : 'failed',
+        })
       })
 
       setWarnings(pipelineResult.warnings)
 
       if (!pipelineResult.ok) {
-        setErrors(pipelineResult.errors.map((e) => `${e.path ? `${e.path}: ` : ''}${e.message}`))
+        const formatted = pipelineResult.errors.map((e) => e.message)
+        // Find the stage that failed and attach errors to it
+        setStages((prev) => prev.map((s) => (s.status === 'failed' ? { ...s, errors: formatted } : s)))
         onFailure?.(pipelineResult.errors.length)
-        exit(new Error('Build failed'))
+        // Defer exit so React renders the errors and failed stage status first
+        setPendingExit(new Error('Build failed'))
         return
       }
 
-      // Stage 3: Write output
-      updateStage(2, { status: 'running' })
+      // Writing output stage — handled here, not by the pipeline
+      updateStage('Writing output', { status: 'running' })
       try {
         await writeBuildOutput(pipelineResult, rootDir)
 
-        // Derive file list from asset hashes (these are the files inside the archive)
         const files = Object.keys(pipelineResult.assetHashes).sort()
 
-        updateStage(2, { status: 'done' })
+        updateStage('Writing output', { status: 'done' })
         setResult({
           name: pipelineResult.data.name,
           version: pipelineResult.data.version,
@@ -83,8 +96,8 @@ export function BuildView({
         onSuccess?.(pipelineResult.data.name, pipelineResult.data.version, files.length, pipelineResult.integrity)
         exit()
       } catch (err) {
-        updateStage(2, { status: 'failed', detail: String(err) })
-        exit(err instanceof Error ? err : new Error(String(err)))
+        updateStage('Writing output', { status: 'failed', detail: String(err) })
+        setPendingExit(err instanceof Error ? err : new Error(String(err)))
       }
     }
 
@@ -114,20 +127,6 @@ export function BuildView({
         </Box>
       )}
 
-      {errors.length > 0 && (
-        <Box flexDirection="column">
-          <Text bold color={THEME.warning}>
-            Errors:
-          </Text>
-          {errors.map((e) => (
-            <Text key={e} color={THEME.warning}>
-              {' '}
-              {e}
-            </Text>
-          ))}
-        </Box>
-      )}
-
       {result && (
         <Box flexDirection="column">
           <Text color={THEME.success} bold>

package/src/tui/views/create/create-view.tsx

@@ -1,7 +1,7 @@
 import { Box, Text } from 'ink'
 import { useCallback, useEffect } from 'react'
 import { ASSET_LABELS, ASSET_TYPES } from '../../../commands/create/types.ts'
-import { isValidKebabCase } from '../../../commands/create-scaffold.ts'
+import { DEFAULT_VERSION, isValidKebabCase } from '../../../commands/create-scaffold.ts'
 import { AssetSection } from '../../components/asset-section.tsx'
 import { Button } from '../../components/button.tsx'
 import { EditableField } from '../../components/editable-field.tsx'
@@ -9,7 +9,7 @@ import { useFocusOrder } from '../../context/focus-order-context.ts'
 import { useFormState } from '../../context/form-state-context.ts'
 import { WizardLayout } from '../../layouts/wizard-layout.tsx'
 
-function computeFocusIds(form: ReturnType<typeof useFormState>['form'], hasAnyAsset: boolean): string[] {
+function computeFocusIds(form: ReturnType<typeof useFormState>['form']): string[] {
   const ids: string[] = ['field-name', 'field-description', 'field-version']
 
   for (const type of ASSET_TYPES) {
@@ -22,14 +22,18 @@ function computeFocusIds(form: ReturnType<typeof useFormState>['form'], hasAnyAs
     ids.push(`add-${type}`)
   }
 
-  if (hasAnyAsset) {
-    ids.push('create-btn')
-  }
+  ids.push('create-btn')
 
   return ids
 }
 
-export function CreateView({ onSubmit }: { onSubmit: () => void }) {
+export function CreateView({
+  onSubmit,
+  onEditDescription,
+}: {
+  onSubmit: () => void
+  onEditDescription?: (section: import('../../context/form-state-context.ts').AssetSectionKey, name: string) => void
+}) {
   const { form } = useFormState()
   const { setFocusIds, focus, focusedId } = useFocusOrder()
 
@@ -54,18 +58,17 @@ export function CreateView({ onSubmit }: { onSubmit: () => void }) {
   const assetsReady = nameSettled && descriptionSettled && versionSettled
 
   const totalAssets = form.assets.skill.items.length + form.assets.command.items.length + form.assets.agent.items.length
-  const hasAnyAsset = totalAssets > 0
-  const canCreate = assetsReady && hasAnyAsset
+  const canCreate = assetsReady && totalAssets > 0
 
   // Recompute focus order
   useEffect(() => {
-    const ids = computeFocusIds(form, hasAnyAsset)
+    const ids = computeFocusIds(form)
     setFocusIds(ids)
 
     if (focusedId && !ids.includes(focusedId)) {
       focus(ids[0] ?? '')
     }
-  }, [form, hasAnyAsset, setFocusIds, focus, focusedId])
+  }, [form, setFocusIds, focus, focusedId])
 
   // Auto-focus name field on mount
   useEffect(() => {
@@ -97,9 +100,9 @@ export function CreateView({ onSubmit }: { onSubmit: () => void }) {
         field="version"
         label="Version"
         hint="SemVer N.N.N"
-        defaultValue="0.1.0"
+        defaultValue={DEFAULT_VERSION}
         dimmed={!versionReady}
-        validate={(v) => (/^\d+\.\d+\.\d+$/.test(v) ? undefined : 'Must be SemVer (e.g., 0.1.0)')}
+        validate={(v) => (/^\d+\.\d+\.\d+$/.test(v) ? undefined : `Must be SemVer (e.g., ${DEFAULT_VERSION})`)}
         onConfirm={() => focus(`add-${ASSET_TYPES[0]}`)}
       />
 
@@ -110,6 +113,7 @@ export function CreateView({ onSubmit }: { onSubmit: () => void }) {
             label={ASSET_LABELS[type]}
             defaultName={form.assets[type].items.length === 0 ? form.fields.name.value : undefined}
             dimmed={!assetsReady}
+            onEditDescription={onEditDescription}
             validate={(v) => {
               if (!isValidKebabCase(v)) return 'Must be kebab-case'
               const editing = form.assets[type].editing
@@ -141,7 +145,7 @@ export function CreateView({ onSubmit }: { onSubmit: () => void }) {
                 ? 'Enter a description to continue'
                 : !versionConfirmed
                   ? 'Enter a version to continue'
-                  : 'Add at least one skill, command, or agent'}
+                  : 'Add at least one skill, agent, or command'}
           </Text>
         </Box>
       )}

package/src/tui/views/create/wizard.tsx

@@ -1,26 +1,46 @@
 import { useApp } from 'ink'
-import { useCallback, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import type { CreateOptions } from '../../../commands/create-scaffold.ts'
 import { FocusModeProvider, useFocusMode } from '../../context/focus-mode-context.ts'
-import { FocusOrderProvider } from '../../context/focus-order-context.ts'
+import { FocusOrderProvider, useFocusOrder } from '../../context/focus-order-context.ts'
+import type { AssetSectionKey, FormState } from '../../context/form-state-context.ts'
 import { FormStateProvider, useFormState } from '../../context/form-state-context.ts'
 import { useExitKeys } from '../../hooks/use-exit-keys.ts'
 import { useNavigationKeys } from '../../hooks/use-navigation-keys.ts'
 import { ConfirmView } from './confirm-view.tsx'
 import { CreateView } from './create-view.tsx'
 
+export interface WizardSnapshot {
+  form: FormState
+  focusedId: string | null
+  selectedItem?: {
+    section: AssetSectionKey
+    name: string
+    field: 'name' | 'description'
+  }
+}
+
 export interface CreateWizardProps {
   onComplete: (opts: CreateOptions) => void
   onCancel: () => void
+  snapshot?: WizardSnapshot
+  onSnapshot?: (snapshot: WizardSnapshot) => void
+  onRequestEditor?: (section: AssetSectionKey, name: string, description: string) => void
 }
 
-function CreateWizardInner({ onComplete, onCancel }: CreateWizardProps) {
+function CreateWizardInner({ onComplete, onCancel, snapshot, onSnapshot, onRequestEditor }: CreateWizardProps) {
   const { exit } = useApp()
   const { setMode } = useFocusMode()
-  const { toCreateOptions } = useFormState()
+  const { form, toCreateOptions } = useFormState()
+  const { focusedId } = useFocusOrder()
 
   const [confirming, setConfirming] = useState(false)
 
+  // Keep the parent informed of current state for snapshot
+  useEffect(() => {
+    onSnapshot?.({ form, focusedId, selectedItem: snapshot?.selectedItem })
+  }, [form, focusedId, onSnapshot, snapshot?.selectedItem])
+
   const cancel = useCallback(() => {
     onCancel()
     exit()
@@ -29,6 +49,14 @@ function CreateWizardInner({ onComplete, onCancel }: CreateWizardProps) {
   useExitKeys(cancel)
   useNavigationKeys()
 
+  const handleEditDescription = useCallback(
+    (section: AssetSectionKey, name: string) => {
+      const description = form.assets[section].descriptions[name] ?? ''
+      onRequestEditor?.(section, name, description)
+    },
+    [form, onRequestEditor],
+  )
+
   if (confirming) {
     return (
       <ConfirmView
@@ -51,6 +79,7 @@ function CreateWizardInner({ onComplete, onCancel }: CreateWizardProps) {
         setConfirming(true)
         setMode('form-confirmation')
       }}
+      onEditDescription={handleEditDescription}
     />
   )
 }
@@ -58,8 +87,8 @@ function CreateWizardInner({ onComplete, onCancel }: CreateWizardProps) {
 export function CreateWizard(props: CreateWizardProps) {
   return (
     <FocusModeProvider>
-      <FocusOrderProvider>
-        <FormStateProvider>
+      <FocusOrderProvider initialFocusId={props.snapshot?.focusedId}>
+        <FormStateProvider initialState={props.snapshot?.form}>
           <CreateWizardInner {...props} />
         </FormStateProvider>
       </FocusOrderProvider>

package/src/tui/views/edit/edit-confirm-view.tsx

@@ -0,0 +1,93 @@
+import { Box, Text } from 'ink'
+import { useEffect } from 'react'
+import { truncateDescription } from '../../components/asset-description.tsx'
+import { Button } from '../../components/button.tsx'
+import { useFocusOrder } from '../../context/focus-order-context.ts'
+import type { AssetSectionKey } from '../../context/form-state-context.ts'
+import { useFormState } from '../../context/form-state-context.ts'
+import { THEME } from '../../theme.ts'
+
+const ASSET_TYPES: AssetSectionKey[] = ['skill', 'command', 'agent']
+const ASSET_LABELS: Record<AssetSectionKey, string> = {
+  skill: 'Skills',
+  command: 'Commands',
+  agent: 'Agents',
+}
+
+export function EditConfirmView({ onConfirm, onBack }: { onConfirm: () => void; onBack: () => void }) {
+  const { form } = useFormState()
+  const { setFocusIds, focus, focusedId } = useFocusOrder()
+
+  useEffect(() => {
+    setFocusIds(['edit-apply-btn', 'edit-back-btn'])
+    focus('edit-apply-btn')
+  }, [setFocusIds, focus])
+
+  return (
+    <Box flexDirection="column" padding={1} gap={1}>
+      <Text bold color={THEME.brand}>
+        Review changes
+      </Text>
+
+      <Box flexDirection="column">
+        <Box gap={1}>
+          <Text bold>Name:</Text>
+          <Text>{form.fields.name.value || '(none)'}</Text>
+        </Box>
+        <Box gap={1}>
+          <Text bold>Description:</Text>
+          <Text>{truncateDescription(form.fields.description.value || '(none)')}</Text>
+        </Box>
+        <Box gap={1}>
+          <Text bold>Version:</Text>
+          <Text>{form.fields.version.value || '(none)'}</Text>
+        </Box>
+      </Box>
+
+      {ASSET_TYPES.map((type) => {
+        const section = form.assets[type]
+        return (
+          <Box key={type} flexDirection="column">
+            <Text bold>{ASSET_LABELS[type]}:</Text>
+            {section.items.length === 0 ? (
+              <Box marginLeft={2}>
+                <Text dimColor>(none)</Text>
+              </Box>
+            ) : (
+              section.items.map((item) => {
+                const desc = section.descriptions[item] ?? `A ${item} ${type}`
+                return (
+                  <Box key={item} flexDirection="column" marginLeft={2}>
+                    <Box gap={1}>
+                      <Text color={THEME.success}>●</Text>
+                      <Text>{item}</Text>
+                    </Box>
+                    <Box marginLeft={3}>
+                      <Text dimColor>{truncateDescription(desc)}</Text>
+                    </Box>
+                  </Box>
+                )
+              })
+            )}
+          </Box>
+        )
+      })}
+
+      <Box marginTop={1} gap={2}>
+        <Button
+          id="edit-apply-btn"
+          label="[ Yes, apply ]"
+          color={THEME.success}
+          gradient={focusedId === 'edit-apply-btn'}
+          animateGradient={focusedId === 'edit-apply-btn'}
+          onPress={onConfirm}
+        />
+        <Button id="edit-back-btn" label="[ No, go back ]" color={THEME.warning} onPress={onBack} />
+      </Box>
+
+      <Box>
+        <Text dimColor>← → switch · Enter confirm</Text>
+      </Box>
+    </Box>
+  )
+}

package/src/tui/views/edit/edit-types.ts

@@ -0,0 +1,34 @@
+import type { AssetType, FacetManifest } from '@agent-facets/core'
+
+/** A reconciliation item that needs a resolution before editing can proceed. */
+export type ReconciliationItem =
+  | { kind: 'addition'; type: AssetType; name: string; path: string }
+  | { kind: 'missing'; type: AssetType; name: string; expectedPath: string }
+  | { kind: 'front-matter'; type: AssetType; name: string; path: string }
+
+/** The resolution chosen for a reconciliation item. */
+export type ReconciliationResolution =
+  | { action: 'add-to-manifest' }
+  | { action: 'ignore' }
+  | { action: 'scaffold-template' }
+  | { action: 'remove-from-manifest' }
+  | { action: 'strip-front-matter' }
+
+/** All data needed to run the edit TUI. */
+export interface EditContext {
+  rootDir: string
+  manifest: FacetManifest
+  reconciliationItems: ReconciliationItem[]
+}
+
+/** The result of the edit wizard — either applied changes or cancelled. */
+export type EditResult =
+  | { outcome: 'applied'; manifest: FacetManifest; operations: EditOperation[] }
+  | { outcome: 'cancelled' }
+
+/** A file operation to perform on confirmation. */
+export type EditOperation =
+  | { op: 'write-manifest' }
+  | { op: 'scaffold'; type: AssetType; name: string }
+  | { op: 'delete-file'; type: AssetType; name: string }
+  | { op: 'strip-front-matter'; type: AssetType; name: string; path: string }

package/src/tui/views/edit/edit-view.tsx

@@ -0,0 +1,140 @@
+import { Box, Text } from 'ink'
+import { useCallback, useEffect } from 'react'
+import { DEFAULT_VERSION, isValidKebabCase } from '../../../commands/create-scaffold.ts'
+import { AssetSection } from '../../components/asset-section.tsx'
+import { Button } from '../../components/button.tsx'
+import { EditableField } from '../../components/editable-field.tsx'
+import { useFocusOrder } from '../../context/focus-order-context.ts'
+import type { AssetSectionKey } from '../../context/form-state-context.ts'
+import { useFormState } from '../../context/form-state-context.ts'
+import { THEME } from '../../theme.ts'
+
+const ASSET_TYPES: AssetSectionKey[] = ['skill', 'command', 'agent']
+const ASSET_LABELS: Record<AssetSectionKey, string> = {
+  skill: 'Skills',
+  command: 'Commands',
+  agent: 'Agents',
+}
+
+function computeFocusIds(form: ReturnType<typeof useFormState>['form']): string[] {
+  const ids: string[] = ['field-name', 'field-description', 'field-version']
+
+  for (const type of ASSET_TYPES) {
+    const section = form.assets[type]
+
+    for (let i = 0; i < section.items.length; i++) {
+      ids.push(`item-${type}-${i}`)
+    }
+
+    ids.push(`add-${type}`)
+  }
+
+  ids.push('edit-confirm-btn')
+  return ids
+}
+
+export function EditView({
+  onSubmit,
+  onEditDescription,
+}: {
+  onSubmit: () => void
+  onEditDescription?: (section: AssetSectionKey, name: string) => void
+}) {
+  const { form } = useFormState()
+  const { setFocusIds, focus, focusedId } = useFocusOrder()
+
+  const validateKebab = useCallback((v: string) => {
+    if (!v) return undefined
+    if (!isValidKebabCase(v)) return 'Must be kebab-case (e.g., my-facet)'
+    return undefined
+  }, [])
+
+  useEffect(() => {
+    const ids = computeFocusIds(form)
+    setFocusIds(ids)
+
+    if (focusedId && !ids.includes(focusedId)) {
+      focus(ids[0] ?? '')
+    }
+  }, [form, setFocusIds, focus, focusedId])
+
+  const totalAssets = form.assets.skill.items.length + form.assets.agent.items.length + form.assets.command.items.length
+  const canConfirm = totalAssets > 0
+
+  useEffect(() => {
+    if (!focusedId) {
+      focus('field-name')
+    }
+  }, [focusedId, focus])
+
+  return (
+    <Box flexDirection="column" padding={1} gap={1}>
+      <Text bold color={THEME.brand}>
+        Edit facet
+      </Text>
+
+      <Box flexDirection="column">
+        <EditableField
+          field="name"
+          label="Name"
+          placeholder="my-facet"
+          hint="kebab-case"
+          validate={validateKebab}
+          onConfirm={() => focus('field-description')}
+        />
+
+        <EditableField
+          field="description"
+          label="Description"
+          placeholder="A brief description"
+          onConfirm={() => focus('field-version')}
+        />
+
+        <EditableField
+          field="version"
+          label="Version"
+          hint="SemVer N.N.N"
+          validate={(v) => (/^\d+\.\d+\.\d+$/.test(v) ? undefined : `Must be SemVer (e.g., ${DEFAULT_VERSION})`)}
+          onConfirm={() => focus(`add-${ASSET_TYPES[0]}`)}
+        />
+      </Box>
+
+      {ASSET_TYPES.map((type) => (
+        <Box key={type} marginTop={0}>
+          <AssetSection
+            section={type}
+            label={ASSET_LABELS[type]}
+            onEditDescription={onEditDescription}
+            validate={(v) => {
+              if (!isValidKebabCase(v)) return 'Must be kebab-case'
+              const editing = form.assets[type].editing
+              if (form.assets[type].items.some((item) => item === v && item !== editing)) return `"${v}" already exists`
+              return undefined
+            }}
+          />
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Button
+          id="edit-confirm-btn"
+          label="[ Review & Confirm ]"
+          disabled={!canConfirm}
+          gradient={canConfirm}
+          animateGradient={canConfirm && focusedId === 'edit-confirm-btn'}
+          onPress={onSubmit}
+        />
+      </Box>
+
+      {!canConfirm && (
+        <Box marginLeft={2}>
+          <Text dimColor>Add at least one skill, agent, or command</Text>
+        </Box>
+      )}
+
+      <Box>
+        <Text dimColor>↑ ↓ navigate · Enter edit · Esc Esc exit (no changes)</Text>
+      </Box>
+    </Box>
+  )
+}

package/src/tui/views/edit/manifest-to-form.ts

@@ -0,0 +1,38 @@
+import type { FacetManifest } from '@agent-facets/core'
+import type { AssetSectionKey, FormState } from '../../context/form-state-context.ts'
+
+/** Maps manifest asset keys to form section keys. */
+const MANIFEST_TO_FORM: Record<string, AssetSectionKey> = {
+  skills: 'skill',
+  agents: 'agent',
+  commands: 'command',
+}
+
+/** Builds initial form state from an existing manifest. */
+export function manifestToFormState(manifest: FacetManifest): FormState {
+  const assets: FormState['assets'] = {
+    skill: { items: [], descriptions: {}, editing: undefined, adding: false },
+    agent: { items: [], descriptions: {}, editing: undefined, adding: false },
+    command: { items: [], descriptions: {}, editing: undefined, adding: false },
+  }
+
+  for (const [manifestKey, formKey] of Object.entries(MANIFEST_TO_FORM)) {
+    const section = manifest[manifestKey as keyof FacetManifest]
+    if (section && typeof section === 'object' && !Array.isArray(section)) {
+      const entries = section as Record<string, { description?: string }>
+      for (const [name, descriptor] of Object.entries(entries)) {
+        assets[formKey].items.push(name)
+        assets[formKey].descriptions[name] = descriptor.description ?? `A ${name} ${formKey}`
+      }
+    }
+  }
+
+  return {
+    fields: {
+      name: { value: manifest.name, status: 'confirmed' },
+      description: { value: manifest.description ?? '', status: 'confirmed' },
+      version: { value: manifest.version, status: 'confirmed' },
+    },
+    assets,
+  }
+}