@neat.is/core 0.4.17 → 0.4.18

package/dist/cli.cjs

@@ -58,9 +58,9 @@ function mountBearerAuth(app, opts) {
   const suffixes = [...DEFAULT_UNAUTH_SUFFIXES, ...opts.extraUnauthenticatedSuffixes ?? []];
   const publicRead = opts.publicRead === true;
   app.addHook("preHandler", (req, reply, done) => {
-    const path51 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
+    const path53 = (req.url.split("?")[0] ?? "").replace(/\/+$/, "");
     for (const suffix of suffixes) {
-      if (path51 === suffix || path51.endsWith(suffix)) {
+      if (path53 === suffix || path53.endsWith(suffix)) {
         done();
         return;
       }
@@ -474,8 +474,10 @@ async function buildOtelReceiver(opts) {
     for (const s of spans) projectQueue.push({ project, span: s });
     projectDrainPromise = projectDrainPromise.then(() => drainProject());
   };
+  const offersProjectRouting = opts.onProjectSpan !== void 0;
   const legacyEndpointWarned = /* @__PURE__ */ new Set();
   function warnLegacyEndpoint(serviceName) {
+    if (!offersProjectRouting) return;
     if (legacyEndpointWarned.has(serviceName)) return;
     legacyEndpointWarned.add(serviceName);
     console.warn(
@@ -611,8 +613,8 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
-var import_node_path50 = __toESM(require("path"), 1);
-var import_node_fs32 = require("fs");
+var import_node_path52 = __toESM(require("path"), 1);
+var import_node_fs34 = require("fs");
 
 // src/banner.ts
 init_cjs_shims();
@@ -1177,19 +1179,19 @@ function confidenceFromMix(edges, now = Date.now()) {
 function longestIncomingWalk(graph, start, maxDepth) {
   let best = { path: [start], edges: [] };
   const visited = /* @__PURE__ */ new Set([start]);
-  function step(node, path51, edges) {
-    if (path51.length > best.path.length) {
-      best = { path: [...path51], edges: [...edges] };
+  function step(node, path53, edges) {
+    if (path53.length > best.path.length) {
+      best = { path: [...path53], edges: [...edges] };
     }
-    if (path51.length - 1 >= maxDepth) return;
+    if (path53.length - 1 >= maxDepth) return;
     const incoming = bestEdgeBySource(graph, graph.inboundEdges(node));
     for (const [srcId, edge] of incoming) {
       if (visited.has(srcId)) continue;
       visited.add(srcId);
-      path51.push(srcId);
+      path53.push(srcId);
       edges.push(edge);
-      step(srcId, path51, edges);
-      path51.pop();
+      step(srcId, path53, edges);
+      path53.pop();
       edges.pop();
       visited.delete(srcId);
     }
@@ -6259,6 +6261,111 @@ function registryLockPath() {
 function daemonPidPath() {
   return import_node_path40.default.join(neatHome(), "neatd.pid");
 }
+function daemonsDir() {
+  return import_node_path40.default.join(neatHome(), "daemons");
+}
+function isFiniteInt(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function parseDaemonRecord(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof obj !== "object" || obj === null) return void 0;
+  const r = obj;
+  const ports = r.ports;
+  if (typeof r.project !== "string" || typeof r.projectPath !== "string" || !isFiniteInt(r.pid) || r.status !== "running" && r.status !== "stopped" || typeof r.startedAt !== "string" || typeof r.neatVersion !== "string" || !ports || !isFiniteInt(ports.rest) || !isFiniteInt(ports.otlp) || !isFiniteInt(ports.web)) {
+    return void 0;
+  }
+  return {
+    project: r.project,
+    projectPath: r.projectPath,
+    pid: r.pid,
+    status: r.status,
+    ports: { rest: ports.rest, otlp: ports.otlp, web: ports.web },
+    startedAt: r.startedAt,
+    neatVersion: r.neatVersion
+  };
+}
+var defaultDiscoveryProbe = { isPidAlive: isPidAliveDefault };
+async function discoverDaemons(probe = defaultDiscoveryProbe) {
+  const dir = daemonsDir();
+  let names;
+  try {
+    names = await import_node_fs25.promises.readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const file = import_node_path40.default.join(dir, name);
+    let raw;
+    try {
+      raw = await import_node_fs25.promises.readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    const record = parseDaemonRecord(raw);
+    if (!record) continue;
+    const live = record.status === "running" && probe.isPidAlive(record.pid);
+    out.push({ record, live, source: file });
+  }
+  out.sort((a, b) => a.record.project.localeCompare(b.record.project));
+  return out;
+}
+async function removeDaemonRecord(source) {
+  await import_node_fs25.promises.unlink(source).catch(() => {
+  });
+}
+async function listMachineProjects(probe = defaultDiscoveryProbe) {
+  const discovered = await discoverDaemons(probe);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const d of discovered) {
+    const key = await normalizeProjectPath(d.record.projectPath);
+    byPath.set(key, {
+      project: d.record.project,
+      projectPath: d.record.projectPath,
+      state: d.live ? "running" : "stopped",
+      ports: d.record.ports,
+      pid: d.record.pid
+    });
+  }
+  let legacy = [];
+  try {
+    legacy = (await readRegistry()).projects;
+  } catch {
+    legacy = [];
+  }
+  for (const entry2 of legacy) {
+    const key = await normalizeProjectPath(entry2.path);
+    if (byPath.has(key)) continue;
+    byPath.set(key, {
+      project: entry2.name,
+      projectPath: entry2.path,
+      state: "registered",
+      registryStatus: entry2.status
+    });
+  }
+  return [...byPath.values()].sort((a, b) => a.project.localeCompare(b.project));
+}
+async function findDaemonByProject(name, probe = defaultDiscoveryProbe) {
+  const discovered = await discoverDaemons(probe);
+  return discovered.find((d) => d.record.project === name);
+}
+function signalDaemonStop(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch (err) {
+    if (err.code === "ESRCH") return false;
+    throw err;
+  }
+}
 function isPidAliveDefault(pid) {
   try {
     process.kill(pid, 0);
@@ -7994,9 +8101,50 @@ var import_semver2 = __toESM(require("semver"), 1);
 // src/installers/templates.ts
 init_cjs_shims();
 var OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-069). OpenTelemetry auto-instrumentation hook.";
-var OTEL_INIT_STAMP = "// neat-template-version: 5 \u2014 layered file-first capture (ADR-090) + http/json protocol pin (#468).";
+var OTEL_INIT_STAMP = "// neat-template-version: 6 \u2014 daemon.json endpoint resolution (ADR-096) + layered file-first capture (ADR-090).";
 var OTEL_OTLP_HEADERS_JS = "if (process.env.NEAT_OTEL_TOKEN) process.env.OTEL_EXPORTER_OTLP_HEADERS ||= 'Authorization=Bearer ' + process.env.NEAT_OTEL_TOKEN";
 var OTEL_OTLP_PROTOCOL_JS = "process.env.OTEL_EXPORTER_OTLP_PROTOCOL ||= 'http/json'";
+var OTEL_ENDPOINT_RESOLVER_CJS = `;(function () {
+  try {
+    if (process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return
+    const __neatFs = require('node:fs')
+    const __neatPath = require('node:path')
+    let __neatDir = process.cwd()
+    for (let __i = 0; __i < 8; __i++) {
+      try {
+        const __rec = JSON.parse(__neatFs.readFileSync(__neatPath.join(__neatDir, 'neat-out', 'daemon.json'), 'utf8'))
+        if (__rec && __rec.ports && typeof __rec.ports.otlp === 'number') {
+          process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = 'http://localhost:' + __rec.ports.otlp + '/v1/traces'
+          break
+        }
+      } catch (_e) {}
+      const __parent = __neatPath.dirname(__neatDir)
+      if (__parent === __neatDir) break
+      __neatDir = __parent
+    }
+  } catch (_e) {}
+  process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/v1/traces'
+})()`;
+var OTEL_ESM_NODE_IMPORTS = "import { readFileSync as __neatReadFileSync } from 'node:fs'\nimport { join as __neatJoin, dirname as __neatDirname } from 'node:path'";
+var OTEL_ENDPOINT_RESOLVER_ESM = `;(function () {
+  try {
+    if (process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return
+    let __neatDir = process.cwd()
+    for (let __i = 0; __i < 8; __i++) {
+      try {
+        const __rec = JSON.parse(__neatReadFileSync(__neatJoin(__neatDir, 'neat-out', 'daemon.json'), 'utf8'))
+        if (__rec && __rec.ports && typeof __rec.ports.otlp === 'number') {
+          process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = 'http://localhost:' + __rec.ports.otlp + '/v1/traces'
+          break
+        }
+      } catch (_e) {}
+      const __parent = __neatDirname(__neatDir)
+      if (__parent === __neatDir) break
+      __neatDir = __parent
+    }
+  } catch (_e) {}
+  process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/v1/traces'
+})()`;
 function neatCaptureSource(ts) {
   const spanT = ts ? ": any" : "";
   const strOpt = ts ? ": string | undefined" : "";
@@ -8285,7 +8433,7 @@ try {
 var OTEL_INIT_CJS = `${OTEL_INIT_HEADER}
 ${OTEL_INIT_STAMP}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_CJS}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8303,8 +8451,9 @@ ${neatWireCaptureSource(false)}
 `;
 var OTEL_INIT_ESM = `${OTEL_INIT_HEADER}
 ${OTEL_INIT_STAMP}
+${OTEL_ESM_NODE_IMPORTS}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8327,8 +8476,9 @@ ${OTEL_INIT_STAMP}
 // strict user tsconfig would reject; suppressing type-checking here keeps the
 // generated file from breaking the host project's \`tsc\` gate (#427) without
 // constraining the runtime logic. The file is regenerated, never hand-edited.
+${OTEL_ESM_NODE_IMPORTS}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8350,11 +8500,14 @@ ${registrations.join("\n")}
 `;
   return template.replace(/__SERVICE_NAME__/g, serviceName).replace(/__PROJECT__/g, projectName).replace(/__INSTRUMENTATION_BLOCK__\n?/g, block);
 }
-function renderEnvNeat(serviceName, projectName) {
+function renderEnvNeat(serviceName, _projectName) {
   return [
     "# Generated by `neat init --apply` (ADR-069).",
     `OTEL_SERVICE_NAME=${serviceName}`,
-    `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/projects/${projectName}/v1/traces`,
+    "# Advisory only \u2014 the generated otel-init resolves the live endpoint from",
+    "# <project>/neat-out/daemon.json (ports.otlp) at boot (ADR-096). This is the",
+    "# canonical default the daemon takes when its first-choice OTLP port is free.",
+    "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces",
     "OTEL_EXPORTER_OTLP_PROTOCOL=http/json",
     "# Set NEAT_OTEL_TOKEN to the daemon's OTLP secret to authenticate exported spans (#410).",
     "# NEAT_OTEL_TOKEN=",
@@ -8377,8 +8530,9 @@ export async function register() {
 }
 `;
 var NEXT_INSTRUMENTATION_NODE_TS = `${NEXT_INSTRUMENTATION_HEADER}
+${OTEL_ESM_NODE_IMPORTS}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8391,7 +8545,7 @@ new NodeSDK({ instrumentations }).start()
 `;
 var NEXT_INSTRUMENTATION_NODE_JS = `${NEXT_INSTRUMENTATION_HEADER}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_CJS}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8410,8 +8564,9 @@ ${registrations.join("\n")}
 }
 var FRAMEWORK_OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-074). OpenTelemetry SDK hook.";
 var FRAMEWORK_OTEL_INIT_TS_BODY = `${FRAMEWORK_OTEL_INIT_HEADER}
+${OTEL_ESM_NODE_IMPORTS}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_ESM}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -8426,7 +8581,7 @@ sdk.start()
 `;
 var FRAMEWORK_OTEL_INIT_JS_BODY = `${FRAMEWORK_OTEL_INIT_HEADER}
 process.env.OTEL_SERVICE_NAME ||= '__SERVICE_NAME__'
-process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||= 'http://localhost:4318/projects/__PROJECT__/v1/traces'
+${OTEL_ENDPOINT_RESOLVER_CJS}
 ${OTEL_OTLP_PROTOCOL_JS}
 ${OTEL_OTLP_HEADERS_JS}
 
@@ -9895,19 +10050,51 @@ function renderPatch(sections) {
 
 // src/orchestrator.ts
 init_cjs_shims();
-var import_node_fs31 = require("fs");
+var import_node_fs33 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_net = __toESM(require("net"), 1);
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_path50 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_readline = __toESM(require("readline"), 1);
+
+// src/daemon.ts
+init_cjs_shims();
+var import_node_fs32 = require("fs");
+var import_node_path49 = __toESM(require("path"), 1);
+var import_node_module = require("module");
+init_otel();
+init_auth();
+
+// src/unrouted.ts
+init_cjs_shims();
+var import_node_fs31 = require("fs");
+var import_node_path48 = __toESM(require("path"), 1);
+
+// src/daemon.ts
+function daemonJsonPath(scanPath) {
+  return import_node_path49.default.join(scanPath, "neat-out", "daemon.json");
+}
+async function readDaemonRecord(scanPath) {
+  try {
+    const raw = await import_node_fs32.promises.readFile(daemonJsonPath(scanPath), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.project === "string" && parsed.ports && typeof parsed.ports.rest === "number" && typeof parsed.ports.otlp === "number" && typeof parsed.ports.web === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/orchestrator.ts
 async function extractAndPersist(opts) {
   const services = await discoverServices(opts.scanPath);
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
   const graphKey = opts.projectExplicit ? opts.project : DEFAULT_PROJECT;
   resetGraph(graphKey);
   const graph = getGraph(graphKey);
-  const projectPaths = pathsForProject(graphKey, import_node_path48.default.join(opts.scanPath, "neat-out"));
+  const projectPaths = pathsForProject(graphKey, import_node_path50.default.join(opts.scanPath, "neat-out"));
   const extraction = await extractFromDirectory(graph, opts.scanPath, {
     errorsPath: projectPaths.errorsPath
   });
@@ -9961,7 +10148,7 @@ async function applyInstallersOver(services, project, options = {}) {
       console.log(`skipping ${svc.dir}: browser bundle; browser-OTel support lands in a future release.`);
     } else if (outcome.outcome === "react-native") {
       reactNative++;
-      const svcName = import_node_path48.default.basename(svc.dir);
+      const svcName = import_node_path50.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as React Native / Expo
   The installer doesn't cover this runtime deterministically.
@@ -9972,7 +10159,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "bun") {
       bun++;
-      const svcName = import_node_path48.default.basename(svc.dir);
+      const svcName = import_node_path50.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Bun
   The installer doesn't cover this runtime deterministically.
@@ -9983,7 +10170,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "deno") {
       deno++;
-      const svcName = import_node_path48.default.basename(svc.dir);
+      const svcName = import_node_path50.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Deno
   The installer doesn't cover this runtime deterministically.
@@ -9994,7 +10181,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "cloudflare-workers") {
       cloudflareWorkers++;
-      const svcName = import_node_path48.default.basename(svc.dir);
+      const svcName = import_node_path50.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Cloudflare Workers
   The installer doesn't cover this runtime deterministically.
@@ -10005,7 +10192,7 @@ async function applyInstallersOver(services, project, options = {}) {
       );
     } else if (outcome.outcome === "electron") {
       electron++;
-      const svcName = import_node_path48.default.basename(svc.dir);
+      const svcName = import_node_path50.default.basename(svc.dir);
       console.log(
         `neat: ${svc.dir} detected as Electron
   The installer doesn't cover this runtime deterministically.
@@ -10086,10 +10273,6 @@ async function fetchDaemonHealth(restPort) {
     });
   });
 }
-async function checkDaemonHealth(restPort) {
-  const body = await fetchDaemonHealth(restPort);
-  return body !== null;
-}
 async function probeProjectHealth(restPort, name) {
   return new Promise((resolve) => {
     const req = import_node_http.default.get(
@@ -10165,12 +10348,6 @@ async function isPortFree(port) {
     server.listen(port, "127.0.0.1");
   });
 }
-async function probePortsFree() {
-  for (const port of NEAT_PORTS) {
-    if (!await isPortFree(port)) return { free: false, held: port };
-  }
-  return { free: true };
-}
 function formatPortCollisionMessage(port) {
   return [
     `neat: port ${port} is in use; the NEAT daemon needs it.`,
@@ -10178,11 +10355,82 @@ function formatPortCollisionMessage(port) {
     `      \`lsof -i :${port}\` to find the holding process.`
   ];
 }
-function spawnDaemonDetached() {
-  const here = import_node_path48.default.dirname(new URL(importMetaUrl).pathname);
+var PORT_ALLOCATION_ATTEMPTS = 8;
+var PORT_STRIDE = 1;
+async function tripleFree(ports) {
+  for (const p of [ports.rest, ports.otlp, ports.web]) {
+    if (!await isPortFree(p)) return false;
+  }
+  return true;
+}
+async function allocatePorts() {
+  const [baseRest, baseOtlp, baseWeb] = NEAT_PORTS;
+  for (let i = 0; i < PORT_ALLOCATION_ATTEMPTS; i++) {
+    const candidate = {
+      rest: baseRest + i * PORT_STRIDE,
+      otlp: baseOtlp + i * PORT_STRIDE,
+      web: baseWeb + i * PORT_STRIDE
+    };
+    if (await tripleFree(candidate)) return candidate;
+  }
+  return null;
+}
+async function persistedPortsFor(scanPath) {
+  const record = await readDaemonRecord(scanPath);
+  if (!record) return null;
+  return { rest: record.ports.rest, otlp: record.ports.otlp, web: record.ports.web };
+}
+async function acquireSpawnLock(scanPath) {
+  const lockPath = import_node_path50.default.join(scanPath, "neat-out", "daemon.spawn.lock");
+  await import_node_fs33.promises.mkdir(import_node_path50.default.dirname(lockPath), { recursive: true });
+  const STALE_LOCK_MS = 6e4;
+  try {
+    const fd = await import_node_fs33.promises.open(lockPath, "wx");
+    await fd.writeFile(`${process.pid}
+`, "utf8");
+    await fd.close();
+    return async () => {
+      await import_node_fs33.promises.unlink(lockPath).catch(() => {
+      });
+    };
+  } catch (err) {
+    if (err.code !== "EEXIST") return null;
+    try {
+      const stat = await import_node_fs33.promises.stat(lockPath);
+      if (Date.now() - stat.mtimeMs > STALE_LOCK_MS) {
+        await import_node_fs33.promises.unlink(lockPath).catch(() => {
+        });
+        return acquireSpawnLock(scanPath);
+      }
+    } catch {
+      return acquireSpawnLock(scanPath);
+    }
+    return null;
+  }
+}
+async function waitForPeerDaemon(restPort, project, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await healthIsForProject(restPort, project)) return true;
+    await new Promise((r) => setTimeout(r, PROBE_INTERVAL_MS));
+  }
+  return healthIsForProject(restPort, project);
+}
+async function healthIsForProject(restPort, project) {
+  const body = await fetchDaemonHealth(restPort);
+  if (body === null) return false;
+  const named = body.project;
+  if (typeof named === "string") return named === project;
+  if (Array.isArray(body.projects)) {
+    return body.projects.some((p) => p.name === project);
+  }
+  return false;
+}
+function spawnDaemonDetached(spec) {
+  const here = import_node_path50.default.dirname(new URL(importMetaUrl).pathname);
   const candidates = [
-    import_node_path48.default.join(here, "neatd.cjs"),
-    import_node_path48.default.join(here, "neatd.js")
+    import_node_path50.default.join(here, "neatd.cjs"),
+    import_node_path50.default.join(here, "neatd.js")
   ];
   let entry2 = null;
   const fsSync = require("fs");
@@ -10202,6 +10450,13 @@ function spawnDaemonDetached() {
   if (!hasToken && (!env.HOST || env.HOST.length === 0)) {
     env.HOST = "127.0.0.1";
   }
+  if (spec) {
+    env.NEAT_PROJECT = spec.project;
+    env.NEAT_PROJECT_PATH = spec.projectPath;
+    env.PORT = String(spec.ports.rest);
+    env.OTEL_PORT = String(spec.ports.otlp);
+    env.NEAT_WEB_PORT = String(spec.ports.web);
+  }
   const child = (0, import_node_child_process3.spawn)(process.execPath, [entry2, "start"], {
     detached: true,
     // stderr inherits the orchestrator's fd so the daemon's
@@ -10240,7 +10495,7 @@ async function runOrchestrator(opts) {
       browser: "skipped"
     }
   };
-  const stat = await import_node_fs31.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs33.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat: ${opts.scanPath} is not a directory`);
     result.exitCode = 2;
@@ -10321,48 +10576,75 @@ async function runOrchestrator(opts) {
       result.exitCode = 1;
     }
   }
-  const restPort = Number(process.env.PORT ?? 8080);
   const timeoutMs = opts.daemonReadyTimeoutMs ?? DEFAULT_DAEMON_READY_TIMEOUT_MS;
-  if (await checkDaemonHealth(restPort)) {
+  const persistedPorts = await persistedPortsFor(opts.scanPath);
+  let allocated = null;
+  if (persistedPorts && await healthIsForProject(persistedPorts.rest, currentProjectName)) {
     result.steps.daemon = "already-running";
+    allocated = persistedPorts;
   } else {
-    const probe = await probePortsFree();
-    if (!probe.free) {
-      for (const line of formatPortCollisionMessage(probe.held)) {
+    if (persistedPorts && await isPortFree(persistedPorts.rest) && await tripleFree(persistedPorts)) {
+      allocated = persistedPorts;
+    } else {
+      allocated = await allocatePorts();
+    }
+    if (!allocated) {
+      for (const line of formatPortCollisionMessage(NEAT_PORTS[0])) {
         console.error(line);
       }
       result.exitCode = 3;
       return result;
     }
-    try {
-      spawnDaemonDetached();
-    } catch (err) {
-      console.error(`neat: daemon spawn failed \u2014 ${err.message}`);
-      result.exitCode = 1;
-      return result;
-    }
-    const ready = await waitForDaemonReady(restPort, timeoutMs);
-    result.steps.daemon = ready.ready ? "spawned" : "timed-out";
-    if (!ready.ready) {
-      console.error(`neat: daemon did not become ready within ${timeoutMs}ms`);
-      if (ready.stillBootstrapping.length > 0) {
-        console.error(
-          `neat: still bootstrapping: ${ready.stillBootstrapping.join(", ")}`
-        );
+    const release = await acquireSpawnLock(opts.scanPath);
+    if (!release) {
+      const reused = await waitForPeerDaemon(allocated.rest, currentProjectName, timeoutMs);
+      if (reused) {
+        result.steps.daemon = "already-running";
+      } else {
+        console.error("neat: another `neat` is spawning this project but its daemon did not come up in time");
+        result.exitCode = 1;
+        return result;
       }
-      if (ready.brokenProjects.length > 0) {
-        console.error(`neat: broken projects: ${ready.brokenProjects.join(", ")}`);
+    } else {
+      try {
+        if (await healthIsForProject(allocated.rest, currentProjectName)) {
+          result.steps.daemon = "already-running";
+        } else {
+          spawnDaemonDetached({
+            project: currentProjectName,
+            projectPath: opts.scanPath,
+            ports: allocated
+          });
+          const ready = await waitForDaemonReady(allocated.rest, timeoutMs);
+          result.steps.daemon = ready.ready ? "spawned" : "timed-out";
+          if (!ready.ready) {
+            console.error(`neat: daemon did not become ready within ${timeoutMs}ms`);
+            if (ready.stillBootstrapping.length > 0) {
+              console.error(`neat: still bootstrapping: ${ready.stillBootstrapping.join(", ")}`);
+            }
+            if (ready.brokenProjects.length > 0) {
+              console.error(`neat: broken projects: ${ready.brokenProjects.join(", ")}`);
+            }
+            result.exitCode = 1;
+            return result;
+          }
+          if (ready.brokenProjects.length > 0) {
+            console.warn(
+              `neat: ${ready.brokenProjects.length} project(s) reported broken: ${ready.brokenProjects.join(", ")}`
+            );
+          }
+        }
+      } catch (err) {
+        console.error(`neat: daemon spawn failed \u2014 ${err.message}`);
+        result.exitCode = 1;
+        return result;
+      } finally {
+        await release();
       }
-      result.exitCode = 1;
-      return result;
-    }
-    if (ready.brokenProjects.length > 0) {
-      console.warn(
-        `neat: ${ready.brokenProjects.length} project(s) reported broken: ${ready.brokenProjects.join(", ")}`
-      );
     }
   }
-  const dashboardUrl = opts.dashboardUrl ?? "http://localhost:6328";
+  const webPort = allocated?.web ?? NEAT_PORTS[2];
+  const dashboardUrl = opts.dashboardUrl ?? `http://localhost:${webPort}`;
   if (opts.noOpen || !process.stdout.isTTY) {
     result.steps.browser = "skipped";
   } else {
@@ -10397,7 +10679,7 @@ function printSummary(result, graph, dashboardUrl) {
 
 // src/cli-verbs.ts
 init_cjs_shims();
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 
 // src/cli-client.ts
 init_cjs_shims();
@@ -10426,10 +10708,10 @@ function createHttpClient(baseUrl, bearerToken) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path51) {
+    async get(path53) {
       let res;
       try {
-        res = await fetch(`${root}${path51}`, {
+        res = await fetch(`${root}${path53}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -10441,16 +10723,16 @@ function createHttpClient(baseUrl, bearerToken) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path51}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path53}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path51, body) {
+    async post(path53, body) {
       let res;
       try {
-        res = await fetch(`${root}${path51}`, {
+        res = await fetch(`${root}${path53}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -10464,7 +10746,7 @@ function createHttpClient(baseUrl, bearerToken) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path51}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path53}: ${text}`,
           text
         );
       }
@@ -10478,12 +10760,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path51 = projectPath(
+  const path53 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path51);
+    const result = await client.get(path53);
     const arrowPath = result.traversalPath.join(" \u2190 ");
     const provenances = result.edgeProvenances.length ? result.edgeProvenances.join(", ") : "(direct, no edges traversed)";
     const summary = `Root cause for ${input.errorNode} is ${result.rootCauseNode}. ` + result.rootCauseReason + (result.fixRecommendation ? ` Recommended fix: ${result.fixRecommendation}.` : "");
@@ -10509,12 +10791,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path51 = projectPath(
+  const path53 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path51);
+    const result = await client.get(path53);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no downstream dependencies. Nothing else would break if it failed.`
@@ -10548,12 +10830,12 @@ function formatBlastEntry(n) {
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path51 = projectPath(
+  const path53 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path51);
+    const result = await client.get(path53);
     if (result.total === 0) {
       return {
         summary: depth === 1 ? `${input.nodeId} has no direct dependencies in the graph.` : `${input.nodeId} has no dependencies (BFS to depth ${depth}).`
@@ -10634,9 +10916,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path51 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path53 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path51);
+    const body = await client.get(path53);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -10926,13 +11208,13 @@ async function resolveProjectEntry(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const resolvedCwd = await normalizeProjectPath(cwd);
   for (const entry2 of entries) {
-    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path49.default.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${import_node_path51.default.sep}`)) {
       return entry2;
     }
   }
   return null;
 }
-async function checkDaemonHealth2(baseUrl) {
+async function checkDaemonHealth(baseUrl) {
   try {
     const res = await fetch(`${baseUrl.replace(/\/$/, "")}/health`, {
       signal: AbortSignal.timeout(1500)
@@ -11033,7 +11315,7 @@ async function runSync(opts) {
       }
     } else {
       const daemonUrl = opts.daemonUrl ?? process.env.NEAT_API_URL ?? "http://localhost:8080";
-      const healthy = await checkDaemonHealth2(daemonUrl);
+      const healthy = await checkDaemonHealth(daemonUrl);
       if (healthy) {
         try {
           await pushSnapshotToRemote({
@@ -11107,11 +11389,15 @@ function usage() {
   console.log("  watch <path>   Start neat-core, watch <path>, re-extract on changes.");
   console.log("                 PORT (default 8080), OTEL_PORT (4318), HOST (0.0.0.0)");
   console.log("                 control listeners. NEAT_OTLP_GRPC=true also opens 4317.");
-  console.log("  list           List every project registered in the machine-level registry.");
-  console.log("  pause <name>   Mark a project paused \u2014 daemon stops watching until resumed.");
-  console.log("  resume <name>  Mark a project active again.");
+  console.log("  list           Report the daemons running on this machine (alias: ps).");
+  console.log("                 Reads ~/.neat/daemons/ and folds in any registered");
+  console.log("                 project no daemon has self-described yet.");
+  console.log("  ps             Alias of list.");
+  console.log("  pause <name>   Stop a project's daemon until it is started again.");
+  console.log("  resume <name>  Bring a paused project back; for a stopped daemon, re-run");
+  console.log("                 `neat <path>` to start it.");
   console.log("  uninstall <name>");
-  console.log("                 Remove a project from the registry. Does not touch");
+  console.log("                 Stop a project's daemon and retire it. Does not touch");
   console.log("                 neat-out/, policy.json, or any user file.");
   console.log("  prune          Drop registry entries whose path is gone from disk.");
   console.log("                 Flags: --json   emit the removed list as JSON");
@@ -11308,6 +11594,14 @@ function printVersion() {
   process.stdout.write(`${readPackageVersion()}
 `);
 }
+function formatMachineProjectRow(r) {
+  if (r.ports) {
+    const where = r.pid !== void 0 ? `	pid=${r.pid}` : "";
+    return `${r.project}	${r.state}	rest=${r.ports.rest} otlp=${r.ports.otlp} web=${r.ports.web}	${r.projectPath}${where}`;
+  }
+  const status2 = r.registryStatus ? `	(${r.registryStatus})` : "";
+  return `${r.project}	${r.state}${status2}	${r.projectPath}`;
+}
 function printDiscoveryReport(opts, services) {
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
   const mode = opts.dryRun ? "dry-run" : opts.apply ? "apply" : "patch-only";
@@ -11346,7 +11640,7 @@ async function buildPatchSections(services, project) {
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await import_node_fs32.promises.stat(opts.scanPath).catch(() => null);
+  const stat = await import_node_fs34.promises.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat init: ${opts.scanPath} is not a directory`);
     return { exitCode: 2, writtenFiles: written };
@@ -11355,13 +11649,13 @@ async function runInit(opts) {
   printDiscoveryReport(opts, services);
   const sections = opts.noInstall ? [] : await buildPatchSections(services, opts.project);
   const patch = renderPatch(sections);
-  const patchPath = import_node_path50.default.join(opts.scanPath, "neat.patch");
+  const patchPath = import_node_path52.default.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await import_node_fs32.promises.writeFile(patchPath, patch, "utf8");
+    await import_node_fs34.promises.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = import_node_path50.default.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await import_node_fs32.promises.stat(gitignorePath).then(() => true).catch(() => false);
+    const gitignorePath = import_node_path52.default.join(opts.scanPath, ".gitignore");
+    const gitignoreExists = await import_node_fs34.promises.stat(gitignorePath).then(() => true).catch(() => false);
     const verb = gitignoreExists ? "append" : "create";
     console.log(`dry-run: would ${verb} ${gitignorePath} (add neat-out/)`);
     console.log("rerun without --dry-run to register and snapshot.");
@@ -11372,9 +11666,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    import_node_path50.default.join(opts.scanPath, "neat-out")
+    import_node_path52.default.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = import_node_path50.default.join(import_node_path50.default.dirname(opts.outPath), import_node_path50.default.basename(projectPaths.errorsPath));
+  const errorsPath = import_node_path52.default.join(import_node_path52.default.dirname(opts.outPath), import_node_path52.default.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -11453,7 +11747,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await import_node_fs32.promises.writeFile(patchPath, patch, "utf8");
+      await import_node_fs34.promises.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -11493,9 +11787,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return import_node_path50.default.resolve(override);
+  if (override && override.length > 0) return import_node_path52.default.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return import_node_path50.default.join(home, ".claude.json");
+  return import_node_path52.default.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet2 = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -11507,7 +11801,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await import_node_fs32.promises.readFile(target, "utf8"));
+      existing = JSON.parse(await import_node_fs34.promises.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -11519,8 +11813,8 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await import_node_fs32.promises.mkdir(import_node_path50.default.dirname(target), { recursive: true });
-    await import_node_fs32.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await import_node_fs34.promises.mkdir(import_node_path52.default.dirname(target), { recursive: true });
+    await import_node_fs34.promises.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
     console.log(`neat skill: wrote mcpServers.neat to ${target}`);
     console.log("restart Claude Code to pick up the new MCP server.");
     return { exitCode: 0 };
@@ -11569,12 +11863,12 @@ async function main() {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = import_node_path50.default.resolve(target);
+    const scanPath = import_node_path52.default.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : import_node_path50.default.basename(scanPath);
+    const projectName = projectExplicit ? project : import_node_path52.default.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, import_node_path50.default.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = import_node_path50.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, import_node_path52.default.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = import_node_path52.default.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
@@ -11595,21 +11889,21 @@ async function main() {
       usage();
       process.exit(2);
     }
-    const scanPath = import_node_path50.default.resolve(target);
-    const stat = await import_node_fs32.promises.stat(scanPath).catch(() => null);
+    const scanPath = import_node_path52.default.resolve(target);
+    const stat = await import_node_fs34.promises.stat(scanPath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       console.error(`neat watch: ${scanPath} is not a directory`);
       process.exit(2);
     }
-    const projectPaths = pathsForProject(project, import_node_path50.default.join(scanPath, "neat-out"));
-    const outPath = import_node_path50.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = import_node_path50.default.resolve(
-      process.env.NEAT_ERRORS_PATH ?? import_node_path50.default.join(import_node_path50.default.dirname(outPath), import_node_path50.default.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, import_node_path52.default.join(scanPath, "neat-out"));
+    const outPath = import_node_path52.default.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = import_node_path52.default.resolve(
+      process.env.NEAT_ERRORS_PATH ?? import_node_path52.default.join(import_node_path52.default.dirname(outPath), import_node_path52.default.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = import_node_path50.default.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path50.default.join(import_node_path50.default.dirname(outPath), import_node_path50.default.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = import_node_path52.default.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? import_node_path52.default.join(import_node_path52.default.dirname(outPath), import_node_path52.default.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path50.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? import_node_path52.default.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -11636,16 +11930,14 @@ async function main() {
     process.on("SIGINT", shutdown);
     return;
   }
-  if (cmd === "list") {
-    const projects = await listProjects();
-    if (projects.length === 0) {
-      console.log("no projects registered. run `neat init <path>` to register one.");
+  if (cmd === "list" || cmd === "ps") {
+    const rows = await listMachineProjects();
+    if (rows.length === 0) {
+      console.log("no daemons running and no projects registered. run `neat init <path>` to register one.");
       return;
     }
-    for (const p of projects) {
-      const seen = p.lastSeenAt ? p.lastSeenAt : "never";
-      const langs = p.languages.length > 0 ? p.languages.join(",") : "-";
-      console.log(`${p.name}	${p.status}	${langs}	${p.path}	last-seen=${seen}`);
+    for (const r of rows) {
+      console.log(formatMachineProjectRow(r));
     }
     return;
   }
@@ -11656,6 +11948,15 @@ async function main() {
       usage();
       process.exit(2);
     }
+    const daemon = await findDaemonByProject(name);
+    if (daemon) {
+      if (daemon.live && signalDaemonStop(daemon.record.pid)) {
+        console.log(`paused: ${name} (${daemon.record.projectPath}) \u2014 stopped daemon pid ${daemon.record.pid}`);
+      } else {
+        console.log(`paused: ${name} (${daemon.record.projectPath}) \u2014 daemon was not running`);
+      }
+      return;
+    }
     try {
       const entry2 = await setStatus(name, "paused");
       console.log(`paused: ${entry2.name} (${entry2.path})`);
@@ -11672,6 +11973,15 @@ async function main() {
       usage();
       process.exit(2);
     }
+    const daemon = await findDaemonByProject(name);
+    if (daemon) {
+      if (daemon.live) {
+        console.log(`resume: ${name} (${daemon.record.projectPath}) \u2014 daemon already running`);
+      } else {
+        console.log(`resume: ${name} (${daemon.record.projectPath}) \u2014 run \`neat ${daemon.record.projectPath}\` to start its daemon again`);
+      }
+      return;
+    }
     try {
       const entry2 = await setStatus(name, "active");
       console.log(`resumed: ${entry2.name} (${entry2.path})`);
@@ -11693,12 +12003,20 @@ async function main() {
       usage();
       process.exit(2);
     }
+    const daemon = await findDaemonByProject(name);
     const removed = await removeProject(name);
-    if (!removed) {
+    if (!daemon && !removed) {
       console.error(`neat uninstall: no project named "${name}"`);
       process.exit(1);
     }
-    console.log(`unregistered: ${removed.name} (${removed.path})`);
+    const projectPath2 = daemon?.record.projectPath ?? removed?.path ?? "(unknown path)";
+    if (daemon) {
+      if (daemon.live && signalDaemonStop(daemon.record.pid)) {
+        console.log(`uninstall: ${name} \u2014 stopped daemon pid ${daemon.record.pid}`);
+      }
+      await removeDaemonRecord(daemon.source);
+    }
+    console.log(`unregistered: ${name} (${projectPath2})`);
     console.log("note: neat-out/, policy.json, and other files at the project path were left in place.");
     return;
   }
@@ -11768,11 +12086,11 @@ async function main() {
   process.exit(1);
 }
 async function tryOrchestrator(cmd, parsed) {
-  const scanPath = import_node_path50.default.resolve(cmd);
-  const stat = await import_node_fs32.promises.stat(scanPath).catch(() => null);
+  const scanPath = import_node_path52.default.resolve(cmd);
+  const stat = await import_node_fs34.promises.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : import_node_path50.default.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : import_node_path52.default.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,