tissues 0.4.1 → 0.5.1

package/README.md

@@ -1,4 +1,4 @@
-# tissues
+# tissues 🧻
 
 AI-enhanced GitHub issue creation with built-in safety guardrails.
 
@@ -32,11 +32,11 @@ Requires Node.js >= 18.
 # Authenticate (auto-detects gh CLI token)
 tissues auth
 
-# Set your active repo
-tissues open
+# Set your active repo (optional — saves typing --repo every time)
+tissues use calebogden/tissues
 
-# Create an issue interactively
-tissues create
+# Create an issue interactively (title as positional argument — no quotes needed)
+tissues create fix the login bug
 
 # Check safety status before running in CI
 tissues status
@@ -54,13 +54,14 @@ Authenticate with GitHub. Auto-detects your `gh` CLI token if you're already log
 tissues auth
 ```
 
-### `tissues open`
+### `tissues use`
 
-Set the active repository context. All subsequent commands use this repo unless overridden with `--repo`.
+Set the active repository context. Optional — all commands also accept `--repo` directly. Once set, subsequent commands use this repo automatically unless overridden.
 
 ```bash
-tissues open
-# prompts: pick a repo from your GitHub account
+tissues use calebogden/tissues   # set by name
+tissues use                      # prompts: pick a repo from your GitHub account
+tissues use --repo calebogden/tissues  # same, via flag
 ```
 
 ### `tissues create`
@@ -68,7 +69,7 @@ tissues open
 Create a new GitHub issue. Runs dedup checks and safety gates before creating anything.
 
 ```bash
-tissues create [options]
+tissues create [title...] [options]
 ```
 
 **Options:**
@@ -78,7 +79,10 @@ tissues create [options]
 | `--repo <owner/name>` | Override active repo |
 | `--template <name>` | Template to use: `bug`, `feature`, `security`, `performance`, `refactor` |
 | `--title <title>` | Issue title (skips interactive prompt) |
-| `--body <text>` | Issue body / description (skips interactive prompt) |
+| `--body <text>` | Issue body / description — the actual content describing the issue (skips interactive prompt) |
+| `--instructions <text>` | AI enhancement instructions: guides how the AI writes the issue body (e.g. "keep it under 200 words", "use formal tone"). Does not appear in the created issue. Optional — skips interactive prompt when provided. |
+| `--no-enhance` | Skip AI enhancement, use rendered template as-is |
+| `--batch <file>` | Create multiple issues from a JSON file. Each item supports: `title`, `body`, `template`, `labels`, `agent`, `session` |
 | `--labels <labels>` | Comma-separated labels to apply |
 | `--agent <name>` | Agent identifier for attribution (default: `human`) |
 | `--session <id>` | Session ID for attribution and idempotency |
@@ -88,8 +92,8 @@ tissues create [options]
 **Examples:**
 
 ```bash
-# Interactive
-tissues create
+# Interactive (title pre-filled from positional argument)
+tissues create fix the login bug
 
 # Fully scripted (no prompts)
 tissues create \
@@ -97,6 +101,7 @@ tissues create \
   --template bug \
   --title "Login fails on Safari 17" \
   --body "Reproducible on fresh profile. Console shows CORS error." \
+  --instructions "Keep it under 150 words and include a clear reproduction checklist." \
   --labels "bug,P1"
 
 # From an AI agent
@@ -192,12 +197,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 +234,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
@@ -275,7 +284,7 @@ Template files support `{{variable}}` substitution:
 | Variable | Value |
 |---|---|
 | `{{title}}` | Issue title |
-| `{{description}}` | User's description |
+| `{{description}}` | Issue description — the actual content describing the issue |
 | `{{agent}}` | Agent identifier |
 | `{{session}}` | Session ID |
 | `{{date}}` | ISO date (YYYY-MM-DD) |
@@ -316,11 +325,10 @@ Every issue created by tissues includes a machine-readable HTML comment at the b
 <!-- tissues-meta
 agent: claude-opus-4-6
 session: abc123
-pid: 84921
 trigger: cli-create
 fingerprint: sha256:3f2a1b...
 created_at: 2026-02-19T15:30:00.000Z
-created_via: tissues-cli/0.3.0
+created_via: tissues-cli/0.5
 -->
 ```
 
@@ -332,6 +340,8 @@ The block is used by tissues to:
 
 You can pass additional fields via `--agent`, `--session`, and the programmatic API.
 
+`pid` is available but opt-in — pass it explicitly via the programmatic API (`pid: process.pid`). It is omitted by default to avoid leaking process info into public issues.
+
 ---
 
 ## State Database

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tissues",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "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,7 +2,8 @@ import { Command } from 'commander'
 import { createRequire } from 'module'
 const { version } = createRequire(import.meta.url)('../package.json')
 import { authCommand } from './commands/auth.js'
-import { openCommand } from './commands/open.js'
+import { configCommand } from './commands/config.js'
+import { useCommand } from './commands/use.js'
 import { createCommand } from './commands/create.js'
 import { listCommand } from './commands/list.js'
 import { statusCommand } from './commands/status.js'
@@ -39,7 +40,7 @@ program
     requireGh()
 
     // Show active repo context on every command (except auth/open)
-    if (name !== 'auth' && name !== 'open' && name !== 'login' && name !== 'status' && name !== 'switch' && name !== 'logout') {
+    if (name !== 'auth' && name !== 'use' && name !== 'login' && name !== 'status' && name !== 'switch' && name !== 'logout') {
       const activeRepo = store.get('activeRepo')
       if (activeRepo) {
         console.log(chalk.dim(`Working in: ${activeRepo}\n`))
@@ -61,7 +62,8 @@ program.hook('preAction', () => {
   authCommand.description(authDescription())
 })
 program.addCommand(authCommand)
-program.addCommand(openCommand)
+program.addCommand(configCommand)
+program.addCommand(useCommand)
 program.addCommand(createCommand)
 program.addCommand(listCommand)
 program.addCommand(statusCommand)

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'
 
@@ -81,280 +88,427 @@ function runPostCreateHook(hookCmd, ctx) {
  * Enhance issue body with AI. Currently a structured placeholder.
  * Wire up real AI (OpenAI / Anthropic) here.
  *
- * @param {string} title
- * @param {string} description
+ * @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) {
+async function enhanceWithAI(title, description, templateBody, instructions) {
   // TODO: wire up real AI (OpenAI / Anthropic)
-  // templateBody is provided as context for the AI to refine
+  // - 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
 }
 
 // ---------------------------------------------------------------------------
-// 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)
+
+  // -----------------------------------------------------------------------
+  // 3. Check safety
+  // -----------------------------------------------------------------------
+  const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
+  const safetyResult = checkSafety(repo, agent, config.safety)
 
-    warnIfCircuitNotClosed(safetyResult.circuitState)
+  warnIfCircuitNotClosed(safetyResult.circuitState)
+
+  if (!safetyResult.allowed) {
+    recordFailure(repo, agent, config.safety)
+    console.error(chalk.red('Safety check failed:'), safetyResult.reason)
+    throw new Error('Safety check failed')
+  }
+
+  // -----------------------------------------------------------------------
+  // 4. Get inputs
+  // -----------------------------------------------------------------------
+  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 description =
+    opts.body ??
+    (await input({
+      message: 'Issue description (optional)',
+    }))
+
+  const instructions =
+    opts.instructions ??
+    (await input({
+      message: 'Issue instruction (optional, guides AI enhancement)',
+    }))
+
+  // -----------------------------------------------------------------------
+  // 5. Pick template
+  // -----------------------------------------------------------------------
+  let templateName = opts.template
+
+  // Fall back to config default
+  if (!templateName) {
+    templateName = config.templates?.default ?? null
+  }
 
-    if (!safetyResult.allowed) {
-      recordFailure(repo, agent, config.safety)
-      console.error(chalk.red('Safety check failed:'), safetyResult.reason)
-      process.exit(1)
+  // 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,
+        })
+      }
     }
 
-    // -----------------------------------------------------------------------
-    // 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 (choices.length > 0) {
+      templateName = await select({
+        message: 'Choose a template',
+        choices,
+      })
+    } else {
+      templateName = 'default'
     }
+  }
 
-    const description =
-      opts.body ??
-      (await input({
-        message: 'Brief description (optional, used for AI enhancement)',
-      }))
+  let template
+  try {
+    template = loadTemplate(templateName, repoRoot)
+  } catch (err) {
+    console.error(chalk.red(`Template error: ${err.message}`))
+    throw new Error(`Template error: ${err.message}`)
+  }
 
-    // -----------------------------------------------------------------------
-    // 5. Pick template
-    // -----------------------------------------------------------------------
-    let templateName = opts.template
+  // -----------------------------------------------------------------------
+  // 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: [] }
+  }
 
-    // Fall back to config default
-    if (!templateName) {
-      templateName = config.templates?.default ?? null
+  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 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,
-          })
-        }
-      }
+  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()
 
-      if (choices.length > 0) {
-        templateName = await select({
-          message: 'Choose a template',
-          choices,
-        })
-      } else {
-        templateName = 'default'
-      }
+    const proceed = await confirm({
+      message: 'Create anyway?',
+      default: false,
+    })
+
+    if (!proceed) {
+      console.log(chalk.dim('Aborted.'))
+      throw new AbortError('Aborted by user')
     }
+  }
 
-    let template
+  // -----------------------------------------------------------------------
+  // 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 {
-      template = loadTemplate(templateName, repoRoot)
-    } catch (err) {
-      console.error(chalk.red(`Template error: ${err.message}`))
-      process.exit(1)
+      body = await enhanceWithAI(title, description, renderedTemplate, instructions)
+      aiSpinner.succeed('Enhanced')
+    } catch {
+      aiSpinner.warn('AI enhancement unavailable — using template as-is')
     }
+  }
 
-    // -----------------------------------------------------------------------
-    // 6. Check dedup
-    // -----------------------------------------------------------------------
-    const session = opts.session ?? null
-    const dedupSpinner = ora('Checking for duplicates...').start()
-    let dedupResult
+  // -----------------------------------------------------------------------
+  // 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 {
-      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 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)
     }
+  }
 
-    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)
-    }
+  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 (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))
+  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}`)
+        }
       }
-      console.warn()
-
-      const proceed = await confirm({
-        message: 'Create anyway?',
-        default: false,
-      })
-
-      if (!proceed) {
-        console.log(chalk.dim('Aborted.'))
-        process.exit(0)
+      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}`))
       }
     }
+  }
 
-    // -----------------------------------------------------------------------
-    // 7. Render template
-    // -----------------------------------------------------------------------
-    const renderedTemplate = renderTemplate(template.body, {
+  // -----------------------------------------------------------------------
+  // 12. Record success
+  // -----------------------------------------------------------------------
+  try {
+    await recordCreation(repo, {
       title,
-      description: description || '',
+      body,
+      issueNumber: issue.number,
       agent,
-      session: session || '',
-      date: new Date().toISOString().slice(0, 10),
-      repo,
     })
+  } catch (err) {
+    // Non-fatal — dedup DB write failure shouldn't abort the command
+    console.warn(chalk.dim(`[dedup] Failed to record fingerprint: ${err.message}`))
+  }
 
-    // -----------------------------------------------------------------------
-    // 8. AI enhancement (stub — passes rendered template as context)
-    // -----------------------------------------------------------------------
-    let body = renderedTemplate
-    const aiSpinner = ora('Enhancing with AI...').start()
-    try {
-      body = await enhanceWithAI(title, description, renderedTemplate)
-      aiSpinner.succeed('Enhanced')
-    } catch {
-      aiSpinner.warn('AI enhancement unavailable — using template as-is')
-    }
+  recordSuccess(repo, agent)
 
-    // -----------------------------------------------------------------------
-    // 9. Add attribution
-    // -----------------------------------------------------------------------
-    const fingerprint = computeFingerprint(title, body)
-    const attribution = renderAttribution({
-      agent,
-      session: session ?? undefined,
-      trigger: 'cli-create',
-      fingerprint: `sha256:${fingerprint}`,
+  // -----------------------------------------------------------------------
+  // Run postCreate hook if configured
+  // -----------------------------------------------------------------------
+  const hookCmd = config.hooks?.postCreate
+  if (hookCmd) {
+    runPostCreateHook(hookCmd, {
+      repo,
+      issueNumber: issue.number,
+      issueUrl: issue.url,
     })
+  }
 
-    body = body.trimEnd() + '\n\n' + attribution
+  return { url: issue.url, number: issue.number }
+}
 
-    // -----------------------------------------------------------------------
-    // 10. Parse labels
-    // -----------------------------------------------------------------------
-    const labels = opts.labels
-      ? opts.labels
-          .split(',')
-          .map((l) => l.trim())
-          .filter(Boolean)
-      : []
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
 
+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('--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 — a prompt that guides how the AI writes the issue body (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 (titleArg, opts) => {
+    // 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(' ')
     // -----------------------------------------------------------------------
-    // Dry run — stop here
+    // Batch mode
     // -----------------------------------------------------------------------
-    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)
-    }
+    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)
+      }
 
-    // -----------------------------------------------------------------------
-    // 11. Create issue
-    // -----------------------------------------------------------------------
-    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 (!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/status.js

@@ -83,7 +83,7 @@ export const statusCommand = new Command('status')
     }
 
     if (!repo) {
-      console.error(chalk.red('No active repo. Set one with: tissues open'))
+      console.error(chalk.red('No active repo. Set one with: tissues use <owner/repo>'))
       process.exit(1)
     }
 

package/src/commands/{open.js → use.js}

@@ -3,10 +3,12 @@ import { pickRepo } from '../lib/repo-picker.js'
 import { setConfig } from '../lib/config.js'
 import chalk from 'chalk'
 
-export const openCommand = new Command('open')
+export const useCommand = new Command('use')
   .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

@@ -56,7 +56,7 @@ function nowISO() {
  * @typedef {object} AttributionOpts
  * @property {string}  [agent]          - agent identifier (e.g. 'claude-opus-4-6')
  * @property {string}  [session]        - session or conversation ID
- * @property {number}  [pid]            - process ID of the creating process
+ * @property {number}  [pid]            - process ID (opt-in; omitted by default)
  * @property {string}  [model]          - AI model used (if any)
  * @property {string}  [trigger]        - how the issue was created (e.g. 'cli-create')
  * @property {string}  [fingerprint]    - content fingerprint (sha256:...)
@@ -72,7 +72,8 @@ function nowISO() {
  * Build a normalized attribution metadata object from raw options.
  *
  * The returned object includes all provided fields plus automatic defaults
- * (`created_at`, `created_via`, `pid`). Undefined/null fields are omitted.
+ * (`created_at`, `created_via`). Undefined/null fields are omitted.
+ * `pid` is opt-in — it is only included if explicitly passed.
  *
  * @param {AttributionOpts} opts
  * @returns {object} metadata record
@@ -100,8 +101,8 @@ export function buildAttribution(opts = {}) {
   if (session != null) meta.session = String(session)
   if (model != null) meta.model = String(model)
 
-  // Process info
-  meta.pid = pid != null ? Number(pid) : process.pid
+  // Process info (pid is opt-in — pass it explicitly to include)
+  if (pid != null) meta.pid = Number(pid)
   meta.trigger = trigger != null ? String(trigger) : 'cli-create'
 
   // Deduplication handles
@@ -120,7 +121,7 @@ export function buildAttribution(opts = {}) {
 
   // Timestamps / versioning
   meta.created_at = createdAt ?? nowISO()
-  meta.created_via = `tissues-cli/${PKG_VERSION}`
+  meta.created_via = `tissues-cli/${PKG_VERSION.split('.').slice(0, 2).join('.')}`
 
   return meta
 }
@@ -137,11 +138,10 @@ export function buildAttribution(opts = {}) {
  * <!-- tissues-meta
  * agent: claude-opus-4-6
  * session: abc123
- * pid: 12345
  * trigger: cli-create
  * fingerprint: sha256:deadbeef
  * created_at: 2026-02-19T15:30:00Z
- * created_via: tissues-cli/0.1.0
+ * created_via: tissues-cli/0.1
  * -->
  *
  * @param {AttributionOpts} opts
@@ -170,7 +170,7 @@ export function renderAttribution(opts = {}) {
  * Returns the parsed key/value pairs as a plain object, or `null` if no
  * attribution block is present in `issueBody`.
  *
- * Numeric fields (`pid`, `risk`, `complexity`, `confidence`) are coerced to
+ * Numeric fields (`risk`, `complexity`, `confidence`) are coerced to
  * numbers. The `context_tags` field is split back into an array.
  *
  * @param {string} issueBody - raw GitHub issue body markdown

package/src/lib/db.js

@@ -277,6 +277,25 @@ export function getCircuitState(repo, agent = 'human') {
   }
 }
 
+/**
+ * Increment the failure count for a circuit without opening it.
+ * Used to persist intermediate failures before the trip threshold is reached.
+ *
+ * @param {string} repo
+ * @param {string} [agent='human']
+ */
+export function incrementFailureCount(repo, agent = 'human') {
+  const db = getDb()
+  const id = `${repo}:${agent}`
+  db.prepare(
+    `INSERT INTO circuit_breaker (id, repo, agent, status, failure_count, updated_at)
+     VALUES (?, ?, ?, 'closed', 1, datetime('now'))
+     ON CONFLICT(id) DO UPDATE SET
+       failure_count = failure_count + 1,
+       updated_at    = datetime('now')`,
+  ).run(id, repo, agent)
+}
+
 /**
  * Trip (open) the circuit breaker and set a cooldown window.
  *

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

package/src/lib/safety.js

@@ -16,6 +16,7 @@ import {
   probeCircuit,
   recordRateEvent,
   countRecentEvents,
+  incrementFailureCount,
   getDb,
 } from './db.js'
 
@@ -206,10 +207,8 @@ export function recordFailure(repo, agent, config = {}) {
       `Cooldown: ${cfg.cooldownMinutes} minutes.`
     )
   } else {
-    // Update failure count without tripping — db.tripCircuit handles the trip;
-    // for intermediate increments we record a 'failure' rate event so the count
-    // is persisted across calls.
-    recordRateEvent(repo, agent, 'failure')
+    // Persist intermediate failure count without opening the circuit yet
+    incrementFailureCount(repo, agent)
   }
 }