@neat.is/core 0.10.1 → 0.10.3-dev.20260930

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   resolveNeatVersion,
   startK8sSubstratePolling,
   writeDaemonRecord
-} from "./chunk-AWIK6T3G.js";
+} from "./chunk-DLQNMU3R.js";
 import {
   buildSearchIndex
 } from "./chunk-BC53SCT7.js";
@@ -17,6 +17,7 @@ import {
   PolicyViolationsLog,
   ProjectNameCollisionError,
   Projects,
+  RegistryError,
   SCHEMA_VERSION,
   addCallEdges,
   addConfigNodes,
@@ -42,9 +43,12 @@ import {
   evaluateAllPolicies,
   extractFromDirectory,
   findDaemonByProject,
+  findProjectByPath,
   formatExtractionBanner,
   formatPrecisionFloorBanner,
+  formatSkippedBanner,
   getGraph,
+  getProject,
   getProviderFieldSchema,
   isEnvRef,
   isPushProvider,
@@ -78,7 +82,7 @@ import {
   startStalenessLoop,
   upsertConnectorEntry,
   validateConnectorEntry
-} from "./chunk-E3YFFIHE.js";
+} from "./chunk-LNIVRE4L.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-5SJHA5ZH.js";
@@ -93,7 +97,7 @@ import {
 } from "./chunk-M7CGATVC.js";
 
 // src/cli.ts
-import path20 from "path";
+import path21 from "path";
 import os5 from "os";
 import { promises as fs18 } from "fs";
 
@@ -3937,6 +3941,20 @@ import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawn as spawn2 } from "child_process";
 import readline from "readline";
+var SnapshotWriteError = class extends Error {
+  constructor(scanPath, nodeCount, edgeCount, cause) {
+    super(`could not write the snapshot for ${scanPath}: ${cause.message}`);
+    this.scanPath = scanPath;
+    this.nodeCount = nodeCount;
+    this.edgeCount = edgeCount;
+    this.cause = cause;
+    this.name = "SnapshotWriteError";
+  }
+  scanPath;
+  nodeCount;
+  edgeCount;
+  cause;
+};
 async function extractAndPersist(opts) {
   const services = await discoverServices(opts.scanPath);
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
@@ -3948,7 +3966,11 @@ async function extractAndPersist(opts) {
     errorsPath: projectPaths.errorsPath
   });
   if (!opts.dryRun) {
-    await saveGraphToDisk(graph, projectPaths.snapshotPath);
+    try {
+      await saveGraphToDisk(graph, projectPaths.snapshotPath);
+    } catch (err) {
+      throw new SnapshotWriteError(opts.scanPath, graph.order, graph.size, err);
+    }
   }
   return {
     graph,
@@ -4186,9 +4208,15 @@ async function snapshotProjectStatus(restPort, project, body) {
   }
   return [{ name: project, status: await probeProjectHealth(restPort, project) }];
 }
-async function waitForDaemonReady(restPort, project, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let lastBootstrapping = [];
+var STILL_WAITING_INTERVAL_MS = 1e4;
+function daemonProgressLine(project, event) {
+  if (event.kind === "starting") return `starting the daemon for ${project}\u2026`;
+  return `still waiting for ${project}'s daemon (${Math.round(event.elapsedMs / 1e3)}s)`;
+}
+async function waitForDaemonReady(restPort, project, timeoutMs, onProgress, reminderIntervalMs = STILL_WAITING_INTERVAL_MS) {
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  let nextReminderAt = startedAt + reminderIntervalMs;
   while (Date.now() < deadline) {
     const body = await fetchDaemonHealth(restPort);
     if (body !== null) {
@@ -4198,15 +4226,10 @@ async function waitForDaemonReady(restPort, project, timeoutMs) {
       if (bootstrapping.length === 0) {
         return { ready: true, brokenProjects: broken, stillBootstrapping: [] };
       }
-      const key = bootstrapping.slice().sort().join(",");
-      const prevKey = lastBootstrapping.slice().sort().join(",");
-      if (key !== prevKey) {
-        const plural = bootstrapping.length === 1 ? "" : "s";
-        console.log(
-          `neat: waiting on ${bootstrapping.length} project${plural}: ${bootstrapping.join(", ")}`
-        );
-        lastBootstrapping = bootstrapping;
-      }
+    }
+    if (Date.now() >= nextReminderAt) {
+      onProgress?.({ kind: "waiting", elapsedMs: Date.now() - startedAt });
+      nextReminderAt += reminderIntervalMs;
     }
     await new Promise((r) => setTimeout(r, PROBE_INTERVAL_MS));
   }
@@ -4331,6 +4354,16 @@ async function healthIsForProject(restPort, project) {
 function daemonLogPath(projectPath3) {
   return path10.join(projectPath3, "neat-out", "daemon.log");
 }
+var DAEMON_LOG_TAIL_LINES = 12;
+async function readDaemonLogTail(projectPath3, maxLines = DAEMON_LOG_TAIL_LINES) {
+  try {
+    const raw = await fs9.readFile(daemonLogPath(projectPath3), "utf8");
+    const lines = raw.split(/\r?\n/).map((l) => l.trimEnd()).filter((l) => l.trim().length > 0);
+    return lines.slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
 function spawnDaemonDetached(spec) {
   const here = path10.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
@@ -4377,6 +4410,73 @@ function spawnDaemonDetached(spec) {
   if (logFd !== null) fsSync.closeSync(logFd);
   return child;
 }
+async function ensureProjectDaemon(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_DAEMON_READY_TIMEOUT_MS;
+  const bindHost = resolveHost(
+    {},
+    typeof process.env.NEAT_AUTH_TOKEN === "string" && process.env.NEAT_AUTH_TOKEN.length > 0
+  );
+  const persistedPorts = await persistedPortsFor(opts.projectPath);
+  if (persistedPorts && await healthIsForProject(persistedPorts.rest, opts.project)) {
+    return { status: "already-running", ports: persistedPorts };
+  }
+  let allocated;
+  if (persistedPorts && await isPortFree(persistedPorts.rest, bindHost) && await tripleFree(persistedPorts, bindHost)) {
+    allocated = persistedPorts;
+  } else {
+    allocated = await allocatePorts(bindHost);
+  }
+  if (!allocated) return { status: "no-ports" };
+  const release = await acquireSpawnLock(opts.projectPath);
+  if (!release) {
+    const reused = await waitForPeerDaemon(allocated.rest, opts.project, timeoutMs);
+    return reused ? { status: "already-running", ports: allocated } : { status: "peer-timeout" };
+  }
+  try {
+    if (await healthIsForProject(allocated.rest, opts.project)) {
+      return { status: "already-running", ports: allocated };
+    }
+    spawnDaemonDetached({
+      project: opts.project,
+      projectPath: opts.projectPath,
+      ports: allocated
+    });
+    opts.onProgress?.({ kind: "starting" });
+    const ready = await waitForDaemonReady(allocated.rest, opts.project, timeoutMs, opts.onProgress);
+    if (!ready.ready) {
+      return {
+        status: "timed-out",
+        ports: allocated,
+        stillBootstrapping: ready.stillBootstrapping,
+        brokenProjects: ready.brokenProjects
+      };
+    }
+    return { status: "spawned", ports: allocated, brokenProjects: ready.brokenProjects };
+  } catch (err) {
+    return { status: "spawn-failed", message: err.message };
+  } finally {
+    await release();
+  }
+}
+async function describeDaemonTimeout(outcome, projectPath3, timeoutMs) {
+  const lines = [`neat: daemon did not become ready within ${timeoutMs}ms`];
+  if (outcome.stillBootstrapping.length > 0) {
+    lines.push(`neat: still bootstrapping: ${outcome.stillBootstrapping.join(", ")}`);
+  }
+  if (outcome.brokenProjects.length > 0) {
+    lines.push(`neat: broken projects: ${outcome.brokenProjects.join(", ")}`);
+  }
+  const logPath = daemonLogPath(projectPath3);
+  const tail = await readDaemonLogTail(projectPath3);
+  if (tail.length > 0) {
+    lines.push("");
+    lines.push(`neat: the daemon's last words (${path10.relative(projectPath3, logPath)}):`);
+    for (const line of tail) lines.push(`  ${line}`);
+  } else {
+    lines.push(`neat: see ${logPath}`);
+  }
+  return lines;
+}
 function openBrowser(url) {
   if (!process.stdout.isTTY) return "failed";
   const platform = process.platform;
@@ -4410,14 +4510,26 @@ async function runOrchestrator(opts) {
     result.exitCode = 2;
     return result;
   }
-  printBanner();
+  if (!opts.skipBanner) printBanner();
   console.log(`neat: ${opts.scanPath}`);
   console.log("");
-  const persisted = await extractAndPersist({
-    scanPath: opts.scanPath,
-    project: opts.project,
-    projectExplicit: opts.projectExplicit
-  });
+  let persisted;
+  try {
+    persisted = await extractAndPersist({
+      scanPath: opts.scanPath,
+      project: opts.project,
+      projectExplicit: opts.projectExplicit
+    });
+  } catch (err) {
+    if (!(err instanceof SnapshotWriteError)) throw err;
+    console.error(`neat: extracted ${opts.scanPath}, but could not write the snapshot.`);
+    console.error(`neat: the graph came to ${err.nodeCount} nodes and ${err.edgeCount} edges \u2014 too large to save.`);
+    console.error(`neat: point neat at one project instead of a tree that holds many:`);
+    console.error(`neat:   npx neat.is <path-to-one-project>`);
+    console.error(`neat: cause: ${err.cause.message}`);
+    result.exitCode = 1;
+    return result;
+  }
   const { graph, services, languages } = persisted;
   result.steps.discovery = { services: services.length, languages };
   console.log(`discovered ${services.length} service(s) across ${languages.length} language(s)`);
@@ -4458,20 +4570,6 @@ async function runOrchestrator(opts) {
     result.exitCode = 1;
     return result;
   }
-  const siblings = await listProjects();
-  const paused = [];
-  for (const p of siblings) {
-    if (p.name !== currentProjectName && p.status === "active") {
-      await setStatus(p.name, "paused");
-      paused.push(p.name);
-    }
-  }
-  if (paused.length > 0) {
-    const plural = paused.length === 1 ? "" : "s";
-    console.log(
-      `neat: paused ${paused.length} sibling project${plural}; run \`neat resume <name>\` to bring one back active.`
-    );
-  }
   if (!runApply) {
     result.steps.apply.skipped = true;
     console.log("skipped instrumentation (--no-instrument)");
@@ -4487,75 +4585,46 @@ async function runOrchestrator(opts) {
     }
   }
   const timeoutMs = opts.daemonReadyTimeoutMs ?? DEFAULT_DAEMON_READY_TIMEOUT_MS;
-  const bindHost = resolveHost(
-    {},
-    typeof process.env.NEAT_AUTH_TOKEN === "string" && process.env.NEAT_AUTH_TOKEN.length > 0
-  );
-  const persistedPorts = await persistedPortsFor(opts.scanPath);
-  let allocated = null;
-  if (persistedPorts && await healthIsForProject(persistedPorts.rest, currentProjectName)) {
-    result.steps.daemon = "already-running";
-    allocated = persistedPorts;
-  } else {
-    if (persistedPorts && await isPortFree(persistedPorts.rest, bindHost) && await tripleFree(persistedPorts, bindHost)) {
-      allocated = persistedPorts;
-    } else {
-      allocated = await allocatePorts(bindHost);
-    }
-    if (!allocated) {
+  const outcome = await ensureProjectDaemon({
+    project: currentProjectName,
+    projectPath: opts.scanPath,
+    timeoutMs,
+    onProgress: (event) => console.log(`neat: ${daemonProgressLine(currentProjectName, event)}`)
+  });
+  const allocated = "ports" in outcome ? outcome.ports : null;
+  switch (outcome.status) {
+    case "already-running":
+      result.steps.daemon = "already-running";
+      break;
+    case "spawned":
+      result.steps.daemon = "spawned";
+      if (outcome.brokenProjects.length > 0) {
+        console.warn(
+          `neat: ${outcome.brokenProjects.length} project(s) reported broken: ${outcome.brokenProjects.join(", ")}`
+        );
+      }
+      break;
+    case "no-ports":
       for (const line of formatPortCollisionMessage(NEAT_PORTS[0])) {
         console.error(line);
       }
       result.exitCode = 3;
       return result;
-    }
-    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;
-      }
-    } 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, currentProjectName, 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();
+    case "timed-out":
+      result.steps.daemon = "timed-out";
+      for (const line of await describeDaemonTimeout(outcome, opts.scanPath, timeoutMs)) {
+        console.error(line);
       }
-    }
+      result.exitCode = 1;
+      return result;
+    case "peer-timeout":
+      console.error("neat: another `neat` is spawning this project but its daemon did not come up in time");
+      result.exitCode = 1;
+      return result;
+    case "spawn-failed":
+      console.error(`neat: daemon spawn failed \u2014 ${outcome.message}`);
+      result.exitCode = 1;
+      return result;
   }
   const webPort = allocated?.web ?? NEAT_PORTS[2];
   const dashboardUrl = opts.dashboardUrl ?? `http://localhost:${webPort}`;
@@ -5335,9 +5404,9 @@ function parseGitHubRemote(url) {
   if (!owner || !name) return null;
   return { owner, name };
 }
-async function cpGetJson(fetchImpl, cpUrl, path21, accessToken) {
+async function cpGetJson(fetchImpl, cpUrl, path22, accessToken) {
   try {
-    const res = await fetchImpl(`${cpUrl}${path21}`, {
+    const res = await fetchImpl(`${cpUrl}${path22}`, {
       headers: { authorization: `Bearer ${accessToken}`, accept: "application/json" },
       signal: AbortSignal.timeout(CP_TIMEOUT_MS)
     });
@@ -5815,10 +5884,10 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path21) {
+    async get(path22) {
       let res;
       try {
-        res = await fetchImpl(`${root}${path21}`, {
+        res = await fetchImpl(`${root}${path22}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -5830,16 +5899,16 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path21}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path22}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path21, body) {
+    async post(path22, body) {
       let res;
       try {
-        res = await fetchImpl(`${root}${path21}`, {
+        res = await fetchImpl(`${root}${path22}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -5853,7 +5922,7 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path21}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path22}: ${text}`,
           text
         );
       }
@@ -5867,12 +5936,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path21 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path21);
+    const result = await client.get(path22);
     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}.` : "");
@@ -5898,12 +5967,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path21 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path21);
+    const result = await client.get(path22);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no dependents. Nothing else would break if it failed.`
@@ -5937,12 +6006,12 @@ function formatBlastEntry(n) {
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path21 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path21);
+    const result = await client.get(path22);
     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}).`
@@ -6034,9 +6103,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path21 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path22 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path21);
+    const body = await client.get(path22);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -6517,6 +6586,122 @@ async function runDoctorCommand(argv, deps = {}) {
   return checks.every((c) => c.ok) ? 0 : 1;
 }
 
+// src/up-cli.ts
+import path14 from "path";
+function parseUpArgs(argv, env) {
+  const args = { json: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") args.json = true;
+    else if (a === "-h" || a === "--help") args.help = true;
+    else if (a === "--project") args.project = argv[++i];
+    else if (a.startsWith("--project=")) args.project = a.slice("--project=".length);
+    else if (a === "--profile") args.profile = argv[++i];
+    else if (a.startsWith("--profile=")) args.profile = a.slice("--profile=".length);
+    else if (args.unknown === void 0) args.unknown = a;
+  }
+  if (!args.project && env.NEAT_PROJECT && env.NEAT_PROJECT.length > 0) args.project = env.NEAT_PROJECT;
+  return args;
+}
+var USAGE = [
+  "usage: neat up [--project <name>] [--json]",
+  "",
+  "Start this project's daemon, or recover it if it died. Does nothing when it is",
+  "already running. Extracts and instruments nothing \u2014 run `neat` for that."
+];
+async function runUpCommand(argv, deps) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  const out = deps.out ?? ((line) => console.log(line));
+  const err = deps.err ?? ((line) => console.error(line));
+  const ensure = deps.ensureDaemon ?? ensureProjectDaemon;
+  const args = parseUpArgs(argv, env);
+  if (args.help) {
+    for (const line of USAGE) out(line);
+    return 0;
+  }
+  if (args.unknown !== void 0) {
+    err(`neat up: unexpected argument \`${args.unknown}\``);
+    for (const line of USAGE) err(line);
+    return 2;
+  }
+  let entry2;
+  try {
+    entry2 = args.project ? await getProject(args.project) : await findProjectByPath(cwd);
+  } catch {
+    entry2 = void 0;
+  }
+  if (!entry2) {
+    err(
+      args.project ? `neat up: no project named "${args.project}" is registered on this machine \u2014 \`neat list\` shows what is.` : "neat up: This directory isn't a NEAT project yet \u2014 run `npx neat.is` here first, or pass --project <name>."
+    );
+    return 2;
+  }
+  let target;
+  try {
+    target = await deps.resolveTarget({ project: entry2.name, profile: args.profile });
+  } catch (e) {
+    err(`neat up: ${e.message}`);
+    return 2;
+  }
+  if (!target.local) {
+    err(`neat up: queries from here go to ${target.endpoint}, through ${target.via}.`);
+    err("neat up: that daemon doesn't run on this machine, so it isn't yours to start.");
+    return 2;
+  }
+  const project = entry2.name;
+  const outcome = await ensure({
+    project,
+    projectPath: entry2.path,
+    // `--json` prints one object and nothing else, so progress stays quiet there.
+    ...args.json ? {} : { onProgress: (event) => out(`neat up: ${daemonProgressLine(project, event)}`) }
+  });
+  const log = daemonLogPath(entry2.path);
+  if (args.json) {
+    const ports = "ports" in outcome ? outcome.ports : void 0;
+    out(
+      JSON.stringify({
+        project: entry2.name,
+        path: entry2.path,
+        status: outcome.status,
+        ...ports ? { endpoint: `http://localhost:${ports.rest}`, ports } : {},
+        ...outcome.status === "spawn-failed" ? { error: outcome.message } : {},
+        log
+      })
+    );
+  }
+  switch (outcome.status) {
+    case "already-running":
+      if (!args.json) {
+        out(`neat up: ${entry2.name} is already running \u2014 http://localhost:${outcome.ports.rest}`);
+      }
+      return 0;
+    case "spawned":
+      if (!args.json) {
+        out(`neat up: started ${entry2.name} \u2014 http://localhost:${outcome.ports.rest}`);
+        out(`neat up: traces on :${outcome.ports.otlp}, log at ${path14.relative(cwd, log) || log}`);
+      }
+      return 0;
+    case "timed-out":
+      if (!args.json) {
+        for (const line of await describeDaemonTimeout(outcome, entry2.path, DEFAULT_DAEMON_READY_TIMEOUT_MS)) err(line);
+      }
+      return 1;
+    case "peer-timeout":
+      if (!args.json) {
+        err("neat up: another `neat` is starting this project, and its daemon did not come up in time.");
+        err(`neat up: see ${log}`);
+      }
+      return 1;
+    case "spawn-failed":
+      if (!args.json) err(`neat up: could not start the daemon \u2014 ${outcome.message}`);
+      return 1;
+    case "no-ports":
+      if (!args.json) for (const line of formatPortCollisionMessage(NEAT_PORTS[0])) err(line);
+      return 3;
+  }
+}
+
 // src/login-cli.ts
 import readline3 from "readline/promises";
 var DEFAULT_PROFILE_NAME = "hosted";
@@ -6778,7 +6963,7 @@ async function defaultReadSecret(prompt) {
 
 // src/welcome.ts
 import { promises as fs13 } from "fs";
-import path14 from "path";
+import path15 from "path";
 import readline4 from "readline/promises";
 var WORDMARK = [
   "\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
@@ -6966,10 +7151,11 @@ async function runSelfHosted(out, readLine, orchestrator, cwd, readRegistry2, in
   out("Building your local graph now\u2026");
   out("");
   const overrides = {
+    headerShown: true,
     ...project !== void 0 ? { project } : {},
     ...declined === void 0 ? {} : declined ? { noInstrument: true } : { yes: true }
   };
-  return orchestrator(cwd, Object.keys(overrides).length > 0 ? overrides : void 0);
+  return orchestrator(cwd, overrides);
 }
 async function askToInstrument(out, readLine) {
   out("Instrument the services for OpenTelemetry now?");
@@ -6985,8 +7171,8 @@ async function askToInstrument(out, readLine) {
   return declined;
 }
 async function resolveProjectName(out, readLine, cwd, readRegistry2) {
-  const here = path14.resolve(cwd);
-  const base = path14.basename(here);
+  const here = path15.resolve(cwd);
+  const base = path15.basename(here);
   let taken;
   try {
     const { projects } = await readRegistry2();
@@ -6995,7 +7181,7 @@ async function resolveProjectName(out, readLine, cwd, readRegistry2) {
     return void 0;
   }
   const clash = taken.get(base);
-  if (clash === void 0 || path14.resolve(clash) === here) return void 0;
+  if (clash === void 0 || path15.resolve(clash) === here) return void 0;
   out("");
   out(`A project named \`${base}\` is already registered (${clash}).`);
   const suggested = firstFreeName(base, taken);
@@ -7008,7 +7194,7 @@ async function resolveProjectName(out, readLine, cwd, readRegistry2) {
       continue;
     }
     const other = taken.get(chosen);
-    if (other !== void 0 && path14.resolve(other) !== here) {
+    if (other !== void 0 && path15.resolve(other) !== here) {
       out(`\`${chosen}\` is registered too (${other}).`);
       continue;
     }
@@ -7033,9 +7219,9 @@ async function shouldShowWelcome(deps = {}) {
   const readRegistry2 = deps.readRegistry ?? (() => readRegistry());
   const hasSnapshot = deps.hasSnapshot ?? defaultHasSnapshot;
   try {
-    const here = path14.resolve(cwd);
+    const here = path15.resolve(cwd);
     const { projects } = await readRegistry2();
-    if (projects.some((p) => path14.resolve(p.path) === here)) return false;
+    if (projects.some((p) => path15.resolve(p.path) === here)) return false;
     if (await hasSnapshot(here)) return false;
     return true;
   } catch {
@@ -7044,7 +7230,7 @@ async function shouldShowWelcome(deps = {}) {
 }
 async function defaultHasSnapshot(cwd) {
   try {
-    const entries = await fs13.readdir(path14.join(cwd, "neat-out"));
+    const entries = await fs13.readdir(path15.join(cwd, "neat-out"));
     return entries.some((e) => e.endsWith(".json"));
   } catch {
     return false;
@@ -7061,7 +7247,7 @@ async function defaultReadLine2(prompt) {
 }
 
 // src/hooks-cli.ts
-import path15 from "path";
+import path16 from "path";
 import os2 from "os";
 import { promises as fs14 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -7070,14 +7256,14 @@ var GUIDE_FILENAME = "GRAPH_FIRST.md";
 var GUIDE_INSTALL_NAME = "neat-graph-first.md";
 var HOOK_MATCHER = "Grep|Glob|Bash";
 function moduleDir() {
-  return typeof __dirname !== "undefined" ? __dirname : path15.dirname(fileURLToPath3(import.meta.url));
+  return typeof __dirname !== "undefined" ? __dirname : path16.dirname(fileURLToPath3(import.meta.url));
 }
 async function readSkillAsset(rel) {
   const here = moduleDir();
   const candidates = [
-    path15.resolve(here, "../../claude-skill", rel),
-    path15.resolve(here, "../../../claude-skill", rel),
-    path15.resolve(here, "../claude-skill", rel)
+    path16.resolve(here, "../../claude-skill", rel),
+    path16.resolve(here, "../../../claude-skill", rel),
+    path16.resolve(here, "../claude-skill", rel)
   ];
   for (const candidate of candidates) {
     try {
@@ -7091,20 +7277,20 @@ async function readSkillAsset(rel) {
 }
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path15.resolve(override);
-  return path15.join(os2.homedir(), ".neat");
+  if (override && override.length > 0) return path16.resolve(override);
+  return path16.join(os2.homedir(), ".neat");
 }
 function claudeSettingsPath() {
   const override = process.env.NEAT_CLAUDE_SETTINGS;
-  if (override && override.length > 0) return path15.resolve(override);
+  if (override && override.length > 0) return path16.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os2.homedir();
-  return path15.join(home, ".claude", "settings.json");
+  return path16.join(home, ".claude", "settings.json");
 }
 function installedHookPath() {
-  return path15.join(neatHome2(), "hooks", HOOK_FILENAME);
+  return path16.join(neatHome2(), "hooks", HOOK_FILENAME);
 }
 function gateFlagPath() {
-  return path15.join(neatHome2(), "hooks", "gate-enabled");
+  return path16.join(neatHome2(), "hooks", "gate-enabled");
 }
 function isNeatSearchEntry(entry2) {
   return (entry2.hooks ?? []).some(
@@ -7137,9 +7323,9 @@ async function runHooks(opts) {
     const hookScript = await readSkillAsset(`hooks/${HOOK_FILENAME}`);
     const guide = await readSkillAsset(GUIDE_FILENAME);
     const scriptPath = installedHookPath();
-    await fs14.mkdir(path15.dirname(scriptPath), { recursive: true });
+    await fs14.mkdir(path16.dirname(scriptPath), { recursive: true });
     await fs14.writeFile(scriptPath, hookScript, { mode: 493 });
-    const guidePath = path15.join(neatHome2(), GUIDE_INSTALL_NAME);
+    const guidePath = path16.join(neatHome2(), GUIDE_INSTALL_NAME);
     await fs14.writeFile(guidePath, guide, "utf8");
     const settingsFile = claudeSettingsPath();
     let settings = {};
@@ -7166,11 +7352,11 @@ async function runHooks(opts) {
       ...settings,
       hooks: { ...hooks, PreToolUse: preToolUse }
     };
-    await fs14.mkdir(path15.dirname(settingsFile), { recursive: true });
+    await fs14.mkdir(path16.dirname(settingsFile), { recursive: true });
     await fs14.writeFile(settingsFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
     const flag = gateFlagPath();
     if (opts.gate) {
-      await fs14.mkdir(path15.dirname(flag), { recursive: true });
+      await fs14.mkdir(path16.dirname(flag), { recursive: true });
       await fs14.writeFile(flag, "1\n", "utf8");
     } else {
       await fs14.rm(flag, { force: true });
@@ -7262,7 +7448,7 @@ async function runHooksCommand(args) {
 }
 
 // src/claude-cli.ts
-import path16 from "path";
+import path17 from "path";
 import { promises as fs15 } from "fs";
 var NEAT_SECTION_HEADING = "## neat";
 var NEAT_DIRECTIVE_BODY = `This project has NEAT wired in: a live, fused semantic graph of the system \u2014
@@ -7297,8 +7483,8 @@ ${NEAT_DIRECTIVE_BODY}
 }
 function claudeMdPath() {
   const override = process.env.NEAT_CLAUDE_MD;
-  if (override && override.length > 0) return path16.resolve(override);
-  return path16.join(process.cwd(), "CLAUDE.md");
+  if (override && override.length > 0) return path17.resolve(override);
+  return path17.join(process.cwd(), "CLAUDE.md");
 }
 function splitAroundSection(raw) {
   const lines = raw.split("\n");
@@ -7337,7 +7523,7 @@ async function runInstall() {
   const raw = await readIfExists(file) ?? "";
   const { before, after, found } = splitAroundSection(raw);
   const next = compose(before, after);
-  await fs15.mkdir(path16.dirname(file), { recursive: true });
+  await fs15.mkdir(path17.dirname(file), { recursive: true });
   await fs15.writeFile(file, next, "utf8");
   const verb = raw.length === 0 ? "created" : found ? "refreshed" : "added";
   console.log(`neat claude: ${verb} the \`${NEAT_SECTION_HEADING}\` section in ${file}`);
@@ -7401,7 +7587,7 @@ async function runClaudeCommand(args) {
 }
 
 // src/codex-cli.ts
-import path17 from "path";
+import path18 from "path";
 import os3 from "os";
 import { promises as fs16 } from "fs";
 import { isDeepStrictEqual } from "util";
@@ -7421,14 +7607,14 @@ var NEAT_GRAPH_FIRST_START = "<!-- neat:graph-first -->";
 var NEAT_GRAPH_FIRST_END = "<!-- /neat:graph-first -->";
 function codexConfigPath() {
   const override = process.env.NEAT_CODEX_CONFIG;
-  if (override && override.length > 0) return path17.resolve(override);
+  if (override && override.length > 0) return path18.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os3.homedir();
-  return path17.join(home, ".codex", "config.toml");
+  return path18.join(home, ".codex", "config.toml");
 }
 function agentsFilePath() {
   const override = process.env.NEAT_CODEX_AGENTS;
-  if (override && override.length > 0) return path17.resolve(override);
-  return path17.join(process.cwd(), "AGENTS.md");
+  if (override && override.length > 0) return path18.resolve(override);
+  return path18.join(process.cwd(), "AGENTS.md");
 }
 function isTableHeader(line) {
   return /^\s*\[\[?[^\]]+\]\]?\s*$/.test(line);
@@ -7611,14 +7797,14 @@ async function runCodex(opts) {
     return { exitCode: 0 };
   }
   if (config.changed) {
-    await fs16.mkdir(path17.dirname(configPath), { recursive: true });
+    await fs16.mkdir(path18.dirname(configPath), { recursive: true });
     await fs16.writeFile(configPath, config.text, "utf8");
     console.log(`neat codex: wrote [mcp_servers.neat] to ${configPath}`);
   } else {
     console.log(`neat codex: ${configPath} already has NEAT's MCP server`);
   }
   if (agents.changed) {
-    await fs16.mkdir(path17.dirname(agentsPath), { recursive: true });
+    await fs16.mkdir(path18.dirname(agentsPath), { recursive: true });
     await fs16.writeFile(agentsPath, agents.text, "utf8");
     console.log(`neat codex: wrote the graph-first block to ${agentsPath}`);
   } else {
@@ -7675,7 +7861,7 @@ async function runCodexCommand(args) {
 }
 
 // src/editors-cli.ts
-import path18 from "path";
+import path19 from "path";
 import os4 from "os";
 import { promises as fs17 } from "fs";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
@@ -7701,17 +7887,17 @@ function homeDir() {
 }
 function xdgConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg && xdg.length > 0 ? path18.resolve(xdg) : path18.join(homeDir(), ".config");
+  return xdg && xdg.length > 0 ? path19.resolve(xdg) : path19.join(homeDir(), ".config");
 }
 function envOverride(name) {
   const v = process.env[name];
-  return v && v.length > 0 ? path18.resolve(v) : void 0;
+  return v && v.length > 0 ? path19.resolve(v) : void 0;
 }
 var CURSOR_CLIENT = {
   id: "cursor",
   label: "Cursor",
   docsUrl: "https://docs.cursor.com/context/mcp",
-  mcpConfigPath: () => envOverride("NEAT_CURSOR_CONFIG") ?? path18.join(homeDir(), ".cursor", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_CURSOR_CONFIG") ?? path19.join(homeDir(), ".cursor", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   // Cursor still reads a single `.cursorrules` at the project root (the modern
@@ -7723,7 +7909,7 @@ var DEVIN_CLIENT = {
   id: "devin",
   label: "Devin Desktop (Cascade)",
   docsUrl: "https://docs.devin.ai/desktop/cascade/mcp",
-  mcpConfigPath: () => envOverride("NEAT_DEVIN_CONFIG") ?? path18.join(homeDir(), ".codeium", "windsurf", "mcp_config.json"),
+  mcpConfigPath: () => envOverride("NEAT_DEVIN_CONFIG") ?? path19.join(homeDir(), ".codeium", "windsurf", "mcp_config.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: ".windsurfrules"
@@ -7732,7 +7918,7 @@ var GEMINI_CLIENT = {
   id: "gemini",
   label: "Gemini CLI",
   docsUrl: "https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md",
-  mcpConfigPath: () => envOverride("NEAT_GEMINI_CONFIG") ?? path18.join(homeDir(), ".gemini", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_GEMINI_CONFIG") ?? path19.join(homeDir(), ".gemini", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "GEMINI.md"
@@ -7741,7 +7927,7 @@ var QWEN_CLIENT = {
   id: "qwen",
   label: "Qwen Code",
   docsUrl: "https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/",
-  mcpConfigPath: () => envOverride("NEAT_QWEN_CONFIG") ?? path18.join(homeDir(), ".qwen", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_QWEN_CONFIG") ?? path19.join(homeDir(), ".qwen", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "QWEN.md"
@@ -7750,7 +7936,7 @@ var AMAZONQ_CLIENT = {
   id: "amazonq",
   label: "Amazon Q Developer CLI",
   docsUrl: "https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-configuration.html",
-  mcpConfigPath: () => envOverride("NEAT_AMAZONQ_CONFIG") ?? path18.join(homeDir(), ".aws", "amazonq", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_AMAZONQ_CONFIG") ?? path19.join(homeDir(), ".aws", "amazonq", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -7758,7 +7944,7 @@ var ROOCODE_CLIENT = {
   id: "roocode",
   label: "Roo Code",
   docsUrl: "https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo",
-  mcpConfigPath: () => envOverride("NEAT_ROOCODE_CONFIG") ?? path18.join(process.cwd(), ".roo", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_ROOCODE_CONFIG") ?? path19.join(process.cwd(), ".roo", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -7771,9 +7957,9 @@ var ZED_CLIENT = {
     if (override) return override;
     if (process.platform === "win32") {
       const appData = process.env.APPDATA;
-      if (appData && appData.length > 0) return path18.join(appData, "Zed", "settings.json");
+      if (appData && appData.length > 0) return path19.join(appData, "Zed", "settings.json");
     }
-    return path18.join(homeDir(), ".config", "zed", "settings.json");
+    return path19.join(homeDir(), ".config", "zed", "settings.json");
   },
   mcpContainerKey: "context_servers",
   format: "jsonc",
@@ -7783,7 +7969,7 @@ var OPENCODE_CLIENT = {
   id: "opencode",
   label: "OpenCode",
   docsUrl: "https://opencode.ai/docs/mcp-servers/",
-  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? path18.join(xdgConfigDir(), "opencode", "opencode.json"),
+  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? path19.join(xdgConfigDir(), "opencode", "opencode.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_OPENCODE_SERVER,
@@ -7793,7 +7979,7 @@ var CRUSH_CLIENT = {
   id: "crush",
   label: "Crush",
   docsUrl: "https://charmbracelet-crush.mintlify.app/configuration/mcp",
-  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? path18.join(xdgConfigDir(), "crush", "crush.json"),
+  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? path19.join(xdgConfigDir(), "crush", "crush.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_CRUSH_SERVER,
@@ -7898,7 +8084,7 @@ async function runEditorInstall(client, opts) {
   const mcpPath = client.mcpConfigPath();
   const serverEntry = client.serverEntry ?? NEAT_MCP_SERVER;
   const hasRules = typeof client.rulesFileName === "string";
-  const rulesPath = hasRules ? path18.join(opts.projectDir, client.rulesFileName) : "";
+  const rulesPath = hasRules ? path19.join(opts.projectDir, client.rulesFileName) : "";
   const mcp = await planMcp(client, mcpPath);
   if (mcp === null) return { exitCode: 1 };
   let existingRules = "";
@@ -7941,10 +8127,10 @@ async function runEditorInstall(client, opts) {
     );
     return { exitCode: 0 };
   }
-  await fs17.mkdir(path18.dirname(mcpPath), { recursive: true });
+  await fs17.mkdir(path19.dirname(mcpPath), { recursive: true });
   await fs17.writeFile(mcpPath, mcp.text, "utf8");
   if (hasRules) {
-    await fs17.mkdir(path18.dirname(rulesPath), { recursive: true });
+    await fs17.mkdir(path19.dirname(rulesPath), { recursive: true });
     await fs17.writeFile(rulesPath, newRules, "utf8");
   }
   console.log(`neat ${client.id}: wired NEAT into ${client.label}`);
@@ -8445,7 +8631,7 @@ function sleep(ms, signal) {
 }
 
 // src/cli-verbs.ts
-import path19 from "path";
+import path20 from "path";
 async function resolveProjectEntry(opts) {
   const entries = await listProjects();
   if (opts.project) {
@@ -8455,7 +8641,7 @@ 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}${path19.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${path20.sep}`)) {
       return entry2;
     }
   }
@@ -8774,6 +8960,8 @@ function usage5() {
   console.log("                   test <id>        re-check an existing connector's credential");
   console.log("                 Credentials default to an env-var reference ($VAR) resolved at");
   console.log("                 run time; the config file is written owner-only (0600).");
+  console.log("  up             Start this project's daemon, or recover it if it died. Does");
+  console.log("                 nothing when it is already running. Flags: --project, --json.");
   console.log("  doctor         Preflight this directory's setup \u2014 Node version, project,");
   console.log("                 and daemon reachability \u2014 and print a fix for anything down.");
   console.log("                 Flags: --json. Exits 0 when all pass, 1 when a check fails.");
@@ -9041,12 +9229,12 @@ async function runInit(opts) {
   printDiscoveryReport(opts, services);
   const sections = opts.noInstall ? [] : await buildPatchSections(services, opts.project);
   const patch = renderPatch(sections);
-  const patchPath = path20.join(opts.scanPath, "neat.patch");
+  const patchPath = path21.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
     await fs18.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = path20.join(opts.scanPath, ".gitignore");
+    const gitignorePath = path21.join(opts.scanPath, ".gitignore");
     const gitignoreExists = await fs18.stat(gitignorePath).then(() => true).catch(() => false);
     const verb = gitignoreExists ? "append" : "create";
     console.log(`dry-run: would ${verb} ${gitignorePath} (add neat-out/)`);
@@ -9058,9 +9246,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    path20.join(opts.scanPath, "neat-out")
+    path21.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = path20.join(path20.dirname(opts.outPath), path20.basename(projectPaths.errorsPath));
+  const errorsPath = path21.join(path21.dirname(opts.outPath), path21.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -9069,15 +9257,13 @@ async function runInit(opts) {
     written.push(gitignoreResult.file);
   }
   const languages = [...new Set(services.map((s) => s.node.language))].sort();
-  let currentProjectName = opts.project;
   try {
-    const entry2 = await addProject({
+    await addProject({
       name: opts.project,
       path: opts.scanPath,
       languages,
       status: "active"
     });
-    currentProjectName = entry2.name;
   } catch (err) {
     if (err instanceof ProjectNameCollisionError) {
       console.error(`neat init: ${err.message}`);
@@ -9086,20 +9272,6 @@ async function runInit(opts) {
     }
     throw err;
   }
-  const siblings = await listProjects();
-  const paused = [];
-  for (const p of siblings) {
-    if (p.name !== currentProjectName && p.status === "active") {
-      await setStatus(p.name, "paused");
-      paused.push(p.name);
-    }
-  }
-  if (paused.length > 0) {
-    const plural = paused.length === 1 ? "" : "s";
-    console.log(
-      `neat: paused ${paused.length} sibling project${plural}; run \`neat resume <name>\` to bring one back active.`
-    );
-  }
   if (!opts.noInstall) {
     if (opts.apply) {
       let instrumented = 0;
@@ -9160,6 +9332,8 @@ async function runInit(opts) {
   if (result.extractionErrors > 0) {
     console.log(`errors:   ${errorsPath}`);
   }
+  const skippedBanner = formatSkippedBanner(result.skippedFiles);
+  if (skippedBanner) console.log(skippedBanner);
   console.log(formatPrecisionFloorBanner(result.extractedDropped));
   if (result.extractionErrors > 0 && isStrictExtractionEnabled()) {
     return { exitCode: 4, writtenFiles: written };
@@ -9180,9 +9354,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return path20.resolve(override);
+  if (override && override.length > 0) return path21.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path20.join(home, ".claude.json");
+  return path21.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -9206,7 +9380,7 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await fs18.mkdir(path20.dirname(target), { recursive: true });
+    await fs18.mkdir(path21.dirname(target), { recursive: true });
     await fs18.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.");
@@ -9256,6 +9430,21 @@ async function main() {
     if (code !== 0) process.exit(code);
     return;
   }
+  if (cmd0 === "up") {
+    const code = await runUpCommand(argv.slice(1), {
+      resolveTarget: async (opts) => {
+        const target = await resolveClientTarget(opts);
+        const named = opts.profile ?? process.env.NEAT_PROFILE;
+        return {
+          endpoint: target.endpoint,
+          local: isLoopbackEndpoint(target.endpoint),
+          via: target.source === "profile" ? `the \`${named}\` profile` : target.source === "active" ? "your active profile" : "your environment"
+        };
+      }
+    });
+    if (code !== 0) process.exit(code);
+    return;
+  }
   if (cmd0 === "login") {
     const code = await runLoginCommand(argv.slice(1));
     if (code !== 0) process.exit(code);
@@ -9328,12 +9517,12 @@ async function main() {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = path20.resolve(target);
+    const scanPath = path21.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : path20.basename(scanPath);
+    const projectName = projectExplicit ? project : path21.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, path20.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = path20.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, path21.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = path21.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
@@ -9354,21 +9543,21 @@ async function main() {
       usage5();
       process.exit(2);
     }
-    const scanPath = path20.resolve(target);
+    const scanPath = path21.resolve(target);
     const stat = await fs18.stat(scanPath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       console.error(`neat watch: ${scanPath} is not a directory`);
       process.exit(2);
     }
-    const projectPaths = pathsForProject(project, path20.join(scanPath, "neat-out"));
-    const outPath = path20.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = path20.resolve(
-      process.env.NEAT_ERRORS_PATH ?? path20.join(path20.dirname(outPath), path20.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, path21.join(scanPath, "neat-out"));
+    const outPath = path21.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = path21.resolve(
+      process.env.NEAT_ERRORS_PATH ?? path21.join(path21.dirname(outPath), path21.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = path20.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? path20.join(path20.dirname(outPath), path20.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = path21.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? path21.join(path21.dirname(outPath), path21.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? path20.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? path21.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -9377,7 +9566,7 @@ async function main() {
       project,
       // Resolve NEAT_HOME so a `neat watch` picks up connectors added to
       // ~/.neat/connectors.json (#871). Same resolution the rest of the CLI uses.
-      neatHome: process.env.NEAT_HOME ? path20.resolve(process.env.NEAT_HOME) : path20.join(os5.homedir(), ".neat"),
+      neatHome: process.env.NEAT_HOME ? path21.resolve(process.env.NEAT_HOME) : path21.join(os5.homedir(), ".neat"),
       ...embeddingsCachePath ? { embeddingsCachePath } : {},
       host: process.env.HOST ?? "0.0.0.0",
       port: Number(process.env.PORT ?? 8080),
@@ -9558,12 +9747,12 @@ async function main() {
   usage5();
   process.exit(1);
 }
-async function tryOrchestrator(cmd, parsed) {
-  const scanPath = path20.resolve(cmd);
+async function tryOrchestrator(cmd, parsed, overrides = {}) {
+  const scanPath = path21.resolve(cmd);
   const stat = await fs18.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : path20.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : path21.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -9571,7 +9760,8 @@ async function tryOrchestrator(cmd, parsed) {
     noInstrument: parsed.noInstrument,
     open: parsed.open,
     noOpen: parsed.noOpen,
-    yes: parsed.yes
+    yes: parsed.yes,
+    ...overrides.skipBanner ? { skipBanner: true } : {}
   });
   return result.exitCode;
 }
@@ -9581,13 +9771,18 @@ async function runWelcomeFlow(parsed) {
     // What the person chose at the door reaches the orchestrator as the flags they
     // stand for: the name as `--project`, the instrument answer as `--no-instrument`
     // or as `yes` (which keeps the orchestrator's own prompt quiet, since the door
-    // already asked).
-    orchestrator: async (cwd, opts) => await tryOrchestrator(cwd, {
-      ...parsed,
-      ...opts?.project !== void 0 ? { project: opts.project } : {},
-      ...opts?.noInstrument !== void 0 ? { noInstrument: opts.noInstrument } : {},
-      ...opts?.yes !== void 0 ? { yes: opts.yes } : {}
-    }) ?? 0,
+    // already asked). `headerShown` isn't a flag anyone can type — it says the
+    // door's wordmark already opened this run, so the orchestrator's banner is skipped.
+    orchestrator: async (cwd, opts) => await tryOrchestrator(
+      cwd,
+      {
+        ...parsed,
+        ...opts?.project !== void 0 ? { project: opts.project } : {},
+        ...opts?.noInstrument !== void 0 ? { noInstrument: opts.noInstrument } : {},
+        ...opts?.yes !== void 0 ? { yes: opts.yes } : {}
+      },
+      { skipBanner: opts?.headerShown === true }
+    ) ?? 0,
     // An explicit flag is an answer; don't ask again.
     instrumentFlagGiven: parsed.noInstrument || parsed.dryRun
   });
@@ -9629,9 +9824,10 @@ function isLoopbackEndpoint(endpoint) {
     return false;
   }
 }
-async function resolveProjectForVerb(client, parsed) {
+async function resolveProjectForVerb(client, parsed, cwdProject) {
   const explicit = resolveProjectFlag(parsed);
   if (explicit) return explicit;
+  if (cwdProject) return cwdProject;
   const projects = await client.get("/projects");
   if (projects.some((p) => p.name === DEFAULT_PROJECT)) {
     return void 0;
@@ -9678,14 +9874,28 @@ async function resolveClientTarget(opts = {}) {
   }
   return { endpoint: "http://localhost:8080", source: "default" };
 }
+async function projectForCwd(cwd = process.cwd()) {
+  try {
+    return (await findProjectByPath(cwd))?.name;
+  } catch {
+    return void 0;
+  }
+}
+function cwdProjectApplies(source) {
+  return source === "daemon-record" || source === "default";
+}
 async function resolveDaemonUrl(project, profile) {
   return (await resolveClientTarget({ project, profile })).endpoint;
 }
 async function runQueryVerb(cmd, parsed) {
   const requestedProject = resolveProjectFlag(parsed);
+  const cwdProject = requestedProject ? void 0 : await projectForCwd();
   let target;
   try {
-    target = await resolveClientTarget({ project: requestedProject, profile: parsed.profile ?? void 0 });
+    target = await resolveClientTarget({
+      project: requestedProject ?? cwdProject,
+      profile: parsed.profile ?? void 0
+    });
   } catch (err) {
     if (err instanceof UnknownProfileError) {
       process.stderr.write(`${err.message}
@@ -9844,7 +10054,11 @@ async function runQueryVerb(cmd, parsed) {
       return 2;
   }
   try {
-    const project = await resolveProjectForVerb(client, parsed);
+    const project = await resolveProjectForVerb(
+      client,
+      parsed,
+      cwdProjectApplies(target.source) ? cwdProject : void 0
+    );
     const result = await makeWork(project);
     if (parsed.json) process.stdout.write(formatJson(result) + "\n");
     else process.stdout.write(formatHuman(result) + "\n");
@@ -9860,7 +10074,8 @@ async function runQueryVerb(cmd, parsed) {
     } else if (err instanceof TransportError) {
       console.error(`neat ${cmd}: ${err.message}. Is the daemon running? (endpoint=${target.endpoint})`);
       if (isLoopbackEndpoint(target.endpoint)) {
-        console.error(`neat ${cmd}: start one with \`neat watch .\`, or \`neat\` to extract and start in one step.`);
+        const upCommand = requestedProject ? `neat up --project ${requestedProject}` : "neat up";
+        console.error(`neat ${cmd}: run \`${upCommand}\` to start it.`);
       }
     } else {
       console.error(`neat ${cmd}: ${err.message}`);
@@ -9870,9 +10085,13 @@ async function runQueryVerb(cmd, parsed) {
 }
 async function runMonitorVerb(parsed) {
   const requestedProject = resolveProjectFlag(parsed);
+  const cwdProject = requestedProject ? void 0 : await projectForCwd();
   let target;
   try {
-    target = await resolveClientTarget({ project: requestedProject, profile: parsed.profile ?? void 0 });
+    target = await resolveClientTarget({
+      project: requestedProject ?? cwdProject,
+      profile: parsed.profile ?? void 0
+    });
   } catch (err) {
     if (err instanceof UnknownProfileError) return 0;
     throw err;
@@ -9880,7 +10099,11 @@ async function runMonitorVerb(parsed) {
   const client = createHttpClient(target.endpoint, target.authToken);
   let project;
   try {
-    project = await resolveProjectForVerb(client, parsed);
+    project = await resolveProjectForVerb(
+      client,
+      parsed,
+      cwdProjectApplies(target.source) ? cwdProject : void 0
+    );
   } catch (err) {
     if (err instanceof ProjectResolutionError) {
       console.error(`neat monitor: ${err.message}`);
@@ -9904,11 +10127,18 @@ async function runMonitorVerb(parsed) {
     process.off("SIGTERM", onSignal);
   }
 }
+function reportFatal(err, log = console.error) {
+  if (err instanceof RegistryError) {
+    log(`neat: ${err.message}`);
+    return 1;
+  }
+  log(err);
+  return 1;
+}
 var entry = process.argv[1] ?? "";
 if (/[\\/](?:cli\.(?:cjs|js)|cli|neat|neat\.is)$/.test(entry)) {
   main().catch((err) => {
-    console.error(err);
-    process.exit(1);
+    process.exit(reportFatal(err));
   });
 }
 export {
@@ -9917,12 +10147,15 @@ export {
   QUERY_VERBS,
   UnknownProfileError,
   commandPrefix,
+  cwdProjectApplies,
   isLoopbackEndpoint,
   isNpxInvocation,
   main,
   parseArgs,
   printBanner,
+  projectForCwd,
   readPackageVersion,
+  reportFatal,
   resolveClientTarget,
   resolveDaemonUrl,
   resolveProjectForVerb,