@neat.is/core 0.4.17 → 0.4.19

package/dist/neatd.cjs

@@ -473,8 +473,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(
@@ -592,14 +594,15 @@ var init_otel = __esm({
 
 // src/neatd.ts
 init_cjs_shims();
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_path44 = __toESM(require("path"), 1);
-var import_node_module = require("module");
+var import_node_module2 = require("module");
 
 // src/daemon.ts
 init_cjs_shims();
 var import_node_fs25 = require("fs");
 var import_node_path42 = __toESM(require("path"), 1);
+var import_node_module = require("module");
 
 // src/graph.ts
 init_cjs_shims();
@@ -5208,7 +5211,9 @@ async function loadGraphFromDisk(graph, outPath) {
   graph.clear();
   graph.import(payload.graph);
 }
-function startPersistLoop(graph, outPath, intervalMs = 6e4) {
+function startPersistLoop(graph, outPath, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 6e4;
+  const exitOnSignal = opts.exitOnSignal ?? true;
   let stopped = false;
   const tick = async () => {
     if (stopped) return;
@@ -5221,7 +5226,7 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
   const interval = setInterval(() => {
     void tick();
   }, intervalMs);
-  const onSignal = (signal) => {
+  const onSignal = exitOnSignal ? (signal) => {
     void (async () => {
       try {
         await saveGraphToDisk(graph, outPath);
@@ -5231,14 +5236,18 @@ function startPersistLoop(graph, outPath, intervalMs = 6e4) {
         process.exit(0);
       }
     })();
-  };
-  process.on("SIGTERM", onSignal);
-  process.on("SIGINT", onSignal);
+  } : null;
+  if (onSignal) {
+    process.on("SIGTERM", onSignal);
+    process.on("SIGINT", onSignal);
+  }
   return () => {
     stopped = true;
     clearInterval(interval);
-    process.off("SIGTERM", onSignal);
-    process.off("SIGINT", onSignal);
+    if (onSignal) {
+      process.off("SIGTERM", onSignal);
+      process.off("SIGINT", onSignal);
+    }
   };
 }
 
@@ -6231,12 +6240,16 @@ function serializeGraph(graph) {
   });
   return { nodes, edges };
 }
-function projectFromReq(req2) {
+function projectFromReq(req2, singleProject) {
   const params = req2.params;
-  return params.project ?? DEFAULT_PROJECT;
+  const named = params.project;
+  if (singleProject) {
+    return named === void 0 || named === DEFAULT_PROJECT ? singleProject : named;
+  }
+  return named ?? DEFAULT_PROJECT;
 }
-function resolveProject(registry, req2, reply, bootstrap) {
-  const name = projectFromReq(req2);
+function resolveProject(registry, req2, reply, bootstrap, singleProject) {
+  const name = projectFromReq(req2, singleProject);
   const ctx = registry.get(name);
   if (!ctx) {
     const phase = bootstrap?.status(name);
@@ -6277,13 +6290,13 @@ function buildLegacyRegistry(opts) {
 function registerRoutes(scope, ctx) {
   const { registry, startedAt, errorsPathFor, staleEventsPathFor } = ctx;
   scope.get("/events", (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     handleSse(req2, reply, { project: proj.name });
   });
   if (ctx.scope === "project") {
     scope.get("/health", async (req2, reply) => {
-      const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+      const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const uptimeMs = Date.now() - startedAt;
       return {
@@ -6301,14 +6314,14 @@ function registerRoutes(scope, ctx) {
     });
   }
   scope.get("/graph", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     return serializeGraph(proj.graph);
   });
   scope.get(
     "/graph/node/:id",
     async (req2, reply) => {
-      const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+      const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const { id } = req2.params;
       if (!proj.graph.hasNode(id)) {
@@ -6320,7 +6333,7 @@ function registerRoutes(scope, ctx) {
   scope.get(
     "/graph/edges/:id",
     async (req2, reply) => {
-      const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+      const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const { id } = req2.params;
       if (!proj.graph.hasNode(id)) {
@@ -6332,7 +6345,7 @@ function registerRoutes(scope, ctx) {
     }
   );
   scope.get("/graph/dependencies/:nodeId", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const { nodeId } = req2.params;
     if (!proj.graph.hasNode(nodeId)) {
@@ -6347,7 +6360,7 @@ function registerRoutes(scope, ctx) {
     return getTransitiveDependencies(proj.graph, nodeId, depth);
   });
   scope.get("/graph/divergences", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     let typeFilter;
     if (req2.query.type) {
@@ -6382,7 +6395,7 @@ function registerRoutes(scope, ctx) {
     });
   });
   scope.get("/incidents", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const epath = errorsPathFor(proj);
     if (!epath) return { count: 0, total: 0, events: [] };
@@ -6394,7 +6407,7 @@ function registerRoutes(scope, ctx) {
     return { count: sliced.length, total, events: sliced };
   });
   scope.get("/stale-events", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const spath = staleEventsPathFor(proj);
     if (!spath) return { count: 0, total: 0, events: [] };
@@ -6409,7 +6422,7 @@ function registerRoutes(scope, ctx) {
   scope.get(
     "/incidents/:nodeId",
     async (req2, reply) => {
-      const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+      const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const { nodeId } = req2.params;
       if (!proj.graph.hasNode(nodeId)) {
@@ -6425,7 +6438,7 @@ function registerRoutes(scope, ctx) {
     }
   );
   scope.get("/graph/root-cause/:nodeId", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const { nodeId } = req2.params;
     if (!proj.graph.hasNode(nodeId)) {
@@ -6445,7 +6458,7 @@ function registerRoutes(scope, ctx) {
     return result;
   });
   scope.get("/graph/blast-radius/:nodeId", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const { nodeId } = req2.params;
     if (!proj.graph.hasNode(nodeId)) {
@@ -6458,7 +6471,7 @@ function registerRoutes(scope, ctx) {
     return getBlastRadius(proj.graph, nodeId, depth);
   });
   scope.get("/search", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const raw = (req2.query.q ?? "").trim();
     if (!raw) return reply.code(400).send({ error: "query parameter `q` is required" });
@@ -6489,7 +6502,7 @@ function registerRoutes(scope, ctx) {
   scope.get(
     "/graph/diff",
     async (req2, reply) => {
-      const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+      const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
       if (!proj) return;
       const against = req2.query.against;
       if (!against) {
@@ -6504,7 +6517,7 @@ function registerRoutes(scope, ctx) {
     }
   );
   scope.post("/snapshot", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const body = req2.body;
     if (!body || typeof body !== "object" || !body.snapshot) {
@@ -6533,7 +6546,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.post("/graph/scan", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6549,7 +6562,7 @@ function registerRoutes(scope, ctx) {
     };
   });
   scope.get("/policies", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const policyPath = ctx.policyFilePathFor(proj);
     if (!policyPath) {
@@ -6566,7 +6579,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.get("/policies/violations", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const log = new PolicyViolationsLog(proj.paths.policyViolationsPath);
     let violations = await log.readAll();
@@ -6586,7 +6599,7 @@ function registerRoutes(scope, ctx) {
     return { violations };
   });
   scope.post("/policies/check", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const parsed = import_types25.PoliciesCheckBodySchema.safeParse(req2.body ?? {});
     if (!parsed.success) {
@@ -6622,7 +6635,7 @@ function registerRoutes(scope, ctx) {
     };
   });
   scope.get("/extend/list-uninstrumented", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6635,7 +6648,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.get("/extend/lookup", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     const { library, version } = req2.query;
     if (!library) {
@@ -6648,7 +6661,7 @@ function registerRoutes(scope, ctx) {
     return result;
   });
   scope.get("/extend/describe", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6661,7 +6674,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.post("/extend/apply", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6681,7 +6694,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.post("/extend/dry-run", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6701,7 +6714,7 @@ function registerRoutes(scope, ctx) {
     }
   });
   scope.post("/extend/rollback", async (req2, reply) => {
-    const proj = resolveProject(registry, req2, reply, ctx.bootstrap);
+    const proj = resolveProject(registry, req2, reply, ctx.bootstrap, ctx.singleProject);
     if (!proj) return;
     if (!proj.scanPath) {
       return reply.code(409).send({ error: "scan path not configured for this project", project: proj.name });
@@ -6764,7 +6777,8 @@ async function buildApi(opts) {
     errorsPathFor,
     staleEventsPathFor,
     policyFilePathFor,
-    bootstrap: opts.bootstrap
+    bootstrap: opts.bootstrap,
+    singleProject: opts.singleProject?.name
   };
   app.get("/health", async () => {
     const uptimeMs = Date.now() - startedAt;
@@ -6787,10 +6801,29 @@ async function buildApi(opts) {
     return {
       ok: true,
       uptimeMs,
+      // ADR-096 §7 — a per-project daemon carries its project at the top level
+      // so a spawn can confirm a daemon found on a reused port is serving THIS
+      // project before reusing it. The legacy multi-project daemon omits it and
+      // is matched against the `projects` array instead.
+      ...opts.singleProject ? { project: opts.singleProject.name } : {},
       projects
     };
   });
   app.get("/projects", async (_req, reply) => {
+    if (opts.singleProject) {
+      const phase = opts.bootstrap?.status(opts.singleProject.name);
+      const entry2 = {
+        name: opts.singleProject.name,
+        path: opts.singleProject.path,
+        registeredAt: new Date(startedAt).toISOString(),
+        languages: [],
+        // The daemon is serving this project, so it's active unless its
+        // bootstrap broke. ('bootstrapping' still reads as active — the project
+        // is the one to land on; its graph route answers 503 until ready.)
+        status: phase === "broken" ? "broken" : "active"
+      };
+      return [entry2];
+    }
     try {
       return await listProjects();
     } catch (err) {
@@ -6850,6 +6883,59 @@ function unroutedErrorsPath(neatHome3) {
 }
 
 // src/daemon.ts
+function daemonJsonPath(scanPath) {
+  return import_node_path42.default.join(scanPath, "neat-out", "daemon.json");
+}
+function daemonsDiscoveryDir(home) {
+  const base = home && home.length > 0 ? home : neatHomeFromEnv();
+  return import_node_path42.default.join(base, "daemons");
+}
+function daemonDiscoveryPath(project, home) {
+  return import_node_path42.default.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
+}
+function sanitizeDiscoveryName(project) {
+  return project.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function neatHomeFromEnv() {
+  const env = process.env.NEAT_HOME;
+  if (env && env.length > 0) return import_node_path42.default.resolve(env);
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return import_node_path42.default.join(home, ".neat");
+}
+function resolveNeatVersion() {
+  if (process.env.NEAT_LOCAL_VERSION && process.env.NEAT_LOCAL_VERSION.length > 0) {
+    return process.env.NEAT_LOCAL_VERSION;
+  }
+  try {
+    const req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req2("../package.json");
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function writeDaemonRecord(record, home) {
+  const body = JSON.stringify(record, null, 2) + "\n";
+  await writeAtomically(daemonJsonPath(record.projectPath), body);
+  try {
+    await writeAtomically(daemonDiscoveryPath(record.project, home), body);
+  } catch (err) {
+    console.warn(
+      `neatd: could not write discovery copy for "${record.project}" \u2014 ${err.message}`
+    );
+  }
+}
+async function clearDaemonRecord(record, home) {
+  try {
+    const stopped = { ...record, status: "stopped" };
+    await writeAtomically(daemonJsonPath(record.projectPath), JSON.stringify(stopped, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    await import_node_fs25.promises.unlink(daemonDiscoveryPath(record.project, home));
+  } catch {
+  }
+}
 function teardownSlot(slot) {
   try {
     slot.stopPersist();
@@ -6931,7 +7017,7 @@ async function bootstrapProject(entry2) {
   const detachEvents = attachGraphToEventBus(graph, { project: entry2.name });
   try {
     await extractFromDirectory(graph, entry2.path);
-    const stopPersist = startPersistLoop(graph, outPath);
+    const stopPersist = startPersistLoop(graph, outPath, { exitOnSignal: false });
     await touchLastSeen(entry2.name).catch(() => {
     });
     return {
@@ -6966,6 +7052,23 @@ function resolveOtlpPort(opts) {
   }
   return 4318;
 }
+function resolveWebPort() {
+  const env = process.env.NEAT_WEB_PORT;
+  if (env && env.length > 0) {
+    const n = Number.parseInt(env, 10);
+    if (Number.isFinite(n)) return n;
+  }
+  return 6328;
+}
+function portFromListenAddress(address, fallback) {
+  try {
+    const port = new URL(address).port;
+    const n = Number.parseInt(port, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  } catch {
+  }
+  return fallback;
+}
 function resolveHost(opts, authTokenSet) {
   if (opts.host && opts.host.length > 0) return opts.host;
   const env = process.env.HOST;
@@ -6976,13 +7079,24 @@ function resolveHost(opts, authTokenSet) {
 async function startDaemon(opts = {}) {
   const home = neatHomeFor(opts);
   const regPath = registryPath();
-  try {
-    await import_node_fs25.promises.access(regPath);
-  } catch {
+  const projectArg = typeof opts.project === "string" && opts.project.length > 0 ? opts.project : process.env.NEAT_PROJECT && process.env.NEAT_PROJECT.length > 0 ? process.env.NEAT_PROJECT : null;
+  const projectPathArg = opts.projectPath && opts.projectPath.length > 0 ? opts.projectPath : process.env.NEAT_PROJECT_PATH && process.env.NEAT_PROJECT_PATH.length > 0 ? process.env.NEAT_PROJECT_PATH : null;
+  const singleProject = projectArg;
+  const singleProjectPath = singleProject && projectPathArg ? import_node_path42.default.resolve(projectPathArg) : null;
+  if (singleProject && !singleProjectPath) {
     throw new Error(
-      `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
+      `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
     );
   }
+  if (!singleProject) {
+    try {
+      await import_node_fs25.promises.access(regPath);
+    } catch {
+      throw new Error(
+        `neatd: registry not found at ${regPath}. Run \`neat init <path>\` to register a project before starting the daemon.`
+      );
+    }
+  }
   const pidPath = import_node_path42.default.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
@@ -7071,21 +7185,37 @@ async function startDaemon(opts = {}) {
       });
     }
   }
+  async function enumerateProjects() {
+    if (singleProject && singleProjectPath) {
+      return [
+        {
+          name: singleProject,
+          path: singleProjectPath,
+          registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          languages: [],
+          status: "active"
+        }
+      ];
+    }
+    return listProjects();
+  }
   async function loadAll() {
-    try {
-      const pruned = await pruneRegistry();
-      for (const entry2 of pruned) {
-        console.log(
-          `neatd: pruned project "${entry2.name}" \u2014 registered path ${entry2.path} is gone`
-        );
-        slots.delete(entry2.name);
-        bootstrapStatus.delete(entry2.name);
-        bootstrapStartedAt.delete(entry2.name);
+    if (!singleProject) {
+      try {
+        const pruned = await pruneRegistry();
+        for (const entry2 of pruned) {
+          console.log(
+            `neatd: pruned project "${entry2.name}" \u2014 registered path ${entry2.path} is gone`
+          );
+          slots.delete(entry2.name);
+          bootstrapStatus.delete(entry2.name);
+          bootstrapStartedAt.delete(entry2.name);
+        }
+      } catch (err) {
+        console.warn(`neatd: registry prune skipped \u2014 ${err.message}`);
       }
-    } catch (err) {
-      console.warn(`neatd: registry prune skipped \u2014 ${err.message}`);
     }
-    const projects = await listProjects();
+    const projects = await enumerateProjects();
     const seen = /* @__PURE__ */ new Set();
     const pending = [];
     for (const entry2 of projects) {
@@ -7110,7 +7240,7 @@ async function startDaemon(opts = {}) {
     }
     await Promise.allSettled(pending);
   }
-  const initialEntries = await listProjects().catch(() => []);
+  const initialEntries = await enumerateProjects().catch(() => []);
   for (const entry2 of initialEntries) {
     bootstrapStatus.set(entry2.name, "bootstrapping");
     bootstrapStartedAt.set(entry2.name, Date.now());
@@ -7120,6 +7250,7 @@ async function startDaemon(opts = {}) {
   let otlpApp = null;
   let restAddress = "";
   let otlpAddress = "";
+  let daemonRecord = null;
   if (bind) {
     const auth = readAuthEnv();
     const host = resolveHost(opts, Boolean(auth.authToken));
@@ -7142,7 +7273,13 @@ async function startDaemon(opts = {}) {
               elapsedMs: now - (bootstrapStartedAt.get(name) ?? now)
             }));
           }
-        }
+        },
+        // ADR-096 §4/§5/§7 — hand the daemon's identity to buildApi so the REST
+        // surface reflects "the daemon is the project": `GET /projects` reports
+        // only this project (the dashboard pins to it), and the daemon-wide
+        // `/health` carries it at the top level for the spawn-reuse identity
+        // check. Absent for the legacy multi-project daemon.
+        singleProject: singleProject && singleProjectPath ? { name: singleProject, path: singleProjectPath } : void 0
       });
       restAddress = await restApp.listen({ port: restPort, host });
       console.log(`neatd: REST listening on ${restAddress}`);
@@ -7159,6 +7296,25 @@ async function startDaemon(opts = {}) {
       );
     }
     async function resolveTargetSlot(serviceName, traceId) {
+      if (singleProject) {
+        let slot2 = slots.get(singleProject);
+        if (!slot2) {
+          slot2 = await tryRecoverSlot({
+            name: singleProject,
+            path: singleProjectPath,
+            registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            languages: [],
+            status: "active"
+          });
+        } else if (slot2.status === "broken") {
+          slot2 = await tryRecoverSlot(slot2.entry);
+        }
+        if (!slot2 || slot2.status !== "active") {
+          warnDroppedSpan(singleProject, slot2?.errorReason ?? "unknown");
+          return null;
+        }
+        return slot2;
+      }
       const liveEntries = await listProjects().catch(() => []);
       const target = routeSpanToProject(serviceName, liveEntries);
       let slot = slots.get(target) ?? slots.get(DEFAULT_PROJECT);
@@ -7261,6 +7417,42 @@ async function startDaemon(opts = {}) {
         `neatd: failed to bind OTLP on port ${otlpPort} \u2014 ${err.message}`
       );
     }
+    if (singleProject && singleProjectPath) {
+      const ports = {
+        rest: portFromListenAddress(restAddress, restPort),
+        otlp: portFromListenAddress(otlpAddress, otlpPort),
+        // The daemon doesn't bind the web port itself (neatd spawns the web
+        // child); it records the allocated value passed through so the
+        // dashboard and `neat ps` agree on where to look.
+        web: typeof opts.webPort === "number" ? opts.webPort : resolveWebPort()
+      };
+      daemonRecord = {
+        project: singleProject,
+        projectPath: singleProjectPath,
+        pid: process.pid,
+        status: "running",
+        ports,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        neatVersion: resolveNeatVersion()
+      };
+      try {
+        await writeDaemonRecord(daemonRecord, home);
+        console.log(
+          `neatd: project "${singleProject}" \u2192 REST ${ports.rest} / OTLP ${ports.otlp} / web ${ports.web} (daemon.json written)`
+        );
+      } catch (err) {
+        for (const slot of slots.values()) teardownSlot(slot);
+        if (restApp) await restApp.close().catch(() => {
+        });
+        if (otlpApp) await otlpApp.close().catch(() => {
+        });
+        await import_node_fs25.promises.unlink(pidPath).catch(() => {
+        });
+        throw new Error(
+          `neatd: failed to write daemon.json for "${singleProject}" \u2014 ${err.message}`
+        );
+      }
+    }
   }
   const initialBootstrap = loadAll().catch((err) => {
     console.warn(`neatd: initial bootstrap pass failed \u2014 ${err.message}`);
@@ -7300,7 +7492,7 @@ async function startDaemon(opts = {}) {
   const REGISTRY_RELOAD_DEBOUNCE_MS = 500;
   let registryWatcher = null;
   let reloadTimer = null;
-  try {
+  if (!singleProject) try {
     const regDir = import_node_path42.default.dirname(regPath);
     const regBase = import_node_path42.default.basename(regPath);
     registryWatcher = (0, import_node_fs25.watch)(regDir, (_eventType, filename) => {
@@ -7340,9 +7532,18 @@ async function startDaemon(opts = {}) {
     });
     if (restApp) await restApp.close().catch(() => {
     });
+    for (const slot of slots.values()) {
+      if (slot.status === "active" && slot.outPath) {
+        await saveGraphToDisk(slot.graph, slot.outPath).catch(() => {
+        });
+      }
+    }
     for (const slot of slots.values()) {
       teardownSlot(slot);
     }
+    if (daemonRecord) {
+      await clearDaemonRecord(daemonRecord, home);
+    }
     await import_node_fs25.promises.unlink(pidPath).catch(() => {
     });
   };
@@ -7354,7 +7555,8 @@ async function startDaemon(opts = {}) {
     restAddress,
     otlpAddress,
     bootstrap: tracker,
-    initialBootstrap
+    initialBootstrap,
+    daemonRecord
   };
 }
 
@@ -7364,9 +7566,40 @@ init_auth();
 // src/web-spawn.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
+var import_node_fs26 = require("fs");
 var import_node_net = __toESM(require("net"), 1);
 var import_node_path43 = __toESM(require("path"), 1);
 var DEFAULT_WEB_PORT = 6328;
+var DEFAULT_REST_PORT = 8080;
+function asValidPort(value) {
+  const n = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isInteger(n) && n > 0 && n <= 65535 ? n : null;
+}
+function projectRoot() {
+  const fromEnv = process.env.NEAT_SCAN_PATH;
+  return import_node_path43.default.resolve(fromEnv && fromEnv.length > 0 ? fromEnv : process.cwd());
+}
+async function readDaemonPorts(root) {
+  try {
+    const raw = await import_node_fs26.promises.readFile(import_node_path43.default.join(root, "neat-out", "daemon.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const ports = parsed?.ports ?? {};
+    return { web: asValidPort(ports.web), rest: asValidPort(ports.rest) };
+  } catch {
+    return { web: null, rest: null };
+  }
+}
+function resolveWebPorts(args) {
+  const { daemonWeb, daemonRest, webPortEnv, apiUrlEnv, restPortArg } = args;
+  const portFromEnv = webPortEnv && webPortEnv.length > 0 ? Number.parseInt(webPortEnv, 10) : null;
+  if (portFromEnv !== null && (!Number.isFinite(portFromEnv) || portFromEnv <= 0 || portFromEnv > 65535)) {
+    throw new Error(`neatd: invalid NEAT_WEB_PORT="${webPortEnv}"`);
+  }
+  const webPort = daemonWeb ?? portFromEnv ?? DEFAULT_WEB_PORT;
+  const restPort = daemonRest ?? asValidPort(restPortArg) ?? DEFAULT_REST_PORT;
+  const apiUrl = apiUrlEnv ?? `http://localhost:${restPort}`;
+  return { webPort, apiUrl };
+}
 async function assertPortFree(port) {
   await new Promise((resolve, reject) => {
     const tester = import_node_net.default.createServer();
@@ -7398,42 +7631,105 @@ function resolveWebPackageDir() {
 function resolveStandaloneServerEntry(webDir) {
   return import_node_path43.default.join(webDir, ".next/standalone/packages/web/server.js");
 }
-async function spawnWebUI(restPort) {
-  const portRaw = process.env.NEAT_WEB_PORT;
-  const port = portRaw && portRaw.length > 0 ? Number.parseInt(portRaw, 10) : DEFAULT_WEB_PORT;
-  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
-    throw new Error(`neatd: invalid NEAT_WEB_PORT="${portRaw}"`);
-  }
+async function pickInternalPort() {
+  return new Promise((resolve, reject) => {
+    const srv = import_node_net.default.createServer();
+    srv.once("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (addr && typeof addr === "object") {
+        const port = addr.port;
+        srv.close(() => resolve(port));
+      } else {
+        srv.close(() => reject(new Error("neatd: could not pick an internal web port")));
+      }
+    });
+  });
+}
+async function spawnWebUI(restPort, opts = {}) {
+  const root = projectRoot();
+  const fromDaemon = await readDaemonPorts(root);
+  const { webPort: port, apiUrl } = resolveWebPorts({
+    daemonWeb: fromDaemon.web,
+    daemonRest: fromDaemon.rest,
+    webPortEnv: process.env.NEAT_WEB_PORT,
+    apiUrlEnv: process.env.NEAT_API_URL,
+    restPortArg: restPort
+  });
   await assertPortFree(port);
-  const cwd = resolveWebPackageDir();
-  const serverEntry = resolveStandaloneServerEntry(cwd);
-  try {
-    require.resolve(serverEntry);
-  } catch {
-    throw new Error(
-      `neatd: web UI standalone build missing at ${serverEntry}. The published @neat.is/web tarball should include it; if you're running from a monorepo checkout, run \`npm run build --workspace @neat.is/web\` first, or set NEAT_WEB_DISABLED=1 to skip the web UI.`
-    );
+  const serverEntry = opts.serverEntry ?? resolveStandaloneServerEntry(resolveWebPackageDir());
+  if (!opts.skipBuildCheck) {
+    try {
+      require.resolve(serverEntry);
+    } catch {
+      throw new Error(
+        `neatd: web UI standalone build missing at ${serverEntry}. The published @neat.is/web tarball should include it; if you're running from a monorepo checkout, run \`npm run build --workspace @neat.is/web\` first, or set NEAT_WEB_DISABLED=1 to skip the web UI.`
+      );
+    }
   }
-  const env = {
-    ...process.env,
-    PORT: String(port),
-    HOSTNAME: process.env.HOSTNAME ?? "0.0.0.0",
-    NEAT_API_URL: process.env.NEAT_API_URL ?? `http://localhost:${restPort}`
-  };
-  const child = (0, import_node_child_process2.spawn)(process.execPath, [serverEntry], {
-    cwd: import_node_path43.default.dirname(serverEntry),
-    env,
-    stdio: ["ignore", "inherit", "inherit"],
-    detached: false
+  let child = null;
+  let internalPort = 0;
+  let starting = null;
+  let stopped = false;
+  function ensureStarted() {
+    if (starting) return starting;
+    starting = (async () => {
+      internalPort = await pickInternalPort();
+      const env = {
+        ...process.env,
+        PORT: String(internalPort),
+        HOSTNAME: "127.0.0.1",
+        NEAT_API_URL: apiUrl
+      };
+      child = (0, import_node_child_process2.spawn)(process.execPath, [serverEntry], {
+        cwd: import_node_path43.default.dirname(serverEntry),
+        env,
+        stdio: ["ignore", "inherit", "inherit"],
+        detached: false
+      });
+      child.on("error", (err) => {
+        console.error(`neatd: web UI spawn error \u2014 ${err.message}`);
+      });
+      await waitForListening(internalPort);
+      console.log(`neatd: web UI ready on http://localhost:${port}`);
+    })();
+    return starting;
+  }
+  const liveSockets = /* @__PURE__ */ new Set();
+  const front = import_node_net.default.createServer((socket) => {
+    liveSockets.add(socket);
+    socket.on("close", () => liveSockets.delete(socket));
+    socket.on("error", () => socket.destroy());
+    ensureStarted().then(() => {
+      if (stopped) {
+        socket.destroy();
+        return;
+      }
+      const upstream = import_node_net.default.connect(internalPort, "127.0.0.1");
+      upstream.on("error", () => socket.destroy());
+      socket.pipe(upstream);
+      upstream.pipe(socket);
+      socket.on("close", () => upstream.destroy());
+      upstream.on("close", () => socket.destroy());
+    }).catch((err) => {
+      console.error(`neatd: web UI failed to start \u2014 ${err.message}`);
+      socket.destroy();
+    });
   });
-  child.on("error", (err) => {
-    console.error(`neatd: web UI spawn error \u2014 ${err.message}`);
+  await new Promise((resolve, reject) => {
+    front.once("error", reject);
+    front.listen(port, "127.0.0.1", () => resolve());
   });
-  console.log(`neatd: web UI listening on http://localhost:${port}`);
-  let stopped = false;
+  console.log(`neatd: web UI listening on http://localhost:${port} (starts on first open)`);
   async function stop() {
-    if (stopped || !child.pid) return;
+    if (stopped) return;
     stopped = true;
+    await new Promise((resolve) => {
+      front.close(() => resolve());
+      for (const socket of liveSockets) socket.destroy();
+      liveSockets.clear();
+    });
+    if (!child || !child.pid) return;
     try {
       child.kill("SIGTERM");
     } catch {
@@ -7441,18 +7737,46 @@ async function spawnWebUI(restPort) {
     await new Promise((resolve) => {
       const t = setTimeout(() => {
         try {
-          child.kill("SIGKILL");
+          child?.kill("SIGKILL");
         } catch {
         }
         resolve();
       }, 3e3);
-      child.once("exit", () => {
+      child?.once("exit", () => {
         clearTimeout(t);
         resolve();
       });
     });
   }
-  return { child, port, stop };
+  return {
+    get child() {
+      return child;
+    },
+    port,
+    started: () => child !== null,
+    stop
+  };
+}
+async function waitForListening(port, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const ok = await new Promise((resolve) => {
+      const s = import_node_net.default.connect(port, "127.0.0.1");
+      s.once("connect", () => {
+        s.destroy();
+        resolve(true);
+      });
+      s.once("error", () => {
+        s.destroy();
+        resolve(false);
+      });
+    });
+    if (ok) return;
+    if (Date.now() > deadline) {
+      throw new Error(`neatd: web UI did not start listening on :${port} within ${timeoutMs}ms`);
+    }
+    await new Promise((r) => setTimeout(r, 150));
+  }
 }
 
 // src/version-skew.ts
@@ -7525,7 +7849,7 @@ function localVersion() {
     return process.env.NEAT_LOCAL_VERSION;
   }
   try {
-    const req2 = (0, import_node_module.createRequire)(importMetaUrl);
+    const req2 = (0, import_node_module2.createRequire)(importMetaUrl);
     const pkg = req2("../package.json");
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
@@ -7541,7 +7865,7 @@ function neatHome2() {
 }
 async function readPid() {
   try {
-    const raw = await import_node_fs26.promises.readFile(import_node_path44.default.join(neatHome2(), "neatd.pid"), "utf8");
+    const raw = await import_node_fs27.promises.readFile(import_node_path44.default.join(neatHome2(), "neatd.pid"), "utf8");
     const n = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(n) ? n : null;
   } catch {
@@ -7555,10 +7879,19 @@ function restPortFromEnv() {
   const raw = process.env.PORT;
   return raw && raw.length > 0 ? Number.parseInt(raw, 10) : 8080;
 }
+function webPortFromEnv() {
+  const raw = process.env.NEAT_WEB_PORT;
+  if (!raw || raw.length === 0) return void 0;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
 async function cmdStart() {
+  const project = process.env.NEAT_PROJECT;
+  const projectPath = process.env.NEAT_PROJECT_PATH;
+  const startOpts = project && project.length > 0 ? { project, projectPath, webPort: webPortFromEnv() } : {};
   let handle;
   try {
-    handle = await startDaemon();
+    handle = await startDaemon(startOpts);
   } catch (err) {
     if (err instanceof BindAuthorityError) {
       console.error(`neatd: ${err.message}`);