nexus-prime 7.3.0 → 7.3.1

package/dist/cli/install-wizard.js

@@ -17,6 +17,7 @@ import { runPostinstallCleanup } from '../postinstall/cleanup.js';
 import { openBrowser, printHandoffBanner, withSpinner } from './interactive-setup.js';
 import { appendToManifest, detectArchitectureUpgrade, loadManifest, recordArchitectureGeneration, recordPath, recordRegistration, recordSetupMarker, INSTALL_ARCH_GENERATION, } from '../install/manifest.js';
 import { enumerateNgramArchives } from '../install/state-locator.js';
+import { NEXUS_HOOK_COMMAND_MARKER, writeNexusClaudeCodeHooks } from '../install/claude-code-hooks.js';
 /** Compute sha256 of a file's content. Returns null if the file cannot be read. */
 export function computeFileHash(filePath) {
     try {
@@ -148,35 +149,8 @@ function _nexusMcpEntry(workspaceRoot) {
  */
 function _writeClaudeCodeHooks(workspaceRoot) {
     const settingsPath = join(workspaceRoot, '.claude', 'settings.json');
-    let existing = {};
-    if (existsSync(settingsPath)) {
-        try {
-            existing = JSON.parse(readFileSync(settingsPath, 'utf8'));
-        }
-        catch { /* start fresh if unreadable */ }
-    }
-    const NEXUS_CMD_MARKER = 'nexus-prime hook';
-    const nexusHooks = {
-        UserPromptSubmit: [{ matcher: '', hooks: [{ type: 'command', command: 'nexus-prime hook bootstrap' }] }],
-        PreToolUse: [{ matcher: 'Edit|Write|MultiEdit', hooks: [{ type: 'command', command: 'nexus-prime hook mindkit' }] }],
-        PostToolUse: [{ matcher: 'Edit|Write|MultiEdit|Bash', hooks: [{ type: 'command', command: 'nexus-prime hook memory' }] }],
-        Stop: [{ matcher: '', hooks: [{ type: 'command', command: 'nexus-prime hook session-dna' }] }],
-    };
-    const existingHooks = (existing.hooks && typeof existing.hooks === 'object' && !Array.isArray(existing.hooks))
-        ? existing.hooks
-        : {};
-    for (const [event, entries] of Object.entries(nexusHooks)) {
-        const current = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
-        // Strip stale nexus-prime hook entries then append fresh ones
-        const filtered = current.filter((e) => typeof e === 'object' && e !== null &&
-            !(Array.isArray(e.hooks) &&
-                e.hooks.some((h) => typeof h === 'object' && h !== null && typeof h.command === 'string' &&
-                    h.command.includes(NEXUS_CMD_MARKER))));
-        existingHooks[event] = [...filtered, ...entries];
-    }
-    existing.hooks = existingHooks;
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(existing, null, 2), 'utf8');
+    // Single source of truth: hook spec + dedup logic live in install/claude-code-hooks.ts.
+    writeNexusClaudeCodeHooks(settingsPath);
     const isHome = workspaceRoot === homedir();
     appendToManifest((m) => {
         const withPath = recordPath(m, { path: settingsPath, kind: 'file', scope: 'state' });
@@ -184,7 +158,7 @@ function _writeClaudeCodeHooks(workspaceRoot) {
             target: isHome ? 'claude-home' : 'claude-workspace',
             filePath: settingsPath,
             jsonPath: ['hooks'],
-            entryMarker: NEXUS_CMD_MARKER,
+            entryMarker: NEXUS_HOOK_COMMAND_MARKER,
         });
     });
 }

package/dist/cli.js

@@ -38,67 +38,24 @@ import { runUninstall } from './cli/uninstall.js';
 import { runCleanup } from './cli/cleanup.js';
 import { runDoctorStorage } from './cli/doctor-storage.js';
 const tokenEngine = new TokenSupremacyEngine();
+import { getNexusHookSpec, writeNexusClaudeCodeHooks, } from './install/claude-code-hooks.js';
 /**
  * Write (or merge) nexus-prime Claude Code hook entries into ~/.claude/settings.json.
- * Idempotent: removes any pre-existing `nexus-prime hook *` entries before adding fresh ones.
+ * Idempotent — delegates to the shared writer in install/claude-code-hooks.ts
+ * so cli.ts and install-wizard.ts cannot drift on the hook spec or dedup logic.
  */
 function writeClaudeCodeHooks(settingsPath, dryRun) {
-    let settings = {};
-    if (existsSync(settingsPath)) {
-        try {
-            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-        }
-        catch {
-            settings = {};
-        }
-    }
-    const hooks = (settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks))
-        ? { ...settings.hooks }
-        : {};
-    const nexusHooks = {
-        UserPromptSubmit: [
-            { hooks: [{ type: 'command', command: 'nexus-prime hook bootstrap', timeout: 30 }] },
-        ],
-        PreToolUse: [
-            {
-                matcher: 'Edit|Write|MultiEdit',
-                hooks: [{ type: 'command', command: 'nexus-prime hook mindkit', timeout: 10 }],
-            },
-        ],
-        PostToolUse: [
-            {
-                matcher: 'Edit|Write|MultiEdit|Bash',
-                hooks: [{ type: 'command', command: 'nexus-prime hook memory', timeout: 10 }],
-            },
-        ],
-        Stop: [
-            { hooks: [{ type: 'command', command: 'nexus-prime hook session-dna', timeout: 60 }] },
-        ],
-    };
-    for (const [event, entries] of Object.entries(nexusHooks)) {
-        const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
-        // Remove stale nexus-prime hook entries before re-adding
-        const filtered = existing.filter((entry) => {
-            if (!entry || typeof entry !== 'object')
-                return true;
-            const hooksList = entry.hooks;
-            if (!Array.isArray(hooksList))
-                return true;
-            return !hooksList.some((h) => h && typeof h.command === 'string' &&
-                h.command.startsWith('nexus-prime hook'));
-        });
-        hooks[event] = [...filtered, ...entries];
-    }
-    settings.hooks = hooks;
+    const result = writeNexusClaudeCodeHooks(settingsPath, { dryRun });
     if (dryRun) {
         console.log('Hooks preview (would write to ~/.claude/settings.json):');
-        console.log(JSON.stringify(nexusHooks, null, 2));
+        console.log(JSON.stringify(getNexusHookSpec(), null, 2));
         return;
     }
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
-    console.log(`   Hooks: ${settingsPath}`);
-    Object.keys(nexusHooks).forEach(ev => console.log(`     ${ev} → nexus-prime hook ${ev.toLowerCase().replace('tooluse', '').trim() || ev}`));
+    console.log(`   Hooks: ${settingsPath}${result.changed ? '' : ' (no change)'}`);
+    result.events.forEach((ev) => {
+        const tail = ev.toLowerCase().replace('tooluse', '').trim() || ev;
+        console.log(`     ${ev} → nexus-prime hook ${tail}`);
+    });
 }
 const program = new Command();
 let nexus = null;

package/dist/dashboard/server.js

@@ -21,6 +21,7 @@ import { handleAuthoringRoutes } from './routes/authoring.js';
 import { handleArchitectsRoutes } from './routes/architects.js';
 import { handleWorkforceRoutes } from './routes/workforce.js';
 import { handleGraphRoutes } from './routes/graph.js';
+import { DASHBOARD_API_VERSION } from './contract.js';
 import { SseBroker } from './stream/sse-broker.js';
 import { nexusEventBus } from '../engines/event-bus.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -30,7 +31,6 @@ const DEFAULT_PORT = parseInt(process.env.NEXUS_DASHBOARD_PORT || '3377', 10);
 const MAX_PORT_SCAN = 24;
 const DASHBOARD_PROBE_TIMEOUT_MS = 3000;
 const DASHBOARD_PROBE_ATTEMPTS = 2;
-const DASHBOARD_API_VERSION = '4';
 const DASHBOARD_SCHEMA_VERSION = 1;
 const DASHBOARD_PRETTY_JSON = process.env.NEXUS_DASHBOARD_PRETTY_JSON === '1';
 const CORE_CAPABILITIES = {

package/dist/install/claude-code-hooks.d.ts

@@ -0,0 +1,33 @@
+/** Marker that identifies a hook entry as Nexus-owned. */
+export declare const NEXUS_HOOK_COMMAND_MARKER = "nexus-prime hook";
+interface HookCommand {
+    type: 'command';
+    command: string;
+    timeout?: number;
+}
+interface HookEntry {
+    matcher?: string;
+    hooks: HookCommand[];
+}
+/**
+ * Canonical Nexus hook spec. Edit here, not in callers.
+ * Timeouts protect Claude Code from a wedged Nexus process — leave them set.
+ */
+export declare function getNexusHookSpec(): Record<string, HookEntry[]>;
+export interface NexusHookWriteResult {
+    /** True when the file would be written (or was written). */
+    changed: boolean;
+    /** Hook event names that ended up with Nexus entries. */
+    events: string[];
+    /** Number of stale Nexus entries removed before re-adding. */
+    staleRemoved: number;
+}
+/**
+ * Idempotent writer for the Nexus hook block. Returns metadata so callers can
+ * report status (`installed | unchanged | dry-run`) without re-implementing
+ * the merge logic.
+ */
+export declare function writeNexusClaudeCodeHooks(settingsPath: string, options?: {
+    dryRun?: boolean;
+}): NexusHookWriteResult;
+export {};

package/dist/install/claude-code-hooks.js

@@ -0,0 +1,96 @@
+/**
+ * Single source of truth for the Claude Code hook entries Nexus Prime owns.
+ * Both `nexus-prime install` (cli.ts) and the install-wizard call into here
+ * so we cannot drift on hook spec, dedup logic, or marker detection.
+ *
+ * Foreign user hooks are preserved — only entries whose command starts with
+ * `nexus-prime hook` are stripped before re-adding.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Marker that identifies a hook entry as Nexus-owned. */
+export const NEXUS_HOOK_COMMAND_MARKER = 'nexus-prime hook';
+/**
+ * Canonical Nexus hook spec. Edit here, not in callers.
+ * Timeouts protect Claude Code from a wedged Nexus process — leave them set.
+ */
+export function getNexusHookSpec() {
+    return {
+        UserPromptSubmit: [
+            { hooks: [{ type: 'command', command: 'nexus-prime hook bootstrap', timeout: 30 }] },
+        ],
+        PreToolUse: [
+            {
+                matcher: 'Edit|Write|MultiEdit',
+                hooks: [{ type: 'command', command: 'nexus-prime hook mindkit', timeout: 10 }],
+            },
+        ],
+        PostToolUse: [
+            {
+                matcher: 'Edit|Write|MultiEdit|Bash',
+                hooks: [{ type: 'command', command: 'nexus-prime hook memory', timeout: 10 }],
+            },
+        ],
+        Stop: [
+            { hooks: [{ type: 'command', command: 'nexus-prime hook session-dna', timeout: 60 }] },
+        ],
+    };
+}
+function isNexusHookEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return false;
+    const hooksList = entry.hooks;
+    if (!Array.isArray(hooksList))
+        return false;
+    return hooksList.some((h) => h && typeof h === 'object'
+        && typeof h.command === 'string'
+        && h.command.trimStart().startsWith(NEXUS_HOOK_COMMAND_MARKER));
+}
+/**
+ * Idempotent writer for the Nexus hook block. Returns metadata so callers can
+ * report status (`installed | unchanged | dry-run`) without re-implementing
+ * the merge logic.
+ */
+export function writeNexusClaudeCodeHooks(settingsPath, options = {}) {
+    const dryRun = options.dryRun ?? false;
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            const raw = fs.readFileSync(settingsPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                settings = parsed;
+            }
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const incomingHooks = getNexusHookSpec();
+    const events = Object.keys(incomingHooks);
+    const existing = (settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks))
+        ? { ...settings.hooks }
+        : {};
+    let staleRemoved = 0;
+    let changed = !fs.existsSync(settingsPath);
+    for (const event of events) {
+        const before = Array.isArray(existing[event]) ? existing[event] : [];
+        const filtered = before.filter((entry) => {
+            const isNexus = isNexusHookEntry(entry);
+            if (isNexus)
+                staleRemoved += 1;
+            return !isNexus;
+        });
+        const next = [...filtered, ...incomingHooks[event]];
+        if (filtered.length !== before.length || next.length !== before.length)
+            changed = true;
+        existing[event] = next;
+    }
+    settings.hooks = existing;
+    if (dryRun || !changed) {
+        return { changed, events, staleRemoved };
+    }
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    return { changed, events, staleRemoved };
+}

package/dist/install/state-locator.js

@@ -88,6 +88,8 @@ export function enumerateStatePaths(stateDir = getNexusStateDir()) {
         { path: path.join(stateDir, 'bootstrap-receipts'), scope: 'state', optional: true },
         { path: path.join(stateDir, 'setup-marker-v6.json'), scope: 'state', optional: true },
         { path: path.join(stateDir, 'install-manifest.json'), scope: 'state', optional: true },
+        { path: path.join(stateDir, 'license.key'), scope: 'state', optional: true },
+        { path: path.join(stateDir, 'trial.json'), scope: 'state', optional: true },
         { path: path.join(stateDir, 'nexus-daemon.lock.json'), scope: 'runtime', optional: true },
     ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.3.0",
+  "version": "7.3.1",
   "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms",
   "type": "module",
   "main": "dist/index.js",