@njeybe/nativ 2.4.1 → 2.5.0

package/dist/core/verifier.js

@@ -1,361 +1,7 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import { checkCodeShape, formatCodeShapeReport } from './code-shape.js';
-import { parseJsonLoose } from './enforcement.js';
-import { resolveMainRoot } from './root-resolver.js';
-export function loadMasterPlan(targetDir) {
-    const planPath = path.join(targetDir, '.ai', 'master_plan.json');
-    if (!fs.existsSync(planPath)) {
-        return { planPath, plan: null, error: `No .ai/master_plan.json found at: ${planPath}` };
-    }
-    try {
-        const raw = fs.readFileSync(planPath, 'utf8');
-        const plan = JSON.parse(raw);
-        return { planPath, plan };
-    }
-    catch (err) {
-        return { planPath, plan: null, error: `Failed to parse .ai/master_plan.json: ${err.message}` };
-    }
-}
 /**
- * Execute a verification command in the workspace directory with timeout and output capture.
+ * Re-exports the modular verifier engine components.
  */
-export async function executeVerification(command, cwd, timeoutMs = 120_000) {
-    const trimmed = (command || '').trim();
-    // Treat empty, 'none', or 'skip' as an informational pass
-    if (!trimmed || trimmed.toLowerCase() === 'none' || trimmed.toLowerCase() === 'skip') {
-        return {
-            success: true,
-            exitCode: 0,
-            command: trimmed || 'none',
-            stdout: '',
-            stderr: '',
-            durationMs: 0,
-            skipped: true,
-        };
-    }
-    // Cross-platform compatibility for common test commands on Windows cmd.exe
-    let finalCommand = trimmed;
-    if (process.platform === 'win32') {
-        if (trimmed === 'true')
-            finalCommand = 'exit 0';
-        else if (trimmed === 'false')
-            finalCommand = 'exit 1';
-    }
-    const start = Date.now();
-    return new Promise((resolve) => {
-        exec(finalCommand, {
-            cwd,
-            timeout: timeoutMs,
-            maxBuffer: 10 * 1024 * 1024,
-            env: process.env,
-        }, (err, stdout, stderr) => {
-            const durationMs = Date.now() - start;
-            const out = (stdout || '').toString();
-            const errOut = (stderr || '').toString();
-            if (err) {
-                const exitCode = typeof err.code === 'number' ? err.code : 1;
-                resolve({
-                    success: false,
-                    exitCode,
-                    command: trimmed,
-                    stdout: out,
-                    stderr: errOut || err.message,
-                    durationMs,
-                    error: err.killed ? `Command timed out after ${timeoutMs}ms` : err.message,
-                });
-            }
-            else {
-                resolve({
-                    success: true,
-                    exitCode: 0,
-                    command: trimmed,
-                    stdout: out,
-                    stderr: errOut,
-                    durationMs,
-                });
-            }
-        });
-    });
-}
-/**
- * Run the code-shape check on a task's target files and print a short summary to stderr.
- * In 'warn' mode (default) the result is untouched; in 'block' mode issues fail it with a reason.
- */
-export function applyCodeShape(result, targetDir, task) {
-    if (result.skipped || !result.success)
-        return result;
-    const report = checkCodeShape(targetDir, task.targetFiles || []);
-    if (report.mode === 'off')
-        return result;
-    result.codeShape = report;
-    const summary = formatCodeShapeReport(report);
-    if (summary)
-        console.error(summary);
-    if (report.mode === 'block' && report.issues.length > 0) {
-        result.success = false;
-        result.exitCode = 1;
-        result.error = `Code shape check failed: ${report.issues.length} issue(s) (codeStyle.mode is "block")`;
-    }
-    return result;
-}
-/** Reads the file, retrying once: antivirus or an editor saving can briefly lock it on Windows. */
-function readConfigText(file) {
-    for (let attempt = 0;; attempt++) {
-        try {
-            return fs.readFileSync(file, 'utf8');
-        }
-        catch (err) {
-            if (err?.code === 'ENOENT')
-                return null;
-            if (attempt >= 1)
-                throw err;
-        }
-    }
-}
-/** `verifyPhases` from the main checkout's `.nativ/config.json`, never from a worktree's own copy. */
-export function loadVerifyPhases(configDir) {
-    let raw;
-    try {
-        raw = readConfigText(path.join(resolveMainRoot(configDir), '.nativ', 'config.json'));
-    }
-    catch (err) {
-        return { phases: [], error: `.nativ/config.json cannot be read (${err?.message})` };
-    }
-    if (raw === null)
-        return { phases: [] };
-    if (!raw.trim())
-        return { phases: [], error: '.nativ/config.json is empty' };
-    let phases;
-    try {
-        phases = parseJsonLoose(raw)?.verifyPhases;
-    }
-    catch (err) {
-        return { phases: [], error: `.nativ/config.json is not valid JSON (${err?.message})` };
-    }
-    if (phases === undefined || phases === null)
-        return { phases: [] };
-    // An empty or null "run" switches a phase off; a missing or mistyped field is a mistake.
-    const isEntry = (p) => typeof p?.name === 'string' && p.name.trim()
-        && (p.run === null || typeof p.run === 'string');
-    if (!Array.isArray(phases) || !phases.every(isEntry)) {
-        return { phases: [], error: 'verifyPhases must be a list of { "name": "...", "run": "..." } entries' };
-    }
-    const active = phases.filter((p) => p.run && p.run.trim());
-    return { phases: active.map((p) => ({ name: p.name.trim(), run: p.run.trim() })) };
-}
-function configFailure(message) {
-    const error = `${message}, so the configured checks could not run. Fix it and verify again.`;
-    const command = '.nativ/config.json';
-    return { success: false, exitCode: 1, command, stdout: '', stderr: error, durationMs: 0, error };
-}
-/** Runs the configured phases in order and stops at the first failure. */
-export async function runVerifyPhases(cwd, configDir, timeout) {
-    const config = loadVerifyPhases(configDir);
-    if (config.error)
-        return { reports: [], failure: configFailure(config.error) };
-    const reports = [];
-    for (const phase of config.phases) {
-        const res = await executeVerification(phase.run, cwd, timeout);
-        reports.push({ name: phase.name, command: res.command, success: res.success, durationMs: res.durationMs });
-        if (!res.success) {
-            const cause = res.error ? `: ${res.error.trim()}` : '';
-            return { reports, failure: { ...res, phases: reports, error: `Phase "${phase.name}" failed${cause}` } };
-        }
-    }
-    return { reports };
-}
-/**
- * The one verification every path shares: the configured phases in order, stopping at the
- * first failure, then the task's own command, then the code-shape check.
- */
-export async function runTaskVerification(task, options) {
-    const configDir = options.configDir ?? options.cwd;
-    const outcome = options.phases ?? (await runVerifyPhases(options.cwd, configDir, options.timeout));
-    // In a batch the shared phase time is counted once, by the batch, not again for every task.
-    if (outcome.failure) {
-        return { ...outcome.failure, phases: outcome.reports, ...(options.phases ? { durationMs: 0 } : {}) };
-    }
-    const raw = await executeVerification(task.verificationCommand, options.cwd, options.timeout);
-    if (outcome.reports.length) {
-        raw.phases = outcome.reports;
-        raw.durationMs += options.phases ? 0 : outcome.reports.reduce((sum, r) => sum + r.durationMs, 0);
-        raw.skipped = false;
-    }
-    return applyCodeShape(raw, options.cwd, task);
-}
-/**
- * Run verification for a single specific task in the plan.
- */
-export async function verifyTask(taskId, targetDirArg, options = {}) {
-    const targetDir = path.resolve(targetDirArg || process.cwd());
-    const { plan, error } = loadMasterPlan(targetDir);
-    if (!plan) {
-        return {
-            taskId,
-            title: 'Unknown',
-            milestoneId: 'unknown',
-            milestoneName: 'Unknown',
-            status: 'unknown',
-            result: {
-                success: false,
-                exitCode: 1,
-                command: '',
-                stdout: '',
-                stderr: error || 'Failed to load master plan',
-                durationMs: 0,
-                error: error || 'Failed to load master plan',
-            },
-        };
-    }
-    let foundTask = null;
-    let foundMilestone = null;
-    for (const m of plan.milestones) {
-        const t = m.tasks.find((item) => item.id === taskId);
-        if (t) {
-            foundTask = t;
-            foundMilestone = m;
-            break;
-        }
-    }
-    if (!foundTask || !foundMilestone) {
-        return {
-            taskId,
-            title: 'Not Found',
-            milestoneId: 'unknown',
-            milestoneName: 'Unknown',
-            status: 'unknown',
-            result: {
-                success: false,
-                exitCode: 1,
-                command: '',
-                stdout: '',
-                stderr: `Task [${taskId}] not found in .ai/master_plan.json`,
-                durationMs: 0,
-                error: `Task [${taskId}] not found`,
-            },
-        };
-    }
-    const result = await runTaskVerification(foundTask, { cwd: targetDir, timeout: options.timeout });
-    return {
-        taskId: foundTask.id,
-        title: foundTask.title,
-        milestoneId: foundMilestone.id,
-        milestoneName: foundMilestone.name,
-        status: foundTask.status,
-        result,
-    };
-}
-/**
- * Verify a batch of tasks (by milestone, all completed tasks, or the active in-progress task).
- */
-export async function verifyBatch(targetDirArg, options = {}) {
-    const targetDir = path.resolve(targetDirArg || process.cwd());
-    const { plan, error } = loadMasterPlan(targetDir);
-    if (!plan) {
-        return {
-            projectName: 'unknown',
-            total: 0,
-            passed: 0,
-            failed: 1,
-            skipped: 0,
-            durationMs: 0,
-            tasks: [
-                {
-                    taskId: 'init',
-                    title: 'Plan Loader',
-                    milestoneId: 'unknown',
-                    milestoneName: 'Unknown',
-                    status: 'unknown',
-                    result: {
-                        success: false,
-                        exitCode: 1,
-                        command: '',
-                        stdout: '',
-                        stderr: error || 'Plan not found',
-                        durationMs: 0,
-                        error: error || 'Plan not found',
-                    },
-                },
-            ],
-        };
-    }
-    // Filter tasks to run
-    const candidates = [];
-    for (const m of plan.milestones) {
-        for (const t of m.tasks) {
-            if (options.taskId && t.id === options.taskId) {
-                candidates.push({ task: t, milestone: m });
-            }
-            else if (options.milestoneId && (m.id === options.milestoneId || m.name.toLowerCase() === options.milestoneId.toLowerCase())) {
-                candidates.push({ task: t, milestone: m });
-            }
-            else if (options.all) {
-                // All tasks with verification commands (prefer completed or in_progress, but include all)
-                candidates.push({ task: t, milestone: m });
-            }
-        }
-    }
-    // If no filters specified, find the current in_progress task, or next ready task
-    if (!options.taskId && !options.milestoneId && !options.all) {
-        let activeTask = null;
-        for (const m of plan.milestones) {
-            const inProgress = m.tasks.find((t) => t.status === 'in_progress');
-            if (inProgress) {
-                activeTask = { task: inProgress, milestone: m };
-                break;
-            }
-        }
-        if (!activeTask) {
-            for (const m of plan.milestones) {
-                const pending = m.tasks.find((t) => t.status === 'pending');
-                if (pending) {
-                    activeTask = { task: pending, milestone: m };
-                    break;
-                }
-            }
-        }
-        if (activeTask) {
-            candidates.push(activeTask);
-        }
-    }
-    const results = [];
-    let passed = 0;
-    let failed = 0;
-    let skipped = 0;
-    let totalDuration = 0;
-    // The phases check the whole project, so one run serves every task in the batch.
-    const phases = candidates.length ? await runVerifyPhases(targetDir, targetDir, options.timeout) : { reports: [] };
-    totalDuration += phases.reports.reduce((sum, r) => sum + r.durationMs, 0);
-    for (const { task, milestone } of candidates) {
-        const vResult = await runTaskVerification(task, { cwd: targetDir, timeout: options.timeout, phases });
-        totalDuration += vResult.durationMs;
-        if (vResult.skipped) {
-            skipped++;
-        }
-        else if (vResult.success) {
-            passed++;
-        }
-        else {
-            failed++;
-        }
-        results.push({
-            taskId: task.id,
-            title: task.title,
-            milestoneId: milestone.id,
-            milestoneName: milestone.name,
-            status: task.status,
-            result: vResult,
-        });
-    }
-    return {
-        projectName: plan.projectName,
-        total: candidates.length,
-        passed,
-        failed,
-        skipped,
-        durationMs: totalDuration,
-        tasks: results,
-    };
-}
+export * from './verifier/types.js';
+export { executeVerification } from './verifier/executor.js';
+export { loadVerifyPhases, runVerifyPhases } from './verifier/phases.js';
+export { loadMasterPlan, applyCodeShape, runTaskVerification, verifyTask, verifyBatch, } from './verifier/task-verifier.js';

package/dist/db/introspector.js

@@ -81,30 +81,30 @@ async function createPostgresDriver(url) {
         },
         async tables() {
             const builder = new TableBuilder();
-            const tables = await client.query(`
-        SELECT t.table_name, obj_description(format('%I.%I', t.table_schema, t.table_name)::regclass, 'pg_class') AS description
-        FROM information_schema.tables t
-        WHERE t.table_schema = current_schema() AND t.table_type = 'BASE TABLE'
+            const tables = await client.query(`
+        SELECT t.table_name, obj_description(format('%I.%I', t.table_schema, t.table_name)::regclass, 'pg_class') AS description
+        FROM information_schema.tables t
+        WHERE t.table_schema = current_schema() AND t.table_type = 'BASE TABLE'
         ORDER BY t.table_name`);
             for (const row of tables.rows) {
                 const table = builder.get(row.table_name);
                 if (row.description)
                     table.description = row.description;
             }
-            const pks = await client.query(`
-        SELECT kcu.table_name, kcu.column_name
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu
-          ON kcu.constraint_name = tc.constraint_name AND kcu.table_schema = tc.table_schema AND kcu.table_name = tc.table_name
+            const pks = await client.query(`
+        SELECT kcu.table_name, kcu.column_name
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu
+          ON kcu.constraint_name = tc.constraint_name AND kcu.table_schema = tc.table_schema AND kcu.table_name = tc.table_name
         WHERE tc.table_schema = current_schema() AND tc.constraint_type = 'PRIMARY KEY'`);
             const pkSet = new Set(pks.rows.map((r) => `${r.table_name}.${r.column_name}`));
-            const columns = await client.query(`
-        SELECT c.table_name, c.column_name, c.data_type, c.udt_name, c.character_maximum_length,
-               c.numeric_precision, c.numeric_scale, c.is_nullable, c.column_default
-        FROM information_schema.columns c
-        JOIN information_schema.tables t
-          ON t.table_schema = c.table_schema AND t.table_name = c.table_name AND t.table_type = 'BASE TABLE'
-        WHERE c.table_schema = current_schema()
+            const columns = await client.query(`
+        SELECT c.table_name, c.column_name, c.data_type, c.udt_name, c.character_maximum_length,
+               c.numeric_precision, c.numeric_scale, c.is_nullable, c.column_default
+        FROM information_schema.columns c
+        JOIN information_schema.tables t
+          ON t.table_schema = c.table_schema AND t.table_name = c.table_name AND t.table_type = 'BASE TABLE'
+        WHERE c.table_schema = current_schema()
         ORDER BY c.table_name, c.ordinal_position`);
             for (const row of columns.rows) {
                 builder.get(row.table_name).columns.push({
@@ -116,31 +116,31 @@ async function createPostgresDriver(url) {
                 });
             }
             // information_schema has no index view — pg_catalog is the only source.
-            const indexes = await client.query(`
-        SELECT t.relname AS table_name, i.relname AS index_name, ix.indisunique AS is_unique,
-               (SELECT array_agg(a.attname::text ORDER BY k.ord)
-                  FROM unnest(ix.indkey::int2[]) WITH ORDINALITY AS k(attnum, ord)
-                  JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum) AS columns
-        FROM pg_index ix
-        JOIN pg_class t ON t.oid = ix.indrelid
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        WHERE n.nspname = current_schema() AND NOT ix.indisprimary AND t.relkind IN ('r', 'p')
+            const indexes = await client.query(`
+        SELECT t.relname AS table_name, i.relname AS index_name, ix.indisunique AS is_unique,
+               (SELECT array_agg(a.attname::text ORDER BY k.ord)
+                  FROM unnest(ix.indkey::int2[]) WITH ORDINALITY AS k(attnum, ord)
+                  JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum) AS columns
+        FROM pg_index ix
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE n.nspname = current_schema() AND NOT ix.indisprimary AND t.relkind IN ('r', 'p')
         ORDER BY t.relname, i.relname`);
             for (const row of indexes.rows) {
                 builder.get(row.table_name).indexes.push({ name: row.index_name, columns: row.columns ?? [], unique: row.is_unique });
             }
-            const fks = await client.query(`
-        SELECT con.conname AS constraint_name, cl.relname AS table_name, a.attname AS column_name,
-               fcl.relname AS ref_table, fa.attname AS ref_column, con.confdeltype AS on_delete
-        FROM pg_constraint con
-        JOIN pg_class cl ON cl.oid = con.conrelid
-        JOIN pg_namespace n ON n.oid = cl.relnamespace
-        JOIN pg_class fcl ON fcl.oid = con.confrelid
-        CROSS JOIN LATERAL unnest(con.conkey, con.confkey) AS k(attnum, fattnum)
-        JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = k.attnum
-        JOIN pg_attribute fa ON fa.attrelid = con.confrelid AND fa.attnum = k.fattnum
-        WHERE n.nspname = current_schema() AND con.contype = 'f'
+            const fks = await client.query(`
+        SELECT con.conname AS constraint_name, cl.relname AS table_name, a.attname AS column_name,
+               fcl.relname AS ref_table, fa.attname AS ref_column, con.confdeltype AS on_delete
+        FROM pg_constraint con
+        JOIN pg_class cl ON cl.oid = con.conrelid
+        JOIN pg_namespace n ON n.oid = cl.relnamespace
+        JOIN pg_class fcl ON fcl.oid = con.confrelid
+        CROSS JOIN LATERAL unnest(con.conkey, con.confkey) AS k(attnum, fattnum)
+        JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = k.attnum
+        JOIN pg_attribute fa ON fa.attrelid = con.confrelid AND fa.attnum = k.fattnum
+        WHERE n.nspname = current_schema() AND con.contype = 'f'
         ORDER BY cl.relname, con.conname`);
             for (const row of fks.rows) {
                 builder.get(row.table_name).foreignKeys.push({
@@ -177,22 +177,22 @@ async function createMysqlDriver(url) {
         },
         async tables() {
             const builder = new TableBuilder();
-            for (const row of await rows(`
-        SELECT TABLE_NAME AS table_name, TABLE_COMMENT AS table_comment
-        FROM information_schema.TABLES
-        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
+            for (const row of await rows(`
+        SELECT TABLE_NAME AS table_name, TABLE_COMMENT AS table_comment
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
         ORDER BY TABLE_NAME`)) {
                 const table = builder.get(row.table_name);
                 if (row.table_comment)
                     table.description = row.table_comment;
             }
-            for (const row of await rows(`
-        SELECT c.TABLE_NAME AS table_name, c.COLUMN_NAME AS column_name, c.COLUMN_TYPE AS column_type,
-               c.IS_NULLABLE AS is_nullable, c.COLUMN_DEFAULT AS column_default, c.COLUMN_KEY AS column_key
-        FROM information_schema.COLUMNS c
-        JOIN information_schema.TABLES t
-          ON t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME AND t.TABLE_TYPE = 'BASE TABLE'
-        WHERE c.TABLE_SCHEMA = DATABASE()
+            for (const row of await rows(`
+        SELECT c.TABLE_NAME AS table_name, c.COLUMN_NAME AS column_name, c.COLUMN_TYPE AS column_type,
+               c.IS_NULLABLE AS is_nullable, c.COLUMN_DEFAULT AS column_default, c.COLUMN_KEY AS column_key
+        FROM information_schema.COLUMNS c
+        JOIN information_schema.TABLES t
+          ON t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME AND t.TABLE_TYPE = 'BASE TABLE'
+        WHERE c.TABLE_SCHEMA = DATABASE()
         ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`)) {
                 builder.get(row.table_name).columns.push({
                     name: row.column_name,
@@ -203,10 +203,10 @@ async function createMysqlDriver(url) {
                 });
             }
             const indexMap = new Map();
-            for (const row of await rows(`
-        SELECT TABLE_NAME AS table_name, INDEX_NAME AS index_name, NON_UNIQUE AS non_unique, COLUMN_NAME AS column_name
-        FROM information_schema.STATISTICS
-        WHERE TABLE_SCHEMA = DATABASE() AND INDEX_NAME <> 'PRIMARY'
+            for (const row of await rows(`
+        SELECT TABLE_NAME AS table_name, INDEX_NAME AS index_name, NON_UNIQUE AS non_unique, COLUMN_NAME AS column_name
+        FROM information_schema.STATISTICS
+        WHERE TABLE_SCHEMA = DATABASE() AND INDEX_NAME <> 'PRIMARY'
         ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX`)) {
                 const key = `${row.table_name}.${row.index_name}`;
                 let entry = indexMap.get(key);
@@ -219,13 +219,13 @@ async function createMysqlDriver(url) {
             }
             for (const { table, index } of indexMap.values())
                 builder.get(table).indexes.push(index);
-            for (const row of await rows(`
-        SELECT k.CONSTRAINT_NAME AS constraint_name, k.TABLE_NAME AS table_name, k.COLUMN_NAME AS column_name,
-               k.REFERENCED_TABLE_NAME AS ref_table, k.REFERENCED_COLUMN_NAME AS ref_column, r.DELETE_RULE AS delete_rule
-        FROM information_schema.KEY_COLUMN_USAGE k
-        JOIN information_schema.REFERENTIAL_CONSTRAINTS r
-          ON r.CONSTRAINT_SCHEMA = k.CONSTRAINT_SCHEMA AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME AND r.TABLE_NAME = k.TABLE_NAME
-        WHERE k.TABLE_SCHEMA = DATABASE() AND k.REFERENCED_TABLE_NAME IS NOT NULL
+            for (const row of await rows(`
+        SELECT k.CONSTRAINT_NAME AS constraint_name, k.TABLE_NAME AS table_name, k.COLUMN_NAME AS column_name,
+               k.REFERENCED_TABLE_NAME AS ref_table, k.REFERENCED_COLUMN_NAME AS ref_column, r.DELETE_RULE AS delete_rule
+        FROM information_schema.KEY_COLUMN_USAGE k
+        JOIN information_schema.REFERENTIAL_CONSTRAINTS r
+          ON r.CONSTRAINT_SCHEMA = k.CONSTRAINT_SCHEMA AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME AND r.TABLE_NAME = k.TABLE_NAME
+        WHERE k.TABLE_SCHEMA = DATABASE() AND k.REFERENCED_TABLE_NAME IS NOT NULL
         ORDER BY k.TABLE_NAME, k.CONSTRAINT_NAME, k.ORDINAL_POSITION`)) {
                 builder.get(row.table_name).foreignKeys.push({
                     name: row.constraint_name,

package/dist/governor/evaluator.d.ts

@@ -1,67 +1,7 @@
-import { ContractPatch, GovernorVerdict, RuleEvaluationResult } from './types.js';
-import { type CandidatePatch, type ContractPatchProposal, type SelfHealingProposal, type TestRestorationProposal, type VerificationProof } from './circuit-breaker.js';
-export declare function getContractHash(filePath: string): string | null;
-/**
- * Replays a candidate against a throwaway copy of the contract in the OS temp
- * directory: governor rules, apply, re-parse, and proof that it changes
- * something while the live `.ai/` file stays byte-identical.
- */
-export declare function verifyCandidateInSandbox(targetDir: string, taskId: string, candidate: CandidatePatch): VerificationProof;
-/**
- * Builds the first backward-compatible candidate that survives an isolated
- * replay. Returns null when no candidate can be proven (a human decides).
- */
-export declare function generateSelfHealingProposal(targetDir: string, patch: ContractPatch, rule: RuleEvaluationResult): ContractPatchProposal | null;
-export interface ProposalApplication {
-    applied: boolean;
-    ruleId: string;
-    message: string;
-}
-/**
- * Applies an operator-approved proposal. Contract patches are re-checked
- * against the live contract and refused if it moved since the proof was taken.
- * Human-approved patches do not count against the task's patch budget.
- */
-export declare function applySelfHealingProposal(targetDir: string, taskId: string, proposal: SelfHealingProposal): ProposalApplication;
-export type TestIntegrityRule = 'TEST_SUITE_DELETED' | 'TEST_ASSERTIONS_REMOVED' | 'TEST_CASES_REMOVED' | 'TESTS_SKIPPED' | 'TESTS_FOCUSED' | 'TEST_SCRIPT_WEAKENED';
-export interface TestIntegrityFinding {
-    rule: TestIntegrityRule;
-    /** Path relative to the project root. */
-    path: string;
-    detail: string;
-}
-export interface TestIntegrityReport extends RuleEvaluationResult {
-    /** Resolved commit the working tree was compared against; null when the check was skipped. */
-    baselineRef: string | null;
-    /** True when the baseline came from `nativ task start` rather than falling back to HEAD. */
-    baselineRecorded: boolean;
-    findings: TestIntegrityFinding[];
-    skippedReason?: string;
-}
-export interface TestSuiteMetrics {
-    assertions: number;
-    testCases: number;
-    skipped: number;
-    focused: number;
-}
-export declare function isTestFile(file: string): boolean;
-/** Heuristic, language-agnostic counts; only deltas against the baseline matter. */
-export declare function measureTestSuite(source: string): TestSuiteMetrics;
-/** Current commit of the checkout at `targetDir`, or null outside git / before the first commit. */
-export declare function resolveGitHead(targetDir: string): string | null;
-/**
- * Enforces that a task never deletes or weakens the test suites that existed
- * when it started: no deleted test files, no fewer assertions or cases, no new
- * skip/only markers, and no test files dropped from package.json test scripts.
- */
-export declare class TestIntegrityGuard {
-    static evaluate(targetDir: string, taskId: string): TestIntegrityReport;
-    /**
-     * Proposal to restore every flagged file from the baseline, with proof that
-     * each baseline blob exists and what the restored suite measures.
-     */
-    static proposeRestoration(targetDir: string, report: TestIntegrityReport): TestRestorationProposal | null;
-}
+import { ContractPatch, GovernorVerdict } from './types.js';
+export * from './patch-applier.js';
+export * from './self-healing.js';
+export * from './test-integrity.js';
 export declare class ContractGovernor {
     static evaluate(targetDir: string, patch: ContractPatch): GovernorVerdict;
 }