@njeybe/nativ 2.4.1 → 2.5.0

package/dist/governor/test-integrity.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { CircuitBreaker, } from './circuit-breaker.js';
+const TEST_CODE_EXTENSION = /\.(?:[cm]?[jt]sx?|py|go|rb|java|kt|cs|php)$/i;
+export function isTestFile(file) {
+    const p = file.replace(/\\/g, '/');
+    if (!TEST_CODE_EXTENSION.test(p) || /(^|\/)node_modules\//.test(p))
+        return false;
+    return (/(^|\/)(?:__tests__|tests?|specs?)\//i.test(p) ||
+        /[._-](?:test|spec)\.[a-z]+$/i.test(p) ||
+        /(^|\/)test[_-][^/]+$/i.test(p));
+}
+/** Heuristic, language-agnostic counts; only deltas against the baseline matter. */
+export function measureTestSuite(source) {
+    const count = (re) => (source.match(re) || []).length;
+    return {
+        assertions: count(/(?<![.\w])(?:assert(?:\.[A-Za-z]+)*|expect|self\.assert[A-Za-z]*|t\.(?:is|ok|not|truthy|falsy|equal|deepEqual|true|false|throws|throwsAsync|notThrows|regex|snapshot|like))\s*\(/g) +
+            count(/^\s*assert\s+(?!\()/gm),
+        testCases: count(/(?<![.\w])(?:it|test|describe|suite|context)(?:\.(?:each|concurrent|serial))?\s*\(/g) +
+            count(/^\s*(?:async\s+)?def\s+test_/gm) +
+            count(/^func\s+Test[A-Z_]/gm),
+        skipped: count(/(?<![.\w])(?:it|test|describe|suite|context)\.(?:skip|todo)\s*\(|(?<![.\w])x(?:it|test|describe)\s*\(|@pytest\.mark\.skip|\bt\.Skip(?:Now|f)?\(/g),
+        focused: count(/(?<![.\w])(?:it|test|describe|suite|context)\.only\s*\(|(?<![.\w])f(?:it|describe)\s*\(/g),
+    };
+}
+function git(targetDir, args) {
+    const res = spawnSync('git', args, {
+        cwd: targetDir,
+        encoding: 'utf8',
+        windowsHide: true,
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    return { ok: res.status === 0, stdout: res.stdout ?? '' };
+}
+/** Current commit of the checkout at `targetDir`, or null outside git / before the first commit. */
+export function resolveGitHead(targetDir) {
+    const res = git(targetDir, ['rev-parse', '--verify', 'HEAD']);
+    return res.ok ? res.stdout.trim() || null : null;
+}
+/** Test files and test-named scripts referenced by `package.json` test scripts. */
+function testScriptReferences(packageJson) {
+    const scripts = new Set();
+    const files = new Set();
+    try {
+        const pkg = JSON.parse(packageJson);
+        for (const [name, command] of Object.entries(pkg?.scripts ?? {})) {
+            if (!/^(?:pre|post)?test(?:[:_-]|$)/.test(name) || typeof command !== 'string')
+                continue;
+            scripts.add(name);
+            for (const token of command.split(/[\s;&|'"]+/)) {
+                if (token && isTestFile(token))
+                    files.add(token.replace(/\\/g, '/').replace(/^\.\//, ''));
+            }
+        }
+    }
+    catch {
+        // Unparseable package.json: nothing to compare.
+    }
+    return { scripts, files };
+}
+function quoteArg(value) {
+    return /^[\w./@:-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+/**
+ * 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 class TestIntegrityGuard {
+    static evaluate(targetDir, taskId) {
+        const pass = (skippedReason, baselineRef = null, baselineRecorded = false) => ({
+            approved: true,
+            blastRadius: 'LOW_ADDITIVE',
+            ruleId: skippedReason ? 'TEST_INTEGRITY_SKIPPED' : 'TEST_INTEGRITY_OK',
+            message: skippedReason ?? 'Existing test suites are intact.',
+            violations: [],
+            baselineRef,
+            baselineRecorded,
+            findings: [],
+            ...(skippedReason ? { skippedReason } : {}),
+        });
+        try {
+            const cfgPath = path.join(targetDir, '.nativ', 'config.json');
+            if (fs.existsSync(cfgPath)) {
+                const raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+                if (raw.testIntegrity === 'off' || raw.profile === 'prototype') {
+                    return pass('Test integrity check disabled by profile or testIntegrity: off');
+                }
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+        if (!git(targetDir, ['rev-parse', '--is-inside-work-tree']).ok)
+            return pass('Not a git repository; test integrity cannot be checked.');
+        const recorded = CircuitBreaker.getBaseline(targetDir, taskId);
+        const recordedValid = recorded ? git(targetDir, ['cat-file', '-e', `${recorded}^{commit}`]).ok : false;
+        const baseline = recordedValid ? recorded : resolveGitHead(targetDir);
+        if (!baseline)
+            return pass('Repository has no commits yet; nothing to protect.');
+        const diff = git(targetDir, ['diff', '--name-status', '-M', '--relative', baseline, '--']);
+        if (!diff.ok)
+            return pass(`Could not diff against ${baseline}.`, baseline, recordedValid);
+        const findings = [];
+        const baselineSource = (file) => {
+            const res = git(targetDir, ['show', `${baseline}:./${file}`]);
+            return res.ok ? res.stdout : null;
+        };
+        for (const line of diff.stdout.split('\n')) {
+            const [status, ...paths] = line.trim().split('\t');
+            if (!status || !paths.length)
+                continue;
+            const kind = status[0];
+            const from = paths[0];
+            const to = paths[paths.length - 1];
+            if (kind === 'D' && isTestFile(from)) {
+                findings.push({ rule: 'TEST_SUITE_DELETED', path: from, detail: `Test file '${from}' was deleted.` });
+                continue;
+            }
+            if (kind === 'R' && isTestFile(from) && !isTestFile(to)) {
+                findings.push({ rule: 'TEST_SUITE_DELETED', path: from, detail: `Test file '${from}' was moved out of the suite to '${to}'.` });
+                continue;
+            }
+            if ((kind === 'M' || kind === 'R') && isTestFile(to)) {
+                const before = baselineSource(from);
+                let after = null;
+                try {
+                    after = fs.readFileSync(path.join(targetDir, to), 'utf8');
+                }
+                catch {
+                    // Unreadable now: treat like a deletion.
+                }
+                if (before === null)
+                    continue;
+                if (after === null) {
+                    findings.push({ rule: 'TEST_SUITE_DELETED', path: to, detail: `Test file '${to}' can no longer be read.` });
+                    continue;
+                }
+                const was = measureTestSuite(before);
+                const now = measureTestSuite(after);
+                if (now.assertions < was.assertions) {
+                    findings.push({ rule: 'TEST_ASSERTIONS_REMOVED', path: to, detail: `'${to}' went from ${was.assertions} to ${now.assertions} assertions.` });
+                }
+                if (now.testCases < was.testCases) {
+                    findings.push({ rule: 'TEST_CASES_REMOVED', path: to, detail: `'${to}' went from ${was.testCases} to ${now.testCases} test cases.` });
+                }
+                if (now.skipped > was.skipped) {
+                    findings.push({ rule: 'TESTS_SKIPPED', path: to, detail: `'${to}' added ${now.skipped - was.skipped} skip/todo marker(s).` });
+                }
+                if (now.focused > was.focused) {
+                    findings.push({ rule: 'TESTS_FOCUSED', path: to, detail: `'${to}' added ${now.focused - was.focused} .only marker(s), silencing the rest of the suite.` });
+                }
+            }
+            if (kind === 'M' && to === 'package.json') {
+                const before = baselineSource('package.json');
+                let after = '';
+                try {
+                    after = fs.readFileSync(path.join(targetDir, 'package.json'), 'utf8');
+                }
+                catch {
+                    // Treated as an empty package.json below.
+                }
+                if (before !== null) {
+                    const was = testScriptReferences(before);
+                    const now = testScriptReferences(after);
+                    const droppedScripts = [...was.scripts].filter((s) => !now.scripts.has(s));
+                    const droppedFiles = [...was.files].filter((f) => !now.files.has(f));
+                    if (droppedScripts.length || droppedFiles.length) {
+                        findings.push({
+                            rule: 'TEST_SCRIPT_WEAKENED',
+                            path: 'package.json',
+                            detail: `package.json test scripts dropped ${[...droppedScripts.map((s) => `script '${s}'`), ...droppedFiles].join(', ')}.`,
+                        });
+                    }
+                }
+            }
+        }
+        if (!findings.length)
+            return pass(undefined, baseline, recordedValid);
+        return {
+            approved: false,
+            blastRadius: 'HIGH_DESTRUCTIVE',
+            ruleId: 'TEST_INTEGRITY_VIOLATION',
+            message: `Task changes would delete or weaken ${findings.length === 1 ? 'an existing test suite' : `existing test suites (${findings.length} findings)`}.`,
+            violations: findings.map((f) => `${f.rule}: ${f.detail}`),
+            baselineRef: baseline,
+            baselineRecorded: recordedValid,
+            findings,
+        };
+    }
+    /**
+     * 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, report) {
+        if (report.approved || !report.baselineRef)
+            return null;
+        const started = Date.now();
+        const files = [...new Set(report.findings.map((f) => f.path))];
+        const baseline = report.baselineRef;
+        const checks = files.map((file) => {
+            const blob = git(targetDir, ['show', `${baseline}:./${file}`]);
+            if (!blob.ok)
+                return { name: `baseline:${file}`, passed: false, detail: `No copy of '${file}' at ${baseline.slice(0, 12)}` };
+            if (!isTestFile(file))
+                return { name: `baseline:${file}`, passed: true, detail: `Baseline copy available (${blob.stdout.length} bytes)` };
+            const m = measureTestSuite(blob.stdout);
+            return {
+                name: `baseline:${file}`,
+                passed: true,
+                detail: `Restores ${m.assertions} assertions and ${m.testCases} test cases (${m.skipped} skipped, ${m.focused} focused)`,
+            };
+        });
+        return {
+            kind: 'restore_tests',
+            proposalId: `heal-${crypto.randomUUID().slice(0, 8)}`,
+            strategy: 'restore_test_suite',
+            rationale: 'Restore the flagged test files from the task baseline, then make the implementation pass the original suite.',
+            requiresHumanApproval: true,
+            candidatesEvaluated: 1,
+            verificationProof: {
+                isolated: true,
+                method: 'baseline_blob_check',
+                passed: checks.length > 0 && checks.every((c) => c.passed),
+                checks,
+                verifiedAt: new Date().toISOString(),
+                durationMs: Date.now() - started,
+            },
+            generatedAt: new Date().toISOString(),
+            baselineRef: baseline,
+            files,
+            commands: [`git checkout ${baseline} -- ${files.map(quoteArg).join(' ')}`],
+        };
+    }
+}

package/dist/index.js

@@ -16,6 +16,7 @@ import { runTestGen, TEST_GEN_FRAMEWORK_HELP } from './commands/test-gen.js';
 import { runBench } from './commands/bench.js';
 import { runTriage } from './commands/triage.js';
 import { runLearnPropose, runLearnDecide, runLearnList } from './commands/learn.js';
+import { runProfileCommand } from './commands/profile.js';
 import { packageVersion } from './core/version.js';
 export function createProgram() {
     const program = new Command();
@@ -103,6 +104,13 @@ export function createProgram() {
         .action(async (targetDir, options) => {
         await runBench(targetDir, options);
     });
+    program
+        .command('profile [profile] [targetDir]')
+        .description('Inspect or switch adaptive ceremony profiles (prototype, solo, enterprise)')
+        .option('--json', 'Output profile configuration as JSON')
+        .action(async (profile, targetDir, options) => {
+        await runProfileCommand(profile, targetDir, options);
+    });
     const task = program
         .command('task')
         .description('Manage task lifecycle and JIT context slicing in .ai/master_plan.json');

package/dist/mcp/capture.d.ts

@@ -0,0 +1,4 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function captureOutput(fn: () => Promise<unknown>, options?: {
+    errorOnExitCode?: boolean;
+}): Promise<CallToolResult>;

package/dist/mcp/capture.js

@@ -0,0 +1,33 @@
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+// Handlers share global console/process.exitCode state, so captured runs are serialized.
+let captureQueue = Promise.resolve();
+export function captureOutput(fn, options = {}) {
+    const run = async () => {
+        const lines = [];
+        const collect = (...args) => {
+            lines.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a, null, 2))).join(' '));
+        };
+        const original = { log: console.log, error: console.error, warn: console.warn, info: console.info };
+        const previousExitCode = process.exitCode;
+        process.exitCode = undefined;
+        console.log = console.error = console.warn = console.info = collect;
+        let failed = false;
+        try {
+            await fn();
+            failed = options.errorOnExitCode !== false && process.exitCode !== undefined && process.exitCode !== 0;
+        }
+        catch (err) {
+            failed = true;
+            lines.push(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            Object.assign(console, original);
+            process.exitCode = previousExitCode;
+        }
+        const text = lines.join('\n').replace(ANSI_PATTERN, '').trim() || '(no output)';
+        return { content: [{ type: 'text', text }], isError: failed || undefined };
+    };
+    const result = captureQueue.then(run, run);
+    captureQueue = result.catch(() => undefined);
+    return result;
+}

package/dist/mcp/resources.d.ts

@@ -0,0 +1,39 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const MCP_RESOURCES: readonly [{
+    readonly name: "context";
+    readonly uris: readonly ["nativ://context"];
+    readonly file: "context.md";
+    readonly mimeType: "text/markdown";
+    readonly description: "Project context, tech stack and guardrails (.ai/context.md)";
+}, {
+    readonly name: "master-plan";
+    readonly uris: readonly ["nativ://master-plan"];
+    readonly file: "master_plan.json";
+    readonly mimeType: "application/json";
+    readonly description: "Milestones, tasks and their status (.ai/master_plan.json)";
+}, {
+    readonly name: "db-schema";
+    readonly uris: readonly ["nativ://db-schema"];
+    readonly file: "db_schema.json";
+    readonly mimeType: "application/json";
+    readonly description: "Database schema contract (.ai/db_schema.json)";
+}, {
+    readonly name: "api-contracts";
+    readonly uris: readonly ["nativ://api-contracts"];
+    readonly file: "api_contracts.json";
+    readonly mimeType: "application/json";
+    readonly description: "API route and schema contracts (.ai/api_contracts.json)";
+}, {
+    readonly name: "escalation";
+    readonly uris: readonly ["nativ://escalation"];
+    readonly file: "escalation.json";
+    readonly mimeType: "application/json";
+    readonly description: "Tier-1 escalation records (.ai/escalation.json)";
+}, {
+    readonly name: "telemetry";
+    readonly uris: readonly ["nativ://telemetry"];
+    readonly file: "telemetry.json";
+    readonly mimeType: "application/json";
+    readonly description: "Execution duration, token usage and cost telemetry (.ai/telemetry.json)";
+}];
+export declare function registerMcpResources(server: McpServer, targetDir: string): void;

package/dist/mcp/resources.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const MCP_RESOURCES = [
+    { name: 'context', uris: ['nativ://context'], file: 'context.md', mimeType: 'text/markdown', description: 'Project context, tech stack and guardrails (.ai/context.md)' },
+    { name: 'master-plan', uris: ['nativ://master-plan'], file: 'master_plan.json', mimeType: 'application/json', description: 'Milestones, tasks and their status (.ai/master_plan.json)' },
+    { name: 'db-schema', uris: ['nativ://db-schema'], file: 'db_schema.json', mimeType: 'application/json', description: 'Database schema contract (.ai/db_schema.json)' },
+    { name: 'api-contracts', uris: ['nativ://api-contracts'], file: 'api_contracts.json', mimeType: 'application/json', description: 'API route and schema contracts (.ai/api_contracts.json)' },
+    { name: 'escalation', uris: ['nativ://escalation'], file: 'escalation.json', mimeType: 'application/json', description: 'Tier-1 escalation records (.ai/escalation.json)' },
+    { name: 'telemetry', uris: ['nativ://telemetry'], file: 'telemetry.json', mimeType: 'application/json', description: 'Execution duration, token usage and cost telemetry (.ai/telemetry.json)' },
+];
+export function registerMcpResources(server, targetDir) {
+    for (const res of MCP_RESOURCES) {
+        for (const uriStr of res.uris) {
+            server.registerResource(res.name, uriStr, { mimeType: res.mimeType, description: res.description }, async (uri) => {
+                const filePath = path.join(targetDir, '.ai', res.file);
+                let text;
+                if (fs.existsSync(filePath)) {
+                    text = fs.readFileSync(filePath, 'utf8');
+                }
+                else if (res.name === 'escalation') {
+                    text = JSON.stringify({ escalations: [] }, null, 2);
+                }
+                else if (res.name === 'telemetry') {
+                    text = JSON.stringify({
+                        version: '1.0.0',
+                        summary: {
+                            totalTasksCompleted: 0,
+                            totalDurationMs: 0,
+                            estimatedTotalTokens: 0,
+                            estimatedTotalCostUsd: 0,
+                            verificationPassRate: 1.0,
+                            circuitBreakerTrips: 0,
+                        },
+                        tasks: [],
+                    }, null, 2);
+                }
+                else {
+                    throw new Error(`.ai/${res.file} not found in ${targetDir}. Run nativ_init first.`);
+                }
+                return { contents: [{ uri: uri.href, mimeType: res.mimeType, text }] };
+            });
+        }
+    }
+}

package/dist/mcp/server.d.ts

@@ -1,3 +1,14 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export { captureOutput } from './capture.js';
+export { registerMcpResources, MCP_RESOURCES } from './resources.js';
+export declare const ESCALATION_TYPES: readonly ["contract_drift", "schema_flaw", "missing_credential", "dependency_conflict", "architectural_ambiguity"];
+/**
+ * Native MCP (Model Context Protocol) server for Nativ over stdio.
+ *
+ * stdout is reserved for JSON-RPC frames, so the existing CLI handlers (which print via console.*)
+ * run inside `captureOutput`, which collects their output and returns it as tool content.
+ * Air-gap: only masked, structure-only commands are exposed. `db sync`, `db ui` and `init --force`
+ * are intentionally absent, and every tool is bound to the server's project root.
+ */
 export declare function createMcpServer(targetDirArg?: string): McpServer;
 export declare function startMcpServer(targetDirArg?: string): Promise<void>;

package/dist/mcp/server.js

@@ -1,4 +1,3 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -16,6 +15,17 @@ import { runTestGen } from '../commands/test-gen.js';
 import { runBench } from '../commands/bench.js';
 import { TEST_FRAMEWORKS } from '../core/test-generator-types.js';
 import { packageVersion } from '../core/version.js';
+import { captureOutput } from './capture.js';
+import { registerMcpResources } from './resources.js';
+export { captureOutput } from './capture.js';
+export { registerMcpResources, MCP_RESOURCES } from './resources.js';
+export const ESCALATION_TYPES = [
+    'contract_drift',
+    'schema_flaw',
+    'missing_credential',
+    'dependency_conflict',
+    'architectural_ambiguity',
+];
 /**
  * Native MCP (Model Context Protocol) server for Nativ over stdio.
  *
@@ -24,54 +34,6 @@ import { packageVersion } from '../core/version.js';
  * Air-gap: only masked, structure-only commands are exposed. `db sync`, `db ui` and `init --force`
  * are intentionally absent, and every tool is bound to the server's project root.
  */
-const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
-const ESCALATION_TYPES = [
-    'contract_drift',
-    'schema_flaw',
-    'missing_credential',
-    'dependency_conflict',
-    'architectural_ambiguity',
-];
-const RESOURCES = [
-    { name: 'context', uris: ['nativ://context'], file: 'context.md', mimeType: 'text/markdown', description: 'Project context, tech stack and guardrails (.ai/context.md)' },
-    { name: 'master-plan', uris: ['nativ://master-plan'], file: 'master_plan.json', mimeType: 'application/json', description: 'Milestones, tasks and their status (.ai/master_plan.json)' },
-    { name: 'db-schema', uris: ['nativ://db-schema'], file: 'db_schema.json', mimeType: 'application/json', description: 'Database schema contract (.ai/db_schema.json)' },
-    { name: 'api-contracts', uris: ['nativ://api-contracts'], file: 'api_contracts.json', mimeType: 'application/json', description: 'API route and schema contracts (.ai/api_contracts.json)' },
-    { name: 'escalation', uris: ['nativ://escalation'], file: 'escalation.json', mimeType: 'application/json', description: 'Tier-1 escalation records (.ai/escalation.json)' },
-    { name: 'telemetry', uris: ['nativ://telemetry'], file: 'telemetry.json', mimeType: 'application/json', description: 'Execution duration, token usage and cost telemetry (.ai/telemetry.json)' },
-];
-// Handlers share global console/process.exitCode state, so captured runs are serialized.
-let captureQueue = Promise.resolve();
-function captureOutput(fn, options = {}) {
-    const run = async () => {
-        const lines = [];
-        const collect = (...args) => {
-            lines.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a, null, 2))).join(' '));
-        };
-        const original = { log: console.log, error: console.error, warn: console.warn, info: console.info };
-        const previousExitCode = process.exitCode;
-        process.exitCode = undefined;
-        console.log = console.error = console.warn = console.info = collect;
-        let failed = false;
-        try {
-            await fn();
-            failed = options.errorOnExitCode !== false && process.exitCode !== undefined && process.exitCode !== 0;
-        }
-        catch (err) {
-            failed = true;
-            lines.push(`Error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        finally {
-            Object.assign(console, original);
-            process.exitCode = previousExitCode;
-        }
-        const text = lines.join('\n').replace(ANSI_PATTERN, '').trim() || '(no output)';
-        return { content: [{ type: 'text', text }], isError: failed || undefined };
-    };
-    const result = captureQueue.then(run, run);
-    captureQueue = result.catch(() => undefined);
-    return result;
-}
 export function createMcpServer(targetDirArg) {
     const targetDir = path.resolve(targetDirArg || process.cwd());
     const server = new McpServer({ name: 'nativ', version: packageVersion() });
@@ -133,7 +95,6 @@ export function createMcpServer(targetDirArg) {
             skipVerify: z.unknown().optional().describe('Not accepted: only a human at a terminal may skip'),
         },
     }, ({ taskId, notes, skipVerify }) => captureOutput(async () => {
-        // Kept in the schema so a stray value is refused instead of silently dropped.
         if (skipVerify !== undefined) {
             throw new Error('skipVerify is not allowed over MCP. Only a human at a terminal can skip verification.');
         }
@@ -235,16 +196,12 @@ export function createMcpServer(targetDirArg) {
         description: 'Read-only health check of the Claude Code integration: MCP server, hooks, permissions, agents, enforcement mode and provider availability (JSON). ' +
             'Reports drift but never repairs it; repairing is `nativ doctor --fix` in a terminal.',
         inputSchema: {},
-    }, 
-    // A report that lists problems is still a successful report, not a tool failure.
-    () => captureOutput(async () => runDoctor(targetDir, { json: true }), { errorOnExitCode: false }));
+    }, () => captureOutput(async () => runDoctor(targetDir, { json: true }), { errorOnExitCode: false }));
     // ─── Database telemetry tools (masked, structure-only) ─────────────────────
     registerNativTool('db_status', {
         description: 'Dev/Prod database connection health, engine, latency and table count. URLs are masked; no credentials are returned.',
         inputSchema: {},
-    }, 
-    // An offline database is a valid status report, not a tool failure.
-    () => captureOutput(() => runDbStatus(targetDir, { json: true }), { errorOnExitCode: false }));
+    }, () => captureOutput(() => runDbStatus(targetDir, { json: true }), { errorOnExitCode: false }));
     registerNativTool('db_inspect', {
         description: 'Introspect live database structure (tables, columns, types, keys, indexes). Structure only; never reads row data.',
         inputSchema: {
@@ -288,39 +245,7 @@ export function createMcpServer(targetDirArg) {
             concurrency: z.number().optional().describe('Number of simulated concurrent agent workers (default 6)'),
         },
     }, async ({ scenario, concurrency }) => captureOutput(() => runBench(targetDir, { scenario, concurrency, json: true })));
-    // ─── Contract resources ────────────────────────────────────────────────────
-    for (const res of RESOURCES) {
-        for (const uriStr of res.uris) {
-            server.registerResource(res.name, uriStr, { mimeType: res.mimeType, description: res.description }, async (uri) => {
-                const filePath = path.join(targetDir, '.ai', res.file);
-                let text;
-                if (fs.existsSync(filePath)) {
-                    text = fs.readFileSync(filePath, 'utf8');
-                }
-                else if (res.name === 'escalation') {
-                    text = JSON.stringify({ escalations: [] }, null, 2);
-                }
-                else if (res.name === 'telemetry') {
-                    text = JSON.stringify({
-                        version: '1.0.0',
-                        summary: {
-                            totalTasksCompleted: 0,
-                            totalDurationMs: 0,
-                            estimatedTotalTokens: 0,
-                            estimatedTotalCostUsd: 0,
-                            verificationPassRate: 1.0,
-                            circuitBreakerTrips: 0,
-                        },
-                        tasks: [],
-                    }, null, 2);
-                }
-                else {
-                    throw new Error(`.ai/${res.file} not found in ${targetDir}. Run nativ_init first.`);
-                }
-                return { contents: [{ uri: uri.href, mimeType: res.mimeType, text }] };
-            });
-        }
-    }
+    registerMcpResources(server, targetDir);
     return server;
 }
 export async function startMcpServer(targetDirArg) {

package/dist/mcp/tools.d.ts

@@ -0,0 +1 @@
+export { ESCALATION_TYPES, createMcpServer, startMcpServer } from './server.js';

package/dist/mcp/tools.js

@@ -0,0 +1 @@
+export { ESCALATION_TYPES, createMcpServer, startMcpServer } from './server.js';