@nerviq/cli 1.29.0 → 1.30.0

package/package.json

@@ -1,67 +1,75 @@
-{
-  "name": "@nerviq/cli",
-  "version": "1.29.0",
-  "description": "The intelligent nervous system for AI coding agents — 2,441 checks (8 platforms × ~300 governance rules), 10 languages, 62 domain packs. Audit, align, and amplify.",
-  "main": "src/index.js",
-  "bin": {
-    "nerviq": "bin/cli.js",
-    "@nerviq/cli": "bin/cli.js",
-    "nerviq-mcp": "src/mcp-server.js"
-  },
-  "files": [
-    "bin",
-    "src",
-    "README.md",
-    "docs",
-    "contracts",
-    "sdk/README.md",
-    "CHANGELOG.md",
-    "SECURITY.md"
-  ],
-  "scripts": {
-    "start": "node bin/cli.js",
-    "build": "npm pack --dry-run",
-    "test": "node test/run.js",
-    "verify:release-metadata": "node tools/validate-release-metadata.js",
-    "prepublish:check": "node tools/pre-publish.js",
-    "prepublishOnly": "node tools/pre-publish.js",
-    "test:jest": "jest",
-    "test:coverage": "jest --coverage",
-    "test:all": "npm test && npx jest && node test/check-matrix.js && node test/codex-check-matrix.js && node test/gemini-check-matrix.js && node test/copilot-check-matrix.js && node test/cursor-check-matrix.js && node test/windsurf-check-matrix.js && node test/aider-check-matrix.js && node test/opencode-check-matrix.js && node test/golden-matrix.js && node test/codex-golden-matrix.js && node test/gemini-golden-matrix.js && node test/copilot-golden-matrix.js && node test/cursor-golden-matrix.js && node test/windsurf-golden-matrix.js && node test/aider-golden-matrix.js && node test/opencode-golden-matrix.js",
-    "benchmark:perf": "node tools/benchmark.js",
-    "catalog": "node -e \"const {generateCatalog}=require('./src/catalog');console.log(JSON.stringify(generateCatalog(),null,2))\""
-  },
-  "keywords": [
-    "nerviq",
-    "ai-agents",
-    "agent-governance",
-    "agent-config",
-    "harmony",
-    "synergy",
-    "audit",
-    "claude",
-    "codex",
-    "gemini",
-    "copilot",
-    "cursor",
-    "windsurf",
-    "aider",
-    "developer-tools",
-    "cli",
-    "mcp",
-    "multi-agent"
-  ],
-  "author": "Nerviq <hello@nerviq.net>",
-  "license": "AGPL-3.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nerviq/nerviq.git"
-  },
-  "homepage": "https://nerviq.net",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "devDependencies": {
-    "jest": "^30.3.0"
-  }
-}
+{
+  "name": "@nerviq/cli",
+  "version": "1.30.0",
+  "description": "The intelligent nervous system for AI coding agents — 2,441 checks (8 platforms × ~300 governance rules), 10 languages, 62 domain packs. Audit, align, and amplify.",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./sdk": "./sdk/index.js",
+    "./sdk/types": "./sdk/index.d.ts",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "nerviq": "bin/cli.js",
+    "@nerviq/cli": "bin/cli.js",
+    "nerviq-mcp": "src/mcp-server.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "sdk",
+    "README.md",
+    "docs",
+    "contracts",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "build": "npm pack --dry-run",
+    "test": "node test/run.js",
+    "verify:release-metadata": "node tools/validate-release-metadata.js",
+    "prepublish:check": "node tools/pre-publish.js",
+    "prepublishOnly": "node tools/pre-publish.js",
+    "postinstall": "node tools/postinstall.js || true",
+    "test:jest": "jest",
+    "test:coverage": "jest --coverage",
+    "test:all": "npm test && npx jest && node test/check-matrix.js && node test/codex-check-matrix.js && node test/gemini-check-matrix.js && node test/copilot-check-matrix.js && node test/cursor-check-matrix.js && node test/windsurf-check-matrix.js && node test/aider-check-matrix.js && node test/opencode-check-matrix.js && node test/golden-matrix.js && node test/codex-golden-matrix.js && node test/gemini-golden-matrix.js && node test/copilot-golden-matrix.js && node test/cursor-golden-matrix.js && node test/windsurf-golden-matrix.js && node test/aider-golden-matrix.js && node test/opencode-golden-matrix.js",
+    "benchmark:perf": "node tools/benchmark.js",
+    "announce:release": "node tools/announce-release.js",
+    "catalog": "node -e \"const {generateCatalog}=require('./src/catalog');console.log(JSON.stringify(generateCatalog(),null,2))\""
+  },
+  "keywords": [
+    "nerviq",
+    "ai-agents",
+    "agent-governance",
+    "agent-config",
+    "harmony",
+    "synergy",
+    "audit",
+    "claude",
+    "codex",
+    "gemini",
+    "copilot",
+    "cursor",
+    "windsurf",
+    "aider",
+    "developer-tools",
+    "cli",
+    "mcp",
+    "multi-agent"
+  ],
+  "author": "Nerviq <hello@nerviq.net>",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nerviq/nerviq.git"
+  },
+  "homepage": "https://nerviq.net",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "jest": "^30.3.0"
+  }
+}

package/sdk/README.md

@@ -1,13 +1,22 @@
-# @nerviq/sdk
+# Nerviq SDK (bundled inside `@nerviq/cli`)
 
 Programmatic SDK for Nerviq audit, Harmony, catalog access, and experimental Synergy workflows.
 
 ## Install
 
 ```bash
-npm install @nerviq/sdk
+npm install @nerviq/cli
 ```
 
+The SDK ships bundled inside `@nerviq/cli` per MEMO-03 (B = BUNDLE, signed 2026-04-28). There is no separate `@nerviq/sdk` npm package — earlier docs that referenced one were aspirational. Both import paths below work:
+
+```js
+const sdk = require('@nerviq/cli/sdk');           // explicit SDK subpath (typed, input-validated)
+const { audit } = require('@nerviq/cli');          // top-level — same exports
+```
+
+The two paths return identical surface; pick whichever is cleaner for your codebase.
+
 ## Stability
 
 - Stable for production workflows: `audit`, `harmonyAudit`, `detectPlatforms`, `getCatalog`
@@ -17,7 +26,7 @@ npm install @nerviq/sdk
 ## Quick Start
 
 ```js
-const { audit, harmonyAudit, detectPlatforms } = require('@nerviq/sdk');
+const { audit, harmonyAudit, detectPlatforms } = require('@nerviq/cli/sdk');
 
 async function main() {
   const repoDir = process.cwd();

package/sdk/examples/langchain-integration.md

@@ -0,0 +1,128 @@
+# LangChain integration — using Nerviq as a tool
+
+> Reference example for AI-09. Wires `@nerviq/cli/sdk` into a LangChain
+> agent as a callable tool, so an autonomous LangChain agent can audit
+> its own repo, check Harmony Score, and surface stale references mid-task.
+>
+> Pairs with: [`self-governing-agent.js`](./self-governing-agent.js) +
+> [/docs/for-agents](https://nerviq.net/docs/for-agents) on the site.
+
+## Why an agent should call Nerviq
+
+A LangChain agent operating inside a developer's repo benefits from knowing whether the agent-config files it's reading are coherent across platforms. Without that awareness, the agent can confidently follow instructions in `CLAUDE.md` that contradict instructions in `AGENTS.md` — and produce code that breaks in someone else's tooling.
+
+Wiring Nerviq as a LangChain tool exposes three primitives:
+
+- `nerviq_audit` — score the repo on a specific platform
+- `nerviq_harmony` — measure cross-platform drift
+- `nerviq_stale_references` — surface the headline stale-reference findings
+
+## JavaScript / Node example
+
+```js
+const { audit, harmonyAudit } = require('@nerviq/cli/sdk');
+const { DynamicTool } = require('@langchain/core/tools');
+
+const nerviqAuditTool = new DynamicTool({
+  name: 'nerviq_audit',
+  description:
+    'Audit the AI coding agent configuration of the given repo directory. ' +
+    'Returns score (0-100), passed/failed counts, top stale-reference findings, ' +
+    'and topNextActions. Call this before substantive code changes when the ' +
+    'task touches CLAUDE.md, AGENTS.md, .cursor/rules, .mcp.json, or hooks.',
+  func: async (dir) => {
+    const result = await audit(dir || process.cwd(), 'claude');
+    return JSON.stringify({
+      score: result.score,
+      organicScore: result.organicScore,
+      passed: result.passed,
+      failed: result.failed,
+      staleReferences: result.staleReferences || null,
+      topNextActions: (result.liteSummary && result.liteSummary.topNextActions) || [],
+    }, null, 2);
+  },
+});
+
+const nerviqHarmonyTool = new DynamicTool({
+  name: 'nerviq_harmony',
+  description:
+    'Measure cross-platform configuration drift between AI coding agents in ' +
+    'the given repo. Returns harmonyScore (0-100) plus a list of named ' +
+    'drifts. Only meaningful when 2+ platforms are detected.',
+  func: async (dir) => {
+    const result = await harmonyAudit(dir || process.cwd());
+    return JSON.stringify({
+      harmonyScore: result.harmonyScore,
+      activePlatforms: result.activePlatforms,
+      drifts: (result.drift && result.drift.drifts) || [],
+    }, null, 2);
+  },
+});
+
+// Add to your agent's tool list:
+const tools = [nerviqAuditTool, nerviqHarmonyTool /*, ...your other tools */];
+```
+
+## Python via subprocess
+
+LangChain agents in Python can shell out to the CLI's `--agent-mode --json` surface:
+
+```python
+from langchain_core.tools import tool
+import json
+import subprocess
+
+@tool
+def nerviq_audit(dir: str = ".") -> str:
+    """Audit AI coding agent configuration. Returns score, stale references,
+    top next actions. Call before substantive code changes."""
+    result = subprocess.run(
+        ["npx", "@nerviq/cli", "audit", "--json", "--agent-mode", "--dir", dir],
+        capture_output=True, text=True, timeout=60,
+    )
+    if result.returncode not in (0, 1, 2):
+        return json.dumps({"error": result.stderr})
+    return result.stdout  # Already JSON
+```
+
+## CrewAI / AutoGen / generic orchestrators
+
+Same pattern: any orchestrator that supports tool definitions can wrap the SDK or shell out to `npx @nerviq/cli audit --json`. The JSON envelope is documented at [/docs/for-agents](https://nerviq.net/docs/for-agents) and stable per CTO-01..05 + BUG-01 (machine-output contract).
+
+For CrewAI specifically:
+
+```python
+from crewai.tools import tool
+import subprocess
+
+@tool("Nerviq audit tool")
+def nerviq_audit(dir: str = "."):
+    """Audit cross-platform AI coding agent configuration."""
+    out = subprocess.run(
+        ["npx", "@nerviq/cli", "audit", "--json", "--dir", dir],
+        capture_output=True, text=True, timeout=60,
+    ).stdout
+    return out
+```
+
+## Don't bypass user consent
+
+Per the [/docs/for-agents](https://nerviq.net/docs/for-agents) trust-boundary policy: the agent should NOT silently apply `--apply --auto` on critical fixes that materially modify governance posture (deny rules, MCP permissions, hooks). Surface the plan via the audit/harmony tool, let the user approve, then apply. The CLI gates `--apply` on `--auto` for exactly this reason — single-flag bypass is intentionally blocked.
+
+## When to call which tool
+
+| Situation | Call |
+|---|---|
+| Task start | `nerviq_audit` (always) |
+| Task touches multiple agents' config | `nerviq_harmony` (drift check) |
+| Stale-reference count > 0 in audit result | Surface to user via the audit response, ask whether to proceed |
+| Task complete | `nerviq_audit` again, compare scores, surface delta to user |
+| User accepts a recommendation | (Optionally) record via `npx @nerviq/cli feedback --key <K> --status accepted` so the local learning loop benefits |
+
+## Reference repo
+
+The full self-governing loop reference (5-step pre/harmony/task/post/feedback pattern) lives at [`sdk/examples/self-governing-agent.js`](./self-governing-agent.js). Read that first if you're implementing the orchestration manually rather than letting LangChain/CrewAI drive the loop.
+
+## License
+
+CC0 — copy, modify, integrate freely.

package/sdk/examples/self-governing-agent.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Reference: self-governing AI coding agent loop using @nerviq/cli/sdk.
+ *
+ * This file is the AI-07 reference example for the docs/for-agents page on
+ * nerviq.net. It implements the "Self-governing agent pattern" documented
+ * there: an agent that audits the repo before acting, runs targeted fixes,
+ * makes the actual code change, re-audits to detect regression, and records
+ * outcomes back into the local learning loop.
+ *
+ * Usage (after `npm install @nerviq/cli`):
+ *   node node_modules/@nerviq/cli/sdk/examples/self-governing-agent.js [repo-dir]
+ *
+ * Default repo-dir is process.cwd().
+ *
+ * NOT autonomous in the dangerous sense:
+ *   - This loop NEVER calls --apply --auto silently. Mutations of governance
+ *     posture (deny rules, MCP permissions, hooks) require explicit user
+ *     consent. The example surfaces a plan and waits for the next human
+ *     decision; that's by design and matches the docs/for-agents constraint.
+ */
+
+'use strict';
+
+// Resolve the SDK from npm install OR from the in-repo path (for running this
+// example directly from a checkout of nerviq/nerviq).
+function loadSdk() {
+  try {
+    return require('@nerviq/cli/sdk');
+  } catch {
+    return require('../index.js');
+  }
+}
+const { audit, harmonyAudit, detectPlatforms } = loadSdk();
+const path = require('path');
+
+async function selfGoverningLoop(repoDir, opts = {}) {
+  const dir = path.resolve(repoDir);
+  const log = opts.log || console.log;
+  const HARMONY_DRIFT_THRESHOLD = 60;
+
+  // ── Step 1. Pre-task audit ──────────────────────────────────────────────
+  log('[1/5] pre-task audit…');
+  const platforms = detectPlatforms(dir);
+  log(`      platforms: ${platforms.join(', ') || '(none detected — single-platform repo)'}`);
+
+  const pre = await audit(dir, opts.platform || (platforms[0] || 'claude'));
+  log(`      score: ${pre.score}/100  organic: ${pre.organicScore}/100  failed: ${pre.failed}`);
+
+  // The headline value: stale references. Surface BEFORE doing anything.
+  if (pre.staleReferences && pre.staleReferences.count > 0) {
+    log(`      📌 ${pre.staleReferences.headline}`);
+    for (const sample of pre.staleReferences.topSample) {
+      log(`         · ${sample.file}:${sample.line} — ${sample.fix.split('\n')[0].slice(0, 100)}`);
+    }
+    log('      ↳ recommend: surface to user, ask whether to proceed despite stale refs');
+  }
+
+  // ── Step 2. Cross-platform Harmony check (only if multi-platform) ──────
+  if (platforms.length >= 2) {
+    log('[2/5] harmony check (cross-platform drift)…');
+    const harmony = await harmonyAudit(dir);
+    log(`      harmonyScore: ${harmony.harmonyScore}/100`);
+
+    if (harmony.harmonyScore < HARMONY_DRIFT_THRESHOLD) {
+      log(`      ⚠️  harmony below ${HARMONY_DRIFT_THRESHOLD} — drift between platforms is forming`);
+      log('      ↳ recommend: surface drifts to user, decide whether to harmony-sync before proceeding');
+      // NOTE: a real agent would surface harmony.drift list here and wait for
+      // user approval before running `nerviq harmony-sync --fix`. We do NOT
+      // call it silently from the agent loop.
+    }
+  } else {
+    log('[2/5] harmony check skipped (single-platform repo)');
+  }
+
+  // ── Step 3. Make the actual code change ─────────────────────────────────
+  log('[3/5] doing the actual task… (placeholder — replace with the real agent action)');
+  // In a real agent: execute the user's task. Edit files, run tests, etc.
+  // For this example, simulate a small change so step 4's diff-only audit has
+  // something to compare against.
+  if (typeof opts.doWork === 'function') {
+    await opts.doWork({ dir, preAuditScore: pre.score });
+  } else {
+    log('      (no doWork callback provided — skipping)');
+  }
+
+  // ── Step 4. Post-task diff-only re-audit ────────────────────────────────
+  log('[4/5] post-task diff-only audit…');
+  const post = await audit(dir, opts.platform || (platforms[0] || 'claude'));
+  const delta = post.score - pre.score;
+  const arrow = delta > 0 ? `+${delta}` : delta < 0 ? `${delta}` : '0';
+  log(`      score: ${post.score}/100  Δ ${arrow}  failed: ${post.failed}`);
+
+  if (delta < -3) {
+    log('      🔴 score dropped materially — recommend: rollback or human review');
+  } else if (delta > 0) {
+    log('      ✓ score improved');
+  }
+
+  // ── Step 5. Record outcome (learning loop) ─────────────────────────────
+  log('[5/5] outcome recording — call `nerviq feedback --key <K> --status accepted|rejected|deferred --score-delta <delta>`');
+  log('       (the agent should invoke this once per recommendation it acted on, so suggest-rules can learn the team\'s actual preferences)');
+
+  return {
+    pre,
+    post,
+    delta,
+    platforms,
+    recommendation:
+      delta < -3
+        ? 'rollback-or-review'
+        : pre.staleReferences && pre.staleReferences.count > 0
+          ? 'surface-stale-references-to-user'
+          : delta > 0
+            ? 'continue'
+            : 'no-change',
+  };
+}
+
+if (require.main === module) {
+  const dir = process.argv[2] || process.cwd();
+  selfGoverningLoop(dir, { log: console.log })
+    .then((result) => {
+      console.log('\n=== Loop complete ===');
+      console.log(`Recommendation: ${result.recommendation}`);
+      console.log(`Pre/post score: ${result.pre.score} → ${result.post.score} (Δ ${result.delta})`);
+      process.exitCode = result.recommendation === 'rollback-or-review' ? 1 : 0;
+    })
+    .catch((err) => {
+      console.error(`error: ${err.message}`);
+      process.exitCode = 1;
+    });
+}
+
+module.exports = { selfGoverningLoop };

package/sdk/index.d.ts

@@ -0,0 +1,115 @@
+export type NerviqPlatform =
+  | 'claude'
+  | 'codex'
+  | 'gemini'
+  | 'copilot'
+  | 'cursor'
+  | 'windsurf'
+  | 'aider'
+  | 'opencode';
+
+export interface AuditFinding {
+  key: string;
+  id?: string | null;
+  name: string;
+  category?: string | null;
+  impact?: 'critical' | 'high' | 'medium' | 'low' | null;
+  fix?: string | null;
+  passed: boolean | null;
+  file?: string | null;
+  line?: number | null;
+  sourceUrl?: string | null;
+  confidence?: number | string | null;
+}
+
+export interface AuditAction {
+  key: string;
+  id?: string | null;
+  name: string;
+  impact?: 'critical' | 'high' | 'medium' | 'low' | null;
+  category?: string | null;
+  fix?: string | null;
+  why?: string | null;
+  sourceUrl?: string | null;
+}
+
+export interface AuditResult {
+  platform: string;
+  platformLabel: string;
+  score: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  checkCount: number;
+  results: AuditFinding[];
+  quickWins: AuditAction[];
+  topNextActions: AuditAction[];
+  suggestedNextCommand?: string;
+  /** Convenience alias for `passed` */
+  passing: number;
+  /** Convenience alias for `passed + failed` */
+  total: number;
+}
+
+export interface HarmonyResult {
+  harmonyScore: number;
+  platformScores: Record<string, number | null>;
+  platformResults: Record<string, AuditResult | null>;
+  drift: {
+    drifts: Array<Record<string, unknown>>;
+    harmonyScore: number;
+  };
+  recommendations: Array<Record<string, unknown>>;
+  activePlatforms: Array<Record<string, unknown>>;
+  model: Record<string, unknown>;
+  /** Convenience alias for `harmonyScore` */
+  average: number;
+}
+
+export interface Check {
+  platform: string;
+  id: string | null;
+  key: string;
+  name: string | null;
+  category: string | null;
+  impact: string | null;
+  rating: string | null;
+  fix: string | null;
+  sourceUrl: string | null;
+  confidence: number | null;
+  lastVerified?: string | null;
+  template?: string | null;
+  deprecated?: boolean;
+}
+
+export interface RoutingChoice {
+  platform: string;
+  confidence: number;
+  reasoning: string;
+}
+
+export interface RoutingResult {
+  recommended: RoutingChoice | null;
+  alternatives: RoutingChoice[];
+  taskType: string;
+}
+
+export interface SynergyResult {
+  dir: string;
+  activePlatforms: string[];
+  platformAudits: Record<string, AuditResult>;
+  compound: Record<string, unknown>;
+  amplification: number;
+  compensation: Record<string, unknown>;
+  patterns: Array<Record<string, unknown>>;
+  recommendations: Array<Record<string, unknown>>;
+  errors: Array<{ platform: string; message: string }>;
+  report: string;
+}
+
+export declare function audit(dir: string, platform?: NerviqPlatform): Promise<AuditResult>;
+export declare function harmonyAudit(dir: string): Promise<HarmonyResult>;
+export declare function synergyReport(dir: string): Promise<SynergyResult>;
+export declare function detectPlatforms(dir: string): string[];
+export declare function getCatalog(): Check[];
+export declare function routeTask(description: string, platforms?: string[]): RoutingResult;

package/sdk/index.js

@@ -0,0 +1,94 @@
+const path = require('path');
+const fs = require('fs');
+
+const VALID_PLATFORMS = ['claude', 'codex', 'cursor', 'copilot', 'gemini', 'windsurf', 'aider', 'opencode'];
+
+function loadCore() {
+  try {
+    return require('@nerviq/cli');
+  } catch {
+    return require('..');
+  }
+}
+
+function validateDir(dir) {
+  if (!dir || typeof dir !== 'string') {
+    throw new Error('dir is required and must be a string. Pass a valid directory path.');
+  }
+  const resolved = path.resolve(dir);
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Directory not found: ${resolved}. Pass an existing directory path.`);
+  }
+  return resolved;
+}
+
+function validatePlatform(platform) {
+  if (platform && !VALID_PLATFORMS.includes(platform)) {
+    throw new Error(`Unsupported platform '${platform}'. Use one of: ${VALID_PLATFORMS.join(', ')}`);
+  }
+}
+
+async function audit(dir, platform = 'claude') {
+  const resolved = validateDir(dir);
+  validatePlatform(platform);
+  const core = loadCore();
+  const result = await core.audit({
+    dir: resolved,
+    platform,
+    silent: true,
+  });
+  // Add convenience aliases for SDK consumers
+  if (result) {
+    result.passing = result.passed;
+    result.total = (result.passed || 0) + (result.failed || 0);
+  }
+  return result;
+}
+
+async function harmonyAudit(dir) {
+  const resolved = validateDir(dir);
+  const core = loadCore();
+  const result = await core.harmonyAudit({
+    dir: resolved,
+    silent: true,
+  });
+  // Add convenience alias for SDK consumers
+  if (result) {
+    result.average = result.harmonyScore;
+  }
+  return result;
+}
+
+async function synergyReport(dir) {
+  const resolved = validateDir(dir);
+  const core = loadCore();
+  return core.synergyReport(resolved);
+}
+
+function detectPlatforms(dir) {
+  const resolved = validateDir(dir);
+  const core = loadCore();
+  return core.detectPlatforms(resolved);
+}
+
+function getCatalog() {
+  const core = loadCore();
+  return core.getCatalog();
+}
+
+function routeTask(description, platforms) {
+  if (!description || typeof description !== 'string') {
+    throw new Error('description is required and must be a non-empty string.');
+  }
+  const core = loadCore();
+  return core.routeTask(description, platforms || []);
+}
+
+module.exports = {
+  audit,
+  harmonyAudit,
+  synergyReport,
+  detectPlatforms,
+  getCatalog,
+  routeTask,
+};

package/sdk/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@nerviq/sdk",
+  "version": "0.9.5",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "description": "Programmatic SDK for Nerviq — audit, harmony, synergy for AI coding agents",
+  "license": "AGPL-3.0",
+  "dependencies": {
+    "@nerviq/cli": "^0.9.5"
+  }
+}