nexus-prime 7.1.1 → 7.2.0

package/dist/agents/adapters/mcp/handlers/orchestration.js

@@ -293,7 +293,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                             detailLevel === 'debug' && bootstrap.tokenOptimization?.autoApplied && bootstrap.tokenOptimization?.plan
                                 ? `Auto token plan\n\`\`\`txt\n${bootstrap.tokenOptimization.plan}\n\`\`\``
                                 : '',
-                            detailLevel === 'debug' ? formatJsonDetails('Structured details', payload) : '',
+                            formatJsonDetails('Structured details', payload),
                             hctx.formatProtocolChecklist(),
                         ].filter(Boolean).join('\n\n'),
                     }],
@@ -499,6 +499,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                     `Verification: ${verifiedWorkers}/${execution.workerResults.length} worker(s) verified`,
                                     `Tokens: saved ${Number(execution.tokenTelemetry?.savedTokens || 0).toLocaleString()} · compression ${Number(execution.tokenTelemetry?.compressionPct || 0)}%`,
                                     autoTokenApplyNote || null,
+                                    `Payload ref: ${workspace.stateKey} · ${detailLevel}`,
                                     ...(detailLevel === 'debug' ? [
                                         `Specialists: ${execution.plannerState?.selectedSpecialists.map((specialist) => specialist.name).slice(0, 4).join(', ') || 'none selected'}`,
                                         `Assets: ${(execution.activeSkills || []).length} skills · ${(execution.activeWorkflows || []).length} workflows · ${(runtimeUsage.artifactSelectionAudit?.selected?.length || 0)} audited selections`,
@@ -512,7 +513,7 @@ export async function handleOrchestrationGroup(toolName, hctx, request, args, ct
                                     ] : []),
                                 ]),
                                 detailLevel === 'debug' && execution.result ? `Result\n\`\`\`\n${execution.result}\n\`\`\`` : `Result preview\n\`\`\`\n${truncateText(execution.result || summarizeExecution(execution), 900)}\n\`\`\``,
-                                detailLevel === 'debug' ? formatJsonDetails('Structured details', payload) : '',
+                                formatJsonDetails('Structured details', payload),
                                 hctx.formatRemainingProtocolSteps(),
                             ].filter(Boolean).join('\n\n'),
                         }],

package/dist/cli/cleanup.js

@@ -1,22 +1,15 @@
 /**
  * nexus cleanup — bound the growth of worktree + runs directories.
  *
- * Different from `uninstall`: this never touches persistent state. It enforces
- * TTL / count / bytes budgets over transient scratch dirs so local disk usage
- * can't balloon without an operator noticing.
- *
- * Defaults chosen to be loose enough that a busy day of work doesn't trip them:
- *   - TTL:       12h per worktree, 6h per run
- *   - maxCount:  32 worktrees, 64 runs
- *   - maxBytes:  2 GiB across worktrees, 1 GiB across runs
- *
- * Override with env: NEXUS_WORKTREE_TTL_MS, NEXUS_WORKTREE_MAX_COUNT,
- * NEXUS_WORKTREE_MAX_BYTES, NEXUS_RUNS_TTL_MS, NEXUS_RUNS_MAX_COUNT,
- * NEXUS_RUNS_MAX_BYTES.
+ * This never touches durable memory. It enforces aggressive defaults because
+ * transient Nexus state must never surprise users with 10GB+ growth. Heavy
+ * artifacts can still be retained by raising env budgets explicitly.
  */
+import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { formatBytes, sweepDirectory, sweepOrphanWorktrees, } from '../install/fs-purge.js';
-import { getNexusStateDir, getWorktreeRoots, getRuntimeTmpRoots, } from '../install/state-locator.js';
+import { getNexusStateDir, getWorktreeRoots, getRuntimeTmpRoots, NEXUS_TMP_GLOB_PREFIXES, } from '../install/state-locator.js';
 function parseIntEnv(name, fallback) {
     const raw = process.env[name];
     const parsed = Number.parseInt(raw ?? '', 10);
@@ -24,18 +17,42 @@ function parseIntEnv(name, fallback) {
 }
 export function resolveWorktreeBudget() {
     return {
-        ttlMs: parseIntEnv('NEXUS_WORKTREE_TTL_MS', 12 * 60 * 60 * 1000),
-        maxCount: parseIntEnv('NEXUS_WORKTREE_MAX_COUNT', 32),
-        maxBytes: parseIntEnv('NEXUS_WORKTREE_MAX_BYTES', 2 * 1024 * 1024 * 1024),
+        ttlMs: parseIntEnv('NEXUS_WORKTREE_TTL_MS', 60 * 60 * 1000),
+        maxCount: parseIntEnv('NEXUS_WORKTREE_MAX_COUNT', 8),
+        maxBytes: parseIntEnv('NEXUS_WORKTREE_MAX_BYTES', 512 * 1024 * 1024),
     };
 }
 export function resolveRunsBudget() {
     return {
-        ttlMs: parseIntEnv('NEXUS_RUNS_TTL_MS', 6 * 60 * 60 * 1000),
-        maxCount: parseIntEnv('NEXUS_RUNS_MAX_COUNT', 64),
-        maxBytes: parseIntEnv('NEXUS_RUNS_MAX_BYTES', 1024 * 1024 * 1024),
+        ttlMs: parseIntEnv('NEXUS_RUNS_TTL_MS', 30 * 60 * 1000),
+        maxCount: parseIntEnv('NEXUS_RUNS_MAX_COUNT', 16),
+        maxBytes: parseIntEnv('NEXUS_RUNS_MAX_BYTES', 256 * 1024 * 1024),
     };
 }
+function collectLegacyTmpRoots() {
+    const tmpRoot = os.tmpdir();
+    let entries = [];
+    try {
+        entries = fs.readdirSync(tmpRoot);
+    }
+    catch {
+        return [];
+    }
+    const roots = new Set();
+    for (const entry of entries) {
+        if (!NEXUS_TMP_GLOB_PREFIXES.some((prefix) => entry.startsWith(prefix)))
+            continue;
+        const fullPath = path.join(tmpRoot, entry);
+        try {
+            if (fs.statSync(fullPath).isDirectory())
+                roots.add(fullPath);
+        }
+        catch {
+            // ignore races with concurrently removed tmp dirs
+        }
+    }
+    return [...roots].sort();
+}
 export async function runCleanup(options) {
     const dryRun = options.dryRun || !options.fix;
     const repoRoot = options.repoRoot ?? process.cwd();
@@ -51,7 +68,6 @@ export async function runCleanup(options) {
     };
     const label = dryRun ? '[dry-run]' : '[cleanup]';
     console.log(`\n${label} Nexus cleanup — repo: ${repoRoot}`);
-    // Worktree roots
     for (const root of getWorktreeRoots()) {
         const sweep = sweepDirectory(root, {
             maxAgeMs: worktreeBudget.ttlMs,
@@ -65,6 +81,7 @@ export async function runCleanup(options) {
         report.totalEntriesRemoved += sweep.removed.length;
         if (sweep.entriesBefore > 0 || sweep.removed.length > 0) {
             console.log(`  worktree: ${root}`);
+            console.log(`    budget: ttl=${Math.round(worktreeBudget.ttlMs / 60000)}m, max=${worktreeBudget.maxCount}, bytes=${formatBytes(worktreeBudget.maxBytes)}`);
             console.log(`    before: ${sweep.entriesBefore} entries, ${formatBytes(sweep.totalBytesBefore)}`);
             console.log(`    removed: ${sweep.removed.length} entries, ${formatBytes(sweep.removed.reduce((s, r) => s + r.bytes, 0))}`);
             for (const r of sweep.removed) {
@@ -72,8 +89,12 @@ export async function runCleanup(options) {
             }
         }
     }
-    // Runs roots
-    for (const root of [path.join(getNexusStateDir(), 'runs'), ...getRuntimeTmpRoots()]) {
+    const runsRoots = new Set([
+        path.join(getNexusStateDir(), 'runs'),
+        ...getRuntimeTmpRoots(),
+        ...collectLegacyTmpRoots(),
+    ]);
+    for (const root of runsRoots) {
         const sweep = sweepDirectory(root, {
             maxAgeMs: runsBudget.ttlMs,
             maxCount: runsBudget.maxCount,
@@ -86,11 +107,11 @@ export async function runCleanup(options) {
         report.totalEntriesRemoved += sweep.removed.length;
         if (sweep.entriesBefore > 0 || sweep.removed.length > 0) {
             console.log(`  runs: ${root}`);
+            console.log(`    budget: ttl=${Math.round(runsBudget.ttlMs / 60000)}m, max=${runsBudget.maxCount}, bytes=${formatBytes(runsBudget.maxBytes)}`);
             console.log(`    before: ${sweep.entriesBefore} entries, ${formatBytes(sweep.totalBytesBefore)}`);
             console.log(`    removed: ${sweep.removed.length} entries, ${formatBytes(sweep.removed.reduce((s, r) => s + r.bytes, 0))}`);
         }
     }
-    // Orphan worktrees (dir exists on disk but `git worktree list` forgot about it)
     try {
         const orphanReport = await sweepOrphanWorktrees(repoRoot, { dryRun });
         report.orphans.paths = orphanReport.ops.filter((op) => op.kind !== 'missing').map((op) => op.path);

package/dist/cli/uninstall.d.ts

@@ -2,17 +2,12 @@ import { loadManifest } from '../install/manifest.js';
 import { type StopAllNexusProcessesOptions } from '../install/process-cleanup.js';
 export interface UninstallOptions {
     dryRun: boolean;
-    /** Stop daemons and unregister all known clients. Accepted for CLI clarity; uninstall already does this by default. */
     all?: boolean;
-    /** Preferred purge flag. */
     purge?: boolean;
-    /** Back-compat alias for purge. */
     purgeAll?: boolean;
     yes: boolean;
     workspaceRoot?: string;
-    /** Skip interactive prompt in tests. */
     _forceYes?: boolean;
-    /** Test-only process cleanup injection; production callers should not set this. */
     _processCleanup?: StopAllNexusProcessesOptions;
 }
 export interface UninstallReport {

package/dist/cli/uninstall.js

@@ -1,14 +1,10 @@
 /**
  * nexus uninstall — reverse every mutation Nexus Prime made to this machine.
  *
- * `--dry-run`   walks the install manifest + heuristics and prints what would
- *               happen without touching anything.
- * `--purge`     additionally removes persistent state (memory.db, synapse.db,
- *               architects.db, logs, caches, worktrees). Requires `--yes`.
- *
- * The manifest is authoritative where present. Heuristics fill the gap when
- * the manifest is missing (e.g. legacy installs). Every destructive step has
- * a dry-run preview, and leftovers are always reported.
+ * `--dry-run` walks registrations, processes, markers, and filesystem paths.
+ * Default uninstall unregisters clients, stops processes, clears markers, removes
+ * transient scratch, and clears the install manifest. `--purge` also deletes
+ * durable state such as memory, Synapse, Architects, logs, caches, and worktrees.
  */
 import * as fs from 'fs';
 import * as readline from 'readline';
@@ -73,7 +69,6 @@ export async function runUninstall(options) {
     }
     const label = dryRun ? '[dry-run]' : '[uninstall]';
     console.log(`\n${label} Nexus Prime uninstall — workspace: ${workspaceRoot}`);
-    // Step 1 — reverse IDE registrations before stopping processes so clients do not immediately respawn MCP sessions.
     const manifest = loadManifest();
     const unregisterReport = unregisterNexusRegistrations({ workspaceRoot, dryRun, manifest });
     const removedRegs = unregisterReport.reports.filter((r) => r.removed);
@@ -83,13 +78,11 @@ export async function runUninstall(options) {
     for (const r of removedRegs) {
         console.log(`      - ${r.filePath} :: ${r.jsonPath.join('.') || '(root)'}`);
     }
-    // Step 2 — stop Nexus MCP/daemon processes and remove lockfiles.
     const processReport = await stopAllNexusProcesses({ ...options._processCleanup, dryRun });
     report.daemonsKilled = processReport.daemonsKilled;
     report.lockfilesRemoved = processReport.lockfilesRemoved;
     report.errors.push(...processReport.errors);
     console.log(`  ${dryRun ? '◦' : '✓'} processes: ${report.daemonsKilled} process(es), ${report.lockfilesRemoved} lockfile(s)`);
-    // Step 3 — remove setup markers.
     const markers = new Set([setupMarkerPath, ...manifest.setupMarkers]);
     for (const marker of markers) {
         if (!fs.existsSync(marker))
@@ -107,7 +100,6 @@ export async function runUninstall(options) {
             }
         }
     }
-    // Step 4 — purge filesystem artifacts.
     const extras = manifest.paths.map((e) => ({ path: e.path, scope: e.scope }));
     let stateReport = null;
     let tmpReport = null;
@@ -116,7 +108,6 @@ export async function runUninstall(options) {
         tmpReport = purgeTmpRoots({ dryRun });
     }
     else {
-        // Default (no --purge-all): only transient tmp dirs. Persistent state stays.
         tmpReport = purgeTmpRoots({ dryRun });
     }
     const totals = [stateReport, tmpReport]
@@ -137,11 +128,9 @@ export async function runUninstall(options) {
             console.log(`      - ${op.path}  (${formatBytes(op.bytes)})`);
         }
     }
-    // Step 5 — final manifest clear, but only on full uninstall, not dry-run.
-    if (!dryRun && purgeAll) {
+    if (!dryRun) {
         clearManifest(installManifestPath);
     }
-    // Step 6 — leftover audit.
     report.leftovers = collectLeftovers(nexusStateDir);
     if (report.leftovers.length > 0) {
         console.log(`  ! leftovers (still present in state dir):`);
@@ -156,7 +145,8 @@ export async function runUninstall(options) {
     report.ok = report.errors.length === 0 && (dryRun || (purgeAll ? report.leftovers.length === 0 : true));
     console.log(`\n${label} done. ${report.ok ? 'OK' : 'completed with issues'}.`);
     if (!purgeAll && !dryRun) {
-        console.log('  Persistent state preserved. Re-run with --purge --yes to remove everything.');
+        console.log('  Persistent memory preserved. All registrations, processes, manifest, and transient scratch were removed.');
+        console.log('  Re-run with --purge --yes to delete durable memory/Synapse/Architects state too.');
     }
     return report;
 }

package/dist/engines/runtime-hygiene.js

@@ -6,7 +6,7 @@ import { SessionDNAManager } from './session-dna.js';
 import { clearBootstrapReceipt, readBootstrapReceipt } from './bootstrap/bootstrap-registry.js';
 import { doctorGitWorktrees } from './worktree-health.js';
 import { sweepDirectory, sweepOrphanWorktrees } from '../install/fs-purge.js';
-import { getWorktreeRoots } from '../install/state-locator.js';
+import { getRuntimeTmpRoots, getWorktreeRoots } from '../install/state-locator.js';
 import { resolveWorktreeBudget, resolveRunsBudget } from '../cli/cleanup.js';
 function isOlderThan(target, maxAgeMs) {
     try {
@@ -59,15 +59,12 @@ function cleanupTmpDirEntries(rootDir, opts) {
 export async function runStartupHygiene(input) {
     const mode = input.mode ?? 'stale';
     const stateDir = resolveNexusStateDir();
-    // 1) Runtime registry snapshots (dashboard + operators) — safe to prune stale/dead entries.
     const registryDir = path.join(stateDir, 'runtime-registry');
     const registryBefore = fs.existsSync(registryDir) ? fs.readdirSync(registryDir).filter((f) => f.endsWith('.json')).length : 0;
     const registry = new RuntimeRegistry(stateDir);
     registry.pruneStalePublic();
     const registryAfter = fs.existsSync(registryDir) ? fs.readdirSync(registryDir).filter((f) => f.endsWith('.json')).length : 0;
-    // 2) SessionDNA stale locks + orphan session JSONs (best-effort).
     const cleanedSessionLocks = SessionDNAManager.cleanStale(path.join(stateDir, 'sessions'));
-    // 3) Bootstrap receipt — safe to clear when stale/invalid (never deletes installed configs).
     let clearedBootstrapReceipt = false;
     if (mode === 'fresh') {
         clearBootstrapReceipt(input.workspaceStateRoot);
@@ -75,40 +72,32 @@ export async function runStartupHygiene(input) {
     }
     else {
         const receipt = readBootstrapReceipt(input.workspaceStateRoot);
-        // If the receipt is stale or corrupt, readBootstrapReceipt returns null; clear the file to avoid confusing future probes.
         if (receipt === null) {
             clearBootstrapReceipt(input.workspaceStateRoot);
             clearedBootstrapReceipt = true;
         }
     }
-    // 4) Git worktree metadata — only prunes Nexus-owned broken/stale entries.
     let worktreeDoctorOverall;
     try {
         const health = await doctorGitWorktrees(input.repoRoot);
         worktreeDoctorOverall = health.overall;
     }
     catch {
-        // ignore — hygiene must not block startup
+        // hygiene must not block startup
     }
-    // 5) Temp artifacts (transient only). Never touches memory DB / vault.
     const tmpDir = os.tmpdir();
-    const maxAgeMs = 2 * 60 * 60 * 1000;
+    const maxAgeMs = mode === 'fresh' ? 0 : 30 * 60 * 1000;
     let cleanedTmpEntries = 0;
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-runs'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-worktrees'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-runtime-skills'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-runtime-workflows'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-runtime-hooks'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-runtime-automations'), { mode, maxAgeMs });
-    cleanedTmpEntries += cleanupTmpDirEntries(path.join(tmpDir, 'nexus-prime-sessions'), { mode, maxAgeMs });
+    const transientRoots = [...getRuntimeTmpRoots(), ...getWorktreeRoots()];
+    for (const root of transientRoots) {
+        cleanedTmpEntries += cleanupTmpDirEntries(root, { mode, maxAgeMs });
+    }
     cleanedTmpEntries += cleanupTmpDirEntries(tmpDir, { mode, maxAgeMs, matchPrefix: 'nexus-prime-feature-registry-' });
+    cleanedTmpEntries += cleanupTmpDirEntries(tmpDir, { mode, maxAgeMs, matchPrefix: 'nexus-reset-test-' });
     if (mode === 'fresh') {
-        // Optional fresh wipe of purely transient runtime UI/event buffers.
         cleanedTmpEntries += safeUnlink(path.join(stateDir, 'events.jsonl')) ? 1 : 0;
         cleanedTmpEntries += safeUnlink(path.join(stateDir, 'dashboard-state.json')) ? 1 : 0;
     }
-    // 6) Bounded worktree sweep — enforce TTL / count / bytes budgets so growth
-    //    stays bounded even when users never run `nexus cleanup`.
     const worktreeBudget = resolveWorktreeBudget();
     let boundedWorktreeSweeps = 0;
     for (const root of getWorktreeRoots()) {
@@ -123,34 +112,33 @@ export async function runStartupHygiene(input) {
             boundedWorktreeSweeps += sweep.removed.length;
         }
         catch {
-            // sweep is best-effort
+            // best-effort
         }
     }
-    // 7) Orphan worktree sweep — dirs exist on disk but git forgot them.
     let orphanWorktreesRemoved = 0;
     try {
         const orphans = await sweepOrphanWorktrees(input.repoRoot, { dryRun: false });
         orphanWorktreesRemoved = orphans.ops.filter((op) => op.removed).length;
     }
     catch {
-        // ignore — orphan sweep must not block startup
+        // ignore
     }
-    // 8) Bounded runs sweep.
     const runsBudget = resolveRunsBudget();
     let boundedRunsSweeps = 0;
-    try {
-        const runsRoot = path.join(input.workspaceStateRoot, 'runs');
-        const sweep = sweepDirectory(runsRoot, {
-            maxAgeMs: runsBudget.ttlMs,
-            maxCount: runsBudget.maxCount,
-            maxBytes: runsBudget.maxBytes,
-            dryRun: false,
-            keepRoot: true,
-        });
-        boundedRunsSweeps += sweep.removed.length;
-    }
-    catch {
-        // best-effort
+    for (const runsRoot of [path.join(input.workspaceStateRoot, 'runs'), ...getRuntimeTmpRoots()]) {
+        try {
+            const sweep = sweepDirectory(runsRoot, {
+                maxAgeMs: runsBudget.ttlMs,
+                maxCount: runsBudget.maxCount,
+                maxBytes: runsBudget.maxBytes,
+                dryRun: false,
+                keepRoot: true,
+            });
+            boundedRunsSweeps += sweep.removed.length;
+        }
+        catch {
+            // best-effort
+        }
     }
     return {
         mode,

package/dist/install/process-cleanup.js

@@ -1,9 +1,11 @@
 /**
  * process-cleanup — stop every Nexus-owned process without touching anything else.
  *
- * Wraps `runPostinstallCleanup` (which handles the per-workspace daemon lock)
- * and adds a final scan for lockfiles across the entire state dir in case a
- * workspace-local daemon was started from a now-deleted path.
+ * Wraps lockfile cleanup and adds a process-table sweep for legacy launch
+ * shapes. Older installs can be started by npx/npm, by MCP clients as
+ * `node .../dist/index.js`, or by dashboard/daemon commands that never wrote a
+ * current lockfile. Uninstall must catch all of those, otherwise users think
+ * Nexus was removed while stale workers keep writing state.
  */
 import * as fs from 'fs';
 import { spawnSync } from 'child_process';
@@ -36,30 +38,43 @@ export function killProcessTree(pid) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function normalizeCommand(command) {
+    return command.replace(/\s+/g, ' ').trim();
+}
+function looksLikeNexusEntrypoint(command) {
+    const normalized = normalizeCommand(command);
+    return /\bnexus-prime(?:\s|$)/.test(normalized)
+        || /(?:^|[\s"'])npx(?:\.cmd)?(?:\s+--yes)?\s+nexus-prime(?:\s|$)/.test(normalized)
+        || /(?:^|[\s"'])npm(?:\.cmd)?\s+(?:exec|x)\s+(?:--\s+)?nexus-prime(?:\s|$)/.test(normalized)
+        || /[\\/]nexus-prime[\\/](?:dist[\\/])?(?:index|cli)\.js(?:\s|$)/.test(normalized)
+        || /[\\/]node_modules[\\/]\.bin[\\/]nexus-prime(?:\s|$)/.test(normalized);
+}
+function isBenignNexusCommand(command) {
+    const normalized = normalizeCommand(command);
+    return /\b(npm|pnpm|yarn)\s+(?:install|add|remove|uninstall|view|info|show)\b/.test(normalized)
+        || /\b(vitest|jest|tsc|tsx)\b.*\bsrc[\\/]install[\\/]process-cleanup\.ts\b/.test(normalized);
+}
 function isNexusProcessCommand(command) {
-    return /\bnexus-prime(?:\s|$)/.test(command)
-        && (/\bmcp(?:\s|$)/.test(command)
-            || /\bdaemon\s+__serve(?:\s|$)/.test(command));
+    const normalized = normalizeCommand(command);
+    if (!looksLikeNexusEntrypoint(normalized) || isBenignNexusCommand(normalized))
+        return false;
+    // Runtime surfaces that can keep writing state / holding dashboard ports.
+    if (/\b(mcp|daemon\s+__serve|dashboard|server|serve|start|orchestrate|bootstrap)\b/.test(normalized)) {
+        return true;
+    }
+    // MCP clients often launch the compiled entrypoint without a visible subcommand.
+    return /[\\/]nexus-prime[\\/]dist[\\/](?:index|cli)\.js(?:\s|$)/.test(normalized)
+        || /[\\/]node_modules[\\/]\.bin[\\/]nexus-prime(?:\s|$)/.test(normalized);
 }
-export function listNexusProcessPids() {
-    if (process.platform === 'win32') {
-        return [];
-    }
-    const result = spawnSync('ps', ['-axo', 'pid=,command='], {
-        encoding: 'utf8',
-        timeout: 5_000,
-    });
-    if (result.status !== 0) {
-        return [];
-    }
+function parseProcessLines(stdout) {
     const candidates = [];
-    for (const line of (result.stdout ?? '').split(/\r?\n/)) {
-        const match = line.match(/^\s*(\d+)\s+(.+)$/);
+    for (const line of (stdout ?? '').split(/\r?\n/)) {
+        const match = line.match(/^\s*(\d+)\s+(.+)$/) ?? line.match(/^\s*(\d+)\t(.+)$/);
         if (!match)
             continue;
         const pid = Number(match[1]);
         const command = match[2];
-        if (pid === process.pid || !Number.isInteger(pid) || pid <= 0)
+        if (pid === process.pid || pid === process.ppid || !Number.isInteger(pid) || pid <= 1)
             continue;
         if (!isNexusProcessCommand(command))
             continue;
@@ -67,6 +82,28 @@ export function listNexusProcessPids() {
     }
     return candidates;
 }
+export function listNexusProcessPids() {
+    if (process.platform === 'win32') {
+        const result = spawnSync('powershell.exe', [
+            '-NoProfile',
+            '-Command',
+            "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'nexus-prime|nexus-prime.*dist|node_modules.*nexus-prime' } | ForEach-Object { \"$($_.ProcessId)`t$($_.CommandLine)\" }",
+        ], {
+            encoding: 'utf8',
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return result.status === 0 ? parseProcessLines(result.stdout ?? '') : [];
+    }
+    const result = spawnSync('ps', ['-axo', 'pid=,command='], {
+        encoding: 'utf8',
+        timeout: 5_000,
+    });
+    if (result.status !== 0) {
+        return [];
+    }
+    return parseProcessLines(result.stdout ?? '');
+}
 async function stopPid(pid, options) {
     if (options.dryRun) {
         return { stopped: true };

package/package.json

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