nexus-prime 7.3.0 → 7.4.0

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/app/views/knowledge.js

@@ -228,11 +228,15 @@ function renderTopologyStats() {
         $('topo-build-btn')?.addEventListener('click', _buildTopology);
         return;
     }
+    const m = t.meta || {};
     const rows=[
-        ['Nodes', fmtNum(t.nodes?.length)],
-        ['Edges', fmtNum(t.edges?.length)],
-        ['Files', fmtNum(t.nodes?.filter(n=>n.type==='file').length)],
-        ['Memories', fmtNum(t.nodes?.filter(n=>n.type==='memory').length)],
+        ['Nodes',    fmtNum(t.nodes?.length)],
+        ['Edges',    fmtNum(t.edges?.length)],
+        ['Files',    fmtNum(m.fileCount   ?? t.nodes?.filter(n=>n.type==='file').length)],
+        ['Modules',  fmtNum(m.moduleCount ?? t.nodes?.filter(n=>n.type==='module').length)],
+        ['Memories', fmtNum(m.memoryCount ?? t.nodes?.filter(n=>n.type==='memory').length)],
+        ['Concepts', fmtNum(m.conceptCount ?? t.nodes?.filter(n=>n.type==='concept').length)],
+        ['Source',   t.provenance?.graphSource || m.graphSource || '—'],
     ];
     el.innerHTML=rows.map(([k,v])=>`<div class="row"><span class="row-k">${esc(k)}</span><span class="row-v">${esc(v)}</span></div>`).join('');
 }

package/dist/dashboard/app/views/repo.js

@@ -81,12 +81,14 @@ function _renderMeta() {
     el.innerHTML = [
         `<span>${esc(_topo.repoName || 'workspace')}</span>`,
         `<span>${fmtNum(meta.fileCount ?? 0)} files</span>`,
+        meta.moduleCount ? `<span>${fmtNum(meta.moduleCount)} modules</span>` : null,
+        meta.memoryCount ? `<span>${fmtNum(meta.memoryCount)} memories</span>` : null,
+        meta.conceptCount ? `<span>${fmtNum(meta.conceptCount)} concepts</span>` : null,
         `<span>${fmtNum(meta.edgeCount ?? 0)} edges</span>`,
         `<span>${esc(provenance.graphSource || meta.graphSource || 'unknown-source')}</span>`,
-        `<span>${esc(provenance.freshness || meta.freshness || 'n/a')}</span>`,
         `<span>${esc(buildLabel)}</span>`,
         `<span>${esc(generatedAt)}</span>`,
-    ].join(' · ');
+    ].filter(Boolean).join(' · ');
     _syncBuildControls();
 }
 
@@ -129,18 +131,18 @@ function _renderGraph() {
     if (_sim) _sim.stop();
 
     _sim = d3.forceSimulation(nodes)
-        .force('link',   d3.forceLink(links).id(d => d.id).distance(d => _edgeDistance(d.type)).strength(0.22))
-        .force('charge', d3.forceManyBody().strength(d => d.type === 'memory' ? -40 : -70))
+        .force('link',   d3.forceLink(links).id(d => d.id).distance(d => _edgeDistance(d.type)).strength(d => _edgeLinkStrength(d)))
+        .force('charge', d3.forceManyBody().strength(d => _nodeCharge(d)))
         .force('center', d3.forceCenter(W / 2, H / 2))
-        .force('collide', d3.forceCollide(d => _nodeR(d) + 3));
+        .force('collide', d3.forceCollide(d => _nodeR(d) + 4));
 
     const linkLayer = d3s.append('g').attr('class', 'links');
     const linkEl = linkLayer.selectAll('line')
         .data(links).enter().append('line')
         .attr('stroke', d => _edgeColor(d.type))
-        .attr('stroke-width', d => d.type === 'imports' ? 1.3 : 1)
-        .attr('stroke-opacity', d => d.type === 'memory-overlay' ? 0.35 : 0.5)
-        .attr('stroke-dasharray', d => ['memory-overlay', 'memory-association'].includes(d.type) ? '3,3' : null);
+        .attr('stroke-width', d => _edgeWidth(d))
+        .attr('stroke-opacity', d => _edgeOpacity(d))
+        .attr('stroke-dasharray', d => _edgeDash(d.type));
 
     const nodeLayer = d3s.append('g').attr('class', 'nodes');
     const nodeEl = nodeLayer.selectAll('.repo-node')
@@ -170,6 +172,7 @@ function _renderGraph() {
 function _makeNodeEl(d) {
     const doc = document.createElementNS('http://www.w3.org/2000/svg', 'g');
     const r = _nodeR(d);
+
     if (d.type === 'memory') {
         const c = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
         c.setAttribute('r', String(r));
@@ -182,12 +185,58 @@ function _makeNodeEl(d) {
         return doc;
     }
 
-    const half = r;
+    if (d.type === 'module') {
+        // Diamond shape — rotated square
+        const diamond = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
+        diamond.setAttribute('points', `0,${-r} ${r},0 0,${r} ${-r},0`);
+        diamond.setAttribute('fill', '#f59e0b');
+        diamond.setAttribute('fill-opacity', '0.9');
+        diamond.setAttribute('stroke', '#000');
+        diamond.setAttribute('stroke-width', '1.2');
+        doc.appendChild(diamond);
+        // Short label below diamond
+        const txt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+        txt.setAttribute('text-anchor', 'middle');
+        txt.setAttribute('y', String(r + 9));
+        txt.setAttribute('font-size', '7');
+        txt.setAttribute('fill', '#a3a3a3');
+        txt.setAttribute('pointer-events', 'none');
+        txt.textContent = (d.label || '').slice(0, 14);
+        doc.appendChild(txt);
+        return doc;
+    }
+
+    if (d.type === 'concept') {
+        // Hexagon shape
+        const pts = [];
+        for (let i = 0; i < 6; i++) {
+            const angle = (i * Math.PI) / 3 - Math.PI / 6;
+            pts.push(`${(r * Math.cos(angle)).toFixed(1)},${(r * Math.sin(angle)).toFixed(1)}`);
+        }
+        const hex = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
+        hex.setAttribute('points', pts.join(' '));
+        hex.setAttribute('fill', '#a855f7');
+        hex.setAttribute('fill-opacity', '0.85');
+        hex.setAttribute('stroke', '#000');
+        hex.setAttribute('stroke-width', '1');
+        doc.appendChild(hex);
+        const txt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+        txt.setAttribute('text-anchor', 'middle');
+        txt.setAttribute('y', String(r + 9));
+        txt.setAttribute('font-size', '7');
+        txt.setAttribute('fill', '#c084fc');
+        txt.setAttribute('pointer-events', 'none');
+        txt.textContent = (d.label || '').slice(0, 12);
+        doc.appendChild(txt);
+        return doc;
+    }
+
+    // File node — rectangle
     const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
-    rect.setAttribute('x', String(-half));
-    rect.setAttribute('y', String(-half));
-    rect.setAttribute('width', String(half * 2));
-    rect.setAttribute('height', String(half * 2));
+    rect.setAttribute('x', String(-r));
+    rect.setAttribute('y', String(-r));
+    rect.setAttribute('width', String(r * 2));
+    rect.setAttribute('height', String(r * 2));
     rect.setAttribute('rx', '2');
     rect.setAttribute('fill', _fileColor(d));
     rect.setAttribute('fill-opacity', '0.8');
@@ -198,31 +247,66 @@ function _makeNodeEl(d) {
 }
 
 function _nodeR(d) {
-    if (d.type === 'memory') return 4 + (d.priority || 0.3) * 8;
+    if (d.type === 'memory')  return 4 + (d.priority || 0.3) * 8;
+    if (d.type === 'module')  return 9;
+    if (d.type === 'concept') return 7;
     return 5;
 }
 
+function _nodeCharge(d) {
+    if (d.type === 'module')  return -120;
+    if (d.type === 'concept') return -90;
+    if (d.type === 'memory')  return -40;
+    return -70;
+}
+
 function _edgeDistance(type) {
+    if (type === 'belongs-to')         return 42;
+    if (type === 'concept-of')         return 95;
     if (type === 'memory-association') return 85;
-    if (type === 'memory-overlay') return 70;
-    if (type === 'configures') return 80;
-    if (type === 'tests') return 60;
+    if (type === 'memory-overlay')     return 70;
+    if (type === 'configures')         return 80;
+    if (type === 'tests')              return 60;
     return 55;
 }
 
+function _edgeLinkStrength(d) {
+    if (d.type === 'belongs-to') return 0.5;
+    if (d.type === 'imports')    return 0.3;
+    return 0.2;
+}
+
 function _edgeColor(type) {
-    if (type === 'imports') return '#27272a';
-    if (type === 'tests') return '#22c55e';
-    if (type === 'configures') return '#78716c';
-    if (type === 'memory-overlay') return '#00d4ff';
+    if (type === 'imports')            return '#27272a';
+    if (type === 'tests')              return '#22c55e';
+    if (type === 'configures')         return '#78716c';
+    if (type === 'memory-overlay')     return '#00d4ff';
     if (type === 'memory-association') return '#3f3f46';
+    if (type === 'belongs-to')         return '#52525b';
+    if (type === 'concept-of')         return '#a855f7';
     return '#27272a';
 }
 
+function _edgeWidth(d) {
+    const base = d.type === 'imports' ? 1.3 : d.type === 'belongs-to' ? 0.8 : 1;
+    return d.strength != null ? base * (0.5 + d.strength * 0.6) : base;
+}
+
+function _edgeOpacity(d) {
+    const base = ['memory-overlay', 'concept-of', 'belongs-to'].includes(d.type) ? 0.35 : 0.5;
+    return d.strength != null ? Math.min(0.85, base * (0.5 + d.strength * 0.7)) : base;
+}
+
+function _edgeDash(type) {
+    if (['memory-overlay', 'memory-association', 'concept-of'].includes(type)) return '3,3';
+    if (type === 'belongs-to') return '2,4';
+    return null;
+}
+
 function _memColor(d) {
     const tier = d.tier || 'cortex';
-    if (tier === 'prefrontal' || tier === 'working') return '#00d4ff';
-    if (tier === 'hippocampus' || tier === 'episodic') return '#00ff88';
+    if (tier === 'prefrontal' || tier === 'working')    return '#00d4ff';
+    if (tier === 'hippocampus' || tier === 'episodic')  return '#00ff88';
     return '#ffd14d';
 }
 
@@ -254,7 +338,7 @@ function _onHover(d, nodeEl, linkEl) {
 
 function _onHoverOut(nodeEl, linkEl) {
     nodeEl.attr('opacity', 1);
-    linkEl.attr('stroke-opacity', l => l.type === 'memory-overlay' ? 0.35 : 0.5);
+    linkEl.attr('stroke-opacity', l => _edgeOpacity(l));
     _hideTooltip();
 }
 
@@ -264,6 +348,11 @@ function _onClick(d) {
     if (d.type === 'file') {
         rows.push(['Path', d.path]);
         rows.push(['Kind', d.kind || 'other']);
+        if (d.module) rows.push(['Module', d.module]);
+    } else if (d.type === 'module') {
+        rows.push(['Module path', d.path]);
+    } else if (d.type === 'concept') {
+        rows.push(['Terms', d.terms?.join(', ') || d.label]);
     } else {
         rows.push(['Tier', d.tier || 'cortex']);
         rows.push(['Priority', (d.priority || 0).toFixed(2)]);

package/dist/dashboard/routes/graph.js

@@ -5,24 +5,34 @@ const FILE_LIMIT = 120;
 const MEMORY_LIMIT = 60;
 const FILE_READ_LIMIT = 64 * 1024;
 const MAX_STRUCTURAL_EDGES = 360;
+const MAX_MODULE_EDGES = 300;
+const MAX_MEMORY_OVERLAY_EDGES = FILE_LIMIT * 2;
 const MAX_MEMORY_ASSOC_EDGES = 120;
+const MAX_CONCEPT_EDGES = 240;
+const MEMORY_FILE_SIM_THRESHOLD = 0.08;
+const MEMORY_ASSOC_SIM_THRESHOLD = 0.12;
+const CONCEPT_MIN_OCCURRENCES = 2;
+const CONCEPT_MAX = 20;
 const IMPORT_CANDIDATE_SUFFIXES = [
     '',
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mts',
-    '.cts',
-    '.json',
-    '.yaml',
-    '.yml',
-    '.toml',
-    `${path.sep}index.ts`,
-    `${path.sep}index.tsx`,
-    `${path.sep}index.js`,
-    `${path.sep}index.jsx`,
+    '.ts', '.tsx', '.js', '.jsx', '.mts', '.cts',
+    '.json', '.yaml', '.yml', '.toml',
+    `${path.sep}index.ts`, `${path.sep}index.tsx`,
+    `${path.sep}index.js`, `${path.sep}index.jsx`,
 ];
+const GENERIC_TERMS = new Set([
+    'the', 'and', 'for', 'with', 'this', 'that', 'are', 'was',
+    'has', 'from', 'not', 'but', 'all', 'use', 'its', 'via',
+    'can', 'will', 'when', 'into', 'also', 'only', 'each',
+    'been', 'have', 'more', 'than', 'some', 'any', 'how',
+]);
+const GENERIC_TAGS = new Set([
+    'task', 'finding', 'note', 'important', 'todo', 'fix', 'done',
+    'bug', 'feature', 'info', 'update', 'change', 'work', 'new',
+    'code', 'file', 'data', 'type', 'value', 'item', 'list',
+    'run', 'log', 'error', 'result', 'output', 'input',
+]);
+// ── File helpers ─────────────────────────────────────────────────────────────
 function classifyFileKind(relPath) {
     const normalized = relPath.replace(/\\/g, '/');
     const ext = path.extname(normalized).toLowerCase();
@@ -37,6 +47,17 @@ function classifyFileKind(relPath) {
     }
     return 'other';
 }
+function extractModulePath(relPath) {
+    const normalized = relPath.replace(/\\/g, '/');
+    const parts = normalized.split('/');
+    if (parts.length < 2)
+        return null;
+    if (parts[0] === 'src' && parts.length >= 3)
+        return `${parts[0]}/${parts[1]}`;
+    if (['test', 'tests', 'scripts'].includes(parts[0]))
+        return parts[0];
+    return parts[0];
+}
 async function readFileSnippet(absPath) {
     try {
         const stat = await fs.stat(absPath);
@@ -54,9 +75,8 @@ function extractRelativeImports(source) {
     let match = null;
     while ((match = pattern.exec(source))) {
         const spec = String(match[1] || match[2] || match[3] || '').trim();
-        if (spec.startsWith('.')) {
+        if (spec.startsWith('.'))
             specs.add(spec);
-        }
     }
     return [...specs];
 }
@@ -73,15 +93,6 @@ function resolveRelativeTarget(importerAbsPath, spec, absToRel) {
 function normalizedBaseName(relPath) {
     return path.basename(relPath).replace(/\.(test|spec)\.[^.]+$/i, '').replace(/\.[^.]+$/i, '').toLowerCase();
 }
-function pushEdge(edges, seen, source, target, type, limit) {
-    if (!source || !target || source === target || edges.length >= limit)
-        return;
-    const key = `${source}:${target}:${type}`;
-    if (seen.has(key))
-        return;
-    seen.add(key);
-    edges.push({ source, target, type });
-}
 function scoreConfigReference(configText, relPath) {
     if (!configText)
         return 0;
@@ -94,6 +105,42 @@ function scoreConfigReference(configText, relPath) {
         return 1;
     return 0;
 }
+// ── Semantic similarity ───────────────────────────────────────────────────────
+function tokenizeText(text) {
+    return text
+        .toLowerCase()
+        .replace(/[/\\._\-:,;()[\]{}'"`<>@#!?=+*&%$^~]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !GENERIC_TERMS.has(w));
+}
+function tokenOverlapScore(aTokens, bTokens) {
+    if (!aTokens.length || !bTokens.length)
+        return 0;
+    const bSet = new Set(bTokens);
+    let overlap = 0;
+    for (const t of aTokens) {
+        if (bSet.has(t))
+            overlap++;
+    }
+    const union = aTokens.length + bTokens.length - overlap;
+    return union === 0 ? 0 : overlap / union;
+}
+function extractConceptTerms(tags) {
+    return tags
+        .map(t => t.replace(/^[#@]/, '').toLowerCase().trim())
+        .filter(t => t.length > 3 && !GENERIC_TAGS.has(t) && !GENERIC_TERMS.has(t));
+}
+// ── Edge helpers ──────────────────────────────────────────────────────────────
+function pushEdge(edges, seen, source, target, type, limit, strength) {
+    if (!source || !target || source === target || edges.length >= limit)
+        return;
+    const key = `${source}:${target}:${type}`;
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    edges.push({ source, target, type, ...(strength !== undefined ? { strength } : {}) });
+}
+// ── Route handler ─────────────────────────────────────────────────────────────
 export const handleGraphRoutes = async (ctx, req, res, url) => {
     if (req.method === 'POST' && url.pathname === '/api/knowledge-topology/build') {
         const repoIdentity = ctx.getSelectedRepoIdentity(url);
@@ -104,13 +151,7 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
             ? repoIdentity.repoName.trim()
             : path.basename(repoRoot) || 'workspace';
         void ensureCrGraphBuilt(repoRoot);
-        ctx.respondJson(res, {
-            ok: true,
-            status: 'queued',
-            repoRoot,
-            repoName,
-            queuedAt: Date.now(),
-        }, 202);
+        ctx.respondJson(res, { ok: true, status: 'queued', repoRoot, repoName, queuedAt: Date.now() }, 202);
         return true;
     }
     if (req.method === 'GET' && url.pathname === '/api/knowledge-topology') {
@@ -127,6 +168,7 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
             const repoName = typeof repoIdentity?.repoName === 'string' && repoIdentity.repoName.trim()
                 ? repoIdentity.repoName.trim()
                 : path.basename(repoRoot) || 'workspace';
+            // ── File nodes ─────────────────────────────────────────────────────────
             let filePaths = [];
             try {
                 filePaths = await orchestrator?.listTopologyFiles?.(FILE_LIMIT) ?? [];
@@ -145,10 +187,36 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
                     label: path.basename(relPath),
                     path: relPath,
                     absPath: path.normalize(absPath),
+                    module: extractModulePath(relPath),
                 };
             });
-            const absToRel = new Map(fileNodes.map((node) => [node.absPath, node.path]));
-            const fileRelSet = new Set(fileNodes.map((node) => node.path));
+            const absToRel = new Map(fileNodes.map((n) => [n.absPath, n.path]));
+            const fileRelSet = new Set(fileNodes.map((n) => n.path));
+            // Pre-tokenize file paths+labels for similarity scoring
+            const fileTokens = new Map();
+            for (const node of fileNodes) {
+                fileTokens.set(node.id, [...tokenizeText(node.path), ...tokenizeText(node.label)]);
+            }
+            // ── Module nodes + belongs-to edges ────────────────────────────────────
+            const modulePathSet = new Set();
+            for (const node of fileNodes) {
+                if (node.module)
+                    modulePathSet.add(node.module);
+            }
+            const moduleNodes = [...modulePathSet].sort().map((mod) => ({
+                id: `module:${mod}`,
+                type: 'module',
+                label: path.basename(mod),
+                path: mod,
+            }));
+            const belongsToEdges = [];
+            const belongsToSeen = new Set();
+            for (const node of fileNodes) {
+                if (node.module) {
+                    pushEdge(belongsToEdges, belongsToSeen, node.id, `module:${node.module}`, 'belongs-to', MAX_MODULE_EDGES, 1.0);
+                }
+            }
+            // ── Structural edges (imports / tests / configures) ────────────────────
             const structuralEdges = [];
             const structuralSeen = new Set();
             for (const node of fileNodes) {
@@ -160,66 +228,130 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
                 for (const spec of extractRelativeImports(fileText)) {
                     const targetRel = resolveRelativeTarget(node.absPath, spec, absToRel);
                     if (targetRel) {
-                        pushEdge(structuralEdges, structuralSeen, node.id, `file:${targetRel}`, 'imports', MAX_STRUCTURAL_EDGES);
+                        pushEdge(structuralEdges, structuralSeen, node.id, `file:${targetRel}`, 'imports', MAX_STRUCTURAL_EDGES, 1.0);
                     }
                 }
                 if (node.kind === 'test') {
                     const affinityMatches = fileNodes
-                        .filter((candidate) => candidate.kind === 'source')
-                        .filter((candidate) => normalizedBaseName(candidate.path) === normalizedBaseName(node.path))
-                        .sort((left, right) => left.path.length - right.path.length)
+                        .filter((c) => c.kind === 'source' && normalizedBaseName(c.path) === normalizedBaseName(node.path))
+                        .sort((a, b) => a.path.length - b.path.length)
                         .slice(0, 2);
-                    for (const match of affinityMatches) {
-                        pushEdge(structuralEdges, structuralSeen, node.id, match.id, 'tests', MAX_STRUCTURAL_EDGES);
+                    for (const m of affinityMatches) {
+                        pushEdge(structuralEdges, structuralSeen, node.id, m.id, 'tests', MAX_STRUCTURAL_EDGES, 0.9);
                     }
                 }
                 if (node.kind === 'config') {
                     const configMatches = fileNodes
-                        .filter((candidate) => candidate.kind === 'source')
-                        .map((candidate) => ({
-                        candidate,
-                        score: scoreConfigReference(fileText, candidate.path),
-                    }))
-                        .filter((entry) => entry.score > 0)
-                        .sort((left, right) => right.score - left.score || left.candidate.path.length - right.candidate.path.length)
+                        .filter((c) => c.kind === 'source')
+                        .map((c) => ({ c, score: scoreConfigReference(fileText, c.path) }))
+                        .filter((e) => e.score > 0)
+                        .sort((a, b) => b.score - a.score || a.c.path.length - b.c.path.length)
                         .slice(0, 4);
-                    for (const match of configMatches) {
-                        pushEdge(structuralEdges, structuralSeen, node.id, match.candidate.id, 'configures', MAX_STRUCTURAL_EDGES);
+                    for (const { c, score } of configMatches) {
+                        pushEdge(structuralEdges, structuralSeen, node.id, c.id, 'configures', MAX_STRUCTURAL_EDGES, score / 3);
                     }
                 }
             }
+            // ── Memory nodes ───────────────────────────────────────────────────────
             const snapshots = memory?.listSnapshots?.(MEMORY_LIMIT, { state: 'active' }) ?? [];
-            const memoryNodes = snapshots.map((snapshot) => ({
-                id: `memory:${snapshot.id}`,
+            const memoryNodes = snapshots.map((s) => ({
+                id: `memory:${s.id}`,
                 type: 'memory',
-                label: (snapshot.excerpt ?? '').slice(0, 60) || snapshot.id.slice(0, 16),
-                tier: snapshot.tier ?? 'cortex',
-                priority: snapshot.priority ?? 0.3,
-                tags: Array.isArray(snapshot.tags) ? snapshot.tags : [],
-                promoted: snapshot.tier === 'hippocampus' || snapshot.tier === 'cortex',
+                label: (s.excerpt ?? '').slice(0, 60) || s.id.slice(0, 16),
+                tier: s.tier ?? 'cortex',
+                priority: s.priority ?? 0.3,
+                tags: Array.isArray(s.tags) ? s.tags : [],
+                promoted: s.tier === 'hippocampus' || s.tier === 'cortex',
             }));
+            // ── Memory → file overlay (token similarity, not fragile string match) ─
             const memoryOverlayEdges = [];
             const memoryOverlaySeen = new Set();
             for (const snapshot of snapshots) {
                 const excerpt = String(snapshot.excerpt ?? '');
-                for (const relPath of fileRelSet) {
-                    if (excerpt.includes(relPath) || excerpt.includes(path.basename(relPath))) {
-                        pushEdge(memoryOverlayEdges, memoryOverlaySeen, `memory:${snapshot.id}`, `file:${relPath}`, 'memory-overlay', FILE_LIMIT * 2);
-                        break;
+                const excerptTokens = tokenizeText(excerpt);
+                const scored = [];
+                for (const node of fileNodes) {
+                    // Exact path match first (high confidence)
+                    if (excerpt.includes(node.path) || excerpt.includes(path.basename(node.path))) {
+                        scored.push({ nodeId: node.id, score: 0.95 });
+                        continue;
+                    }
+                    // Token overlap (semantic match)
+                    const fTokens = fileTokens.get(node.id) ?? [];
+                    const sim = tokenOverlapScore(excerptTokens, fTokens);
+                    if (sim >= MEMORY_FILE_SIM_THRESHOLD) {
+                        scored.push({ nodeId: node.id, score: sim });
+                    }
+                }
+                // Cap at top 3 links per memory — keeps graph readable
+                scored.sort((a, b) => b.score - a.score);
+                for (const { nodeId, score } of scored.slice(0, 3)) {
+                    pushEdge(memoryOverlayEdges, memoryOverlaySeen, `memory:${snapshot.id}`, nodeId, 'memory-overlay', MAX_MEMORY_OVERLAY_EDGES, score);
+                }
+            }
+            // ── Memory ↔ memory association (specific tags + excerpt similarity) ───
+            const memoryAssocEdges = [];
+            const memoryAssocSeen = new Set();
+            const memCache = snapshots.map((s, i) => ({
+                id: memoryNodes[i]?.id ?? `memory:${s.id}`,
+                tokens: tokenizeText(String(s.excerpt ?? '')),
+                specificTags: (Array.isArray(s.tags) ? s.tags : [])
+                    .map((t) => t.replace(/^[#@]/, '').toLowerCase())
+                    .filter((t) => t.length > 3 && !GENERIC_TAGS.has(t)),
+            }));
+            for (let i = 0; i < memCache.length && memoryAssocEdges.length < MAX_MEMORY_ASSOC_EDGES; i++) {
+                for (let j = i + 1; j < memCache.length && memoryAssocEdges.length < MAX_MEMORY_ASSOC_EDGES; j++) {
+                    const a = memCache[i];
+                    const b = memCache[j];
+                    const sharedTags = a.specificTags.filter((t) => b.specificTags.includes(t)).length;
+                    const textSim = tokenOverlapScore(a.tokens, b.tokens);
+                    if (sharedTags >= 1 || textSim >= MEMORY_ASSOC_SIM_THRESHOLD) {
+                        const strength = Math.min(1, sharedTags * 0.35 + textSim);
+                        pushEdge(memoryAssocEdges, memoryAssocSeen, a.id, b.id, 'memory-association', MAX_MEMORY_ASSOC_EDGES, strength);
                     }
                 }
             }
-            const memoryAssociationEdges = [];
-            const memoryAssociationSeen = new Set();
-            for (let i = 0; i < memoryNodes.length && memoryAssociationEdges.length < MAX_MEMORY_ASSOC_EDGES; i += 1) {
-                for (let j = i + 1; j < memoryNodes.length && memoryAssociationEdges.length < MAX_MEMORY_ASSOC_EDGES; j += 1) {
-                    const sharedTagCount = memoryNodes[i].tags.filter((tag) => memoryNodes[j].tags.includes(tag)).length;
-                    if (sharedTagCount >= 2) {
-                        pushEdge(memoryAssociationEdges, memoryAssociationSeen, memoryNodes[i].id, memoryNodes[j].id, 'memory-association', MAX_MEMORY_ASSOC_EDGES);
+            // ── Concept nodes (prominent memory tags, ≥2 occurrences) ──────────────
+            const conceptCounts = new Map();
+            for (const snapshot of snapshots) {
+                const tags = Array.isArray(snapshot.tags) ? snapshot.tags : [];
+                for (const term of extractConceptTerms(tags)) {
+                    conceptCounts.set(term, (conceptCounts.get(term) ?? 0) + 1);
+                }
+            }
+            const conceptTerms = [...conceptCounts.entries()]
+                .filter(([, count]) => count >= CONCEPT_MIN_OCCURRENCES)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, CONCEPT_MAX)
+                .map(([term]) => term);
+            const conceptNodes = conceptTerms.map((term) => ({
+                id: `concept:${term}`,
+                type: 'concept',
+                label: term,
+                terms: [term],
+            }));
+            // concept-of edges: memory → concept (via tags)
+            const conceptEdges = [];
+            const conceptEdgesSeen = new Set();
+            for (const snapshot of snapshots) {
+                const tags = Array.isArray(snapshot.tags) ? snapshot.tags : [];
+                for (const term of extractConceptTerms(tags)) {
+                    if ((conceptCounts.get(term) ?? 0) >= CONCEPT_MIN_OCCURRENCES) {
+                        pushEdge(conceptEdges, conceptEdgesSeen, `memory:${snapshot.id}`, `concept:${term}`, 'concept-of', MAX_CONCEPT_EDGES, 0.8);
                     }
                 }
             }
-            const edges = [...structuralEdges, ...memoryOverlayEdges, ...memoryAssociationEdges];
+            // file → concept (via file name token match)
+            for (const node of fileNodes) {
+                const fTokens = fileTokens.get(node.id) ?? [];
+                for (const term of conceptTerms) {
+                    if (fTokens.includes(term)) {
+                        pushEdge(conceptEdges, conceptEdgesSeen, node.id, `concept:${term}`, 'concept-of', MAX_CONCEPT_EDGES, 0.7);
+                    }
+                }
+            }
+            // ── Assemble ───────────────────────────────────────────────────────────
+            const edges = [...belongsToEdges, ...structuralEdges, ...memoryOverlayEdges, ...memoryAssocEdges, ...conceptEdges];
             const graphSource = structuralEdges.length > 0
                 ? 'heuristic-local-relationships'
                 : fileNodes.length > 0
@@ -227,37 +359,31 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
                     : memoryOverlayEdges.length > 0 || memoryNodes.length > 0
                         ? 'memory-overlay-fallback'
                         : 'empty';
-            // fallbackMode tells the dashboard whether this payload represents a real
-            // topology, a degraded approximation, or no graph at all. The memory view
-            // uses this to pick between rendering the graph, a synthetic-data banner,
-            // or a "no graph yet" empty state — so we stop drawing edges that lie.
             const fallbackMode = graphSource === 'heuristic-local-relationships' ? 'none'
                 : graphSource === 'runtime-topology-shell' ? 'synthetic'
                     : graphSource === 'memory-overlay-fallback' ? 'topology-missing'
                         : 'empty';
             const sources = [
                 fileNodes.length > 0 ? 'runtime-topology-files' : null,
-                structuralEdges.some((edge) => edge.type === 'imports') ? 'heuristic-imports' : null,
-                structuralEdges.some((edge) => edge.type === 'tests') ? 'heuristic-test-affinity' : null,
-                structuralEdges.some((edge) => edge.type === 'configures') ? 'heuristic-config-affinity' : null,
-                memoryOverlayEdges.length > 0 ? 'memory-overlay' : null,
-                memoryAssociationEdges.length > 0 ? 'memory-association' : null,
-            ].filter((value) => Boolean(value));
-            // Deterministic ordering so two consecutive loads produce the same node
-            // list (id-sorted). The D3 simulation may still animate, but the input
-            // is stable — no more "graph jumps between refreshes" surprise.
+                moduleNodes.length > 0 ? 'module-grouping' : null,
+                structuralEdges.some((e) => e.type === 'imports') ? 'heuristic-imports' : null,
+                structuralEdges.some((e) => e.type === 'tests') ? 'heuristic-test-affinity' : null,
+                structuralEdges.some((e) => e.type === 'configures') ? 'heuristic-config-affinity' : null,
+                memoryOverlayEdges.length > 0 ? 'memory-overlay-similarity' : null,
+                memoryAssocEdges.length > 0 ? 'memory-association' : null,
+                conceptNodes.length > 0 ? 'concept-extraction' : null,
+            ].filter((v) => Boolean(v));
+            // Deterministic ordering — stable across refreshes
             const sortedFileNodes = [...fileNodes].sort((a, b) => a.id.localeCompare(b.id));
+            const sortedModuleNodes = [...moduleNodes].sort((a, b) => a.id.localeCompare(b.id));
             const sortedMemoryNodes = [...memoryNodes].sort((a, b) => String(a.id).localeCompare(String(b.id)));
-            const sortedEdges = [...edges].sort((a, b) => {
-                const leftKey = `${a.source}|${a.target}|${a.type}`;
-                const rightKey = `${b.source}|${b.target}|${b.type}`;
-                return leftKey.localeCompare(rightKey);
-            });
+            const sortedConceptNodes = [...conceptNodes].sort((a, b) => a.id.localeCompare(b.id));
+            const sortedEdges = [...edges].sort((a, b) => `${a.source}|${a.target}|${a.type}`.localeCompare(`${b.source}|${b.target}|${b.type}`));
             return {
                 generatedAt: Date.now(),
                 repoName,
                 repoRoot,
-                nodes: [...sortedFileNodes, ...sortedMemoryNodes],
+                nodes: [...sortedFileNodes, ...sortedModuleNodes, ...sortedMemoryNodes, ...sortedConceptNodes],
                 edges: sortedEdges,
                 fallbackMode,
                 provenance: {
@@ -276,10 +402,14 @@ export const handleGraphRoutes = async (ctx, req, res, url) => {
                 },
                 meta: {
                     fileCount: fileNodes.length,
+                    moduleCount: moduleNodes.length,
                     memoryCount: memoryNodes.length,
+                    conceptCount: conceptNodes.length,
                     structuralEdgeCount: structuralEdges.length,
+                    belongsToEdgeCount: belongsToEdges.length,
                     memoryOverlayEdgeCount: memoryOverlayEdges.length,
-                    memoryAssociationEdgeCount: memoryAssociationEdges.length,
+                    memoryAssociationEdgeCount: memoryAssocEdges.length,
+                    conceptEdgeCount: conceptEdges.length,
                     edgeCount: edges.length,
                     graphSource,
                     fallbackMode,

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/engines/instruction-gateway.js

@@ -329,12 +329,16 @@ export class InstructionGateway {
             const workspaceRuntimeDir = path.join(repoRoot, '.agent', 'runtime');
             workspaceJsonPath = path.join(workspaceRuntimeDir, 'packet.json');
             workspaceMarkdownPath = path.join(workspaceRuntimeDir, 'packet.md');
-            void fs.promises.mkdir(workspaceRuntimeDir, { recursive: true }).then(() => Promise.all([
-                fs.promises.writeFile(workspaceJsonPath, JSON.stringify(packet, null, 2), 'utf8'),
-                fs.promises.writeFile(workspaceMarkdownPath, renderInstructionPacketMarkdown(packet), 'utf8'),
-            ])).catch((err) => {
+            // Sync write: callers read this file immediately after execute() returns.
+            // Fire-and-forget async races the reader and causes truncated JSON.parse failures.
+            try {
+                fs.mkdirSync(workspaceRuntimeDir, { recursive: true });
+                fs.writeFileSync(workspaceJsonPath, JSON.stringify(packet, null, 2), 'utf8');
+                fs.writeFileSync(workspaceMarkdownPath, renderInstructionPacketMarkdown(packet), 'utf8');
+            }
+            catch (err) {
                 console.error(`[nexus-prime] Failed to persist instruction packet to workspace: ${err}`);
-            });
+            }
         }
         else if (isRoot) {
             console.error('[nexus-prime] Persistence to system root is disabled for stability.');

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/dist/phantom/runtime.js

@@ -2782,8 +2782,8 @@ export class SubAgentRuntime {
             return;
         const runtimeDir = path.join(worktreeDir, '.agent', 'runtime');
         fs.mkdirSync(runtimeDir, { recursive: true });
-        void fs.promises.writeFile(path.join(runtimeDir, 'packet.json'), JSON.stringify(packet, null, 2), 'utf8');
-        void fs.promises.writeFile(path.join(runtimeDir, 'packet.md'), renderInstructionPacketMarkdown(packet), 'utf8');
+        fs.writeFileSync(path.join(runtimeDir, 'packet.json'), JSON.stringify(packet, null, 2), 'utf8');
+        fs.writeFileSync(path.join(runtimeDir, 'packet.md'), renderInstructionPacketMarkdown(packet), 'utf8');
     }
     gatherSkillBindings(skills, allowMutateSkills) {
         return skills.flatMap((skill) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.3.0",
+  "version": "7.4.0",
   "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",