tissues 0.5.2 → 0.6.1

package/src/commands/create.js

@@ -8,35 +8,63 @@ import { checkSafety, recordSuccess, recordFailure } from '../lib/safety.js'
 import { checkDuplicate, recordCreation } from '../lib/dedup.js'
 import { listTemplates, loadTemplate, renderTemplate } from '../lib/templates.js'
 import { renderAttribution } from '../lib/attribution.js'
-import { computeFingerprint } from '../lib/dedup.js'
 import { pickRepo } from '../lib/repo-picker.js'
+import { writeDraft, updateDraftItem, writeToDrafts, markComplete, markFailed, hasPending, countPending, attachFile } from '../lib/drafts.js'
 import {
   requireAuth,
   createIssue,
+  verifyIssue,
   listLabels,
+  listIssues,
   createLabel,
   addLabelsToIssue,
+  uploadImageToRepo,
 } from '../lib/gh.js'
-import chalk from 'chalk'
+import { enhance, checkAvailable } from '../lib/ai/index.js'
+import { runEnhancePipeline } from '../lib/ai/enhance.js'
+import { clipboardHasImage, saveClipboardImage } from '../lib/clipboard.js'
+import { bold, dim, red, green, yellow, cyan } from '../lib/color.js'
 import ora from 'ora'
+import { theme } from '../lib/theme.js'
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Split freeform user input into a title and body.
+ *
+ * Rules:
+ * 1. Explicit newlines → first line = title, rest = body
+ * 2. Short input (≤80 chars) → just a title
+ * 3. Long single line → break at last word boundary before 80 chars
+ *
+ * @param {string} text
+ * @returns {{ title: string, body: string }}
+ */
+function splitInput(text) {
+  const trimmed = text.trim()
+  if (trimmed.includes('\n')) {
+    const idx = trimmed.indexOf('\n')
+    return { title: trimmed.slice(0, idx).trim(), body: trimmed.slice(idx + 1).trim() }
+  }
+  if (trimmed.length <= 80) return { title: trimmed, body: '' }
+  const cut = trimmed.lastIndexOf(' ', 80)
+  const at = cut > 20 ? cut : 80
+  return { title: trimmed.slice(0, at).trim(), body: trimmed }
+}
+
 /**
  * Print the circuit breaker state if it is not 'closed'.
  *
  * @param {string} circuitState
  */
 function warnIfCircuitNotClosed(circuitState) {
-  if (circuitState === 'closed') return
-  const stateColor = circuitState === 'open' ? chalk.red : chalk.yellow
+  if (circuitState !== 'open') return
   console.warn(
-    chalk.yellow('[safety]') +
-      ' Circuit breaker is ' +
-      stateColor(circuitState.toUpperCase()) +
-      '. Use `tissues status` to view details.',
+    yellow('[safety]') +
+      ' Issue submission is paused due to recent failures.' +
+      ' Run ' + cyan('tissues status') + ' for details.',
   )
 }
 
@@ -52,7 +80,7 @@ function formatDedupResult(result) {
   if (result.existingIssue) {
     const { number, title, url } = result.existingIssue
     if (number) parts.push(`  Existing issue: #${number}${title ? ` — ${title}` : ''}`)
-    if (url) parts.push(`  URL: ${chalk.cyan(url)}`)
+    if (url) parts.push(`  URL: ${cyan(url)}`)
   }
   return parts.join('\n')
 }
@@ -76,34 +104,10 @@ function runPostCreateHook(hookCmd, ctx) {
       stdio: 'inherit',
     })
   } catch (err) {
-    console.warn(chalk.yellow(`[hooks] postCreate hook failed: ${err.message}`))
+    console.warn(yellow(`[hooks] postCreate hook failed: ${err.message}`))
   }
 }
 
-// ---------------------------------------------------------------------------
-// AI enhancement stub
-// ---------------------------------------------------------------------------
-
-/**
- * Enhance issue body with AI. Currently a structured placeholder.
- * Wire up real AI (OpenAI / Anthropic) here.
- *
- * @param {string} title - issue title
- * @param {string} description - the actual issue content describing what the issue is about;
- *   this is rendered into the template body via {{description}} and forms the core of the issue
- * @param {string} templateBody - already-rendered template body to use as context
- * @param {string} [instructions] - optional AI prompt instructions that guide *how* the AI
- *   writes or post-processes the issue body (e.g. "keep it under 200 words",
- *   "after creating, send to this webhook: https://..."). Does NOT appear in the issue itself.
- * @returns {Promise<string>}
- */
-async function enhanceWithAI(title, description, templateBody, instructions) {
-  // TODO: wire up real AI (OpenAI / Anthropic)
-  // - description goes INTO the issue body (rendered via {{description}} in the template)
-  // - instructions guide the AI behaviour but are NOT included in the output
-  return templateBody
-}
-
 // ---------------------------------------------------------------------------
 // AbortError — thrown for user-initiated cancellations (exit 0)
 // ---------------------------------------------------------------------------
@@ -127,7 +131,7 @@ class AbortError extends Error {
  * @throws {AbortError} when the user cancels interactively
  * @throws {Error} on hard failures
  */
-async function runCreate(opts) {
+export async function runCreate(opts) {
   // -----------------------------------------------------------------------
   // 0. Ensure authenticated
   // -----------------------------------------------------------------------
@@ -141,7 +145,7 @@ async function runCreate(opts) {
     repo = store.get('activeRepo')
   }
   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()
   }
@@ -151,45 +155,190 @@ async function runCreate(opts) {
   // -----------------------------------------------------------------------
   const repoRoot = findRepoRoot()
   const config = loadConfig(repoRoot)
+  const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
 
   // -----------------------------------------------------------------------
-  // 3. Check safety
+  // 3. Get inputs
   // -----------------------------------------------------------------------
-  const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
-  const safetyResult = checkSafety(repo, agent, config.safety)
-
-  warnIfCircuitNotClosed(safetyResult.circuitState)
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY
+
+  let title, description, instructions
+
+  if (opts.title) {
+    // --title flag: skip wizard entirely (scripted / batch / ai use)
+    title = opts.title
+    description = opts.body ?? undefined
+    instructions = opts.instructions ?? undefined
+  } else if (isInteractive) {
+    // Single freeform prompt
+    const rawInput = await input({
+      message: "What's the issue",
+      default: opts._titleDefault,
+      theme,
+    })
+    if (!rawInput || !rawInput.trim()) {
+      console.error(red('Input is required.'))
+      throw new Error('Input is required')
+    }
+    const split = splitInput(rawInput)
+    title = split.title
+    description = opts.body ?? (split.body || undefined)
+    instructions = opts.instructions ?? undefined
+    // Pass the full user text as instructions for AI enhancement
+    if (!instructions && rawInput.trim().length > title.length) {
+      instructions = rawInput.trim()
+    }
+    // Preserve raw input for triage step — AI will refine title/description
+    opts._rawInput = rawInput.trim()
+  } else {
+    // Non-interactive without --title
+    title = opts._titleDefault
+    description = opts.body ?? undefined
+    instructions = opts.instructions ?? undefined
+  }
 
-  if (!safetyResult.allowed) {
-    recordFailure(repo, agent, config.safety)
-    console.error(chalk.red('Safety check failed:'), safetyResult.reason)
-    throw new Error('Safety check failed')
+  if (!title || !title.trim()) {
+    if (!isInteractive) {
+      console.error(red('Input is required. Pass --title <title> when running non-interactively.'))
+    } else {
+      console.error(red('Input is required.'))
+    }
+    throw new Error('Input is required')
   }
 
   // -----------------------------------------------------------------------
-  // 4. Get inputs
+  // 3b. Parse labels early (needed by dedup context and draft write)
   // -----------------------------------------------------------------------
-  const title =
-    opts.title ?? (await input({ message: 'Issue title', default: opts._titleDefault }))
-  if (!title || !title.trim()) {
-    console.error(chalk.red('Title is required.'))
-    throw new Error('Title is required')
+  const labels = opts.labels
+    ? opts.labels
+        .split(',')
+        .map((l) => l.trim())
+        .filter(Boolean)
+    : []
+
+  // -----------------------------------------------------------------------
+  // 3c. Check dedup BEFORE writing draft (no phantom drafts on block)
+  // -----------------------------------------------------------------------
+  const relatedIssues = []
+
+  if (!opts.draft) {
+    const dedupSpinner = ora('Checking for duplicates...').start()
+    let dedupResult
+    try {
+      dedupResult = await checkDuplicate(repo, {
+        title,
+        body: description,
+        agent,
+      })
+      dedupSpinner.stop()
+    } catch (err) {
+      dedupSpinner.warn(`Dedup check failed (skipping): ${err.message}`)
+      dedupResult = { action: 'allow', results: [] }
+    }
+
+    if (dedupResult.action === 'block') {
+      if (!isInteractive) recordFailure(repo, agent, config.safety)
+      const blockReasons = dedupResult.results.filter((r) => r.action === 'block')
+      for (const r of blockReasons) {
+        console.error(formatDedupResult(r))
+      }
+      console.error(red('Duplicate detected — issue not created.'))
+      throw new Error('Duplicate detected')
+    }
+
+    if (dedupResult.action === 'warn' && !opts.force) {
+      console.warn(yellow('\nSimilar issue(s) found:'))
+      for (const r of dedupResult.results.filter((r) => r.action === 'warn')) {
+        console.warn(formatDedupResult(r))
+        if (r.existingIssue?.number) {
+          relatedIssues.push({ number: r.existingIssue.number })
+        }
+      }
+      console.warn()
+
+      const proceed = await confirm({
+        message: 'Create anyway?',
+        default: false,
+        theme,
+      })
+
+      if (!proceed) {
+        console.log(dim('Aborted.'))
+        throw new AbortError('Aborted by user')
+      }
+    }
   }
 
-  const description =
-    opts.body ??
-    (await input({
-      message: 'Issue description (optional)',
-    }))
+  // -----------------------------------------------------------------------
+  // 3d. Write draft — user data is safe from this point on
+  // -----------------------------------------------------------------------
+  const draft = opts.dryRun
+    ? null
+    : writeDraft({ repo, title, description, instructions, labels }, repoRoot)
+
+  // -----------------------------------------------------------------------
+  // 3e. Attach files (--attach flag and clipboard image detection)
+  // -----------------------------------------------------------------------
+  const attachPaths = opts.attach
+    ? opts.attach.split(',').map((p) => p.trim()).filter(Boolean)
+    : []
+
+  const attachments = []
+  const imageUrls = [] // URLs from uploaded images for embedding in body
+  if (draft) {
+    // Attach files from --attach flag
+    for (const fp of attachPaths) {
+      try {
+        const meta = attachFile(draft.id, fp, repoRoot)
+        attachments.push(meta)
+        console.log(green('  ✔') + ` Attached: ${meta.filename} (${Math.round(meta.size / 1024)} KB)`)
+
+        // Upload image files to repo for embedding
+        if (/\.(png|jpe?g|gif|webp)$/i.test(fp)) {
+          try {
+            const imgName = `${Date.now()}-${meta.filename}`
+            const { url } = uploadImageToRepo(repo, fp, imgName)
+            imageUrls.push({ filename: meta.filename, url })
+            console.log(green('  ✔') + ` Uploaded to repo`)
+          } catch (uploadErr) {
+            console.warn(yellow(`  ⚠ Could not upload ${meta.filename}: ${uploadErr.message}`))
+          }
+        }
+      } catch (err) {
+        console.warn(yellow(`  ⚠ Could not attach ${fp}: ${err.message}`))
+      }
+    }
 
-  const instructions =
-    opts.instructions ??
-    (await input({
-      message: 'Issue instruction (optional, guides AI enhancement)',
-    }))
+    // Auto-detect clipboard image in interactive mode (no confirmation prompt)
+    if (isInteractive && !opts.dryRun && clipboardHasImage()) {
+      const { getAttachmentDir } = await import('../lib/drafts.js')
+      const attachDir = getAttachmentDir(draft.id, repoRoot)
+      fs.mkdirSync(attachDir, { recursive: true })
+      const clipName = `clipboard-${Date.now()}.png`
+      const destPath = `${attachDir}/${clipName}`
+      const saved = saveClipboardImage(destPath)
+      if (saved) {
+        const stat = fs.statSync(destPath)
+        const meta = { filename: clipName, size: stat.size, type: 'image/png' }
+        attachments.push(meta)
+        console.log(green('  ✔') + ` Clipboard image attached (${Math.round(stat.size / 1024)} KB)`)
+
+        // Upload to repo for embedding
+        try {
+          const { url } = uploadImageToRepo(repo, destPath, clipName)
+          imageUrls.push({ filename: 'Clipboard image', url })
+          console.log(green('  ✔') + ` Uploaded to repo`)
+        } catch (uploadErr) {
+          console.warn(yellow(`  ⚠ Could not upload clipboard image: ${uploadErr.message}`))
+        }
+      } else {
+        console.warn(yellow('  ⚠ Could not save clipboard image'))
+      }
+    }
+  }
 
   // -----------------------------------------------------------------------
-  // 5. Pick template
+  // 4. Pick template
   // -----------------------------------------------------------------------
   let templateName = opts.template
 
@@ -208,7 +357,7 @@ async function runCreate(opts) {
       if (!seen.has(tpl.key)) {
         seen.add(tpl.key)
         choices.push({
-          name: `${tpl.name} ${chalk.dim(`(${tpl.source})`)}`,
+          name: `${tpl.name} ${dim(`(${tpl.source})`)}`,
           value: tpl.key,
         })
       }
@@ -218,6 +367,7 @@ async function runCreate(opts) {
       templateName = await select({
         message: 'Choose a template',
         choices,
+        theme,
       })
     } else {
       templateName = 'default'
@@ -228,60 +378,14 @@ async function runCreate(opts) {
   try {
     template = loadTemplate(templateName, repoRoot)
   } catch (err) {
-    console.error(chalk.red(`Template error: ${err.message}`))
+    console.error(red(`Template error: ${err.message}`))
     throw new Error(`Template error: ${err.message}`)
   }
 
   // -----------------------------------------------------------------------
-  // 6. Check dedup
+  // 5. Render template
   // -----------------------------------------------------------------------
   const session = opts.session ?? null
-  const dedupSpinner = ora('Checking for duplicates...').start()
-  let dedupResult
-  try {
-    dedupResult = await checkDuplicate(repo, {
-      title,
-      body: description,
-      agent,
-      // No idempotency key by default — callers who need deterministic keys
-      // can pass --session and combine with agent + title in future work
-    })
-    dedupSpinner.stop()
-  } catch (err) {
-    dedupSpinner.warn(`Dedup check failed (skipping): ${err.message}`)
-    dedupResult = { action: 'allow', results: [] }
-  }
-
-  if (dedupResult.action === 'block') {
-    recordFailure(repo, agent, config.safety)
-    console.error(chalk.red('Duplicate detected — issue not created.'))
-    for (const r of dedupResult.results.filter((r) => r.action === 'block')) {
-      console.error(formatDedupResult(r))
-    }
-    throw new Error('Duplicate detected')
-  }
-
-  if (dedupResult.action === 'warn' && !opts.force) {
-    console.warn(chalk.yellow('\nSimilar issue(s) found:'))
-    for (const r of dedupResult.results.filter((r) => r.action === 'warn')) {
-      console.warn(formatDedupResult(r))
-    }
-    console.warn()
-
-    const proceed = await confirm({
-      message: 'Create anyway?',
-      default: false,
-    })
-
-    if (!proceed) {
-      console.log(chalk.dim('Aborted.'))
-      throw new AbortError('Aborted by user')
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // 7. Render template
-  // -----------------------------------------------------------------------
   const renderedTemplate = renderTemplate(template.body, {
     title,
     description: description || '',
@@ -292,63 +396,234 @@ async function runCreate(opts) {
   })
 
   // -----------------------------------------------------------------------
-  // 8. AI enhancement (skip for --no-enhance or --dry-run)
+  // 6. AI enhancement (skip for --no-enhance or --dry-run)
   // -----------------------------------------------------------------------
   let body = renderedTemplate
+  let pipelineResult = null
   if (opts.enhance !== false && !opts.dryRun) {
-    const aiSpinner = ora('Enhancing with AI...').start()
-    try {
-      body = await enhanceWithAI(title, description, renderedTemplate, instructions)
-      aiSpinner.succeed('Enhanced')
-    } catch {
-      aiSpinner.warn('AI enhancement unavailable — using template as-is')
+    const enhancementNames = opts.enhancements
+      ? opts.enhancements.split(',').map((s) => s.trim()).filter(Boolean)
+      : undefined
+    const aiContext = {
+      template: templateName,
+      labels: opts.labels ? opts.labels.split(',').map((l) => l.trim()).filter(Boolean) : [],
+      provider: opts.provider,
+      model: opts.model,
+      enhancements: enhancementNames,
+    }
+    if (checkAvailable(config, aiContext)) {
+      const pipelineConfig = config.ai?.pipeline || {}
+      const usePipeline = opts.pipeline === true ||
+        (pipelineConfig.enabled && opts.pipeline !== false)
+
+      if (usePipeline) {
+        // Multi-step pipeline enhancement
+        let aiSpinner = ora('Enhancing with AI pipeline...').start()
+        try {
+          // Gather existing issues and repo labels for pipeline context
+          let existingIssues = []
+          let repoLabels = []
+          try { existingIssues = listIssues(repo) } catch { /* non-fatal */ }
+          try { repoLabels = listLabels(repo) } catch { /* non-fatal */ }
+
+          // When --title is explicit, skip triage (no rawInput to analyze)
+          const rawInput = opts.title ? '' : (opts._rawInput || '')
+
+          pipelineResult = await runEnhancePipeline(config, {
+            rawInput,
+            title,
+            description,
+            instructions,
+            templateBody: renderedTemplate,
+            labels,
+            existingIssues,
+            repoLabels,
+          }, {
+            onStepStart(step) {
+              if (!aiSpinner.isSpinning) aiSpinner = ora().start()
+              aiSpinner.text = `${step.displayName}...`
+            },
+            onStepDone(step, ctx) {
+              let detail = ''
+              if (step.name === 'triage') detail = ctx.title ? `: ${ctx.title}` : ''
+              if (step.name === 'dedup') detail = ctx.dedupScore ? ` (${ctx.dedupScore.level})` : ' (none)'
+              if (step.name === 'scope') detail = ctx.scopeAnalysis ? ` (${ctx.scopeAnalysis.files.length} files)` : ''
+              if (step.name === 'complexity') detail = ctx.complexity != null ? `: ${ctx.complexity}/10` : ''
+              if (step.name === 'risk') detail = ctx.risk != null ? `: ${ctx.risk}/10` : ''
+              if (step.name === 'labels') detail = ctx.aiLabels?.length ? `: ${ctx.aiLabels.join(', ')}` : ''
+              aiSpinner.succeed(`${step.displayName}${detail}`)
+            },
+            onStepSkip(step) { /* silent */ },
+            onStepFail(step, err) {
+              if (!aiSpinner.isSpinning) aiSpinner = ora().start()
+              aiSpinner.warn(`${step.displayName} failed`)
+              console.warn(dim(`  ${err.message}`))
+            },
+          }, aiContext)
+
+          aiSpinner.stop()
+          body = pipelineResult.body || renderedTemplate
+
+          // Use AI-derived title if triage step produced one
+          if (pipelineResult.title && pipelineResult.title !== title) {
+            title = pipelineResult.title
+          }
+
+          // Merge AI-suggested labels
+          if (pipelineResult.aiLabels?.length) {
+            for (const l of pipelineResult.aiLabels) {
+              if (!labels.includes(l)) labels.push(l)
+            }
+          }
+
+          // Collect AI dedup matches as related issues
+          if (pipelineResult.dedupScore?.matches?.length) {
+            const seen = new Set(relatedIssues.map((i) => i.number))
+            for (const m of pipelineResult.dedupScore.matches) {
+              if (m.number && !seen.has(m.number)) {
+                relatedIssues.push({ number: m.number })
+                seen.add(m.number)
+              }
+            }
+          }
+
+          // Warn on high AI dedup confidence
+          if (pipelineResult.dedupScore?.level === 'high' && !opts.force) {
+            console.warn(yellow('\nAI detected likely duplicate:'))
+            for (const m of pipelineResult.dedupScore.matches || []) {
+              console.warn(dim(`  #${m.number}: ${m.reason}`))
+            }
+            console.warn()
+          }
+        } catch (err) {
+          aiSpinner.stop()
+          if (/\b401\b/.test(err.message)) {
+            console.warn(red('  API key is invalid or expired.'))
+            console.warn(dim('  Run ') + cyan('tissues config') + dim(' to update your API key.'))
+          } else {
+            console.warn(yellow('Pipeline failed — falling back to single-shot enhancement'))
+            console.warn(dim(`  ${err.message}`))
+          }
+          // Fall back to single-shot
+          try {
+            body = await enhance(config, title, description, renderedTemplate, instructions, aiContext)
+          } catch {
+            // Use template as-is
+          }
+        }
+      } else {
+        // Single-shot enhancement (original behavior)
+        const aiSpinner = ora('Enhancing with AI...').start()
+        try {
+          body = await enhance(config, title, description, renderedTemplate, instructions, aiContext)
+          aiSpinner.succeed('Enhanced')
+        } catch (err) {
+          if (/\b401\b/.test(err.message)) {
+            aiSpinner.fail('AI enhancement failed')
+            console.warn(red('  API key is invalid or expired.'))
+            console.warn(dim('  Run ') + cyan('tissues config') + dim(' to update your API key.'))
+            console.warn(dim('  Continuing without AI enhancement.\n'))
+          } else {
+            aiSpinner.warn(`AI enhancement failed — using template as-is`)
+            console.warn(dim(`  ${err.message}`))
+          }
+        }
+      }
     }
   }
 
   // -----------------------------------------------------------------------
-  // 9. Add attribution
+  // 6b. Embed uploaded images in body
+  // -----------------------------------------------------------------------
+  if (imageUrls.length > 0) {
+    const imageMarkdown = imageUrls
+      .map(({ filename, url }) => `![${filename}](${url})`)
+      .join('\n')
+    body = body.trimEnd() + '\n\n' + imageMarkdown
+  }
+
+  // -----------------------------------------------------------------------
+  // 6c. Add related issues (dedup matches)
+  // -----------------------------------------------------------------------
+  if (relatedIssues.length > 0) {
+    const refs = relatedIssues.map((i) => `#${i.number}`).join(' ')
+    body = body.trimEnd() + `\n\n---\n**Possibly Duplicate:** ${refs}`
+  }
+
+  // -----------------------------------------------------------------------
+  // 7. Add attribution
   // -----------------------------------------------------------------------
-  const fingerprint = computeFingerprint(title, body)
   const attributionBlock = renderAttribution({
-    agent,
     session: session ?? undefined,
-    trigger: 'cli-create',
-    fingerprint: `sha256:${fingerprint}`,
+    model: opts.model ?? undefined,
   })
 
-  body = body.trimEnd() + '\n\n' + attributionBlock
+  if (attributionBlock) {
+    body = body.trimEnd() + '\n\n' + attributionBlock
+  }
 
   // -----------------------------------------------------------------------
-  // 10. Parse labels
+  // 8. Update draft with processed body — draft → pending
   // -----------------------------------------------------------------------
-  const labels = opts.labels
-    ? opts.labels
-        .split(',')
-        .map((l) => l.trim())
-        .filter(Boolean)
-    : []
+  if (draft) {
+    updateDraftItem(draft.id, { title, body, labels }, repoRoot)
+  }
 
   // -----------------------------------------------------------------------
   // Dry run — stop here
   // -----------------------------------------------------------------------
   if (opts.dryRun) {
     const border = '─'.repeat(44)
-    console.log(chalk.cyan(`\n─── DRY RUN ${border.slice(11)}`))
-    console.log(`  ${chalk.bold('Repo:    ')}  ${repo}`)
-    console.log(`  ${chalk.bold('Title:   ')}  ${title}`)
-    console.log(`  ${chalk.bold('Agent:   ')}  ${agent}`)
-    console.log(`  ${chalk.bold('Template:')} ${template.name} (${template.source})`)
-    if (labels.length > 0) console.log(`  ${chalk.bold('Labels:  ')}  ${labels.join(', ')}`)
-    console.log(`\n  ${chalk.bold('Body:')}`)
+    console.log(cyan(`\n─── DRY RUN ${border.slice(11)}`))
+    console.log(`  ${bold('Repo:    ')}  ${repo}`)
+    console.log(`  ${bold('Title:   ')}  ${title}`)
+    console.log(`  ${bold('Agent:   ')}  ${agent}`)
+    console.log(`  ${bold('Template:')} ${template.name} (${template.source})`)
+    if (labels.length > 0) console.log(`  ${bold('Labels:  ')}  ${labels.join(', ')}`)
+    console.log(`\n  ${bold('Body:')}`)
     console.log(renderedTemplate)
-    console.log(`\n  ${chalk.dim('─── attribution (invisible on GitHub) ───')}`)
-    console.log(chalk.dim(attributionBlock))
-    console.log(chalk.cyan(`${border}\n  No issue created.\n`))
+    if (attributionBlock) {
+      console.log(`\n  ${dim('─── attribution ───')}`)
+      console.log(dim(attributionBlock))
+    }
+    console.log(cyan(`${border}\n  No issue created.\n`))
+    return null
+  }
+
+  // -----------------------------------------------------------------------
+  // 9. Draft mode — stop here, issue is already saved
+  // -----------------------------------------------------------------------
+  if (opts.draft) {
+    console.log()
+    console.log(green('✔') + '  ' + bold('Draft saved.'))
+    console.log(`   ${dim('Title:')} ${title}`)
+    if (labels.length > 0) console.log(`   ${dim('Labels:')} ${labels.join(', ')}`)
+    console.log(dim('   Run ') + cyan('tissues drafts') + dim(' to review and send.'))
     return null
   }
 
   // -----------------------------------------------------------------------
-  // 11. Create issue (with graceful label handling)
+  // 10. Check safety (skip circuit breaker for interactive/human wizard)
+  // -----------------------------------------------------------------------
+  if (!isInteractive) {
+    const safetyResult = checkSafety(repo, agent, config.safety)
+    warnIfCircuitNotClosed(safetyResult.circuitState)
+
+    if (!safetyResult.allowed) {
+      // Issue is saved in drafts — tell the user and exit cleanly
+      console.log()
+      console.log(
+        yellow('⏸') + '  ' + bold('Issue saved to drafts.') +
+        ' Safety check blocked submission:',
+      )
+      console.log(dim(`   ${safetyResult.reason}`))
+      console.log(dim('   Run ') + cyan('tissues drafts') + dim(' to send when ready.'))
+      process.exit(0)
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 12. Create issue (with graceful label handling)
   // -----------------------------------------------------------------------
   let existingLabels = labels
   let missingLabels = []
@@ -366,21 +641,38 @@ async function runCreate(opts) {
   const createSpinner = ora('Creating issue...').start()
   let issue
   try {
-    issue = await createIssue(repo, { title, body, labels: existingLabels })
-    createSpinner.succeed(`Issue created: ${chalk.cyan(issue.url)}`)
+    issue = createIssue(repo, { title, body, labels: existingLabels })
+    createSpinner.succeed(`Issue created: ${cyan(issue.url)}`)
   } catch (err) {
     // GitHub API failures are NOT safety failures — do not record to circuit
     createSpinner.fail(`Failed to create issue: ${err.message}`)
+    markFailed(draft.id, err.message, repoRoot)
+    console.log(dim('   Issue saved to drafts. Run ') + cyan('tissues drafts') + dim(' to retry.'))
     throw new Error(`Failed to create issue: ${err.message}`)
   }
 
+  // -----------------------------------------------------------------------
+  // 13. Verify issue exists before removing draft
+  // -----------------------------------------------------------------------
+  const verified = verifyIssue(repo, issue.number)
+  if (!verified) {
+    console.warn(
+      yellow(`  Issue #${issue.number} could not be verified — keeping in drafts`),
+    )
+    console.log(dim('   Run ') + cyan('tissues drafts') + dim(' to retry.'))
+    // Don't throw — the issue URL was returned, it may still be fine
+  } else {
+    markComplete(draft.id, { issueNumber: issue.number, issueUrl: issue.url }, repoRoot)
+  }
+
   if (missingLabels.length > 0) {
     console.log(
-      chalk.yellow(`Labels not found: ${missingLabels.join(', ')} — issue created without them`),
+      yellow(`Labels not found: ${missingLabels.join(', ')} — issue created without them`),
     )
     const createMissing = await confirm({
       message: 'Create missing labels and apply them?',
       default: true,
+      theme,
     })
     if (createMissing) {
       for (const labelName of missingLabels) {
@@ -394,26 +686,45 @@ async function runCreate(opts) {
       }
       try {
         addLabelsToIssue(repo, issue.number, missingLabels)
-        console.log(chalk.green('✓ Labels created and applied'))
+        console.log(green('✓ Labels created and applied'))
       } catch (err) {
-        console.warn(chalk.yellow(`Failed to apply labels: ${err.message}`))
+        console.warn(yellow(`Failed to apply labels: ${err.message}`))
       }
     }
   }
 
   // -----------------------------------------------------------------------
-  // 12. Record success
+  // 13b. Attachment notice
+  // -----------------------------------------------------------------------
+  if (attachments.length > 0) {
+    const nonUploaded = attachments.length - imageUrls.length
+    if (nonUploaded > 0) {
+      const { getAttachmentDir } = await import('../lib/drafts.js')
+      const attachDir = getAttachmentDir(draft.id, repoRoot)
+      console.log(
+        dim(`  📎 ${nonUploaded} non-image attachment${nonUploaded === 1 ? '' : 's'} saved locally. Upload manually to the issue.`),
+      )
+      console.log(dim(`     ${attachDir}`))
+    }
+    if (imageUrls.length > 0) {
+      console.log(dim(`  📎 ${imageUrls.length} image${imageUrls.length === 1 ? '' : 's'} uploaded and embedded in issue body.`))
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 14. Record success
   // -----------------------------------------------------------------------
   try {
     await recordCreation(repo, {
       title,
       body,
       issueNumber: issue.number,
+      url: issue.url,
       agent,
     })
   } catch (err) {
     // Non-fatal — dedup DB write failure shouldn't abort the command
-    console.warn(chalk.dim(`[dedup] Failed to record fingerprint: ${err.message}`))
+    console.warn(dim(`[dedup] Failed to record fingerprint: ${err.message}`))
   }
 
   recordSuccess(repo, agent)
@@ -441,7 +752,7 @@ export const createCommand = new Command('create')
   .description('Create a new GitHub issue')
   .argument('[title...]', 'Issue title (positional shorthand for --title)')
   .option('--repo <repo>', 'Repository override (owner/name)')
-  .option('--template <name>', 'Template to use (bug, feature, security, performance, refactor)')
+  .option('--template <name>', 'Template to use (default, bug, feature, or custom)')
   .option('--agent <name>', 'Agent identifier for attribution (default: human)')
   .option('--session <id>', 'Session ID for attribution')
   .option('--title <title>', 'Issue title (skips interactive prompt)')
@@ -450,7 +761,14 @@ export const createCommand = new Command('create')
   .option('--labels <labels>', 'Comma-separated labels to apply')
   .option('--force', 'Skip dedup warnings (still blocks on exact matches)')
   .option('--dry-run', 'Check dedup and safety without creating the issue')
+  .option('--draft', 'Save to drafts without creating the issue')
+  .option('--attach <paths>', 'Comma-separated file paths to attach')
   .option('--no-enhance', 'Skip AI enhancement, use rendered template as-is')
+  .option('--pipeline', 'Force multi-step AI pipeline even if config disabled')
+  .option('--no-pipeline', 'Force single-shot AI enhancement even if pipeline enabled')
+  .option('--enhancements <names>', 'Comma-separated enhancement names to run (e.g. "context,risk")')
+  .option('--provider <name>', 'AI provider override (anthropic, openai, gemini)')
+  .option('--model <name>', 'AI model override')
   .option(
     '--batch <file>',
     'Create multiple issues from a JSON file (title, body, template, labels, agent, session per item)',
@@ -459,6 +777,24 @@ export const createCommand = new Command('create')
     // Positional words → prefill the prompt (user can still edit)
     // --title flag → skip the prompt entirely (scripted/batch use)
     if (titleArg?.length && !opts.title) opts._titleDefault = titleArg.join(' ')
+
+    // -----------------------------------------------------------------------
+    // Recovery check — notify user if there are pending draft items
+    // -----------------------------------------------------------------------
+    if (!opts.batch && !opts.dryRun) {
+      const repoRoot = findRepoRoot()
+      const pending = countPending(repoRoot)
+      if (pending > 0) {
+        console.log(
+          cyan('✨') +
+            ` ${bold(`${pending} issue${pending === 1 ? '' : 's'} saved`)} from a previous session.`,
+        )
+        console.log(
+          dim('    Run ') + cyan('tissues drafts') + dim(' to manage them, or continue to create a new issue.\n'),
+        )
+      }
+    }
+
     // -----------------------------------------------------------------------
     // Batch mode
     // -----------------------------------------------------------------------
@@ -467,18 +803,18 @@ export const createCommand = new Command('create')
       try {
         items = JSON.parse(fs.readFileSync(opts.batch, 'utf8'))
       } catch (err) {
-        console.error(chalk.red(`Failed to read batch file: ${err.message}`))
+        console.error(red(`Failed to read batch file: ${err.message}`))
         process.exit(1)
       }
 
       if (!Array.isArray(items)) {
-        console.error(chalk.red('Batch file must contain a JSON array'))
+        console.error(red('Batch file must contain a JSON array'))
         process.exit(1)
       }
 
       const results = []
       for (const [i, item] of items.entries()) {
-        console.log(chalk.dim(`\n[${i + 1}/${items.length}] "${item.title}"`))
+        console.log(dim(`\n[${i + 1}/${items.length}] "${item.title}"`))
         // item fields override CLI opts; labels array → comma-string for runCreate
         const itemOpts = {
           ...opts,
@@ -493,10 +829,10 @@ export const createCommand = new Command('create')
         }
       }
 
-      console.log(chalk.bold('\nBatch summary:'))
+      console.log(bold('\nBatch summary:'))
       for (const r of results) {
-        if (r.ok) console.log(chalk.green(`  ✔ ${r.title}`) + chalk.dim(` — ${r.url}`))
-        else console.log(chalk.red(`  ✖ ${r.title}`) + chalk.dim(` — ${r.error}`))
+        if (r.ok) console.log(green(`  ✔ ${r.title}`) + dim(` — ${r.url}`))
+        else console.log(red(`  ✖ ${r.title}`) + dim(` — ${r.error}`))
       }
       process.exit(results.every((r) => r.ok) ? 0 : 1)
       return
@@ -507,7 +843,37 @@ export const createCommand = new Command('create')
     // -----------------------------------------------------------------------
     try {
       const result = await runCreate(opts)
-      if (result === null) process.exit(0) // dry-run
+      if (result === null) process.exit(0) // dry-run or draft
+    } catch (err) {
+      process.exit(err.isAbort ? 0 : 1)
+    }
+  })
+
+// ---------------------------------------------------------------------------
+// Draft command — alias for create --draft
+// ---------------------------------------------------------------------------
+
+export const draftCommand = new Command('draft')
+  .description('Draft an issue without creating it')
+  .argument('[title...]', 'Issue title')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .option('--template <name>', 'Template to use')
+  .option('--agent <name>', 'Agent identifier for attribution (default: human)')
+  .option('--session <id>', 'Session ID for attribution')
+  .option('--title <title>', 'Issue title (skips interactive prompt)')
+  .option('--body <body>', 'Issue body / description (skips interactive prompt)')
+  .option('--instructions <text>', 'AI enhancement instruction')
+  .option('--labels <labels>', 'Comma-separated labels to apply')
+  .option('--attach <paths>', 'Comma-separated file paths to attach')
+  .option('--no-enhance', 'Skip AI enhancement, use rendered template as-is')
+  .option('--provider <name>', 'AI provider override (anthropic, openai, gemini)')
+  .option('--model <name>', 'AI model override')
+  .action(async (titleArg, opts) => {
+    if (titleArg?.length && !opts.title) opts._titleDefault = titleArg.join(' ')
+    opts.draft = true
+    try {
+      await runCreate(opts)
+      process.exit(0)
     } catch (err) {
       process.exit(err.isAbort ? 0 : 1)
     }