nexus-prime 7.9.33 → 7.9.35

package/README.md

@@ -446,6 +446,7 @@ Nexus Prime was designed privacy-first, because the code on your machine is your
 - 🏠 **100% local.** All data lives on your disk, in your home directory.
 - 🚫 **No cloud sync.** Your code, your memory, your logs — never uploaded.
 - 🔐 **Bounded local trial.** You can run locally for 15 days without signing up; a license is required after the trial expires.
+- 🧱 **Binary-first release path.** The current NPM package remains intact, and a prepared shim lane can turn NPM into a signed-binary downloader once binary artifacts are published and verified.
 - 📊 **Telemetry is opt-in.** Off by default. When on, only aggregate, anonymous event counts are sent — never source code, never memory contents.
 - 🗑️ **Uninstall is clean.** Everything lives in one directory you can delete.
 

package/dist/binary-shim.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { defaultManifestUrl, installBinaryFromChannel, readPackageVersion, } from './install/binary-channel.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const installOnly = args.includes('--install-only');
+    const forwardedArgs = args.filter((arg) => arg !== '--install-only');
+    const version = readPackageVersion();
+    const channel = process.env.NEXUS_BINARY_CHANNEL ?? 'stable';
+    const result = await installBinaryFromChannel({
+        version,
+        channel,
+        manifestUrl: process.env.NEXUS_BINARY_MANIFEST_URL ?? defaultManifestUrl(version, channel),
+    });
+    if (installOnly) {
+        const verb = result.downloaded ? 'installed' : 'verified';
+        console.log(`[nexus-prime] binary ${verb}: ${result.binaryPath}`);
+        return;
+    }
+    const child = spawnSync(result.binaryPath, forwardedArgs, {
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (child.error)
+        throw child.error;
+    process.exit(typeof child.status === 'number' ? child.status : 1);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[nexus-prime] binary channel unavailable: ${message}`);
+    console.error('[nexus-prime] Set NEXUS_BINARY_MANIFEST_URL or install the full npm package until binary releases are configured.');
+    process.exit(1);
+});

package/dist/install/binary-channel.js

@@ -0,0 +1,213 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_BINARY_BASE_URL = 'https://nexus-prime.cfd/api/releases/nexus-prime';
+const LICENSE_ENV_KEYS = ['NEXUS_PRIME_LICENSE_KEY', 'NEXUS_LICENSE_KEY'];
+export function detectBinaryPlatform(platform = process.platform, arch = process.arch) {
+    const normalizedArch = arch === 'x64' || arch === 'arm64' ? arch : '';
+    if (!normalizedArch)
+        throw new Error(`Unsupported Nexus Prime binary architecture: ${arch}`);
+    if (platform === 'darwin' || platform === 'linux' || platform === 'win32') {
+        return `${platform}-${normalizedArch}`;
+    }
+    throw new Error(`Unsupported Nexus Prime binary platform: ${platform}`);
+}
+export function defaultBinaryRoot() {
+    return process.env.NEXUS_BINARY_ROOT
+        ? path.resolve(process.env.NEXUS_BINARY_ROOT)
+        : path.join(os.homedir(), '.nexus-prime', 'bin');
+}
+export function defaultLicenseFile() {
+    return process.env.NEXUS_LICENSE_FILE
+        ? path.resolve(process.env.NEXUS_LICENSE_FILE)
+        : path.join(os.homedir(), '.nexus-prime', 'license.key');
+}
+export function defaultInstallIdFile() {
+    return process.env.NEXUS_INSTALL_ID_FILE
+        ? path.resolve(process.env.NEXUS_INSTALL_ID_FILE)
+        : path.join(os.homedir(), '.nexus-prime', 'install-id');
+}
+export function defaultManifestUrl(version, channel = 'stable') {
+    if (process.env.NEXUS_BINARY_MANIFEST_URL)
+        return process.env.NEXUS_BINARY_MANIFEST_URL;
+    const base = (process.env.NEXUS_BINARY_BASE_URL || DEFAULT_BINARY_BASE_URL).replace(/\/+$/u, '');
+    return `${base}/${encodeURIComponent(version)}/${encodeURIComponent(channel)}/manifest`;
+}
+export function binaryNameForPlatform(platform) {
+    return platform.startsWith('win32') ? 'nexus-prime.exe' : 'nexus-prime';
+}
+export function readBinaryLicenseKey(licenseFile = defaultLicenseFile()) {
+    for (const key of LICENSE_ENV_KEYS) {
+        const value = process.env[key]?.trim();
+        if (value)
+            return value;
+    }
+    try {
+        if (!fs.existsSync(licenseFile))
+            return undefined;
+        const value = fs.readFileSync(licenseFile, 'utf8').trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readOrCreateInstallId(installIdFile = defaultInstallIdFile()) {
+    try {
+        if (fs.existsSync(installIdFile)) {
+            const existing = fs.readFileSync(installIdFile, 'utf8').trim();
+            if (existing)
+                return existing;
+        }
+        const installId = crypto.randomUUID();
+        fs.mkdirSync(path.dirname(installIdFile), { recursive: true });
+        fs.writeFileSync(installIdFile, `${installId}\n`, { mode: 0o600 });
+        return installId;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildBinaryRequestHeaders(context = {}) {
+    const headers = {
+        'accept': 'application/json, application/octet-stream',
+        'x-nexus-client': 'npm-binary-shim',
+    };
+    if (context.version)
+        headers['x-nexus-package-version'] = context.version;
+    if (context.channel)
+        headers['x-nexus-channel'] = context.channel;
+    if (context.platform)
+        headers['x-nexus-platform'] = context.platform;
+    if (context.installId)
+        headers['x-nexus-install-id'] = context.installId;
+    if (context.licenseKey)
+        headers.authorization = `Bearer ${context.licenseKey}`;
+    return headers;
+}
+export function installedBinaryPath(input) {
+    return path.join(input.binaryRoot ?? defaultBinaryRoot(), input.version, input.platform, input.executableName ?? binaryNameForPlatform(input.platform));
+}
+export function readPackageVersion(fallback = '0.0.0') {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.join(here, '..', '..', 'package.json'),
+            path.join(here, '..', 'package.json'),
+            path.join(process.cwd(), 'package.json'),
+        ];
+        for (const candidate of candidates) {
+            if (!fs.existsSync(candidate))
+                continue;
+            const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            if (pkg.version)
+                return pkg.version;
+        }
+    }
+    catch {
+        // Keep shim startup resilient.
+    }
+    return fallback;
+}
+export async function fetchBinaryManifest(manifestUrl, context = {}) {
+    const raw = await readUrlText(manifestUrl, context);
+    const manifest = JSON.parse(raw);
+    if (manifest.schemaVersion !== 1 || manifest.product !== 'nexus-prime') {
+        throw new Error('Invalid Nexus Prime binary manifest');
+    }
+    return manifest;
+}
+export async function installBinaryFromChannel(options = {}) {
+    const version = options.version ?? readPackageVersion();
+    const channel = options.channel ?? process.env.NEXUS_BINARY_CHANNEL ?? 'stable';
+    const platform = detectBinaryPlatform(options.platform, options.arch);
+    const manifestUrl = options.manifestUrl ?? defaultManifestUrl(version, channel);
+    const context = {
+        version,
+        channel,
+        platform,
+        licenseKey: options.licenseKey ?? readBinaryLicenseKey(options.licenseFile),
+        installId: options.installId ?? readOrCreateInstallId(options.installIdFile),
+    };
+    const manifest = await fetchBinaryManifest(manifestUrl, context);
+    if (manifest.version !== version) {
+        throw new Error(`Binary manifest version mismatch: package=${version} manifest=${manifest.version}`);
+    }
+    const artifact = manifest.artifacts[platform];
+    if (!artifact)
+        throw new Error(`No Nexus Prime binary artifact for ${platform}`);
+    const binaryPath = installedBinaryPath({
+        binaryRoot: options.binaryRoot,
+        version,
+        platform,
+        executableName: artifact.executableName,
+    });
+    if (!options.force && fs.existsSync(binaryPath)) {
+        const current = await sha256File(binaryPath);
+        if (current === artifact.sha256.toLowerCase()) {
+            return { platform, binaryPath, version, downloaded: false, manifestUrl };
+        }
+    }
+    fs.mkdirSync(path.dirname(binaryPath), { recursive: true });
+    const tmpPath = `${binaryPath}.download`;
+    await downloadUrlToFile(artifact.url, tmpPath, context);
+    const actualSha = await sha256File(tmpPath);
+    if (actualSha !== artifact.sha256.toLowerCase()) {
+        fs.rmSync(tmpPath, { force: true });
+        throw new Error(`Binary checksum mismatch for ${platform}: expected ${artifact.sha256}, got ${actualSha}`);
+    }
+    if (typeof artifact.size === 'number') {
+        const stat = fs.statSync(tmpPath);
+        if (stat.size !== artifact.size) {
+            fs.rmSync(tmpPath, { force: true });
+            throw new Error(`Binary size mismatch for ${platform}: expected ${artifact.size}, got ${stat.size}`);
+        }
+    }
+    fs.renameSync(tmpPath, binaryPath);
+    if (!platform.startsWith('win32'))
+        fs.chmodSync(binaryPath, 0o755);
+    return { platform, binaryPath, version, downloaded: true, manifestUrl };
+}
+export async function sha256File(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('sha256');
+        const stream = fs.createReadStream(filePath);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+export function redactUrlForLog(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
+    }
+    catch {
+        return url.replace(/[?#].*$/u, '');
+    }
+}
+async function readUrlText(url, context) {
+    if (url.startsWith('file://')) {
+        return fs.readFileSync(fileURLToPath(url), 'utf8');
+    }
+    const response = await fetch(url, { headers: buildBinaryRequestHeaders(context) });
+    if (!response.ok)
+        throw new Error(`Failed to fetch ${redactUrlForLog(url)}: HTTP ${response.status}`);
+    return response.text();
+}
+async function downloadUrlToFile(url, destination, context) {
+    if (url.startsWith('file://')) {
+        fs.copyFileSync(fileURLToPath(url), destination);
+        return;
+    }
+    const response = await fetch(url, { headers: buildBinaryRequestHeaders(context) });
+    if (!response.ok || !response.body) {
+        throw new Error(`Failed to download ${redactUrlForLog(url)}: HTTP ${response.status}`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    fs.writeFileSync(destination, bytes);
+}

package/package.json

@@ -1,116 +1,25 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.33",
-  "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms",
+  "version": "7.9.35",
+  "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms (binary installer shim)",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./hooks": {
-      "import": "./dist/adapters/hooks/index.js",
-      "types": "./dist/adapters/hooks/index.d.ts"
-    },
-    "./admin": {
-      "import": "./dist/adapters/admin/index.js",
-      "types": "./dist/adapters/admin/index.d.ts"
-    }
+  "bin": {
+    "nexus-prime": "dist/binary-shim.js"
   },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "postinstall": "node dist/binary-shim.js --install-only"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sir-ad/nexus-prime.git"
   },
   "homepage": "https://nexus-prime.cfd/",
-  "bin": {
-    "nexus-prime": "dist/cli.js"
-  },
-  "scripts": {
-    "prepare": "git config core.hooksPath .hooks || true",
-    "nexus:dev": "node dev-orchestrator.mjs",
-    "generate:competitive-landscape": "tsx scripts/generate-competitive-landscape.ts",
-    "generate:readme-catalog": "tsx scripts/generate-readme-runtime-catalog.ts",
-    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
-    "prebuild": "npm run clean",
-    "prepush": "tsx scripts/check-file-sizes.ts && tsx scripts/perf-bench.ts",
-    "size-check": "tsx scripts/check-file-sizes.ts",
-    "build": "tsc && node dist/build-assets.js",
-    "postinstall": "node -e \"const fs=require('fs');const p='dist/postinstall-runner.js';if(fs.existsSync(p)){import('./'+p).catch(e=>{console.error('[nexus-prime] postinstall bootstrap skipped:',e&&e.message?e.message:e);});}\"",
-    "dev": "tsc --watch",
-    "start": "node dist/cli.js start",
-    "init": "node dist/cli.js init",
-    "test:public": "tsx test/public-surface.test.ts",
-    "test:synapse": "tsx src/synapse/__tests__/run.ts",
-    "test:architects": "tsx src/architects/__tests__/run.ts",
-    "test": "npm run build && tsx test/basic.test.ts && tsx test/memory.test.ts && tsx test/memory-regressions.test.ts && tsx test/memory-bridge.test.ts && tsx test/automation-runtime.test.ts && tsx test/session-dna-search.test.ts && tsx test/channel-gateway.test.ts && tsx test/semantic-ranking.test.ts && tsx test/storage-maintenance.test.ts && tsx test/ngram-index.test.ts && tsx test/security-shield.test.ts && tsx test/compaction-sentinel.test.ts && tsx test/context-compressor.test.ts && tsx test/embedder.test.ts && tsx test/skill-learner.test.ts && tsx test/skill-distribution.test.ts && tsx test/darwin-integration.test.ts && tsx test/github-bridge.test.ts && tsx test/telemetry-remote.test.ts && tsx test/orchestrator-engine.test.ts && tsx test/phase9.test.ts && tsx test/work-ledger.test.ts && tsx src/verify-token-scoring.ts && tsx test/phantom.test.ts && tsx test/rag-collections.test.ts && tsx test/dashboard.test.ts && tsx test/docs.test.ts && tsx test/competitive-landscape.test.ts && tsx test/runtime-upgrade-path.test.ts && tsx test/runtime-setup.test.ts && tsx test/control-plane-integration.test.ts && tsx test/runtime-timeout.test.ts && tsx test/mcp-dashboard-contract.test.ts && tsx test/dashboard-surfaces.test.ts && tsx test/startup-and-runtime-regressions.test.ts && tsx test/mcp-readiness-truth.test.ts && tsx test/mcp-stdio-session.test.ts && tsx test/kernel-context.test.ts && tsx test/kernel-execution.test.ts && tsx test/kernel-runtime.test.ts && tsx test/adapter-boundary.test.ts && tsx test/mcp-deprecation.test.ts && tsx test/dashboard-mutations.test.ts && tsx test/dashboard-agent-control.test.ts && tsx test/dashboard-runtime-adapters.test.ts && tsx test/hooks-adapter.test.ts && tsx test/admin-adapter.test.ts && tsx test/pkg-subexport.test.ts && tsx test/dashboard-sse-only.test.ts && tsx test/license-sync-offline.test.ts && tsx test/mcp-killlist-v2.test.ts && tsx test/uninstall.test.ts && tsx test/uninstall-lifecycle.test.ts && tsx test/install-arch-upgrade.test.ts && tsx test/unregister-configs.test.ts && tsx test/cleanup-storage.test.ts && tsx test/dashboard-memory-truthfulness.test.ts && tsx test/runtime-lifecycle.test.ts && tsx test/orchestrate-pipeline.test.ts && tsx test/daemon-supervisor.test.ts && tsx test/auto-optimize-tokens.test.ts && npm run test:synapse && npm run test:architects && npm run test:public",
-    "lint": "eslint src --ext .ts",
-    "verify:pricing": "tsx scripts/verify-provider-pricing.ts",
-    "audit:prod": "npm audit --omit=dev",
-    "smoke:release": "tsx scripts/release-smoke.ts",
-    "qa:release": "npm run build && npm run lint && npm test && npm pack --dry-run && npm run audit:prod && npm run smoke:release"
-  },
-  "keywords": [
-    "ai",
-    "agents",
-    "mcp",
-    "memory",
-    "token-optimization",
-    "multi-agent",
-    "orchestration",
-    "guardrails",
-    "self-evolving",
-    "nexus-prime"
-  ],
-  "author": "sir-ad",
   "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "better-sqlite3": "^12.6.2",
-    "commander": "^11.1.0",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "js-yaml": "^4.1.1",
-    "pino": "^8.17.2",
-    "uuid": "^14.0.0",
-    "ws": "^8.20.1",
-    "zod": "^3.22.4"
-  },
-  "overrides": {
-    "@hono/node-server": "^1.19.13",
-    "express-rate-limit": "^8.3.1",
-    "hono": "^4.12.14",
-    "express": {
-      "path-to-regexp": "0.1.13"
-    },
-    "router": {
-      "path-to-regexp": "8.4.0"
-    },
-    "undici": "^7.24.2"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.8",
-    "@types/express": "^4.17.21",
-    "@types/jest": "^29.5.11",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.11.0",
-    "@types/uuid": "^11.0.0",
-    "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "@typescript-eslint/parser": "^6.19.0",
-    "esbuild": "^0.27.3",
-    "eslint": "^8.56.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
-    "tsx": "^4.20.6",
-    "typescript": "^5.3.3"
-  },
   "engines": {
     "node": ">=20.0.0"
   }

package/dist/adapters/admin/authoring.d.ts

@@ -1,14 +0,0 @@
-/**
- * Admin adapter — authoring.
- *
- * Programmatic specialist / skill file creation. Authoritative home for
- * the markdown builders that used to live in
- * `src/dashboard/routes/authoring.ts` (POST handlers are being retired
- * in PR7 Phase 3). Reachable from CLI and hosts without going through MCP.
- */
-import type { CreateSpecialistInput, CreateSpecialistResult, CreateSkillInput, CreateSkillResult } from './types.js';
-export interface AuthoringAdmin {
-    createSpecialist(input: CreateSpecialistInput): Promise<CreateSpecialistResult>;
-    createSkill(input: CreateSkillInput): Promise<CreateSkillResult>;
-}
-export declare function createAuthoringAdmin(repoRoot: string): AuthoringAdmin;

package/dist/adapters/admin/authoring.js

@@ -1,116 +0,0 @@
-/**
- * Admin adapter — authoring.
- *
- * Programmatic specialist / skill file creation. Authoritative home for
- * the markdown builders that used to live in
- * `src/dashboard/routes/authoring.ts` (POST handlers are being retired
- * in PR7 Phase 3). Reachable from CLI and hosts without going through MCP.
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-/** Sanitize an id to safe filesystem characters. */
-function safeId(raw) {
-    return raw.replace(/[^a-z0-9._-]/gi, '-').toLowerCase().slice(0, 120);
-}
-/**
- * Render a specialist definition to markdown in the format expected by
- * the specialist detail loader at `.agents/specialists/<id>.md`.
- */
-function specialistToMarkdown(input) {
-    const name = input.name;
-    const division = input.division ?? 'custom';
-    const description = input.description ?? '';
-    const emoji = input.emoji ?? '🤖';
-    const authority = input.authority ?? 'advisory';
-    const domains = input.domains ?? [];
-    const mission = input.mission ?? '';
-    const rules = input.rules ?? [];
-    const workflow = input.workflow ?? [];
-    const deliverables = input.deliverables ?? [];
-    const lines = [
-        `# ${emoji} ${name}`,
-        '',
-        `**Division**: ${division}  `,
-        `**Authority**: ${authority}  `,
-        `**Domains**: ${domains.join(', ') || '—'}  `,
-        '',
-        '## Description',
-        '',
-        description || '_No description provided._',
-        '',
-        '## Mission',
-        '',
-        mission || '_No mission provided._',
-        '',
-    ];
-    if (rules.length) {
-        lines.push('## Rules', '');
-        rules.forEach((r) => lines.push(`- ${r}`));
-        lines.push('');
-    }
-    if (workflow.length) {
-        lines.push('## Workflow', '');
-        workflow.forEach((w) => lines.push(`- ${w}`));
-        lines.push('');
-    }
-    if (deliverables.length) {
-        lines.push('## Deliverables', '');
-        deliverables.forEach((d) => lines.push(`- ${d}`));
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-/**
- * Render a skill definition to markdown for `.agents/skills/<id>.md`.
- */
-function skillToMarkdown(input) {
-    const name = input.name;
-    const description = input.description ?? '';
-    const trigger = input.trigger ?? '';
-    const steps = input.steps ?? [];
-    const lines = [
-        `# ${name}`,
-        '',
-        description || '_No description provided._',
-        '',
-    ];
-    if (trigger) {
-        lines.push('## Trigger', '', trigger, '');
-    }
-    if (steps.length) {
-        lines.push('## Steps', '');
-        steps.forEach((s) => lines.push(`- ${s}`));
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-function requireName(name, kind) {
-    if (typeof name !== 'string' || name.trim().length === 0) {
-        throw new Error(`admin.createAuthoring: ${kind} name is required`);
-    }
-    return name.trim();
-}
-export function createAuthoringAdmin(repoRoot) {
-    return {
-        async createSpecialist(input) {
-            const name = requireName(input.name, 'specialist');
-            const specialistId = safeId(name);
-            const dir = path.join(repoRoot, '.agents', 'specialists');
-            const filePath = path.join(dir, `${specialistId}.md`);
-            const content = specialistToMarkdown({ ...input, name });
-            await fs.promises.mkdir(dir, { recursive: true });
-            await fs.promises.writeFile(filePath, content, 'utf8');
-            return { ok: true, specialistId, filePath };
-        },
-        async createSkill(input) {
-            const name = requireName(input.name, 'skill');
-            const skillId = safeId(name);
-            const dir = path.join(repoRoot, '.agents', 'skills');
-            const filePath = path.join(dir, `${skillId}.md`);
-            const content = skillToMarkdown({ ...input, name });
-            await fs.promises.mkdir(dir, { recursive: true });
-            await fs.promises.writeFile(filePath, content, 'utf8');
-            return { ok: true, skillId, filePath };
-        },
-    };
-}

package/dist/adapters/admin/control.d.ts

@@ -1,39 +0,0 @@
-/**
- * Admin adapter — control.
- *
- * Thin facade over operator-grade runtime actions: license management and
- * memory export/import. Exposes what already exists in the engines as a
- * library call so hosts can trigger it without going through MCP JSON-RPC.
- */
-import type { LicenseStatus } from '../../licensing/index.js';
-import type { MemoryEngine, MemoryExportBundle, MemoryImportResult, MemoryItem } from '../../engines/memory.js';
-export interface MemoryExportOptions {
-    limit?: number;
-    scope?: MemoryItem['scope'];
-    state?: MemoryItem['state'];
-    sessionId?: string;
-}
-export interface ControlLicenseAdmin {
-    /** Current license status (no I/O). */
-    status(): LicenseStatus;
-    /** Validate + persist a license key. Returns updated status. */
-    activate(token: string): LicenseStatus;
-    /** Remove the license key and reset to free tier. */
-    deactivate(): void;
-    /** Sync with the licensing backend. Requires network. */
-    sync(): Promise<LicenseStatus>;
-}
-export interface ControlMemoryAdmin {
-    /** Export in-memory items to a bundle. Requires ctx.memory. */
-    export(options?: MemoryExportOptions): MemoryExportBundle;
-    /** Import a bundle (from path or object). Requires ctx.memory. */
-    import(input: {
-        path?: string;
-        bundle?: MemoryExportBundle;
-    }): Promise<MemoryImportResult>;
-}
-export interface ControlAdmin {
-    license: ControlLicenseAdmin;
-    memory: ControlMemoryAdmin;
-}
-export declare function createControlAdmin(_repoRoot: string, memory?: MemoryEngine): ControlAdmin;

package/dist/adapters/admin/control.js

@@ -1,41 +0,0 @@
-/**
- * Admin adapter — control.
- *
- * Thin facade over operator-grade runtime actions: license management and
- * memory export/import. Exposes what already exists in the engines as a
- * library call so hosts can trigger it without going through MCP JSON-RPC.
- */
-import { getSharedLicenseManager, syncLicense } from '../../licensing/index.js';
-function requireMemory(memory) {
-    if (!memory) {
-        throw new Error('admin.control.memory: ctx.memory required — pass a MemoryEngine instance to createAdmin()');
-    }
-}
-export function createControlAdmin(_repoRoot, memory) {
-    return {
-        license: {
-            status() {
-                return getSharedLicenseManager().getStatus();
-            },
-            activate(token) {
-                return getSharedLicenseManager().activate(token);
-            },
-            deactivate() {
-                getSharedLicenseManager().deactivate();
-            },
-            sync() {
-                return syncLicense();
-            },
-        },
-        memory: {
-            export(options = {}) {
-                requireMemory(memory);
-                return memory.exportBundle(options);
-            },
-            async import(input) {
-                requireMemory(memory);
-                return memory.importBundle(input);
-            },
-        },
-    };
-}

package/dist/adapters/admin/index.d.ts

@@ -1,38 +0,0 @@
-/**
- * Admin adapter — barrel.
- *
- * Operator-grade, in-process host surface for authoring (specialist/skill
- * file creation) and control-plane actions (license management, memory
- * export/import) that don't belong on the observer-only dashboard and
- * don't need to go through MCP JSON-RPC.
- *
- *   import { createAdmin } from 'nexus-prime/admin';
- *
- *   const admin = createAdmin({ repoRoot });
- *   await admin.authoring.createSpecialist({ name: 'Fix Auth', ... });
- *   admin.control.license.activate(token);
- *   admin.control.memory.export();  // requires ctx.memory
- *
- * Layering:
- * - may import from `src/kernel/**`, `src/engines/**`, `src/adapters/shared/**`.
- * - MUST NOT import from `src/agents/adapters/mcp/**` or `src/dashboard/**`.
- *   Enforced by `test/adapter-boundary.test.ts`.
- */
-import { type AuthoringAdmin } from './authoring.js';
-import { type ControlAdmin } from './control.js';
-import type { AdminContext } from './types.js';
-export type { AdminContext, CreateSpecialistInput, CreateSpecialistResult, CreateSkillInput, CreateSkillResult, } from './types.js';
-export type { AuthoringAdmin, } from './authoring.js';
-export type { ControlAdmin, ControlLicenseAdmin, ControlMemoryAdmin, MemoryExportOptions, } from './control.js';
-export interface Admin {
-    authoring: AuthoringAdmin;
-    control: ControlAdmin;
-}
-/**
- * Compose an admin surface bound to an absolute repoRoot. Fail-fast: throws
- * if `ctx.repoRoot` is missing or not absolute, mirroring the hooks adapter
- * contract from PR6.
- *
- * Pass `ctx.memory` to enable admin.control.memory.* methods.
- */
-export declare function createAdmin(ctx: AdminContext): Admin;

package/dist/adapters/admin/index.js

@@ -1,39 +0,0 @@
-/**
- * Admin adapter — barrel.
- *
- * Operator-grade, in-process host surface for authoring (specialist/skill
- * file creation) and control-plane actions (license management, memory
- * export/import) that don't belong on the observer-only dashboard and
- * don't need to go through MCP JSON-RPC.
- *
- *   import { createAdmin } from 'nexus-prime/admin';
- *
- *   const admin = createAdmin({ repoRoot });
- *   await admin.authoring.createSpecialist({ name: 'Fix Auth', ... });
- *   admin.control.license.activate(token);
- *   admin.control.memory.export();  // requires ctx.memory
- *
- * Layering:
- * - may import from `src/kernel/**`, `src/engines/**`, `src/adapters/shared/**`.
- * - MUST NOT import from `src/agents/adapters/mcp/**` or `src/dashboard/**`.
- *   Enforced by `test/adapter-boundary.test.ts`.
- */
-import * as path from 'node:path';
-import { createAuthoringAdmin } from './authoring.js';
-import { createControlAdmin } from './control.js';
-/**
- * Compose an admin surface bound to an absolute repoRoot. Fail-fast: throws
- * if `ctx.repoRoot` is missing or not absolute, mirroring the hooks adapter
- * contract from PR6.
- *
- * Pass `ctx.memory` to enable admin.control.memory.* methods.
- */
-export function createAdmin(ctx) {
-    if (!ctx.repoRoot || !path.isAbsolute(ctx.repoRoot)) {
-        throw new Error('createAdmin: ctx.repoRoot must be an absolute path');
-    }
-    return {
-        authoring: createAuthoringAdmin(ctx.repoRoot),
-        control: createControlAdmin(ctx.repoRoot, ctx.memory),
-    };
-}