tissues 0.6.1 → 0.6.2

package/src/lib/dedup.test.js

@@ -0,0 +1,227 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizeText, computeFingerprint, computeIdempotencyKey, jaccardSimilarity, scoreDedupConfidence } from './dedup.js'
+
+describe('normalizeText', () => {
+  test('lowercases input', () => {
+    assert.equal(normalizeText('Hello World'), 'hello world')
+  })
+
+  test('replaces non-alphanumeric characters with spaces', () => {
+    assert.equal(normalizeText('foo-bar_baz!qux'), 'foo bar baz qux')
+  })
+
+  test('collapses multiple spaces into one', () => {
+    assert.equal(normalizeText('foo   bar   baz'), 'foo bar baz')
+  })
+
+  test('trims leading and trailing whitespace', () => {
+    assert.equal(normalizeText('  hello world  '), 'hello world')
+  })
+
+  test('handles empty string', () => {
+    assert.equal(normalizeText(''), '')
+  })
+
+  test('handles only special characters', () => {
+    assert.equal(normalizeText('!!!---...'), '')
+  })
+
+  test('preserves digits', () => {
+    assert.equal(normalizeText('fix bug 42 in v2'), 'fix bug 42 in v2')
+  })
+
+  test('normalizes punctuation-heavy title', () => {
+    assert.equal(normalizeText('[BUG]: Fix null-pointer exception!'), 'bug fix null pointer exception')
+  })
+})
+
+describe('computeFingerprint', () => {
+  test('returns a 64-character hex string', () => {
+    const fp = computeFingerprint('Title', 'Body text')
+    assert.equal(typeof fp, 'string')
+    assert.equal(fp.length, 64)
+    assert.match(fp, /^[0-9a-f]{64}$/)
+  })
+
+  test('same inputs produce same fingerprint', () => {
+    const fp1 = computeFingerprint('Fix login bug', 'The login page crashes when...')
+    const fp2 = computeFingerprint('Fix login bug', 'The login page crashes when...')
+    assert.equal(fp1, fp2)
+  })
+
+  test('different titles produce different fingerprints', () => {
+    const fp1 = computeFingerprint('Fix login bug', 'Same body')
+    const fp2 = computeFingerprint('Fix signup bug', 'Same body')
+    assert.notEqual(fp1, fp2)
+  })
+
+  test('different bodies produce different fingerprints', () => {
+    const fp1 = computeFingerprint('Same title', 'Body A')
+    const fp2 = computeFingerprint('Same title', 'Body B')
+    assert.notEqual(fp1, fp2)
+  })
+
+  test('only uses first 500 chars of body', () => {
+    const body500 = 'a'.repeat(500)
+    const body501 = 'a'.repeat(500) + 'z'
+    const fp3 = computeFingerprint('T', body500)
+    const fp4 = computeFingerprint('T', body501)
+    assert.equal(fp3, fp4)
+  })
+
+  test('handles null/undefined body gracefully', () => {
+    const fp1 = computeFingerprint('Title', null)
+    const fp2 = computeFingerprint('Title', undefined)
+    const fp3 = computeFingerprint('Title', '')
+    assert.equal(fp1, fp3)
+    assert.equal(fp2, fp3)
+  })
+})
+
+describe('computeIdempotencyKey', () => {
+  test('returns a 64-character hex string', () => {
+    const key = computeIdempotencyKey({ agent: 'bot', trigger: 'cli', issueType: 'bug', repo: 'owner/repo' })
+    assert.equal(typeof key, 'string')
+    assert.equal(key.length, 64)
+    assert.match(key, /^[0-9a-f]{64}$/)
+  })
+
+  test('same context produces same key', () => {
+    const ctx = { agent: 'bot', trigger: 'api', issueType: 'feature', repo: 'org/proj' }
+    assert.equal(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx))
+  })
+
+  test('different agent produces different key', () => {
+    const ctx = { agent: 'bot-a', trigger: 'api', issueType: 'bug', repo: 'org/repo' }
+    const ctx2 = { ...ctx, agent: 'bot-b' }
+    assert.notEqual(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx2))
+  })
+
+  test('different repo produces different key', () => {
+    const ctx = { agent: 'bot', trigger: 'api', issueType: 'bug', repo: 'org/repo-a' }
+    const ctx2 = { ...ctx, repo: 'org/repo-b' }
+    assert.notEqual(computeIdempotencyKey(ctx), computeIdempotencyKey(ctx2))
+  })
+})
+
+describe('jaccardSimilarity', () => {
+  test('identical strings return 1.0', () => {
+    assert.equal(jaccardSimilarity('fix login crash', 'fix login crash'), 1)
+  })
+
+  test('both empty strings return 1.0', () => {
+    assert.equal(jaccardSimilarity('', ''), 1)
+  })
+
+  test('both only stop words return 1.0', () => {
+    // After stop-word removal, both are empty token sets
+    assert.equal(jaccardSimilarity('the and or', 'is are was'), 1)
+  })
+
+  test('one empty string returns 0', () => {
+    assert.equal(jaccardSimilarity('', 'fix login'), 0)
+    assert.equal(jaccardSimilarity('fix login', ''), 0)
+  })
+
+  test('one all-stop-words vs meaningful tokens returns 0', () => {
+    assert.equal(jaccardSimilarity('the and or', 'fix login crash'), 0)
+  })
+
+  test('zero word overlap returns 0', () => {
+    assert.equal(jaccardSimilarity('stop agents hallucinating', 'sadfdasfa'), 0)
+  })
+
+  test('partial overlap computes correct ratio', () => {
+    // tokens: {fix,login,crash} vs {fix,login,error} → intersection=2, union=4
+    const sim = jaccardSimilarity('fix login crash', 'fix login error')
+    assert.equal(sim, 2 / 4)
+  })
+
+  test('stop words are stripped from comparison', () => {
+    // "fix the login crash" → {fix,login,crash}; "fix a login error" → {fix,login,error}
+    const sim = jaccardSimilarity('fix the login crash', 'fix a login error')
+    assert.equal(sim, 2 / 4)
+  })
+
+  test('high overlap for near-duplicate titles', () => {
+    // {fix,login,crash} vs {fix,login,crash,safari} → 3/4 = 0.75
+    const sim = jaccardSimilarity('fix login crash', 'fix login crash on safari')
+    assert.equal(sim, 3 / 4)
+  })
+
+  test('symmetric: sim(a,b) === sim(b,a)', () => {
+    const a = 'authentication error in production'
+    const b = 'authorization failure in staging'
+    assert.equal(jaccardSimilarity(a, b), jaccardSimilarity(b, a))
+  })
+
+  test('returns value in [0, 1] range', () => {
+    const pairs = [
+      ['', 'abc'],
+      ['abc', ''],
+      ['abc', 'abc'],
+      ['totally', 'different'],
+      ['Fix null pointer', 'fix null-pointer exception in login'],
+    ]
+    for (const [a, b] of pairs) {
+      const sim = jaccardSimilarity(a, b)
+      assert.ok(sim >= 0 && sim <= 1, `similarity out of range for "${a}", "${b}": ${sim}`)
+    }
+  })
+
+  test('short titles with different words have low similarity', () => {
+    // "fix bug" → {fix,bug}, "fix auth" → {fix,auth} → 1/3 = 0.33
+    const sim = jaccardSimilarity('fix bug', 'fix auth')
+    assert.ok(sim < 0.5, `expected < 0.5 for short distinct titles, got ${sim}`)
+  })
+
+  test('case insensitive', () => {
+    assert.equal(jaccardSimilarity('Fix Login Crash', 'fix login crash'), 1)
+  })
+
+  test('punctuation ignored', () => {
+    // Punctuation stripped: "fix login crash!" → {fix,login,crash}, same as "fix login crash"
+    assert.equal(jaccardSimilarity('fix login crash!', 'fix login crash'), 1)
+  })
+})
+
+describe('scoreDedupConfidence', () => {
+  test('high confidence at 70+', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 50, fileMentions: 20, labelMatches: 5 })
+    assert.equal(result.level, 'high')
+    assert.equal(result.confidence, 75)
+  })
+
+  test('medium confidence at 40-69', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 30, fileMentions: 15, labelMatches: 0 })
+    assert.equal(result.level, 'medium')
+    assert.equal(result.confidence, 45)
+  })
+
+  test('low confidence at 21-39', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 20, fileMentions: 5, labelMatches: 0 })
+    assert.equal(result.level, 'low')
+    assert.equal(result.confidence, 25)
+  })
+
+  test('none confidence at 20 or below', () => {
+    const result = scoreDedupConfidence({ titleOverlap: 10, fileMentions: 5, labelMatches: 5 })
+    assert.equal(result.level, 'none')
+    assert.equal(result.confidence, 20)
+  })
+
+  test('clamps to 0-100 range', () => {
+    const high = scoreDedupConfidence({ titleOverlap: 60, fileMentions: 40, labelMatches: 20 })
+    assert.equal(high.confidence, 100)
+
+    const low = scoreDedupConfidence({ titleOverlap: -10, fileMentions: 0, labelMatches: 0 })
+    assert.equal(low.confidence, 0)
+  })
+
+  test('defaults to zero for missing fields', () => {
+    const result = scoreDedupConfidence({})
+    assert.equal(result.confidence, 0)
+    assert.equal(result.level, 'none')
+  })
+})

package/src/lib/defaults.js

@@ -53,6 +53,10 @@ export const BUILT_IN_DEFAULTS = {
       ollama: 'llama3.2',
       'openai-compat': null,            // user must set
       command: null,                     // not applicable
+      'gemini-cli': null,               // uses CLI default
+      'claude-cli': null,               // uses CLI default
+      'codex-cli': null,                // uses CLI default
+      openclaw: null,                   // set by gateway
     },
     keys: {
       anthropic: null,
@@ -62,6 +66,11 @@ export const BUILT_IN_DEFAULTS = {
     },
     ollama: { url: 'http://localhost:11434' },
     custom: { url: null },              // openai-compat base URL
+    openclaw: {                         // OpenClaw gateway config
+      gatewayUrl: null,                 // default: http://localhost:18790
+      token: null,                      // or OPENCLAW_GATEWAY_TOKEN env var
+      agentId: null,                    // optional agent ID
+    },
     command: null,                       // e.g. 'co inference'
     providers: {},                       // named custom providers: { "my-gemini": { command: "co gemini", timeout: 120000 } }
     routes: [],                         // routing rules
@@ -95,6 +104,17 @@ export const BUILT_IN_DEFAULTS = {
     },
   },
 
+  // Background sync
+  sync: {
+    enabled: false,           // opt-in
+    repos: [],                // empty = activeRepo only
+    interval: 300,            // seconds (5 min default)
+    adaptiveInterval: true,   // adjust based on user activity
+    issueLimit: 500,          // max issues per repo per sync
+    includeClosedDays: 30,    // sync issues closed within N days
+    autoStart: false,         // auto-fork daemon on first CLI use
+  },
+
   // Hooks (shell commands to run)
   hooks: {
     postCreate: null, // e.g., 'slack-notify.sh'

package/src/lib/defaults.test.js

@@ -0,0 +1,217 @@
+import { test, describe } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { BUILT_IN_DEFAULTS, findRepoRoot, loadConfig, getConfigValue, userConfigPath } from './defaults.js'
+
+describe('BUILT_IN_DEFAULTS', () => {
+  test('has safety section with expected keys', () => {
+    assert.ok(BUILT_IN_DEFAULTS.safety)
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.maxPerHour, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.burstLimit, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.burstWindowMinutes, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.tripThreshold, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.cooldownMinutes, 'number')
+    assert.equal(typeof BUILT_IN_DEFAULTS.safety.globalMaxPerHour, 'number')
+  })
+
+  test('has dedup section with thresholds', () => {
+    assert.ok(BUILT_IN_DEFAULTS.dedup)
+    assert.equal(BUILT_IN_DEFAULTS.dedup.blockAbove, 0.95)
+    assert.equal(BUILT_IN_DEFAULTS.dedup.warnAbove, 0.80)
+    assert.ok(typeof BUILT_IN_DEFAULTS.dedup.fingerprintTTLDays === 'number')
+  })
+
+  test('has attribution section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.attribution)
+    assert.equal(BUILT_IN_DEFAULTS.attribution.required, false)
+    assert.equal(BUILT_IN_DEFAULTS.attribution.defaultAgent, 'human')
+  })
+
+  test('has templates section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.templates)
+    assert.ok(typeof BUILT_IN_DEFAULTS.templates.dir === 'string')
+    assert.equal(BUILT_IN_DEFAULTS.templates.default, 'default')
+  })
+
+  test('has ai section', () => {
+    assert.ok(BUILT_IN_DEFAULTS.ai)
+    assert.equal(typeof BUILT_IN_DEFAULTS.ai.enabled, 'boolean')
+    assert.ok(typeof BUILT_IN_DEFAULTS.ai.provider === 'string')
+    assert.equal(BUILT_IN_DEFAULTS.ai.model, null)
+    assert.ok(BUILT_IN_DEFAULTS.ai.models)
+    assert.ok(typeof BUILT_IN_DEFAULTS.ai.models.anthropic === 'string')
+    assert.ok(BUILT_IN_DEFAULTS.ai.keys)
+    assert.ok(Array.isArray(BUILT_IN_DEFAULTS.ai.routes))
+  })
+
+  test('has hooks section with null defaults', () => {
+    assert.ok(BUILT_IN_DEFAULTS.hooks)
+    assert.equal(BUILT_IN_DEFAULTS.hooks.postCreate, null)
+    assert.equal(BUILT_IN_DEFAULTS.hooks.postClose, null)
+  })
+})
+
+describe('findRepoRoot', () => {
+  test('finds a git repo root from a subdirectory', () => {
+    // The project itself is a git repo
+    const root = findRepoRoot(path.join(process.cwd(), 'src', 'lib'))
+    assert.ok(root, 'should find a repo root')
+    assert.ok(fs.existsSync(path.join(root, '.git')))
+  })
+
+  test('returns null when no git repo found', () => {
+    // Use os.tmpdir() which (almost certainly) has no .git above it
+    const root = findRepoRoot(os.tmpdir())
+    // On some systems tmpdir might be inside a git repo; just check type
+    assert.ok(root === null || typeof root === 'string')
+  })
+
+  test('returns the directory that contains .git, not a subdirectory', () => {
+    const root = findRepoRoot(process.cwd())
+    assert.ok(root)
+    assert.ok(fs.existsSync(path.join(root, '.git')))
+    // The .git directory should be a direct child, not deeper
+    const gitPath = path.join(root, '.git')
+    const stat = fs.statSync(gitPath)
+    assert.ok(stat.isDirectory() || stat.isFile()) // worktrees use a file
+  })
+})
+
+describe('userConfigPath', () => {
+  test('returns a string path ending in config.json', () => {
+    const p = userConfigPath()
+    assert.ok(typeof p === 'string')
+    assert.ok(p.endsWith('config.json'))
+  })
+
+  test('includes tissues in the path', () => {
+    const p = userConfigPath()
+    assert.ok(p.includes('tissues'))
+  })
+
+  test('is under the home directory', () => {
+    const p = userConfigPath()
+    const home = os.homedir()
+    assert.ok(p.startsWith(home))
+  })
+})
+
+describe('loadConfig', () => {
+  test('returns an object with all built-in sections when no files exist', () => {
+    // Use a temp dir with .git so loadConfig does not pick up project-level config
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-defaults-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      const cfg = loadConfig(tmpDir)
+      assert.ok(cfg.safety)
+      assert.ok(cfg.dedup)
+      assert.ok(cfg.attribution)
+      assert.ok(cfg.templates)
+      assert.ok(cfg.ai)
+      assert.ok(cfg.hooks)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('CLI overrides take highest priority', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-cli-override-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 999 } })
+      assert.equal(cfg.safety.maxPerHour, 999)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('repo-level config overrides built-in defaults', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-repo-cfg-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'config.json'),
+      JSON.stringify({ safety: { maxPerHour: 50 } })
+    )
+    try {
+      const cfg = loadConfig(tmpDir)
+      assert.equal(cfg.safety.maxPerHour, 50)
+      // Other fields still come from defaults
+      assert.equal(cfg.safety.burstLimit, BUILT_IN_DEFAULTS.safety.burstLimit)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('CLI overrides take priority over repo config', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-priority-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(
+      path.join(tmpDir, '.tissues', 'config.json'),
+      JSON.stringify({ safety: { maxPerHour: 50 } })
+    )
+    try {
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 100 } })
+      assert.equal(cfg.safety.maxPerHour, 100)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('deep merge does not clobber sibling keys', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-deep-merge-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    try {
+      // Override only one key in safety; others should remain
+      const cfg = loadConfig(tmpDir, { safety: { maxPerHour: 20 } })
+      assert.equal(cfg.safety.maxPerHour, 20)
+      assert.equal(cfg.safety.burstLimit, BUILT_IN_DEFAULTS.safety.burstLimit)
+      assert.equal(cfg.safety.tripThreshold, BUILT_IN_DEFAULTS.safety.tripThreshold)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  test('invalid JSON in repo config is silently ignored', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-bad-json-test-'))
+    fs.mkdirSync(path.join(tmpDir, '.git'))
+    fs.mkdirSync(path.join(tmpDir, '.tissues'))
+    fs.writeFileSync(path.join(tmpDir, '.tissues', 'config.json'), 'not json {{{')
+    try {
+      const cfg = loadConfig(tmpDir)
+      // Should fall back gracefully to defaults
+      assert.equal(cfg.safety.maxPerHour, BUILT_IN_DEFAULTS.safety.maxPerHour)
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('getConfigValue', () => {
+  test('retrieves a nested value using dot notation', () => {
+    // Use the actual tissues repo root — the project itself is a git repo
+    const val = getConfigValue('safety.maxPerHour')
+    assert.ok(typeof val === 'number')
+    assert.ok(val > 0)
+  })
+
+  test('returns undefined for unknown key path', () => {
+    const val = getConfigValue('nonexistent.key.path')
+    assert.equal(val, undefined)
+  })
+
+  test('retrieves top-level section', () => {
+    const safety = getConfigValue('safety')
+    assert.ok(safety && typeof safety === 'object')
+    assert.ok('maxPerHour' in safety)
+  })
+
+  test('retrieves deeply nested ai.models.anthropic', () => {
+    const model = getConfigValue('ai.models.anthropic')
+    assert.ok(typeof model === 'string')
+    assert.ok(model.length > 0)
+  })
+})

package/src/lib/drafts-perf.test.js

@@ -0,0 +1,203 @@
+/**
+ * Performance and adversarial tests for drafts.js.
+ *
+ * These tests verify that drafts are correct under load:
+ *   - 100 concurrent writes produce no collisions
+ *   - Reading 1000 items completes in < 500ms
+ *   - Corrupt files don't prevent other items from processing
+ *   - writeToDrafts during an active readDrafts doesn't cause double-processing
+ *
+ * Run standalone: node --test src/lib/drafts-perf.test.js
+ */
+
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+import {
+  getDraftsDir,
+  writeToDrafts,
+  readDrafts,
+  markComplete,
+  hasPending,
+  countPending,
+} from './drafts.js'
+
+function makeTempRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tissues-drafts-perf-'))
+  fs.mkdirSync(path.join(dir, '.git'))
+  return dir
+}
+
+// ---------------------------------------------------------------------------
+// 100 concurrent writes
+// ---------------------------------------------------------------------------
+
+describe('100 concurrent writes', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('all 100 files exist with unique IDs', async () => {
+    const writes = Array.from({ length: 100 }, (_, i) =>
+      Promise.resolve(
+        writeToDrafts({ repo: 'perf/repo', title: `Issue ${i}`, body: `body ${i}` }, tmpDir),
+      ),
+    )
+
+    const items = await Promise.all(writes)
+    const ids = new Set(items.map((i) => i.id))
+
+    assert.equal(ids.size, 100, 'all 100 IDs should be unique')
+    assert.equal(countPending(tmpDir), 100, 'all 100 files should be on disk')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Reading 1000 items
+// ---------------------------------------------------------------------------
+
+describe('readDrafts() at scale', () => {
+  let tmpDir
+
+  before(() => {
+    tmpDir = makeTempRepo()
+    const dir = getDraftsDir(tmpDir)
+
+    // Pre-seed 1000 items directly (faster than writeToDrafts loop)
+    for (let i = 0; i < 1000; i++) {
+      const id = `perf${String(i).padStart(6, '0')}`
+      const record = {
+        id,
+        repo: 'perf/repo',
+        title: `Issue ${i}`,
+        body: `body ${i}`,
+        labels: [],
+        createdAt: new Date(Date.now() - (1000 - i) * 1000).toISOString(),
+        status: 'pending',
+        attemptCount: 0,
+      }
+      fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(record), 'utf8')
+    }
+  })
+
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('reads 1000 items in < 500ms', () => {
+    const start = Date.now()
+    const items = readDrafts(tmpDir)
+    const elapsed = Date.now() - start
+
+    assert.equal(items.length, 1000)
+    assert.ok(elapsed < 500, `readDrafts took ${elapsed}ms — expected < 500ms`)
+  })
+
+  test('results are sorted by createdAt', () => {
+    const items = readDrafts(tmpDir)
+    for (let i = 1; i < items.length; i++) {
+      const prev = new Date(items[i - 1].createdAt)
+      const curr = new Date(items[i].createdAt)
+      assert.ok(prev <= curr, `item ${i - 1} should be before item ${i}`)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Corrupt files don't break the rest
+// ---------------------------------------------------------------------------
+
+describe('adversarial: corrupt files in drafts', () => {
+  let tmpDir
+
+  before(() => {
+    tmpDir = makeTempRepo()
+    const dir = getDraftsDir(tmpDir)
+
+    // Write 5 valid items
+    for (let i = 0; i < 5; i++) {
+      writeToDrafts({ repo: 'a/b', title: `Valid ${i}`, body: '' }, tmpDir)
+    }
+
+    // Inject 3 corrupt files
+    fs.writeFileSync(path.join(dir, 'corrupt1.json'), '{ this is not json', 'utf8')
+    fs.writeFileSync(path.join(dir, 'corrupt2.json'), '', 'utf8')
+    fs.writeFileSync(path.join(dir, 'corrupt3.json'), 'null', 'utf8')
+  })
+
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('readDrafts() skips corrupt files and returns all valid items', () => {
+    const items = readDrafts(tmpDir)
+    // Should get 5 valid items (null is valid JSON but has no .id, gets returned anyway)
+    const validItems = items.filter((i) => i && i.id)
+    assert.equal(validItems.length, 5, 'should return all 5 valid items')
+  })
+
+  test('hasPending() does not throw on corrupt dir', () => {
+    assert.doesNotThrow(() => hasPending(tmpDir))
+    assert.equal(hasPending(tmpDir), true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// New write during read doesn't cause double-processing
+// ---------------------------------------------------------------------------
+
+describe('concurrent write during read', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('item written after readDrafts snapshot is not included in that batch', () => {
+    // Write 3 items before read
+    writeToDrafts({ repo: 'c/d', title: 'Pre A', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'c/d', title: 'Pre B', body: '' }, tmpDir)
+    writeToDrafts({ repo: 'c/d', title: 'Pre C', body: '' }, tmpDir)
+
+    // Snapshot the batch
+    const batch = readDrafts(tmpDir)
+    assert.equal(batch.length, 3)
+
+    // Write a new item AFTER reading — simulates concurrent create
+    writeToDrafts({ repo: 'c/d', title: 'Post D', body: '' }, tmpDir)
+
+    // The batch we already read should not include the late arrival
+    const lateArrival = batch.find((i) => i.title === 'Post D')
+    assert.equal(lateArrival, undefined, 'late-arriving item should not appear in existing batch')
+
+    // A fresh read should see all 4
+    const fresh = readDrafts(tmpDir)
+    assert.equal(fresh.length, 4)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// SIGTERM survival (file persists if process would be killed mid-flush)
+// ---------------------------------------------------------------------------
+
+describe('durability: file survives after write', () => {
+  let tmpDir
+
+  before(() => { tmpDir = makeTempRepo() })
+  after(() => { fs.rmSync(tmpDir, { recursive: true, force: true }) })
+
+  test('draft file exists immediately after writeToDrafts (before any network call)', () => {
+    // Simulate: we write draft, then "crash" (don't call createIssue)
+    const item = writeToDrafts({ repo: 'e/f', title: 'Crash survivor', body: 'important' }, tmpDir)
+
+    // The file should exist on disk right now
+    const dir = getDraftsDir(tmpDir)
+    const filePath = path.join(dir, `${item.id}.json`)
+    assert.ok(fs.existsSync(filePath), 'file must exist immediately after write')
+
+    // Simulate a re-run: readDrafts finds it
+    const recovered = readDrafts(tmpDir)
+    const mine = recovered.find((i) => i.id === item.id)
+    assert.ok(mine, 'file should be recoverable via readDrafts after simulated crash')
+    assert.equal(mine.status, 'pending')
+  })
+})