tissues 0.4.1 → 0.5.0

package/README.md

@@ -1,4 +1,4 @@
-# tissues
+# tissues 🧻
 
 AI-enhanced GitHub issue creation with built-in safety guardrails.
 
@@ -192,12 +192,11 @@ Every issue created by tissues includes a machine-readable `<!-- tissues-meta --
 
 ## Configuration
 
-Configuration is loaded and merged from four sources in ascending priority order:
+Configuration is loaded and merged from three sources in ascending priority order:
 
 1. Built-in defaults
 2. User-level config: `~/.config/tissues/config.json`
 3. Repo-level config: `.tissues/config.json`
-4. Environment variables: `TISSUES_*`
 
 ### Example `.tissues/config.json`
 
@@ -230,15 +229,20 @@ Configuration is loaded and merged from four sources in ascending priority order
 }
 ```
 
-### Environment Variables
+### `tissues config`
 
-Environment variables follow the pattern `TISSUES_<SECTION>_<KEY>`:
+Get or set persistent user-level config values using dot notation. Values are stored in `~/.config/tissues/config.json`.
 
 ```bash
-TISSUES_SAFETY_MAX_PER_HOUR=5
-TISSUES_SAFETY_BURST_LIMIT=3
-TISSUES_SAFETY_GLOBAL_MAX_PER_HOUR=20
-TISSUES_ATTRIBUTION_DEFAULT_AGENT=my-agent
+# Set a value
+tissues config set safety.maxPerHour 5
+tissues config set attribution.defaultAgent my-agent
+
+# Read a value
+tissues config get safety.maxPerHour
+
+# Show all resolved config
+tissues config list
 ```
 
 ### Hooks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tissues",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "AI-enhanced GitHub issue creation with built-in safety guardrails. Wraps gh CLI with circuit breakers, rate limiting, dedup, and templates.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -2,6 +2,7 @@ import { Command } from 'commander'
 import { createRequire } from 'module'
 const { version } = createRequire(import.meta.url)('../package.json')
 import { authCommand } from './commands/auth.js'
+import { configCommand } from './commands/config.js'
 import { openCommand } from './commands/open.js'
 import { createCommand } from './commands/create.js'
 import { listCommand } from './commands/list.js'
@@ -61,6 +62,7 @@ program.hook('preAction', () => {
   authCommand.description(authDescription())
 })
 program.addCommand(authCommand)
+program.addCommand(configCommand)
 program.addCommand(openCommand)
 program.addCommand(createCommand)
 program.addCommand(listCommand)

package/src/commands/config.js

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+import fs from 'node:fs'
+import path from 'node:path'
+import chalk from 'chalk'
+import { loadConfig, userConfigPath, BUILT_IN_DEFAULTS } from '../lib/defaults.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function readUserConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(userConfigPath(), 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeUserConfig(obj) {
+  const filePath = userConfigPath()
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, 2) + '\n', 'utf8')
+}
+
+function getNestedValue(obj, dotKey) {
+  return dotKey.split('.').reduce((o, k) => (o != null ? o[k] : undefined), obj)
+}
+
+function setNestedValue(obj, dotKey, value) {
+  const parts = dotKey.split('.')
+  const result = { ...obj }
+  let cursor = result
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i]
+    cursor[k] = cursor[k] && typeof cursor[k] === 'object' ? { ...cursor[k] } : {}
+    cursor = cursor[k]
+  }
+  cursor[parts[parts.length - 1]] = value
+  return result
+}
+
+function coerceValue(dotKey, raw) {
+  const parts = dotKey.split('.')
+  if (parts.length !== 2) return raw
+  const [section, field] = parts
+  const defaultVal = BUILT_IN_DEFAULTS[section]?.[field]
+  if (typeof defaultVal === 'number') {
+    const n = Number(raw)
+    if (isNaN(n)) throw new Error(`Expected a number for ${dotKey}, got: ${raw}`)
+    return n
+  }
+  if (typeof defaultVal === 'boolean') {
+    if (raw === 'true' || raw === '1') return true
+    if (raw === 'false' || raw === '0') return false
+    throw new Error(`Expected true/false for ${dotKey}, got: ${raw}`)
+  }
+  if (raw === 'null') return null
+  return raw
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export const configCommand = new Command('config')
+  .description('Get or set persistent configuration values')
+
+configCommand
+  .command('get <key>')
+  .description('Get a config value (dot notation, e.g. safety.maxPerHour)')
+  .action((key) => {
+    const cfg = loadConfig()
+    const value = getNestedValue(cfg, key)
+    if (value === undefined) {
+      console.error(chalk.red(`Unknown config key: ${key}`))
+      process.exit(1)
+    }
+    console.log(value)
+  })
+
+configCommand
+  .command('set <key> <value>')
+  .description('Set a config value (dot notation, e.g. safety.maxPerHour 5)')
+  .action((key, rawValue) => {
+    let value
+    try {
+      value = coerceValue(key, rawValue)
+    } catch (err) {
+      console.error(chalk.red(err.message))
+      process.exit(1)
+    }
+    const current = readUserConfig()
+    const updated = setNestedValue(current, key, value)
+    writeUserConfig(updated)
+    console.log(chalk.green(`✔ Set ${key} = ${value}`))
+  })
+
+configCommand
+  .command('list')
+  .description('Show all resolved config values')
+  .action(() => {
+    const cfg = loadConfig()
+    console.log(JSON.stringify(cfg, null, 2))
+  })

package/src/commands/create.js

@@ -1,4 +1,5 @@
 import { execSync } from 'node:child_process'
+import fs from 'node:fs'
 import { Command } from 'commander'
 import { input, select, confirm } from '@inquirer/prompts'
 import { store } from '../lib/config.js'
@@ -9,7 +10,13 @@ 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 { requireAuth, createIssue } from '../lib/gh.js'
+import {
+  requireAuth,
+  createIssue,
+  listLabels,
+  createLabel,
+  addLabelsToIssue,
+} from '../lib/gh.js'
 import chalk from 'chalk'
 import ora from 'ora'
 
@@ -93,181 +100,190 @@ async function enhanceWithAI(title, description, templateBody) {
 }
 
 // ---------------------------------------------------------------------------
-// Command
+// AbortError — thrown for user-initiated cancellations (exit 0)
 // ---------------------------------------------------------------------------
 
-export const createCommand = new Command('create')
-  .description('Create a new GitHub issue')
-  .option('--repo <repo>', 'Repository override (owner/name)')
-  .option('--template <name>', 'Template to use (bug, feature, security, performance, refactor)')
-  .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('--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')
-  .action(async (opts) => {
-    // -----------------------------------------------------------------------
-    // 0. Ensure authenticated
-    // -----------------------------------------------------------------------
-    requireAuth()
+class AbortError extends Error {
+  constructor(msg) {
+    super(msg)
+    this.isAbort = true
+  }
+}
 
-    // -----------------------------------------------------------------------
-    // 1. Resolve repo
-    // -----------------------------------------------------------------------
-    let repo = opts.repo
-    if (!repo) {
-      repo = store.get('activeRepo')
-    }
-    if (!repo) {
-      console.log(chalk.yellow('No active repo. Pick one:\n'))
-      repo = await pickRepo()
-      console.log()
-    }
+// ---------------------------------------------------------------------------
+// Core create logic (extracted so batch mode can reuse it)
+// ---------------------------------------------------------------------------
 
-    // -----------------------------------------------------------------------
-    // 2. Load config
-    // -----------------------------------------------------------------------
-    const repoRoot = findRepoRoot()
-    const config = loadConfig(repoRoot)
+/**
+ * Run the full issue-creation flow.
+ *
+ * @param {object} opts - command options (same shape as Commander opts)
+ * @returns {Promise<{ url: string, number: number } | null>} null for dry-run
+ * @throws {AbortError} when the user cancels interactively
+ * @throws {Error} on hard failures
+ */
+async function runCreate(opts) {
+  // -----------------------------------------------------------------------
+  // 0. Ensure authenticated
+  // -----------------------------------------------------------------------
+  requireAuth()
+
+  // -----------------------------------------------------------------------
+  // 1. Resolve repo
+  // -----------------------------------------------------------------------
+  let repo = opts.repo
+  if (!repo) {
+    repo = store.get('activeRepo')
+  }
+  if (!repo) {
+    console.log(chalk.yellow('No active repo. Pick one:\n'))
+    repo = await pickRepo()
+    console.log()
+  }
 
-    // -----------------------------------------------------------------------
-    // 3. Check safety
-    // -----------------------------------------------------------------------
-    const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
-    const safetyResult = checkSafety(repo, agent, config.safety)
+  // -----------------------------------------------------------------------
+  // 2. Load config
+  // -----------------------------------------------------------------------
+  const repoRoot = findRepoRoot()
+  const config = loadConfig(repoRoot)
 
-    warnIfCircuitNotClosed(safetyResult.circuitState)
+  // -----------------------------------------------------------------------
+  // 3. Check safety
+  // -----------------------------------------------------------------------
+  const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
+  const safetyResult = checkSafety(repo, agent, config.safety)
 
-    if (!safetyResult.allowed) {
-      recordFailure(repo, agent, config.safety)
-      console.error(chalk.red('Safety check failed:'), safetyResult.reason)
-      process.exit(1)
-    }
+  warnIfCircuitNotClosed(safetyResult.circuitState)
 
-    // -----------------------------------------------------------------------
-    // 4. Get inputs
-    // -----------------------------------------------------------------------
-    const title = opts.title ?? (await input({ message: 'Issue title' }))
-    if (!title || !title.trim()) {
-      console.error(chalk.red('Title is required.'))
-      process.exit(1)
-    }
+  if (!safetyResult.allowed) {
+    recordFailure(repo, agent, config.safety)
+    console.error(chalk.red('Safety check failed:'), safetyResult.reason)
+    throw new Error('Safety check failed')
+  }
 
-    const description =
-      opts.body ??
-      (await input({
-        message: 'Brief description (optional, used for AI enhancement)',
-      }))
+  // -----------------------------------------------------------------------
+  // 4. Get inputs
+  // -----------------------------------------------------------------------
+  const title = opts.title ?? (await input({ message: 'Issue title' }))
+  if (!title || !title.trim()) {
+    console.error(chalk.red('Title is required.'))
+    throw new Error('Title is required')
+  }
 
-    // -----------------------------------------------------------------------
-    // 5. Pick template
-    // -----------------------------------------------------------------------
-    let templateName = opts.template
+  const description =
+    opts.body ??
+    (await input({
+      message: 'Brief description (optional, used for AI enhancement)',
+    }))
 
-    // Fall back to config default
-    if (!templateName) {
-      templateName = config.templates?.default ?? null
-    }
+  // -----------------------------------------------------------------------
+  // 5. Pick template
+  // -----------------------------------------------------------------------
+  let templateName = opts.template
 
-    // If still unresolved and interactive, let user pick
-    if (!templateName) {
-      const available = listTemplates(repoRoot)
-      // Deduplicate by key (higher-priority sources shadow lower ones)
-      const seen = new Set()
-      const choices = []
-      for (const tpl of available) {
-        if (!seen.has(tpl.key)) {
-          seen.add(tpl.key)
-          choices.push({
-            name: `${tpl.name} ${chalk.dim(`(${tpl.source})`)}`,
-            value: tpl.key,
-          })
-        }
-      }
+  // Fall back to config default
+  if (!templateName) {
+    templateName = config.templates?.default ?? null
+  }
 
-      if (choices.length > 0) {
-        templateName = await select({
-          message: 'Choose a template',
-          choices,
+  // If still unresolved and interactive, let user pick
+  if (!templateName) {
+    const available = listTemplates(repoRoot)
+    // Deduplicate by key (higher-priority sources shadow lower ones)
+    const seen = new Set()
+    const choices = []
+    for (const tpl of available) {
+      if (!seen.has(tpl.key)) {
+        seen.add(tpl.key)
+        choices.push({
+          name: `${tpl.name} ${chalk.dim(`(${tpl.source})`)}`,
+          value: tpl.key,
         })
-      } else {
-        templateName = 'default'
       }
     }
 
-    let template
-    try {
-      template = loadTemplate(templateName, repoRoot)
-    } catch (err) {
-      console.error(chalk.red(`Template error: ${err.message}`))
-      process.exit(1)
-    }
-
-    // -----------------------------------------------------------------------
-    // 6. Check dedup
-    // -----------------------------------------------------------------------
-    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
+    if (choices.length > 0) {
+      templateName = await select({
+        message: 'Choose a template',
+        choices,
       })
-      dedupSpinner.stop()
-    } catch (err) {
-      dedupSpinner.warn(`Dedup check failed (skipping): ${err.message}`)
-      dedupResult = { action: 'allow', results: [] }
+    } else {
+      templateName = 'default'
     }
+  }
 
-    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))
-      }
-      process.exit(1)
-    }
+  let template
+  try {
+    template = loadTemplate(templateName, repoRoot)
+  } catch (err) {
+    console.error(chalk.red(`Template error: ${err.message}`))
+    throw new Error(`Template error: ${err.message}`)
+  }
 
-    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()
+  // -----------------------------------------------------------------------
+  // 6. Check dedup
+  // -----------------------------------------------------------------------
+  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: [] }
+  }
 
-      const proceed = await confirm({
-        message: 'Create anyway?',
-        default: false,
-      })
+  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 (!proceed) {
-        console.log(chalk.dim('Aborted.'))
-        process.exit(0)
-      }
+  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()
 
-    // -----------------------------------------------------------------------
-    // 7. Render template
-    // -----------------------------------------------------------------------
-    const renderedTemplate = renderTemplate(template.body, {
-      title,
-      description: description || '',
-      agent,
-      session: session || '',
-      date: new Date().toISOString().slice(0, 10),
-      repo,
+    const proceed = await confirm({
+      message: 'Create anyway?',
+      default: false,
     })
 
-    // -----------------------------------------------------------------------
-    // 8. AI enhancement (stub — passes rendered template as context)
-    // -----------------------------------------------------------------------
-    let body = renderedTemplate
+    if (!proceed) {
+      console.log(chalk.dim('Aborted.'))
+      throw new AbortError('Aborted by user')
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 7. Render template
+  // -----------------------------------------------------------------------
+  const renderedTemplate = renderTemplate(template.body, {
+    title,
+    description: description || '',
+    agent,
+    session: session || '',
+    date: new Date().toISOString().slice(0, 10),
+    repo,
+  })
+
+  // -----------------------------------------------------------------------
+  // 8. AI enhancement (skip for --no-enhance or --dry-run)
+  // -----------------------------------------------------------------------
+  let body = renderedTemplate
+  if (opts.enhance !== false && !opts.dryRun) {
     const aiSpinner = ora('Enhancing with AI...').start()
     try {
       body = await enhanceWithAI(title, description, renderedTemplate)
@@ -275,86 +291,207 @@ export const createCommand = new Command('create')
     } catch {
       aiSpinner.warn('AI enhancement unavailable — using template as-is')
     }
+  }
 
-    // -----------------------------------------------------------------------
-    // 9. Add attribution
-    // -----------------------------------------------------------------------
-    const fingerprint = computeFingerprint(title, body)
-    const attribution = renderAttribution({
+  // -----------------------------------------------------------------------
+  // 9. Add attribution
+  // -----------------------------------------------------------------------
+  const fingerprint = computeFingerprint(title, body)
+  const attributionBlock = renderAttribution({
+    agent,
+    session: session ?? undefined,
+    trigger: 'cli-create',
+    fingerprint: `sha256:${fingerprint}`,
+  })
+
+  body = body.trimEnd() + '\n\n' + attributionBlock
+
+  // -----------------------------------------------------------------------
+  // 10. Parse labels
+  // -----------------------------------------------------------------------
+  const labels = opts.labels
+    ? opts.labels
+        .split(',')
+        .map((l) => l.trim())
+        .filter(Boolean)
+    : []
+
+  // -----------------------------------------------------------------------
+  // 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(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`))
+    return null
+  }
+
+  // -----------------------------------------------------------------------
+  // 11. Create issue (with graceful label handling)
+  // -----------------------------------------------------------------------
+  let existingLabels = labels
+  let missingLabels = []
+
+  if (labels.length > 0) {
+    try {
+      const repoLabelNames = listLabels(repo)
+      existingLabels = labels.filter((l) => repoLabelNames.includes(l))
+      missingLabels = labels.filter((l) => !repoLabelNames.includes(l))
+    } catch {
+      // If listLabels fails, proceed with all labels (original behavior)
+    }
+  }
+
+  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)}`)
+  } catch (err) {
+    // GitHub API failures are NOT safety failures — do not record to circuit
+    createSpinner.fail(`Failed to create issue: ${err.message}`)
+    throw new Error(`Failed to create issue: ${err.message}`)
+  }
+
+  if (missingLabels.length > 0) {
+    console.log(
+      chalk.yellow(`Labels not found: ${missingLabels.join(', ')} — issue created without them`),
+    )
+    const createMissing = await confirm({
+      message: 'Create missing labels and apply them?',
+      default: true,
+    })
+    if (createMissing) {
+      for (const labelName of missingLabels) {
+        const labelSpinner = ora(`Creating label "${labelName}"...`).start()
+        try {
+          createLabel(repo, labelName)
+          labelSpinner.succeed(`Label created: ${labelName}`)
+        } catch (err) {
+          labelSpinner.warn(`Failed to create label "${labelName}": ${err.message}`)
+        }
+      }
+      try {
+        addLabelsToIssue(repo, issue.number, missingLabels)
+        console.log(chalk.green('✓ Labels created and applied'))
+      } catch (err) {
+        console.warn(chalk.yellow(`Failed to apply labels: ${err.message}`))
+      }
+    }
+  }
+
+  // -----------------------------------------------------------------------
+  // 12. Record success
+  // -----------------------------------------------------------------------
+  try {
+    await recordCreation(repo, {
+      title,
+      body,
+      issueNumber: issue.number,
       agent,
-      session: session ?? undefined,
-      trigger: 'cli-create',
-      fingerprint: `sha256:${fingerprint}`,
     })
+  } catch (err) {
+    // Non-fatal — dedup DB write failure shouldn't abort the command
+    console.warn(chalk.dim(`[dedup] Failed to record fingerprint: ${err.message}`))
+  }
 
-    body = body.trimEnd() + '\n\n' + attribution
+  recordSuccess(repo, agent)
 
-    // -----------------------------------------------------------------------
-    // 10. Parse labels
-    // -----------------------------------------------------------------------
-    const labels = opts.labels
-      ? opts.labels
-          .split(',')
-          .map((l) => l.trim())
-          .filter(Boolean)
-      : []
+  // -----------------------------------------------------------------------
+  // Run postCreate hook if configured
+  // -----------------------------------------------------------------------
+  const hookCmd = config.hooks?.postCreate
+  if (hookCmd) {
+    runPostCreateHook(hookCmd, {
+      repo,
+      issueNumber: issue.number,
+      issueUrl: issue.url,
+    })
+  }
 
-    // -----------------------------------------------------------------------
-    // Dry run — stop here
-    // -----------------------------------------------------------------------
-    if (opts.dryRun) {
-      console.log(chalk.cyan('\n--- DRY RUN ---'))
-      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(chalk.bold('\nBody preview:'))
-      console.log(chalk.dim(body))
-      console.log(chalk.cyan('--- END DRY RUN (no issue created) ---\n'))
-      process.exit(0)
-    }
+  return { url: issue.url, number: issue.number }
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
 
+export const createCommand = new Command('create')
+  .description('Create a new GitHub issue')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .option('--template <name>', 'Template to use (bug, feature, security, performance, refactor)')
+  .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('--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('--no-enhance', 'Skip AI enhancement, use rendered template as-is')
+  .option(
+    '--batch <file>',
+    'Create multiple issues from a JSON file (title, body, template, labels, agent, session per item)',
+  )
+  .action(async (opts) => {
     // -----------------------------------------------------------------------
-    // 11. Create issue
+    // Batch mode
     // -----------------------------------------------------------------------
-    const createSpinner = ora('Creating issue...').start()
-    let issue
-    try {
-      issue = await createIssue(repo, { title, body, labels })
-      createSpinner.succeed(`Issue created: ${chalk.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}`)
-      process.exit(1)
+    if (opts.batch) {
+      let items
+      try {
+        items = JSON.parse(fs.readFileSync(opts.batch, 'utf8'))
+      } catch (err) {
+        console.error(chalk.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'))
+        process.exit(1)
+      }
+
+      const results = []
+      for (const [i, item] of items.entries()) {
+        console.log(chalk.dim(`\n[${i + 1}/${items.length}] "${item.title}"`))
+        // item fields override CLI opts; labels array → comma-string for runCreate
+        const itemOpts = {
+          ...opts,
+          ...item,
+          labels: item.labels?.join(',') ?? opts.labels,
+        }
+        try {
+          const result = await runCreate(itemOpts)
+          results.push({ title: item.title, url: result?.url, ok: true })
+        } catch (err) {
+          results.push({ title: item.title, error: err.message, ok: false })
+        }
+      }
+
+      console.log(chalk.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}`))
+      }
+      process.exit(results.every((r) => r.ok) ? 0 : 1)
+      return
     }
 
     // -----------------------------------------------------------------------
-    // 12. Record success
+    // Single mode
     // -----------------------------------------------------------------------
     try {
-      await recordCreation(repo, {
-        title,
-        body,
-        issueNumber: issue.number,
-        agent,
-      })
+      const result = await runCreate(opts)
+      if (result === null) process.exit(0) // dry-run
     } catch (err) {
-      // Non-fatal — dedup DB write failure shouldn't abort the command
-      console.warn(chalk.dim(`[dedup] Failed to record fingerprint: ${err.message}`))
-    }
-
-    recordSuccess(repo, agent)
-
-    // -----------------------------------------------------------------------
-    // Run postCreate hook if configured
-    // -----------------------------------------------------------------------
-    const hookCmd = config.hooks?.postCreate
-    if (hookCmd) {
-      runPostCreateHook(hookCmd, {
-        repo,
-        issueNumber: issue.number,
-        issueUrl: issue.url,
-      })
+      process.exit(err.isAbort ? 0 : 1)
     }
   })

package/src/commands/open.js

@@ -6,7 +6,9 @@ import chalk from 'chalk'
 export const openCommand = new Command('open')
   .description('Set the active repository context')
   .argument('[repo]', 'Repository in owner/name format (e.g. owner/repo)')
-  .action(async (repo) => {
+  .option('--repo <repo>', 'Repository in owner/name format (alias for positional argument)')
+  .action(async (repoArg, opts) => {
+    const repo = repoArg || opts.repo
     if (repo) {
       setConfig({ activeRepo: repo })
       console.log(chalk.green(`✓ Active repo set to ${repo}`))

package/src/lib/attribution.js

@@ -101,7 +101,7 @@ export function buildAttribution(opts = {}) {
   if (model != null) meta.model = String(model)
 
   // Process info
-  meta.pid = pid != null ? Number(pid) : process.pid
+  if (pid != null) meta.pid = Number(pid)
   meta.trigger = trigger != null ? String(trigger) : 'cli-create'
 
   // Deduplication handles

package/src/lib/defaults.js

@@ -6,7 +6,7 @@ import os from 'node:os'
 // Built-in defaults
 // ---------------------------------------------------------------------------
 
-const BUILT_IN_DEFAULTS = {
+export const BUILT_IN_DEFAULTS = {
   // Safety
   safety: {
     maxPerHour: 10,
@@ -50,12 +50,6 @@ const BUILT_IN_DEFAULTS = {
   },
 }
 
-// ---------------------------------------------------------------------------
-// Env var prefix
-// ---------------------------------------------------------------------------
-
-const ENV_PREFIX = 'TISSUES_'
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -113,64 +107,10 @@ function readJsonFile(filePath) {
  *
  * @returns {string}
  */
-function userConfigPath() {
+export function userConfigPath() {
   return path.join(os.homedir(), '.config', 'tissues', 'config.json')
 }
 
-/**
- * Convert a flat `TISSUES_SECTION_KEY=value` environment variable map into
- * a nested object matching the config shape.
- *
- * Variable names are lowercased and split on `_` to build the path:
- *   TISSUES_SAFETY_MAX_PER_HOUR=20  →  { safety: { maxPerHour: 20 } }
- *
- * Simple camelCase reconstruction: after stripping the prefix and splitting on
- * `_`, the first segment is the section; the remaining segments are joined in
- * camelCase.
- *
- * Only variables whose section exists in BUILT_IN_DEFAULTS are included so we
- * do not accidentally pollute the config with unrelated env vars.
- *
- * @returns {object}
- */
-function configFromEnv() {
-  const result = {}
-  const knownSections = new Set(Object.keys(BUILT_IN_DEFAULTS))
-
-  for (const [rawKey, rawValue] of Object.entries(process.env)) {
-    if (!rawKey.startsWith(ENV_PREFIX)) continue
-    const stripped = rawKey.slice(ENV_PREFIX.length).toLowerCase()
-    const parts = stripped.split('_')
-    if (parts.length < 2) continue
-
-    const section = parts[0]
-    if (!knownSections.has(section)) continue
-
-    // Join remaining parts as camelCase
-    const remainingParts = parts.slice(1)
-    const fieldName = remainingParts
-      .map((p, i) => (i === 0 ? p : p.charAt(0).toUpperCase() + p.slice(1)))
-      .join('')
-
-    // Coerce value type based on built-in defaults
-    let value = rawValue
-    const builtInSection = BUILT_IN_DEFAULTS[section]
-    if (builtInSection && fieldName in builtInSection) {
-      const defaultVal = builtInSection[fieldName]
-      if (typeof defaultVal === 'number') {
-        value = Number(rawValue)
-      } else if (typeof defaultVal === 'boolean') {
-        value = rawValue === 'true' || rawValue === '1'
-      }
-    }
-
-    if (!result[section]) result[section] = {}
-    result[section][fieldName] = value
-  }
-
-  return result
-}
-
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -200,8 +140,7 @@ export function findRepoRoot(startDir) {
  *   1. Built-in defaults  (lowest)
  *   2. User-level config  (~/.config/tissues/config.json)
  *   3. Repo-level config  (<repoRoot>/.tissues/config.json)
- *   4. Environment vars   (TISSUES_*)
- *   5. CLI flags          (passed as `cliOverrides`, highest)
+ *   4. CLI flags          (passed as `cliOverrides`, highest)
  *
  * @param {string} [repoRoot] - path to the repo root; auto-detected if omitted
  * @param {object} [cliOverrides] - values from parsed CLI flags (already nested)
@@ -223,11 +162,7 @@ export function loadConfig(repoRoot, cliOverrides) {
     if (repoCfg) merged = deepMerge(merged, repoCfg)
   }
 
-  // 4. Environment variables
-  const envCfg = configFromEnv()
-  if (Object.keys(envCfg).length > 0) merged = deepMerge(merged, envCfg)
-
-  // 5. CLI overrides
+  // 4. CLI overrides
   if (cliOverrides && typeof cliOverrides === 'object') {
     merged = deepMerge(merged, cliOverrides)
   }

package/src/lib/gh.js

@@ -44,10 +44,6 @@ export function requireGh() {
  * @returns {string | null}
  */
 export function getToken() {
-  // Env vars take priority (CI/CD)
-  const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN
-  if (envToken) return envToken
-
   try {
     return execFileSync('gh', ['auth', 'token'], {
       encoding: 'utf8',
@@ -221,6 +217,59 @@ export function createIssue(repo, { title, body, labels }) {
   return { number, url }
 }
 
+/**
+ * List all label names for a repo.
+ * @param {string} repo - owner/name
+ * @returns {string[]}
+ */
+export function listLabels(repo) {
+  const raw = execFileSync('gh', [
+    'label', 'list',
+    '--repo', repo,
+    '--json', 'name',
+    '--jq', '.[].name',
+  ], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).trim()
+
+  if (!raw) return []
+  return raw.split('\n').filter(Boolean)
+}
+
+/**
+ * Create a label in a repo with a default color.
+ * @param {string} repo - owner/name
+ * @param {string} name - label name
+ */
+export function createLabel(repo, name) {
+  execFileSync('gh', [
+    'label', 'create', name,
+    '--repo', repo,
+    '--color', '#0075ca',
+  ], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
+/**
+ * Apply labels to an existing issue.
+ * @param {string} repo - owner/name
+ * @param {number} issueNumber
+ * @param {string[]} labels
+ */
+export function addLabelsToIssue(repo, issueNumber, labels) {
+  execFileSync('gh', [
+    'issue', 'edit', String(issueNumber),
+    '--repo', repo,
+    '--add-label', labels.join(','),
+  ], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
 /**
  * List open issues for a repo.
  * @param {string} repo - owner/name