tissues 0.5.2 → 0.6.0

package/src/commands/drafts.js

@@ -0,0 +1,288 @@
+import { Command } from 'commander'
+import { store } from '../lib/config.js'
+import { loadConfig, findRepoRoot } from '../lib/defaults.js'
+import { readDrafts, markComplete, markDuplicate, markFailed, countPending } from '../lib/drafts.js'
+import { checkSafety, recordSuccess, recordFailure } from '../lib/safety.js'
+import { checkDuplicate, recordCreation } from '../lib/dedup.js'
+import { createIssue, verifyIssue } from '../lib/gh.js'
+import { bold, dim, red } from '../lib/color.js'
+import ora from 'ora'
+import { select, confirm } from '@inquirer/prompts'
+import { theme } from '../lib/theme.js'
+
+function isCancelled(err) {
+  return err?.name === 'ExitPromptError' || err?.message?.includes('User force closed')
+}
+
+async function promptOrBack(fn) {
+  try { return await fn() } catch (err) { if (isCancelled(err)) return Symbol.for('back'); throw err }
+}
+
+function timeAgo(isoString) {
+  const ts = new Date(isoString)
+  const diffMs = Date.now() - ts.getTime()
+  if (diffMs < 0) return 'just now'
+  const seconds = Math.floor(diffMs / 1000)
+  if (seconds < 60) return `${seconds}s ago`
+  const minutes = Math.floor(diffMs / 60_000)
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(diffMs / 3_600_000)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(diffMs / 86_400_000)
+  return `${days}d ago`
+}
+
+// ---------------------------------------------------------------------------
+// Publish logic — creates GitHub issues from pending drafts
+// ---------------------------------------------------------------------------
+
+async function publishItems(repo, repoRoot, config, agent) {
+  const allItems = readDrafts(repoRoot)
+  const flushable = new Set(['pending', 'draft'])
+  const items = allItems.filter((item) => item.repo === repo && flushable.has(item.status))
+
+  if (items.length === 0) {
+    const total = countPending(repoRoot)
+    if (total > 0) {
+      console.log(dim(`No pending items for ${repo}.`))
+      console.log(dim(`(${total} item(s) belong to other repos or have failed)`))
+    } else {
+      console.log(dim('No drafts to publish.'))
+    }
+    return
+  }
+
+  console.log(bold(`Publishing ${items.length} issue${items.length === 1 ? '' : 's'}...\n`))
+
+  const flushed = []
+  const skipped = []
+
+  for (const item of items) {
+    const safetyResult = checkSafety(repo, agent, config.safety)
+    if (!safetyResult.allowed) {
+      const remaining = items.length - flushed.length - skipped.length
+      console.log()
+      console.log(dim(`  ⏸ Sent ${flushed.length}/${items.length}. Rate limit reached — ${remaining} still in drafts.`))
+      return
+    }
+
+    const dedupSpinner = ora(`Checking: "${item.title}"`).start()
+    let dedupResult
+    try {
+      dedupResult = await checkDuplicate(repo, { title: item.title, body: item.body, agent })
+      dedupSpinner.stop()
+    } catch (err) {
+      dedupSpinner.warn(`Dedup failed (skipping): ${err.message}`)
+      dedupResult = { action: 'allow', results: [] }
+    }
+
+    if (dedupResult.action === 'block') {
+      recordFailure(repo, agent, config.safety)
+      console.log(dim(`  ⊘ Skipping "${item.title}" — duplicate`))
+      const reason = dedupResult.results.filter((r) => r.action === 'block').map((r) => r.reason).join('; ')
+      markDuplicate(item.id, reason, repoRoot)
+      skipped.push(item)
+      continue
+    }
+
+    const createSpinner = ora(`Creating: "${item.title}"`).start()
+    let issue
+    try {
+      issue = createIssue(repo, { title: item.title, body: item.body, labels: item.labels ?? [] })
+      createSpinner.succeed(`Created: ${issue.url}`)
+    } catch (err) {
+      createSpinner.fail(`Failed: "${item.title}" — ${err.message}`)
+      markFailed(item.id, err.message, repoRoot)
+      continue
+    }
+
+    const verified = verifyIssue(repo, issue.number)
+    if (!verified) {
+      console.warn(dim(`  #${issue.number} could not be verified — keeping in drafts`))
+      continue
+    }
+
+    markComplete(item.id, { issueNumber: issue.number, issueUrl: issue.url }, repoRoot)
+    try {
+      await recordCreation(repo, { title: item.title, body: item.body, issueNumber: issue.number, url: issue.url, agent })
+    } catch { /* non-fatal */ }
+    recordSuccess(repo, agent)
+    flushed.push({ title: item.title, number: issue.number, url: issue.url })
+  }
+
+  console.log()
+  if (flushed.length > 0) {
+    console.log(dim(`  ✓ Published ${flushed.length} issue${flushed.length === 1 ? '' : 's'}`))
+  }
+  if (skipped.length > 0) {
+    console.log(dim(`  ⊘ Skipped ${skipped.length} duplicate${skipped.length === 1 ? '' : 's'}`))
+  }
+  const stillPending = countPending(repoRoot)
+  if (stillPending === 0 && flushed.length > 0) {
+    console.log(dim('  No drafts remaining.'))
+  } else if (stillPending > 0) {
+    console.log(dim(`  ${stillPending} item(s) still in drafts.`))
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Interactive drafts management
+// ---------------------------------------------------------------------------
+
+async function manageDrafts(repo, repoRoot) {
+  while (true) {
+    const allItems = readDrafts(repoRoot)
+    const repoItems = allItems.filter((item) => item.repo === repo)
+    const flushable = new Set(['pending', 'draft'])
+    const pending = repoItems.filter((item) => flushable.has(item.status))
+    const failed = repoItems.filter((item) => item.status === 'failed')
+    const duplicates = repoItems.filter((item) => item.status === 'duplicate')
+    const aborted = repoItems.filter((item) => item.status === 'aborted')
+    const otherRepoCount = allItems.length - repoItems.length
+
+    console.log()
+    if (repoItems.length === 0 && otherRepoCount === 0) {
+      console.log(dim('  No drafts.'))
+      return
+    } else if (repoItems.length === 0) {
+      console.log(dim(`  No items for ${repo}.`))
+      if (otherRepoCount > 0) console.log(dim(`  ${otherRepoCount} in other repos`))
+    } else {
+      if (pending.length > 0) console.log(dim(`  ${pending.length} pending for ${repo}`))
+      if (failed.length > 0) console.log(dim(`  ${failed.length} failed for ${repo}`))
+      if (duplicates.length > 0) console.log(dim(`  ${duplicates.length} duplicate for ${repo}`))
+      if (aborted.length > 0) console.log(dim(`  ${aborted.length} aborted for ${repo}`))
+      if (otherRepoCount > 0) console.log(dim(`  ${otherRepoCount} in other repos`))
+    }
+
+    const choices = []
+    if (pending.length > 0) choices.push({ name: `Publish ${pending.length} pending`, value: 'publish' })
+    if (repoItems.length > 0) choices.push({ name: 'View items', value: 'view' })
+    if (failed.length > 0) choices.push({ name: `Retry ${failed.length} failed`, value: 'retry' })
+    if (repoItems.length > 0) choices.push({ name: 'Delete all', value: 'delete-all' })
+    choices.push({ name: 'Done', value: 'done' })
+
+    const action = await promptOrBack(() => select({ message: 'Drafts', choices, theme }))
+    if (action === Symbol.for('back') || action === 'done') return
+
+    if (action === 'publish') {
+      const config = loadConfig(repoRoot)
+      const agent = config.attribution?.defaultAgent ?? 'human'
+      await publishItems(repo, repoRoot, config, agent)
+      continue
+    }
+
+    if (action === 'retry') {
+      const config = loadConfig(repoRoot)
+      const agent = config.attribution?.defaultAgent ?? 'human'
+      console.log(bold(`\nRetrying ${failed.length} failed item(s)...\n`))
+      for (const item of failed) {
+        const safetyResult = checkSafety(repo, agent, config.safety)
+        if (!safetyResult.allowed) {
+          console.log(dim('  ⏸ Rate limit — try again later.'))
+          break
+        }
+        const spinner = ora(`Creating: "${item.title}"`).start()
+        try {
+          const issue = createIssue(repo, { title: item.title, body: item.body, labels: item.labels ?? [] })
+          spinner.succeed(`Created: ${issue.url}`)
+          markComplete(item.id, { issueNumber: issue.number, issueUrl: issue.url }, repoRoot)
+          recordSuccess(repo, agent)
+        } catch (err) {
+          spinner.fail(`Failed again: ${err.message}`)
+          markFailed(item.id, err.message, repoRoot)
+        }
+      }
+      continue
+    }
+
+    if (action === 'view') {
+      const viewChoices = repoItems.map((item) => {
+        const statusMap = { failed: 'FAIL', duplicate: 'DUP ', aborted: dim('ABRT'), draft: 'DRFT' }
+        const status = statusMap[item.status] ?? 'PEND'
+        return {
+          name: `${status} ${item.title.slice(0, 40).padEnd(40)} ${dim(timeAgo(item.createdAt))}`,
+          value: item.id,
+        }
+      })
+      viewChoices.push({ name: dim('Back'), value: 'back' })
+
+      const itemId = await promptOrBack(() => select({ message: 'Draft items', choices: viewChoices, theme }))
+      if (itemId === Symbol.for('back') || itemId === 'back') continue
+
+      const item = repoItems.find((i) => i.id === itemId)
+      if (item) {
+        console.log(`\n  ${bold(item.title)}`)
+        console.log(`  Status: ${item.status}  Created: ${item.createdAt}`)
+        if (item.error) console.log(`  Error: ${item.error}`)
+        if (item.labels?.length) console.log(`  Labels: ${item.labels.join(', ')}`)
+        console.log(dim('  ─'.repeat(20)))
+        console.log(dim(item.body?.slice(0, 300)))
+        if (item.body?.length > 300) console.log(dim('...'))
+
+        const itemAction = await promptOrBack(() =>
+          select({
+            message: 'Action',
+            choices: [
+              { name: 'Delete this item', value: 'delete' },
+              { name: dim('Back'), value: 'back' },
+            ],
+            theme,
+          }),
+        )
+        if (itemAction === 'delete') {
+          markComplete(item.id, {}, repoRoot)
+          console.log(dim(`  Removed "${item.title}"`))
+        }
+      }
+      continue
+    }
+
+    if (action === 'delete-all') {
+      const ok = await promptOrBack(() =>
+        confirm({ message: `Delete all ${repoItems.length} drafts for ${repo}?`, default: false, theme }),
+      )
+      if (ok === true) {
+        for (const item of repoItems) markComplete(item.id, {}, repoRoot)
+        console.log(dim(`  Deleted ${repoItems.length} items`))
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export const draftsCommand = new Command('drafts')
+  .description('Manage issue drafts (view, publish, retry, delete)')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .action(async (opts) => {
+    let repo = opts.repo || store.get('activeRepo')
+    if (!repo) {
+      console.error(red('No active repo. Set one with: tissues config'))
+      process.exit(1)
+    }
+
+    const repoRoot = findRepoRoot()
+    await manageDrafts(repo, repoRoot)
+  })
+
+// publish subcommand of drafts
+draftsCommand.addCommand(
+  new Command('publish')
+    .description('Publish pending drafts as GitHub issues')
+    .option('--repo <repo>', 'Repository override')
+    .option('--agent <name>', 'Agent identifier (default: human)')
+    .action(async (opts) => {
+      let repo = opts.repo || store.get('activeRepo')
+      if (!repo) {
+        console.error(red('No active repo. Set one with: tissues config'))
+        process.exit(1)
+      }
+      const repoRoot = findRepoRoot()
+      const config = loadConfig(repoRoot)
+      const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
+      await publishItems(repo, repoRoot, config, agent)
+    }),
+)

package/src/commands/list.js

@@ -1,9 +1,10 @@
 import { Command } from 'commander'
 import { search } from '@inquirer/prompts'
 import { store } from '../lib/config.js'
+import { theme } from '../lib/theme.js'
 import { pickRepo } from '../lib/repo-picker.js'
 import { requireAuth, listIssues } from '../lib/gh.js'
-import chalk from 'chalk'
+import { yellow, dim, cyan } from '../lib/color.js'
 import ora from 'ora'
 import { execSync } from 'child_process'
 
@@ -19,7 +20,7 @@ export const listCommand = new Command('list')
     }
 
     if (!repo) {
-      console.log(chalk.yellow('No active repo. Pick one:\n'))
+      console.log(yellow('No active repo. Pick one:\n'))
       repo = await pickRepo()
       console.log()
     }
@@ -29,12 +30,12 @@ export const listCommand = new Command('list')
     spinner.stop()
 
     if (issues.length === 0) {
-      console.log(chalk.dim('No open issues.'))
+      console.log(dim('No open issues.'))
       return
     }
 
     const selected = await search({
-      message: `Open issues in ${chalk.cyan(repo)}`,
+      message: `Open issues in ${cyan(repo)}`,
       source: (input) => {
         const term = (input || '').toLowerCase()
         return issues
@@ -48,12 +49,13 @@ export const listCommand = new Command('list')
             value: i.url,
           }))
       },
+      theme,
     })
 
     // Open in browser
     try {
       execSync(`open "${selected}"`)
     } catch {
-      console.log(`\nOpen: ${chalk.cyan(selected)}`)
+      console.log(`\nOpen: ${cyan(selected)}`)
     }
   })

package/src/commands/status.js

@@ -4,7 +4,9 @@ import { loadConfig, findRepoRoot } from '../lib/defaults.js'
 import { getSafetyStatus, forceReset } from '../lib/safety.js'
 import { getDb } from '../lib/db.js'
 import { getCircuitState, countRecentEvents, probeCircuit } from '../lib/db.js'
-import chalk from 'chalk'
+import { countPending } from '../lib/drafts.js'
+import { getAuthStatus } from '../lib/gh.js'
+import { bold, dim, red, green, yellow, cyan } from '../lib/color.js'
 
 /**
  * Query fingerprint count and last creation time for a repo from the DB.
@@ -66,13 +68,24 @@ function timeAgo(isoString) {
  * @returns {string}
  */
 function colorCircuitState(state) {
-  if (state === 'closed') return chalk.green('closed') + ' ' + chalk.green('✓')
-  if (state === 'open') return chalk.red('open') + ' ' + chalk.red('✗')
-  return chalk.yellow('half-open') + ' ' + chalk.yellow('~')
+  if (state === 'closed') return green('closed') + ' ' + green('✓')
+  if (state === 'open') return red('open') + ' ' + red('✗')
+  return yellow('half-open') + ' ' + yellow('~')
+}
+
+function maskKey(value) {
+  if (!value || typeof value !== 'string') return null
+  if (value.length <= 4) return '****'
+  return '****' + value.slice(-4)
+}
+
+function formatBudget(val) {
+  if (val === 0 || !val) return 'unlimited'
+  return val.toLocaleString()
 }
 
 export const statusCommand = new Command('status')
-  .description('Show safety status (circuit breaker + rate limits) for the active repo')
+  .description('Show auth, safety, and config status')
   .option('--repo <repo>', 'Repository override (owner/name)')
   .option('--agent <name>', "Check a specific agent's status (default: 'human')", 'human')
   .option('--reset', 'Force-reset the circuit breaker to closed')
@@ -83,19 +96,59 @@ export const statusCommand = new Command('status')
     }
 
     if (!repo) {
-      console.error(chalk.red('No active repo. Set one with: tissues use <owner/repo>'))
+      console.error(red('No active repo. Set one with: tissues config'))
       process.exit(1)
     }
 
+    const repoRoot = findRepoRoot()
+    const config = loadConfig(repoRoot)
     const agent = opts.agent
 
+    // --- Auth ---
+    console.log(bold('Auth'))
+    try {
+      const status = getAuthStatus()
+      const active = status.accounts?.find((a) => a.active)
+      if (active) {
+        console.log(`  GitHub: ${green('✔')} ${active.login}`)
+      } else {
+        console.log(`  GitHub: ${red('✗')} not logged in`)
+      }
+    } catch {
+      console.log(`  GitHub: ${red('✗')} gh CLI not available`)
+    }
+    console.log(`  Active repo: ${cyan(repo)}`)
+
+    // --- AI config ---
+    console.log()
+    console.log(bold('AI'))
+    const aiEnabled = config.ai?.enabled !== false
+    console.log(`  Enabled:  ${aiEnabled ? green('yes') : dim('no')}`)
+    if (aiEnabled) {
+      console.log(`  Provider: ${config.ai?.provider || dim('not set')}`)
+      const providers = ['anthropic', 'openai', 'gemini']
+      const keys = providers.filter((p) => config.ai?.keys?.[p]).map((p) => `${p} (${maskKey(config.ai.keys[p])})`)
+      console.log(`  Keys:     ${keys.length > 0 ? keys.join(', ') : dim('none')}`)
+      const budgets = config.ai?.budgets || {}
+      console.log(`  Budgets:  ${formatBudget(budgets.maxTokensPerRequest)}/req, ${formatBudget(budgets.maxTokensPerHour)}/hr, ${formatBudget(budgets.maxTokensPerDay)}/day`)
+      const routes = config.ai?.routes || []
+      console.log(`  Routes:   ${routes.length > 0 ? `${routes.length} rule${routes.length === 1 ? '' : 's'}` : dim('none')}`)
+    }
+
+    // --- Template ---
+    console.log()
+    console.log(bold('Templates'))
+    console.log(`  Default: ${config.templates?.default || 'default'}`)
+
     // Handle --reset before displaying status
     if (opts.reset) {
       forceReset(repo, agent)
-      console.log(chalk.green(`Circuit breaker reset to closed for ${repo} / ${agent}`))
+      console.log(green(`\nCircuit breaker reset to closed for ${repo} / ${agent}`))
     }
 
-    const config = loadConfig(findRepoRoot())
+    // --- Safety ---
+    console.log()
+    console.log(bold('Safety'))
     const safetyCfg = config.safety ?? {}
 
     const cfg = {
@@ -130,7 +183,7 @@ export const statusCommand = new Command('status')
     const agentHourRemaining = Math.max(0, cfg.maxPerHour - agentHourCount)
     const globalHourRemaining = Math.max(0, cfg.globalMaxPerHour - globalHourCount)
 
-    console.log(`Circuit Breaker: ${colorCircuitState(circuitState)}`)
+    console.log(`  Circuit:    ${colorCircuitState(circuitState)}`)
     if (circuitState === 'open' && circuit.cooldownUntil) {
       const until = new Date(
         circuit.cooldownUntil.endsWith('Z') ? circuit.cooldownUntil : circuit.cooldownUntil + 'Z'
@@ -138,29 +191,38 @@ export const statusCommand = new Command('status')
       const diffMs = until - Date.now()
       if (diffMs > 0) {
         const mins = Math.ceil(diffMs / 60_000)
-        console.log(chalk.dim(`  Cooldown: ${mins} minute${mins === 1 ? '' : 's'} remaining`))
+        console.log(dim(`              Cooldown: ${mins} minute${mins === 1 ? '' : 's'} remaining`))
       }
     }
 
     console.log(
-      `Rate Limit: ${agentHourCount}/${cfg.maxPerHour} per hour` +
-        chalk.dim(` (${agentHourRemaining} remaining)`)
+      `  Rate:       ${agentHourCount}/${cfg.maxPerHour} per hour` +
+        dim(` (${agentHourRemaining} remaining)`)
     )
     console.log(
-      `Burst: ${agentBurstCount}/${cfg.burstLimit} in last ${cfg.burstWindowMinutes} min`
+      `  Burst:      ${agentBurstCount}/${cfg.burstLimit} in last ${cfg.burstWindowMinutes} min`
     )
     console.log(
-      `Global: ${globalHourCount}/${cfg.globalMaxPerHour} per hour` +
-        chalk.dim(` (${globalHourRemaining} remaining)`)
+      `  Global:     ${globalHourCount}/${cfg.globalMaxPerHour} per hour` +
+        dim(` (${globalHourRemaining} remaining)`)
     )
 
     console.log()
-
     if (lastCreatedAt) {
-      console.log(`Last issue created: ${timeAgo(lastCreatedAt)}`)
+      console.log(`Last issue: ${timeAgo(lastCreatedAt)}`)
     } else {
-      console.log(chalk.dim('Last issue created: never'))
+      console.log(dim('Last issue: never'))
     }
 
-    console.log(`Fingerprints stored: ${fingerprintCount}`)
+    console.log(`Fingerprints: ${fingerprintCount}`)
+
+    const pendingCount = countPending(repoRoot)
+    if (pendingCount > 0) {
+      console.log(
+        cyan(`Drafts: ${pendingCount} pending`) +
+          dim(' (run ') + cyan('tissues drafts') + dim(' to manage)'),
+      )
+    } else {
+      console.log(dim('Drafts: empty'))
+    }
   })

package/src/commands/templates.js

@@ -0,0 +1,157 @@
+import { Command } from 'commander'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { dim, red, green } from '../lib/color.js'
+import { select, input, editor } from '@inquirer/prompts'
+import { listTemplates, loadTemplate, builtInTemplateKeys } from '../lib/templates.js'
+import { findRepoRoot, loadConfig } from '../lib/defaults.js'
+import { theme } from '../lib/theme.js'
+
+function isCancelled(err) {
+  return err?.name === 'ExitPromptError' || err?.message?.includes('User force closed')
+}
+
+async function promptOrBack(fn) {
+  try { return await fn() } catch (err) { if (isCancelled(err)) return Symbol.for('back'); throw err }
+}
+
+function userTemplateDir() {
+  return path.join(os.homedir(), '.config', 'tissues', 'templates')
+}
+
+export const templatesCommand = new Command('templates')
+  .description('Manage issue templates (view, edit, create)')
+  .action(async () => {
+    while (true) {
+      const repoRoot = findRepoRoot()
+      const templates = listTemplates(repoRoot)
+      const builtInKeys = builtInTemplateKeys()
+
+      // Deduplicate by key
+      const seen = new Set()
+      const choices = []
+      for (const tpl of templates) {
+        if (!seen.has(tpl.key)) {
+          seen.add(tpl.key)
+          choices.push({
+            name: `${tpl.key.padEnd(14)} ${dim(tpl.name)} ${dim(`(${tpl.source})`)}`,
+            value: tpl.key,
+          })
+        }
+      }
+      choices.push({ name: green('Create New Template'), value: '_create' })
+      choices.push({ name: dim('Done'), value: 'done' })
+
+      const chosen = await promptOrBack(() => select({ message: 'Templates', choices, theme }))
+      if (chosen === Symbol.for('back') || chosen === 'done') break
+
+      if (chosen === '_create') {
+        await createNewTemplate(builtInKeys, seen)
+        continue
+      }
+
+      // View / edit existing template
+      await editTemplate(chosen, repoRoot, builtInKeys)
+      console.log()
+    }
+  })
+
+async function createNewTemplate(builtInKeys, existingKeys) {
+  const name = await promptOrBack(() => input({ message: 'Template name (lowercase, no spaces)', theme }))
+  if (name === Symbol.for('back') || !name) return
+
+  const key = name.trim().toLowerCase().replace(/\s+/g, '-')
+  if (!key) return
+
+  // Block reusing exact built-in names
+  if (builtInKeys.includes(key)) {
+    console.log(red(`  "${key}" is a built-in template. Use edit to customize it instead.`))
+    return
+  }
+
+  // Block duplicates
+  if (existingKeys.has(key)) {
+    console.log(red(`  Template "${key}" already exists.`))
+    return
+  }
+
+  const body = await promptOrBack(() =>
+    editor({
+      message: 'Template body (opens editor)',
+      default: `## ${key.charAt(0).toUpperCase() + key.slice(1)}\n\n{{description}}\n\n## Details\n\n`,
+      theme,
+    }),
+  )
+  if (body === Symbol.for('back') || !body) return
+
+  const dir = userTemplateDir()
+  fs.mkdirSync(dir, { recursive: true })
+  const filePath = path.join(dir, `${key}.md`)
+  fs.writeFileSync(filePath, body, 'utf8')
+  console.log(green(`  ✔ Template "${key}" created: ${filePath}`))
+}
+
+async function editTemplate(key, repoRoot, builtInKeys) {
+  let tpl
+  try {
+    tpl = loadTemplate(key, repoRoot)
+  } catch (err) {
+    console.log(red(`  ${err.message}`))
+    return
+  }
+
+  console.log(`\n  ${tpl.name} ${dim(`(${tpl.source})`)}`)
+  console.log(dim('  ─'.repeat(20)))
+  // Show preview (truncated)
+  const preview = tpl.body.split('\n').slice(0, 8).join('\n')
+  console.log(dim(preview))
+  if (tpl.body.split('\n').length > 8) console.log(dim('  ...'))
+  console.log()
+
+  const actionChoices = [
+    { name: 'Edit', value: 'edit' },
+  ]
+  if (builtInKeys.includes(key) && tpl.source === 'built-in') {
+    actionChoices[0] = { name: 'Customize (creates user copy)', value: 'edit' }
+  }
+  // Only allow deleting user templates
+  const userFile = path.join(userTemplateDir(), `${key}.md`)
+  if (fs.existsSync(userFile)) {
+    actionChoices.push({ name: red('Delete user copy'), value: 'delete' })
+  }
+  actionChoices.push({ name: dim('Back'), value: 'back' })
+
+  const action = await promptOrBack(() => select({ message: tpl.name, choices: actionChoices, theme }))
+  if (action === Symbol.for('back') || action === 'back') return
+
+  if (action === 'delete') {
+    fs.unlinkSync(userFile)
+    console.log(green(`  ✔ User copy of "${key}" deleted`))
+    if (builtInKeys.includes(key)) {
+      console.log(dim(`  Built-in "${key}" will be used again.`))
+    }
+    return
+  }
+
+  // Edit — open in editor with current body
+  const newBody = await promptOrBack(() =>
+    editor({
+      message: `Edit ${key}`,
+      default: tpl.body,
+      theme,
+    }),
+  )
+  if (newBody === Symbol.for('back') || !newBody) return
+
+  // Save as user template (even if editing a built-in — creates a user override)
+  const dir = userTemplateDir()
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, `${key}.md`), newBody, 'utf8')
+
+  if (tpl.source === 'built-in') {
+    console.log(green(`  ✔ User copy of "${key}" created (overrides built-in)`))
+  } else {
+    console.log(green(`  ✔ Template "${key}" updated`))
+  }
+}