opencastle 0.31.6 → 0.32.0

package/src/cli/convoy/store.test.ts

@@ -99,11 +99,11 @@ describe('DB creation', () => {
     expect(row.journal_mode).toBe('wal')
   })
 
-  it('sets schema version to 10', () => {
+  it('sets schema version to 11', () => {
     const db = new DatabaseSync(dbPath)
     const row = db.prepare('PRAGMA user_version').get() as { user_version: number }
     db.close()
-    expect(row.user_version).toBe(10)
+    expect(row.user_version).toBe(11)
   })
 
   it('creates all required tables', () => {
@@ -131,7 +131,7 @@ describe('DB creation', () => {
     store2.close()
     // Reassign so afterEach does not double-close
     store = createConvoyStore(dbPath)
-    expect(row.user_version).toBe(10)
+    expect(row.user_version).toBe(11)
   })
 })
 
@@ -208,8 +208,8 @@ describe('schema migration', () => {
     verifyDb.close()
 
     expect(cols.map(c => c.name)).toContain('adapter')
-    // v1 chains through v2→v3→v4→...→v7→v8→v9→v10 in one init, so final version is 10
-    expect(version.user_version).toBe(10)
+    // v1 chains through v2→v3→v4→...→v7→v8→v9→v10→v11 in one init, so final version is 11
+    expect(version.user_version).toBe(11)
   })
 
   it('schema migration v2 to v3 adds cost columns', () => {
@@ -295,7 +295,7 @@ describe('schema migration', () => {
     expect(convoyColNames).toContain('total_tokens')
     expect(convoyColNames).toContain('total_cost_usd')
 
-    expect(version.user_version).toBe(10)
+    expect(version.user_version).toBe(11)
   })
 
   it('schema migration v1 to v3 chains correctly in a single init', () => {
@@ -381,7 +381,7 @@ describe('schema migration', () => {
     expect(convoyColNames).toContain('total_tokens')
     expect(convoyColNames).toContain('total_cost_usd')
 
-    expect(version.user_version).toBe(10)
+    expect(version.user_version).toBe(11)
   })
 
   it('schema migration v3 to v4 creates pipeline table and adds pipeline_id to convoy', () => {
@@ -464,7 +464,7 @@ describe('schema migration', () => {
 
     expect(convoyCols.map(c => c.name)).toContain('pipeline_id')
     expect(tables.map(t => t.name)).toContain('pipeline')
-    expect(version.user_version).toBe(10)
+    expect(version.user_version).toBe(11)
   })
 })
 
@@ -1444,7 +1444,7 @@ describe('schema migration v5 → v6', () => {
     v5Verify.close()
     migratedStore.close()
 
-    expect(row.user_version).toBe(10)
+    expect(row.user_version).toBe(11)
     expect(taskStepTable?.name).toBe('task_step')
     expect(convoy?.id).toBe('convoy-auto')
     expect(task?.id).toBe('task-auto')
@@ -1614,7 +1614,7 @@ describe('schema migration v6→v7 (drift detection columns)', () => {
 
     expect(cols.map(c => c.name)).toContain('drift_score')
     expect(cols.map(c => c.name)).toContain('drift_retried')
-    expect(version.user_version).toBe(10)
+    expect(version.user_version).toBe(11)
   })
 
   it('new databases include drift_score and drift_retried in CREATE TABLE', () => {
@@ -1847,9 +1847,9 @@ describe('migration full chain v4→v10', () => {
 
     const verifyDb = new DatabaseSync(chainDbPath)
 
-    // Verify user_version = 10
+    // Verify user_version = 11
     const version = (verifyDb.prepare('PRAGMA user_version').get() as { user_version: number }).user_version
-    expect(version).toBe(10)
+    expect(version).toBe(11)
 
     // Verify all new tables exist
     const tables = (verifyDb.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{ name: string }>).map(t => t.name)
@@ -1863,7 +1863,7 @@ describe('migration full chain v4→v10', () => {
       'gates', 'on_exhausted', 'injected', 'provenance', 'idempotency_key',
       'current_step', 'total_steps', 'review_level', 'review_verdict', 'review_tokens',
       'review_model', 'panel_attempts', 'dispute_id', 'drift_score', 'drift_retried',
-      'outputs', 'inputs', 'discovered_issues',
+      'outputs', 'inputs', 'discovered_issues', 'compaction_count',
     ]) {
       expect(taskCols).toContain(col)
     }
@@ -2525,10 +2525,10 @@ describe('v9→v10 migration', () => {
 
     migratedStore.close()
 
-    // Verify version = 10
+    // Verify version = 11
     const verifyDb = new DatabaseSync(migDb)
     const version = (verifyDb.prepare('PRAGMA user_version').get() as { user_version: number }).user_version
-    expect(version).toBe(10)
+    expect(version).toBe(11)
 
     // Verify new REAL columns exist
     const convoyCols = (verifyDb.prepare('PRAGMA table_info(convoy)').all() as Array<{ name: string }>).map(c => c.name)

package/src/cli/convoy/store.ts

@@ -17,7 +17,7 @@ import type {
   TaskStepRecord,
 } from './types.js'
 
-const SCHEMA_VERSION = 10
+const SCHEMA_VERSION = 11
 
 // ── Size limits (bytes) ────────────────────────────────────────────────────────
 const LIMIT_SPEC_YAML = 256 * 1024      // 256 KB
@@ -83,7 +83,7 @@ export interface ConvoyStore {
       | 'on_exhausted' | 'injected' | 'provenance' | 'idempotency_key'
       | 'current_step' | 'total_steps' | 'review_level' | 'review_verdict'
       | 'review_tokens' | 'review_model' | 'panel_attempts' | 'dispute_id'
-      | 'drift_score' | 'drift_retried' | 'discovered_issues'
+      | 'drift_score' | 'drift_retried' | 'discovered_issues' | 'compaction_count'
     > & { outputs?: string | null; inputs?: string | null },
   ): void
   insertInjectedTask(record: TaskRecord): void
@@ -101,6 +101,7 @@ export interface ConvoyStore {
         TaskRecord,
         | 'worker_id' | 'worktree' | 'output' | 'exit_code' | 'started_at' | 'finished_at'
         | 'retries' | 'prompt_tokens' | 'completion_tokens' | 'total_tokens' | 'cost_usd' | 'prompt'
+        | 'contract_result'
       >
     >,
   ): void
@@ -114,6 +115,7 @@ export interface ConvoyStore {
     convoyId: string,
     fields: Partial<Pick<TaskRecord, 'drift_score' | 'drift_retried'>>,
   ): void
+  updateTaskCompaction(taskId: string, convoyId: string, compactionCount: number): void
   updateTaskDisputeStatus(taskId: string, convoyId: string, status: ConvoyTaskStatus, disputeId: string): void
   getReadyTasks(convoyId: string): TaskRecord[]
   insertTaskStep(record: Omit<TaskStepRecord, 'id'>): number
@@ -259,9 +261,11 @@ class ConvoyStoreImpl implements ConvoyStore {
           dispute_id        TEXT,
           drift_score       REAL,
           drift_retried     INTEGER NOT NULL DEFAULT 0,
+          compaction_count  INTEGER NOT NULL DEFAULT 0,
           outputs           TEXT,
           inputs            TEXT,
-          discovered_issues TEXT
+          discovered_issues TEXT,
+          contract_result   TEXT
         );
 
         CREATE UNIQUE INDEX IF NOT EXISTS idx_task_idempotency ON task(convoy_id, idempotency_key)
@@ -416,6 +420,10 @@ class ConvoyStoreImpl implements ConvoyStore {
       migrateSchema(this.db, this.dbPath, 9, 10)
       version = 10
     }
+    if (version === 10) {
+      migrateSchema(this.db, this.dbPath, 10, 11)
+      version = 11
+    }
   }
 
   insertConvoy(
@@ -504,7 +512,7 @@ class ConvoyStoreImpl implements ConvoyStore {
       | 'on_exhausted' | 'injected' | 'provenance' | 'idempotency_key'
       | 'current_step' | 'total_steps' | 'review_level' | 'review_verdict'
       | 'review_tokens' | 'review_model' | 'panel_attempts' | 'dispute_id'
-      | 'drift_score' | 'drift_retried' | 'discovered_issues'
+      | 'drift_score' | 'drift_retried' | 'discovered_issues' | 'compaction_count'
     > & { outputs?: string | null; inputs?: string | null },
   ): void {
     this.db
@@ -592,6 +600,7 @@ class ConvoyStoreImpl implements ConvoyStore {
         TaskRecord,
         | 'worker_id' | 'worktree' | 'output' | 'exit_code' | 'started_at' | 'finished_at'
         | 'retries' | 'prompt_tokens' | 'completion_tokens' | 'total_tokens' | 'cost_usd' | 'prompt'
+        | 'contract_result'
       >
     >,
   ): void {
@@ -603,6 +612,7 @@ class ConvoyStoreImpl implements ConvoyStore {
     const extraFields = [
       'worker_id', 'worktree', 'output', 'exit_code', 'started_at', 'finished_at',
       'retries', 'prompt_tokens', 'completion_tokens', 'total_tokens', 'cost_usd', 'prompt',
+      'contract_result',
     ] as const
 
     if (extra) {
@@ -708,6 +718,12 @@ class ConvoyStoreImpl implements ConvoyStore {
     this.db.prepare(`UPDATE task SET ${sets.join(', ')} WHERE id = :id AND convoy_id = :convoy_id`).run(params)
   }
 
+  updateTaskCompaction(taskId: string, convoyId: string, compactionCount: number): void {
+    this.db
+      .prepare('UPDATE task SET compaction_count = :compaction_count WHERE id = :id AND convoy_id = :convoy_id')
+      .run({ id: taskId, convoy_id: convoyId, compaction_count: compactionCount })
+  }
+
   updateTaskDisputeStatus(taskId: string, convoyId: string, status: ConvoyTaskStatus, disputeId: string): void {
     this.db
       .prepare(
@@ -1334,6 +1350,12 @@ export function migrateSchema(db: DatabaseSync, dbPath: string, fromVersion: num
           UPDATE pipeline SET total_cost_usd_num = CAST(total_cost_usd AS REAL) WHERE total_cost_usd IS NOT NULL;
         `)
       }
+      if (v === 10) {
+        db.exec(`
+          ALTER TABLE task ADD COLUMN contract_result TEXT;
+          ALTER TABLE task ADD COLUMN compaction_count INTEGER NOT NULL DEFAULT 0;
+        `)
+      }
       db.exec('COMMIT')
     } catch (err) {
       try { db.exec('ROLLBACK') } catch { /* ignore */ }

package/src/cli/convoy/tdd-gate.test.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect } from 'vitest'
+import {
+  checkTDD,
+  formatTDDFailure,
+  DEFAULT_TDD_CONFIG,
+  type TDDCheckResult,
+} from './tdd-gate.js'
+import type { TDDGateConfig } from './types.js'
+
+const BASE_CONFIG: TDDGateConfig = { ...DEFAULT_TDD_CONFIG }
+
+describe('checkTDD', () => {
+  describe('disabled / skipped', () => {
+    it('returns skipped when config.enabled is false', () => {
+      const result = checkTDD(['src/foo.ts'], [], { ...BASE_CONFIG, enabled: false })
+      expect(result.skipped).toBe(true)
+      expect(result.skip_reason).toBe('disabled')
+      expect(result.passed).toBe(true)
+    })
+
+    it('returns skipped for exempt agent', () => {
+      const result = checkTDD(['src/foo.ts'], [], BASE_CONFIG, 'documentation-writer')
+      expect(result.skipped).toBe(true)
+      expect(result.skip_reason).toBe('exempt_agent')
+      expect(result.passed).toBe(true)
+    })
+
+    it('returns skipped for all exempt agents', () => {
+      for (const agent of ['documentation-writer', 'copywriter', 'seo-specialist', 'researcher']) {
+        const result = checkTDD(['src/foo.ts'], [], BASE_CONFIG, agent)
+        expect(result.skipped).toBe(true)
+      }
+    })
+
+    it('does NOT skip for unknown agent', () => {
+      const result = checkTDD(['src/foo.ts', 'src/foo.test.ts'], [], BASE_CONFIG, 'developer')
+      expect(result.skipped).toBe(false)
+    })
+  })
+
+  describe('exclude patterns', () => {
+    it('excludes **/types.ts', () => {
+      const result = checkTDD(['src/cli/convoy/types.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/cli/convoy/types.ts')
+      expect(result.new_source_files).toHaveLength(0)
+      expect(result.passed).toBe(true)
+    })
+
+    it('excludes **/index.ts', () => {
+      const result = checkTDD(['src/index.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/index.ts')
+      expect(result.passed).toBe(true)
+    })
+
+    it('excludes **/*.d.ts', () => {
+      const result = checkTDD(['src/foo.d.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/foo.d.ts')
+      expect(result.passed).toBe(true)
+    })
+
+    it('excludes **/constants.ts', () => {
+      const result = checkTDD(['src/constants.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/constants.ts')
+      expect(result.passed).toBe(true)
+    })
+
+    it('excludes **/schemas.ts', () => {
+      const result = checkTDD(['src/schemas.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/schemas.ts')
+      expect(result.passed).toBe(true)
+    })
+  })
+
+  describe('test file self-exclusion', () => {
+    it('excludes .test.ts files from source candidates', () => {
+      const result = checkTDD(['src/foo.test.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/foo.test.ts')
+      expect(result.new_source_files).toHaveLength(0)
+      expect(result.passed).toBe(true)
+    })
+
+    it('excludes .spec.ts files from source candidates', () => {
+      const result = checkTDD(['src/foo.spec.ts'], [], BASE_CONFIG)
+      expect(result.excluded_files).toContain('src/foo.spec.ts')
+      expect(result.passed).toBe(true)
+    })
+  })
+
+  describe('block mode (default)', () => {
+    it('passes when source file has test in changedFiles', () => {
+      const result = checkTDD(['src/foo.ts', 'src/foo.test.ts'], [], BASE_CONFIG)
+      expect(result.passed).toBe(true)
+      expect(result.missing_test_files).toHaveLength(0)
+      expect(result.existing_test_files).toContain('src/foo.ts')
+    })
+
+    it('blocks when source file has no test', () => {
+      const result = checkTDD(['src/foo.ts'], [], BASE_CONFIG)
+      expect(result.passed).toBe(false)
+      expect(result.missing_test_files).toContain('src/foo.ts')
+    })
+
+    it('passes when test already exists in allFiles (not changedFiles)', () => {
+      const result = checkTDD(['src/foo.ts'], ['src/foo.test.ts'], BASE_CONFIG)
+      expect(result.passed).toBe(true)
+      expect(result.existing_test_files).toContain('src/foo.ts')
+    })
+
+    it('recognizes .spec.ts as valid test file', () => {
+      const result = checkTDD(['src/foo.ts', 'src/foo.spec.ts'], [], BASE_CONFIG)
+      expect(result.passed).toBe(true)
+      expect(result.existing_test_files).toContain('src/foo.ts')
+    })
+
+    it('handles multiple files, some with tests and some without', () => {
+      const result = checkTDD(
+        ['src/a.ts', 'src/b.ts', 'src/a.test.ts'],
+        [],
+        BASE_CONFIG,
+      )
+      expect(result.passed).toBe(false)
+      expect(result.missing_test_files).toContain('src/b.ts')
+      expect(result.existing_test_files).toContain('src/a.ts')
+      expect(result.missing_test_files).not.toContain('src/a.ts')
+    })
+
+    it('passes when all source files have tests', () => {
+      const result = checkTDD(
+        ['src/a.ts', 'src/b.ts', 'src/a.test.ts', 'src/b.test.ts'],
+        [],
+        BASE_CONFIG,
+      )
+      expect(result.passed).toBe(true)
+      expect(result.missing_test_files).toHaveLength(0)
+    })
+  })
+
+  describe('warn mode', () => {
+    const warnConfig: TDDGateConfig = { ...BASE_CONFIG, mode: 'warn' }
+
+    it('passes even when test file is missing', () => {
+      const result = checkTDD(['src/foo.ts'], [], warnConfig)
+      expect(result.passed).toBe(true)
+      expect(result.missing_test_files).toContain('src/foo.ts')
+      expect(result.skipped).toBe(false)
+    })
+
+    it('still reports all missing test files', () => {
+      const result = checkTDD(['src/a.ts', 'src/b.ts'], [], warnConfig)
+      expect(result.passed).toBe(true)
+      expect(result.missing_test_files).toHaveLength(2)
+    })
+  })
+
+  describe('source pattern filtering', () => {
+    it('ignores files not matching source_patterns', () => {
+      const result = checkTDD(['README.md', 'package.json', '.gitignore'], [], BASE_CONFIG)
+      expect(result.new_source_files).toHaveLength(0)
+      expect(result.passed).toBe(true)
+    })
+
+    it('custom source_patterns work', () => {
+      const config: TDDGateConfig = { ...BASE_CONFIG, source_patterns: ['lib/**/*.ts'] }
+      const result = checkTDD(['lib/foo.ts'], [], config)
+      expect(result.passed).toBe(false)
+      expect(result.missing_test_files).toContain('lib/foo.ts')
+    })
+  })
+
+  describe('nested file paths', () => {
+    it('resolves test path correctly for deeply nested source file', () => {
+      const result = checkTDD(
+        ['src/cli/convoy/foo.ts', 'src/cli/convoy/foo.test.ts'],
+        [],
+        BASE_CONFIG,
+      )
+      expect(result.passed).toBe(true)
+      expect(result.existing_test_files).toContain('src/cli/convoy/foo.ts')
+    })
+
+    it('resolves test path against allFiles for pre-existing test', () => {
+      const result = checkTDD(
+        ['src/cli/convoy/compaction.ts'],
+        ['src/cli/convoy/compaction.test.ts'],
+        BASE_CONFIG,
+      )
+      expect(result.passed).toBe(true)
+    })
+
+    it('blocks when nested source file has no test', () => {
+      const result = checkTDD(['src/cli/convoy/artifacts.ts'], [], BASE_CONFIG)
+      expect(result.passed).toBe(false)
+      expect(result.missing_test_files).toContain('src/cli/convoy/artifacts.ts')
+    })
+  })
+
+  describe('empty inputs', () => {
+    it('passes with no changed files', () => {
+      const result = checkTDD([], [], BASE_CONFIG)
+      expect(result.passed).toBe(true)
+      expect(result.new_source_files).toHaveLength(0)
+    })
+
+    it('passes with no changed files even with allFiles', () => {
+      const result = checkTDD([], ['src/foo.ts', 'src/foo.test.ts'], BASE_CONFIG)
+      expect(result.passed).toBe(true)
+    })
+  })
+})
+
+describe('formatTDDFailure', () => {
+  it('returns success message when no missing test files', () => {
+    const result: TDDCheckResult = {
+      passed: true,
+      new_source_files: ['src/foo.ts'],
+      missing_test_files: [],
+      existing_test_files: ['src/foo.ts'],
+      excluded_files: [],
+      skipped: false,
+    }
+    expect(formatTDDFailure(result)).toBe('TDD Gate: all source files have corresponding tests.')
+  })
+
+  it('formats missing file with correct test path', () => {
+    const result: TDDCheckResult = {
+      passed: false,
+      new_source_files: ['src/cli/convoy/artifacts.ts'],
+      missing_test_files: ['src/cli/convoy/artifacts.ts'],
+      existing_test_files: [],
+      excluded_files: [],
+      skipped: false,
+    }
+    const output = formatTDDFailure(result)
+    expect(output).toContain('TDD Gate BLOCKED: New source files without tests:')
+    expect(output).toContain('src/cli/convoy/artifacts.ts → missing src/cli/convoy/artifacts.test.ts')
+  })
+
+  it('formats multiple missing files', () => {
+    const result: TDDCheckResult = {
+      passed: false,
+      new_source_files: ['src/cli/convoy/artifacts.ts', 'src/cli/convoy/compaction.ts'],
+      missing_test_files: ['src/cli/convoy/artifacts.ts', 'src/cli/convoy/compaction.ts'],
+      existing_test_files: [],
+      excluded_files: [],
+      skipped: false,
+    }
+    const output = formatTDDFailure(result)
+    expect(output).toContain('src/cli/convoy/artifacts.ts → missing src/cli/convoy/artifacts.test.ts')
+    expect(output).toContain('src/cli/convoy/compaction.ts → missing src/cli/convoy/compaction.test.ts')
+  })
+
+  it('formats file without directory correctly', () => {
+    const result: TDDCheckResult = {
+      passed: false,
+      new_source_files: ['foo.ts'],
+      missing_test_files: ['foo.ts'],
+      existing_test_files: [],
+      excluded_files: [],
+      skipped: false,
+    }
+    const output = formatTDDFailure(result)
+    expect(output).toContain('foo.ts → missing foo.test.ts')
+  })
+})
+
+describe('DEFAULT_TDD_CONFIG', () => {
+  it('has expected defaults', () => {
+    expect(DEFAULT_TDD_CONFIG.enabled).toBe(true)
+    expect(DEFAULT_TDD_CONFIG.mode).toBe('block')
+    expect(DEFAULT_TDD_CONFIG.exempt_agents).toContain('documentation-writer')
+    expect(DEFAULT_TDD_CONFIG.exempt_agents).toContain('copywriter')
+    expect(DEFAULT_TDD_CONFIG.exempt_agents).toContain('seo-specialist')
+    expect(DEFAULT_TDD_CONFIG.exempt_agents).toContain('researcher')
+    expect(DEFAULT_TDD_CONFIG.source_patterns).toContain('src/**/*.ts')
+    expect(DEFAULT_TDD_CONFIG.test_patterns).toContain('{name}.test.ts')
+    expect(DEFAULT_TDD_CONFIG.test_patterns).toContain('{name}.spec.ts')
+    expect(DEFAULT_TDD_CONFIG.exclude_patterns).toContain('**/types.ts')
+    expect(DEFAULT_TDD_CONFIG.exclude_patterns).toContain('**/index.ts')
+    expect(DEFAULT_TDD_CONFIG.exclude_patterns).toContain('**/*.d.ts')
+  })
+})

package/src/cli/convoy/tdd-gate.ts

@@ -0,0 +1,154 @@
+import type { TDDGateConfig } from './types.js'
+
+export type { TDDGateConfig }
+
+export const DEFAULT_TDD_CONFIG: TDDGateConfig = {
+  enabled: true,
+  source_patterns: ['src/**/*.ts'],
+  test_patterns: ['{name}.test.ts', '{name}.spec.ts'],
+  exclude_patterns: [
+    '**/types.ts',
+    '**/index.ts',
+    '**/*.d.ts',
+    '**/constants.ts',
+    '**/schemas.ts',
+  ],
+  mode: 'block',
+  exempt_agents: ['documentation-writer', 'copywriter', 'seo-specialist', 'researcher'],
+}
+
+export interface TDDCheckResult {
+  passed: boolean
+  new_source_files: string[]
+  missing_test_files: string[]
+  existing_test_files: string[]
+  excluded_files: string[]
+  skipped: boolean
+  skip_reason?: string
+}
+
+// ── Glob matching ─────────────────────────────────────────────────────────────
+
+function matchGlob(pattern: string, filePath: string): boolean {
+  const path = filePath.replace(/\\/g, '/')
+  const regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*\//g, '(?:.+/)?')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '[^/]*')
+  return new RegExp('^' + regexStr + '$').test(path)
+}
+
+function isTestFile(filePath: string, testPatterns: string[]): boolean {
+  const basename = filePath.split('/').pop() ?? ''
+  return testPatterns.some(pattern => {
+    const idx = pattern.indexOf('{name}')
+    if (idx < 0) return false
+    const prefix = pattern.slice(0, idx).replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    const suffix = pattern.slice(idx + '{name}'.length).replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    return new RegExp('^' + prefix + '[^/]+' + suffix + '$').test(basename)
+  })
+}
+
+function resolveTestPaths(sourceFile: string, testPatterns: string[]): string[] {
+  const lastSlash = sourceFile.lastIndexOf('/')
+  const dir = lastSlash >= 0 ? sourceFile.slice(0, lastSlash) : ''
+  const basename = lastSlash >= 0 ? sourceFile.slice(lastSlash + 1) : sourceFile
+  const lastDot = basename.lastIndexOf('.')
+  const nameWithoutExt = lastDot >= 0 ? basename.slice(0, lastDot) : basename
+
+  return testPatterns.map(pattern => {
+    const testBasename = pattern.replace('{name}', nameWithoutExt)
+    return dir ? dir + '/' + testBasename : testBasename
+  })
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+export function checkTDD(
+  changedFiles: string[],
+  allFiles: string[],
+  config: TDDGateConfig,
+  agent?: string,
+): TDDCheckResult {
+  const empty: TDDCheckResult = {
+    passed: true,
+    new_source_files: [],
+    missing_test_files: [],
+    existing_test_files: [],
+    excluded_files: [],
+    skipped: false,
+  }
+
+  if (!config.enabled) {
+    return { ...empty, skipped: true, skip_reason: 'disabled' }
+  }
+
+  if (agent !== undefined && config.exempt_agents.includes(agent)) {
+    return { ...empty, skipped: true, skip_reason: 'exempt_agent' }
+  }
+
+  const allFileSet = new Set([...changedFiles, ...allFiles])
+
+  // Filter to files matching source_patterns
+  const sourceFiles = changedFiles.filter(f =>
+    config.source_patterns.some(p => matchGlob(p, f)),
+  )
+
+  // Separate excluded vs candidate files
+  const excluded: string[] = []
+  const candidates: string[] = []
+  for (const f of sourceFiles) {
+    if (config.exclude_patterns.some(p => matchGlob(p, f))) {
+      excluded.push(f)
+      continue
+    }
+    if (isTestFile(f, config.test_patterns)) {
+      excluded.push(f)
+      continue
+    }
+    candidates.push(f)
+  }
+
+  // For each candidate, check for corresponding test
+  const missingTestFiles: string[] = []
+  const existingTestFiles: string[] = []
+
+  for (const sourceFile of candidates) {
+    const testPaths = resolveTestPaths(sourceFile, config.test_patterns)
+    const hasTest = testPaths.some(tp => allFileSet.has(tp))
+    if (hasTest) {
+      existingTestFiles.push(sourceFile)
+    } else {
+      missingTestFiles.push(sourceFile)
+    }
+  }
+
+  const passed = missingTestFiles.length === 0 || config.mode === 'warn'
+
+  return {
+    passed,
+    new_source_files: candidates,
+    missing_test_files: missingTestFiles,
+    existing_test_files: existingTestFiles,
+    excluded_files: excluded,
+    skipped: false,
+  }
+}
+
+export function formatTDDFailure(result: TDDCheckResult): string {
+  if (result.missing_test_files.length === 0) {
+    return 'TDD Gate: all source files have corresponding tests.'
+  }
+  const lines = ['TDD Gate BLOCKED: New source files without tests:']
+  for (const sourceFile of result.missing_test_files) {
+    const lastSlash = sourceFile.lastIndexOf('/')
+    const dir = lastSlash >= 0 ? sourceFile.slice(0, lastSlash) : ''
+    const basename = lastSlash >= 0 ? sourceFile.slice(lastSlash + 1) : sourceFile
+    const lastDot = basename.lastIndexOf('.')
+    const nameWithoutExt = lastDot >= 0 ? basename.slice(0, lastDot) : basename
+    const testFile = (dir ? dir + '/' : '') + nameWithoutExt + '.test.ts'
+    lines.push(`  - ${sourceFile} → missing ${testFile}`)
+  }
+  return lines.join('\n')
+}