@neat.is/core 0.10.1-dev.20260928 → 0.10.2

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   resolveNeatVersion,
   startK8sSubstratePolling,
   writeDaemonRecord
-} from "./chunk-HVBD4ULO.js";
+} from "./chunk-CAGAHYDB.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,23 +82,24 @@ import {
   startStalenessLoop,
   upsertConnectorEntry,
   validateConnectorEntry
-} from "./chunk-CNOJ4T6I.js";
+} from "./chunk-TXKOAART.js";
 import {
   startOtelGrpcReceiver
-} from "./chunk-ERE47MCR.js";
+} from "./chunk-5SJHA5ZH.js";
 import {
   __dirname,
   __require,
   assertBindAuthority,
   buildOtelReceiver,
+  isLoopbackHost,
   listenSteppingOtlp,
   readAuthEnv
-} from "./chunk-GDGUY4T6.js";
+} from "./chunk-M7CGATVC.js";
 
 // src/cli.ts
-import path19 from "path";
+import path21 from "path";
 import os5 from "os";
-import { promises as fs17 } from "fs";
+import { promises as fs18 } from "fs";
 
 // src/banner.ts
 import path from "path";
@@ -3936,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();
@@ -3947,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,
@@ -4330,6 +4353,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 = [
@@ -4376,6 +4409,72 @@ 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
+    });
+    const ready = await waitForDaemonReady(allocated.rest, opts.project, timeoutMs);
+    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;
@@ -4409,14 +4508,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)`);
@@ -4452,24 +4563,11 @@ async function runOrchestrator(opts) {
   } catch (err) {
     if (!(err instanceof ProjectNameCollisionError)) throw err;
     console.error(`neat: ${err.message}`);
-    console.error("pass --project <other-name> to register under a different name.");
+    console.error(`neat: run \`neat <path> --project <other-name>\` to register it under a different name,`);
+    console.error(`neat: or \`neat uninstall ${opts.project}\` if the old registration is stale.`);
     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)");
@@ -4485,75 +4583,45 @@ 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
+  });
+  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}`;
@@ -5245,6 +5313,196 @@ async function clearActiveProfile(home = neatHome()) {
   });
 }
 
+// src/daemon-probe.ts
+var PROBE_ATTEMPT_TIMEOUT_MS = 3e4;
+var PROBE_TOTAL_BUDGET_MS = 12e4;
+var PROBE_RETRY_PAUSE_MS = 2e3;
+function isTimeoutError(err) {
+  const name = err?.name;
+  return name === "TimeoutError" || name === "AbortError";
+}
+async function probeOnce(fetchImpl, root, token, timeoutMs) {
+  let res;
+  try {
+    res = await fetchImpl(`${root}/health`, {
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    if (isTimeoutError(err)) return { kind: "timeout" };
+    return { kind: "unreachable", detail: err.message };
+  }
+  if (res.status === 401 || res.status === 403) return { kind: "unauthorized", status: res.status };
+  if (!res.ok) return { kind: "not-neat", status: res.status };
+  const contentType = res.headers.get("content-type") ?? "";
+  if (!contentType.includes("json")) return { kind: "not-neat", status: res.status };
+  return { kind: "ok" };
+}
+async function probeDaemon(fetchImpl, endpoint, token, hooks) {
+  const root = endpoint.replace(/\/$/, "");
+  const deadline = hooks.now() + PROBE_TOTAL_BUDGET_MS;
+  let warned = false;
+  for (; ; ) {
+    const result = await probeOnce(fetchImpl, root, token, PROBE_ATTEMPT_TIMEOUT_MS);
+    if (result.kind !== "timeout") return result;
+    if (!warned) {
+      hooks.onWaiting();
+      warned = true;
+    }
+    if (hooks.now() >= deadline) {
+      return { kind: "unreachable", detail: `no response after ${Math.round(PROBE_TOTAL_BUDGET_MS / 1e3)}s` };
+    }
+    await hooks.sleep(PROBE_RETRY_PAUSE_MS);
+  }
+}
+
+// src/login-connect.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { promises as fs11 } from "fs";
+import path12 from "path";
+var execFileAsync = promisify(execFile);
+async function hasLocalSnapshot(cwd) {
+  try {
+    await fs11.access(path12.join(cwd, "neat-out", "graph.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+var POLL_INTERVAL_MS = 3e3;
+var POLL_BUDGET_MS = 10 * 6e4;
+var CP_TIMEOUT_MS = 1e4;
+async function detectGitHubRepo(cwd) {
+  const read = async (args) => {
+    try {
+      const { stdout } = await execFileAsync("git", args, { cwd, timeout: 5e3 });
+      return stdout.trim();
+    } catch {
+      return null;
+    }
+  };
+  let url = await read(["remote", "get-url", "origin"]);
+  if (!url) {
+    const names = await read(["remote"]);
+    const first = names?.split(/\r?\n/).find((l) => l.trim().length > 0)?.trim();
+    if (!first) return null;
+    url = await read(["remote", "get-url", first]);
+  }
+  if (!url) return null;
+  return parseGitHubRemote(url);
+}
+function parseGitHubRemote(url) {
+  const trimmed = url.trim().replace(/\.git$/, "");
+  const m = trimmed.match(/^https?:\/\/(?:[^@/]+@)?github\.com\/([^/]+)\/([^/]+)$/) ?? trimmed.match(/^git@github\.com:([^/]+)\/([^/]+)$/) ?? trimmed.match(/^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+)$/);
+  if (!m) return null;
+  const owner = m[1];
+  const name = m[2];
+  if (!owner || !name) return null;
+  return { owner, name };
+}
+async function cpGetJson(fetchImpl, cpUrl, path22, accessToken) {
+  try {
+    const res = await fetchImpl(`${cpUrl}${path22}`, {
+      headers: { authorization: `Bearer ${accessToken}`, accept: "application/json" },
+      signal: AbortSignal.timeout(CP_TIMEOUT_MS)
+    });
+    if (!res.ok) return { ok: false };
+    return { ok: true, body: await res.json() };
+  } catch {
+    return { ok: false };
+  }
+}
+async function listBoundRepos(fetchImpl, cpUrl, accessToken, projectId) {
+  const res = await cpGetJson(
+    fetchImpl,
+    cpUrl,
+    `/me/projects/${encodeURIComponent(projectId)}/repos`,
+    accessToken
+  );
+  if (!res.ok || !Array.isArray(res.body)) return null;
+  return res.body;
+}
+async function waitForFirstProject(fetchImpl, cpUrl, accessToken, deps) {
+  const pollMs = deps.pollMs ?? POLL_INTERVAL_MS;
+  const deadline = deps.now() + (deps.budgetMs ?? POLL_BUDGET_MS);
+  for (; ; ) {
+    if (deps.signal?.aborted) return { kind: "aborted" };
+    const me = await cpGetJson(fetchImpl, cpUrl, "/me", accessToken);
+    if (me.ok) {
+      const running = (me.body.projects ?? []).find((p) => p.status === "running");
+      if (running) return { kind: "project", project: running };
+    }
+    if (deps.now() >= deadline) return { kind: "timeout" };
+    await deps.sleep(pollMs);
+    if (deps.signal?.aborted) return { kind: "aborted" };
+  }
+}
+function bindUrl(webUrl, projectId) {
+  return `${webUrl}/config/repos?project=${encodeURIComponent(projectId)}`;
+}
+function onboardingUrl(webUrl) {
+  return `${webUrl}/onboarding`;
+}
+async function runPostLoginConnect(input) {
+  const d = input.deps;
+  const out = d.out ?? ((line) => console.log(line));
+  const fetchImpl = d.fetchImpl ?? fetch;
+  const cwd = d.cwd ?? process.cwd();
+  const detect6 = d.detectRepo ?? detectGitHubRepo;
+  const readLine = d.readLine;
+  const repo = await detect6(cwd);
+  out("");
+  if (!repo) {
+    out("This directory has no GitHub remote, so it can't be bound to the project.");
+    out(`  Push its graph instead:      neat sync --to ${input.project.name}`);
+    out(`  Manage projects and repos:   ${input.webUrl}`);
+    return;
+  }
+  const slug = `${repo.owner}/${repo.name}`;
+  const bound = await listBoundRepos(fetchImpl, input.cpUrl, input.accessToken, input.project.id);
+  const match = bound?.find((r) => r.owner === repo.owner && r.name === repo.name);
+  if (match) {
+    const state = match.syncStatus ? ` (${match.syncStatus})` : "";
+    out(`${slug} is bound to ${input.project.name}${state} \u2014 hosted NEAT extracts it for you.`);
+    out(`  See the graph:  ${input.webUrl}`);
+    return;
+  }
+  out(`${slug} isn't part of ${input.project.name} yet \u2014 logging in connected your account, not this repo.`);
+  out("");
+  const installed = input.me?.github?.installed;
+  const bindLine = installed === false ? "1) Install the GitHub App and bind this repo \u2014 hosted NEAT keeps it in sync" : installed === true ? "1) Bind this repo \u2014 hosted NEAT clones and extracts it, and keeps it in sync" : "1) Bind this repo through the console \u2014 hosted NEAT keeps it in sync";
+  out(bindLine);
+  out(`2) Push the graph on this machine now \u2014 a snapshot, not a subscription`);
+  out("3) Neither, for now");
+  const answer = readLine ? (await readLine("Choose 1, 2 or 3 (Enter skips): "))?.trim() : void 0;
+  if (answer === "1") {
+    const url = bindUrl(input.webUrl, input.project.id);
+    const opened = (d.openBrowser ?? (() => false))(url);
+    out("");
+    out(opened ? `Opened ${url}` : `Open this to bind the repo:
+  ${url}`);
+    return;
+  }
+  if (answer === "2") {
+    const hasGraph = await (d.hasLocalGraph ?? hasLocalSnapshot)(cwd);
+    out("");
+    if (!hasGraph) {
+      out("There is no local graph to push yet. Build one, then push it:");
+      out("  neat");
+      out(`  neat sync --to ${input.project.name}`);
+      return;
+    }
+    out("Push the local graph with:");
+    out(`  neat sync --to ${input.project.name}`);
+    return;
+  }
+  out("");
+  out("No problem \u2014 when you want this repo in the graph:");
+  out(`  Bind it:        ${bindUrl(input.webUrl, input.project.id)}`);
+  out(`  Or push it:     neat sync --to ${input.project.name}`);
+}
+
 // src/login-sso.ts
 var DEFAULT_CP_URL = "https://api.neat.is";
 var DEFAULT_WEB_URL = "https://app.neat.is";
@@ -5270,6 +5528,7 @@ function pickProject(projects, want) {
     return {
       error: {
         code: 1,
+        kind: "no-project",
         message: `no running project to connect to \u2014 create + provision one in the console first${listed}`
       }
     };
@@ -5320,7 +5579,7 @@ async function exchangeCredential(cpUrl, accessToken, opts, deps) {
   if (!cred.endpoint || !cred.authToken) {
     return { error: { code: 1, message: "the credential response was missing endpoint/authToken" } };
   }
-  return { project, cred };
+  return { project, cred, me };
 }
 function defaultOpenBrowser(url) {
   const platform = process.platform;
@@ -5402,12 +5661,50 @@ async function runSsoLogin(opts, deps) {
     }
     accessToken = lb.token;
   }
-  const ex = await exchangeCredential(opts.cpUrl, accessToken, { project: opts.project }, deps);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep2 = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = deps.now ?? Date.now;
+  let ex = await exchangeCredential(opts.cpUrl, accessToken, { project: opts.project }, deps);
+  if ("error" in ex && ex.error.kind === "no-project" && !opts.json) {
+    const url = onboardingUrl(opts.webUrl);
+    out("");
+    out("You don't have a project yet \u2014 let's make one.");
+    const opened = (deps.openBrowser ?? defaultOpenBrowser)(url);
+    out(opened ? `Opened ${url}` : `Open this to create your first project:
+  ${url}`);
+    out("Waiting for it to come up \u2014 Ctrl-C to stop and finish later.");
+    const waited = await waitForFirstProject(fetchImpl, opts.cpUrl, accessToken, {
+      sleep: sleep2,
+      now,
+      ...deps.signal ? { signal: deps.signal } : {}
+    });
+    if (waited.kind === "aborted") {
+      out("Stopped. Run `neat login` again once your project is up.");
+      return 130;
+    }
+    if (waited.kind === "timeout") {
+      err("neat login: no project came up while waiting \u2014 run `neat login` again once it does");
+      return 1;
+    }
+    out(`${waited.project.name} is up.`);
+    ex = await exchangeCredential(opts.cpUrl, accessToken, { project: opts.project }, deps);
+  }
   if ("error" in ex) {
     err(`neat login: ${ex.error.message}`);
     return ex.error.code;
   }
-  const { project, cred } = ex;
+  const { project, cred, me } = ex;
+  const probe = await probeDaemon(fetchImpl, cred.endpoint, cred.authToken, {
+    sleep: sleep2,
+    now,
+    onWaiting: () => err("Waking the hosted daemon \u2014 a cold instance can take up to a minute\u2026")
+  });
+  if (probe.kind !== "ok") {
+    const why = probe.kind === "unreachable" ? probe.detail : probe.kind === "unauthorized" ? `it rejected the credential (HTTP ${probe.status})` : `it answered HTTP ${probe.status} and doesn't look like NEAT`;
+    err(`neat login: "${project.name}" is provisioned, but its daemon isn't answering \u2014 ${why}.`);
+    err(`Nothing was changed. Check the project at ${opts.webUrl} and run \`neat login\` again.`);
+    return probe.kind === "unreachable" ? 3 : 1;
+  }
   await upsertProfile(
     { name: opts.name, endpoint: cred.endpoint, authToken: cred.authToken },
     { makeActive: true, ...deps.home ? { home: deps.home } : {} }
@@ -5435,10 +5732,20 @@ async function runSsoLogin(opts, deps) {
       out(`  OTEL_EXPORTER_OTLP_ENDPOINT=${cred.ingestEndpoint}`);
       out(`  OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer ${cred.otelToken}`);
     }
-    out("");
-    out("This directory isn't part of that graph yet \u2014 logging in connected your account,");
-    out("not this repo, and nothing here has been uploaded.");
-    out(`  Manage projects and repos:  ${opts.webUrl}`);
+    await runPostLoginConnect({
+      cpUrl: opts.cpUrl,
+      webUrl: opts.webUrl,
+      accessToken,
+      project: { id: project.id, name: project.name },
+      me,
+      deps: {
+        fetchImpl,
+        out,
+        ...deps.readLine ? { readLine: deps.readLine } : {},
+        ...deps.openBrowser ? { openBrowser: deps.openBrowser } : { openBrowser: defaultOpenBrowser },
+        ...deps.connect ?? {}
+      }
+    });
     out("");
     out("Run `neat logout` to switch back to your local daemon.");
   }
@@ -5545,8 +5852,8 @@ async function runConnectCommand(rawArgs, deps = {}) {
 }
 
 // src/doctor-cli.ts
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs12 } from "fs";
+import path13 from "path";
 
 // src/cli-client.ts
 import { Provenance as Provenance3 } from "@neat.is/types";
@@ -5574,10 +5881,10 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path20) {
+    async get(path22) {
       let res;
       try {
-        res = await fetchImpl(`${root}${path20}`, {
+        res = await fetchImpl(`${root}${path22}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -5589,16 +5896,16 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path20}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path22}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path20, body) {
+    async post(path22, body) {
       let res;
       try {
-        res = await fetchImpl(`${root}${path20}`, {
+        res = await fetchImpl(`${root}${path22}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -5612,7 +5919,7 @@ function createHttpClient(baseUrl, bearerToken, fetchImpl = fetch) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path20}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path22}: ${text}`,
           text
         );
       }
@@ -5626,12 +5933,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path20 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path20);
+    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}.` : "");
@@ -5657,12 +5964,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path20 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path20);
+    const result = await client.get(path22);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no dependents. Nothing else would break if it failed.`
@@ -5696,12 +6003,12 @@ function formatBlastEntry(n) {
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path20 = projectPath(
+  const path22 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path20);
+    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}).`
@@ -5793,9 +6100,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path20 = 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(path20);
+    const body = await client.get(path22);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -6159,7 +6466,7 @@ function checkNode(nodeVersion) {
 }
 async function neatOutExists(cwd) {
   try {
-    const st = await fs11.stat(path12.join(cwd, "neat-out"));
+    const st = await fs12.stat(path13.join(cwd, "neat-out"));
     return st.isDirectory();
   } catch {
     return false;
@@ -6276,11 +6583,118 @@ 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 outcome = await ensure({ project: entry2.name, projectPath: entry2.path });
+  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 PROBE_ATTEMPT_TIMEOUT_MS = 3e4;
-var PROBE_TOTAL_BUDGET_MS = 12e4;
-var PROBE_RETRY_PAUSE_MS = 2e3;
 var DEFAULT_PROFILE_NAME = "hosted";
 function readFlagValue(argv, i) {
   const arg = argv[i];
@@ -6345,44 +6759,6 @@ function printLoginHelp(out) {
   out('  the profile (default "hosted"); the paste token can also come from NEAT_LOGIN_TOKEN.');
   out("  Exit 0 on success, 1 rejected/needs-action, 2 misuse, 3 unreachable.");
 }
-function isTimeoutError(err) {
-  const name = err?.name;
-  return name === "TimeoutError" || name === "AbortError";
-}
-async function probeOnce(fetchImpl, root, token, timeoutMs) {
-  let res;
-  try {
-    res = await fetchImpl(`${root}/health`, {
-      headers: { authorization: `Bearer ${token}` },
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch (err) {
-    if (isTimeoutError(err)) return { kind: "timeout" };
-    return { kind: "unreachable", detail: err.message };
-  }
-  if (res.status === 401 || res.status === 403) return { kind: "unauthorized", status: res.status };
-  if (!res.ok) return { kind: "not-neat", status: res.status };
-  const contentType = res.headers.get("content-type") ?? "";
-  if (!contentType.includes("json")) return { kind: "not-neat", status: res.status };
-  return { kind: "ok" };
-}
-async function probeDaemon(fetchImpl, endpoint, token, hooks) {
-  const root = endpoint.replace(/\/$/, "");
-  const deadline = hooks.now() + PROBE_TOTAL_BUDGET_MS;
-  let warned = false;
-  for (; ; ) {
-    const result = await probeOnce(fetchImpl, root, token, PROBE_ATTEMPT_TIMEOUT_MS);
-    if (result.kind !== "timeout") return result;
-    if (!warned) {
-      hooks.onWaiting();
-      warned = true;
-    }
-    if (hooks.now() >= deadline) {
-      return { kind: "unreachable", detail: `no response after ${Math.round(PROBE_TOTAL_BUDGET_MS / 1e3)}s` };
-    }
-    await hooks.sleep(PROBE_RETRY_PAUSE_MS);
-  }
-}
 async function runLoginCommand(argv, deps = {}) {
   const out = deps.out ?? ((line) => console.log(line));
   const err = deps.err ?? ((line) => console.error(line));
@@ -6415,8 +6791,13 @@ async function runLoginCommand(argv, deps = {}) {
         fetchImpl,
         out,
         err,
+        readLine,
+        sleep: sleep2,
+        now,
         ...deps.openBrowser ? { openBrowser: deps.openBrowser } : {},
-        ...deps.home ? { home: deps.home } : {}
+        ...deps.home ? { home: deps.home } : {},
+        ...deps.signal ? { signal: deps.signal } : {},
+        ...deps.connect ? { connect: deps.connect } : {}
       }
     );
   }
@@ -6572,8 +6953,8 @@ async function defaultReadSecret(prompt) {
 }
 
 // src/welcome.ts
-import { promises as fs12 } from "fs";
-import path13 from "path";
+import { promises as fs13 } from "fs";
+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",
@@ -6632,15 +7013,17 @@ async function runFrontDoor(deps, out) {
   const login = deps.login ?? (() => Promise.resolve(0));
   const orchestrator = deps.orchestrator ?? (() => Promise.resolve(0));
   const cwd = deps.cwd ?? process.cwd();
+  const flagGiven = deps.instrumentFlagGiven ?? false;
+  const readRegistry2 = deps.readRegistry ?? (() => readRegistry());
   printHeader(out);
   out("Welcome to NEAT. Let's get you a graph of this system.");
   out("");
   const keyReader = deps.readKey !== void 0 ? { read: deps.readKey, done: () => {
   } } : createKeyReader();
   const picked = keyReader !== null ? await selectOption(out, keyReader, deps.moveCursorUp ?? defaultMoveCursorUp) : await selectByNumber(out, readLine);
-  if (picked === void 0) return runSelfHosted(out, readLine, orchestrator, cwd);
+  if (picked === void 0) return runSelfHosted(out, readLine, orchestrator, cwd, readRegistry2, flagGiven);
   if (picked === 0) return login(["--browser"]);
-  return runSelfHosted(out, readLine, orchestrator, cwd);
+  return runSelfHosted(out, readLine, orchestrator, cwd, readRegistry2, flagGiven);
 }
 var MENU_OPTIONS = [
   "Log me into Hosted Neat",
@@ -6743,7 +7126,7 @@ function decodeKey(buf) {
 function defaultMoveCursorUp(rows) {
   if (rows > 0) process.stdout.write(`\x1B[${rows}A`);
 }
-async function runSelfHosted(out, readLine, orchestrator, cwd) {
+async function runSelfHosted(out, readLine, orchestrator, cwd, readRegistry2, instrumentFlagGiven) {
   const wantsPrompt = (await readLine("Print a copy-paste setup prompt for your coding agent? [Y/n]: "))?.trim().toLowerCase();
   if (wantsPrompt !== "n" && wantsPrompt !== "no") {
     out("");
@@ -6754,9 +7137,70 @@ async function runSelfHosted(out, readLine, orchestrator, cwd) {
     out("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     out("");
   }
+  const project = await resolveProjectName(out, readLine, cwd, readRegistry2);
+  const declined = instrumentFlagGiven ? void 0 : await askToInstrument(out, readLine);
   out("Building your local graph now\u2026");
   out("");
-  return orchestrator(cwd);
+  const overrides = {
+    headerShown: true,
+    ...project !== void 0 ? { project } : {},
+    ...declined === void 0 ? {} : declined ? { noInstrument: true } : { yes: true }
+  };
+  return orchestrator(cwd, overrides);
+}
+async function askToInstrument(out, readLine) {
+  out("Instrument the services for OpenTelemetry now?");
+  out("This edits package.json / requirements.txt / go.mod and runs the package manager.");
+  const answer = (await readLine("[Y/n]: "))?.trim().toLowerCase();
+  const declined = answer === "n" || answer === "no";
+  if (declined) {
+    out("");
+    out("Skipping instrumentation \u2014 the graph will hold the declared side only.");
+    out("Run `neat init . --apply` when you want the runtime half.");
+  }
+  out("");
+  return declined;
+}
+async function resolveProjectName(out, readLine, cwd, readRegistry2) {
+  const here = path15.resolve(cwd);
+  const base = path15.basename(here);
+  let taken;
+  try {
+    const { projects } = await readRegistry2();
+    taken = new Map(projects.map((p) => [p.name, p.path]));
+  } catch {
+    return void 0;
+  }
+  const clash = taken.get(base);
+  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);
+  for (; ; ) {
+    const answer = (await readLine(`Name this one: [${suggested}] `))?.trim();
+    if (answer === void 0) return suggested;
+    const chosen = answer.length === 0 ? suggested : answer;
+    if (!isUsableProjectName(chosen)) {
+      out(`"${chosen}" won't work as a project name \u2014 letters, digits, dot, dash and underscore.`);
+      continue;
+    }
+    const other = taken.get(chosen);
+    if (other !== void 0 && path15.resolve(other) !== here) {
+      out(`\`${chosen}\` is registered too (${other}).`);
+      continue;
+    }
+    out("");
+    return chosen;
+  }
+}
+function firstFreeName(base, taken) {
+  for (let n = 2; ; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+function isUsableProjectName(name) {
+  return name.length > 0 && name !== "." && name !== ".." && /^[A-Za-z0-9._-]+$/.test(name);
 }
 async function shouldShowWelcome(deps = {}) {
   const stdinTTY = deps.stdinIsTTY ?? Boolean(process.stdin.isTTY);
@@ -6766,9 +7210,9 @@ async function shouldShowWelcome(deps = {}) {
   const readRegistry2 = deps.readRegistry ?? (() => readRegistry());
   const hasSnapshot = deps.hasSnapshot ?? defaultHasSnapshot;
   try {
-    const here = path13.resolve(cwd);
+    const here = path15.resolve(cwd);
     const { projects } = await readRegistry2();
-    if (projects.some((p) => path13.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 {
@@ -6777,7 +7221,7 @@ async function shouldShowWelcome(deps = {}) {
 }
 async function defaultHasSnapshot(cwd) {
   try {
-    const entries = await fs12.readdir(path13.join(cwd, "neat-out"));
+    const entries = await fs13.readdir(path15.join(cwd, "neat-out"));
     return entries.some((e) => e.endsWith(".json"));
   } catch {
     return false;
@@ -6794,27 +7238,27 @@ async function defaultReadLine2(prompt) {
 }
 
 // src/hooks-cli.ts
-import path14 from "path";
+import path16 from "path";
 import os2 from "os";
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var HOOK_FILENAME = "neat-search-nudge.mjs";
 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 : path14.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 = [
-    path14.resolve(here, "../../claude-skill", rel),
-    path14.resolve(here, "../../../claude-skill", rel),
-    path14.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 {
-      return await fs13.readFile(candidate, "utf8");
+      return await fs14.readFile(candidate, "utf8");
     } catch {
     }
   }
@@ -6824,20 +7268,20 @@ async function readSkillAsset(rel) {
 }
 function neatHome2() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path14.resolve(override);
-  return path14.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 path14.resolve(override);
+  if (override && override.length > 0) return path16.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os2.homedir();
-  return path14.join(home, ".claude", "settings.json");
+  return path16.join(home, ".claude", "settings.json");
 }
 function installedHookPath() {
-  return path14.join(neatHome2(), "hooks", HOOK_FILENAME);
+  return path16.join(neatHome2(), "hooks", HOOK_FILENAME);
 }
 function gateFlagPath() {
-  return path14.join(neatHome2(), "hooks", "gate-enabled");
+  return path16.join(neatHome2(), "hooks", "gate-enabled");
 }
 function isNeatSearchEntry(entry2) {
   return (entry2.hooks ?? []).some(
@@ -6870,14 +7314,14 @@ async function runHooks(opts) {
     const hookScript = await readSkillAsset(`hooks/${HOOK_FILENAME}`);
     const guide = await readSkillAsset(GUIDE_FILENAME);
     const scriptPath = installedHookPath();
-    await fs13.mkdir(path14.dirname(scriptPath), { recursive: true });
-    await fs13.writeFile(scriptPath, hookScript, { mode: 493 });
-    const guidePath = path14.join(neatHome2(), GUIDE_INSTALL_NAME);
-    await fs13.writeFile(guidePath, guide, "utf8");
+    await fs14.mkdir(path16.dirname(scriptPath), { recursive: true });
+    await fs14.writeFile(scriptPath, hookScript, { mode: 493 });
+    const guidePath = path16.join(neatHome2(), GUIDE_INSTALL_NAME);
+    await fs14.writeFile(guidePath, guide, "utf8");
     const settingsFile = claudeSettingsPath();
     let settings = {};
     try {
-      settings = JSON.parse(await fs13.readFile(settingsFile, "utf8"));
+      settings = JSON.parse(await fs14.readFile(settingsFile, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(
@@ -6899,14 +7343,14 @@ async function runHooks(opts) {
       ...settings,
       hooks: { ...hooks, PreToolUse: preToolUse }
     };
-    await fs13.mkdir(path14.dirname(settingsFile), { recursive: true });
-    await fs13.writeFile(settingsFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    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 fs13.mkdir(path14.dirname(flag), { recursive: true });
-      await fs13.writeFile(flag, "1\n", "utf8");
+      await fs14.mkdir(path16.dirname(flag), { recursive: true });
+      await fs14.writeFile(flag, "1\n", "utf8");
     } else {
-      await fs13.rm(flag, { force: true });
+      await fs14.rm(flag, { force: true });
     }
     const mode = opts.gate ? "GATE (deny search until you ask the graph)" : "nudge (search still runs)";
     console.log(`neat hooks: installed the search hook in ${opts.gate ? "gate" : "nudge"} mode`);
@@ -6995,8 +7439,8 @@ async function runHooksCommand(args) {
 }
 
 // src/claude-cli.ts
-import path15 from "path";
-import { promises as fs14 } from "fs";
+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
 code and runtime behaviour (OpenTelemetry) in one model, every fact tagged with
@@ -7030,8 +7474,8 @@ ${NEAT_DIRECTIVE_BODY}
 }
 function claudeMdPath() {
   const override = process.env.NEAT_CLAUDE_MD;
-  if (override && override.length > 0) return path15.resolve(override);
-  return path15.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");
@@ -7059,7 +7503,7 @@ function compose(before, after) {
 }
 async function readIfExists(file) {
   try {
-    return await fs14.readFile(file, "utf8");
+    return await fs15.readFile(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -7070,8 +7514,8 @@ async function runInstall() {
   const raw = await readIfExists(file) ?? "";
   const { before, after, found } = splitAroundSection(raw);
   const next = compose(before, after);
-  await fs14.mkdir(path15.dirname(file), { recursive: true });
-  await fs14.writeFile(file, next, "utf8");
+  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}`);
   console.log("Your agent will now reach for `neat ask` before Read/Grep/Bash. Restart the");
@@ -7092,7 +7536,7 @@ async function runUninstall() {
   }
   const remaining = [before, after].filter((s) => s.length > 0).join("\n\n");
   const next = remaining.length > 0 ? remaining.replace(/\n*$/, "") + "\n" : "";
-  await fs14.writeFile(file, next, "utf8");
+  await fs15.writeFile(file, next, "utf8");
   console.log(`neat claude: removed the \`${NEAT_SECTION_HEADING}\` section from ${file}.`);
   return { exitCode: 0 };
 }
@@ -7134,9 +7578,9 @@ async function runClaudeCommand(args) {
 }
 
 // src/codex-cli.ts
-import path16 from "path";
+import path18 from "path";
 import os3 from "os";
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 import { isDeepStrictEqual } from "util";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 var CODEX_MCP_SERVER = {
@@ -7154,14 +7598,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 path16.resolve(override);
+  if (override && override.length > 0) return path18.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os3.homedir();
-  return path16.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 path16.resolve(override);
-  return path16.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);
@@ -7295,7 +7739,7 @@ async function runCodex(opts) {
   const agentsPath = agentsFilePath();
   let configRaw = "";
   try {
-    configRaw = await fs15.readFile(configPath, "utf8");
+    configRaw = await fs16.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error(`neat codex: failed to read ${configPath} \u2014 ${err.message}`);
@@ -7304,7 +7748,7 @@ async function runCodex(opts) {
   }
   let agentsRaw = "";
   try {
-    agentsRaw = await fs15.readFile(agentsPath, "utf8");
+    agentsRaw = await fs16.readFile(agentsPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error(`neat codex: failed to read ${agentsPath} \u2014 ${err.message}`);
@@ -7344,15 +7788,15 @@ async function runCodex(opts) {
     return { exitCode: 0 };
   }
   if (config.changed) {
-    await fs15.mkdir(path16.dirname(configPath), { recursive: true });
-    await fs15.writeFile(configPath, config.text, "utf8");
+    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 fs15.mkdir(path16.dirname(agentsPath), { recursive: true });
-    await fs15.writeFile(agentsPath, agents.text, "utf8");
+    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 {
     console.log(`neat codex: ${agentsPath} already has the graph-first block`);
@@ -7408,9 +7852,9 @@ async function runCodexCommand(args) {
 }
 
 // src/editors-cli.ts
-import path17 from "path";
+import path19 from "path";
 import os4 from "os";
-import { promises as fs16 } from "fs";
+import { promises as fs17 } from "fs";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import * as jsonc from "jsonc-parser";
 var NEAT_MCP_SERVER = {
@@ -7434,17 +7878,17 @@ function homeDir() {
 }
 function xdgConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg && xdg.length > 0 ? path17.resolve(xdg) : path17.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 ? path17.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") ?? path17.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
@@ -7456,7 +7900,7 @@ var DEVIN_CLIENT = {
   id: "devin",
   label: "Devin Desktop (Cascade)",
   docsUrl: "https://docs.devin.ai/desktop/cascade/mcp",
-  mcpConfigPath: () => envOverride("NEAT_DEVIN_CONFIG") ?? path17.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"
@@ -7465,7 +7909,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") ?? path17.join(homeDir(), ".gemini", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_GEMINI_CONFIG") ?? path19.join(homeDir(), ".gemini", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "GEMINI.md"
@@ -7474,7 +7918,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") ?? path17.join(homeDir(), ".qwen", "settings.json"),
+  mcpConfigPath: () => envOverride("NEAT_QWEN_CONFIG") ?? path19.join(homeDir(), ".qwen", "settings.json"),
   mcpContainerKey: "mcpServers",
   format: "json",
   rulesFileName: "QWEN.md"
@@ -7483,7 +7927,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") ?? path17.join(homeDir(), ".aws", "amazonq", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_AMAZONQ_CONFIG") ?? path19.join(homeDir(), ".aws", "amazonq", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -7491,7 +7935,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") ?? path17.join(process.cwd(), ".roo", "mcp.json"),
+  mcpConfigPath: () => envOverride("NEAT_ROOCODE_CONFIG") ?? path19.join(process.cwd(), ".roo", "mcp.json"),
   mcpContainerKey: "mcpServers",
   format: "json"
 };
@@ -7504,9 +7948,9 @@ var ZED_CLIENT = {
     if (override) return override;
     if (process.platform === "win32") {
       const appData = process.env.APPDATA;
-      if (appData && appData.length > 0) return path17.join(appData, "Zed", "settings.json");
+      if (appData && appData.length > 0) return path19.join(appData, "Zed", "settings.json");
     }
-    return path17.join(homeDir(), ".config", "zed", "settings.json");
+    return path19.join(homeDir(), ".config", "zed", "settings.json");
   },
   mcpContainerKey: "context_servers",
   format: "jsonc",
@@ -7516,7 +7960,7 @@ var OPENCODE_CLIENT = {
   id: "opencode",
   label: "OpenCode",
   docsUrl: "https://opencode.ai/docs/mcp-servers/",
-  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? path17.join(xdgConfigDir(), "opencode", "opencode.json"),
+  mcpConfigPath: () => envOverride("NEAT_OPENCODE_CONFIG") ?? path19.join(xdgConfigDir(), "opencode", "opencode.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_OPENCODE_SERVER,
@@ -7526,7 +7970,7 @@ var CRUSH_CLIENT = {
   id: "crush",
   label: "Crush",
   docsUrl: "https://charmbracelet-crush.mintlify.app/configuration/mcp",
-  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? path17.join(xdgConfigDir(), "crush", "crush.json"),
+  mcpConfigPath: () => envOverride("NEAT_CRUSH_CONFIG") ?? path19.join(xdgConfigDir(), "crush", "crush.json"),
   mcpContainerKey: "mcp",
   format: "json",
   serverEntry: NEAT_CRUSH_SERVER,
@@ -7589,7 +8033,7 @@ async function planMcp(client, mcpPath) {
   const serverEntry = client.serverEntry ?? NEAT_MCP_SERVER;
   let raw = "";
   try {
-    raw = await fs16.readFile(mcpPath, "utf8");
+    raw = await fs17.readFile(mcpPath, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
@@ -7631,7 +8075,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 ? path17.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 = "";
@@ -7640,7 +8084,7 @@ async function runEditorInstall(client, opts) {
   let block = "";
   if (hasRules) {
     try {
-      existingRules = await fs16.readFile(rulesPath, "utf8");
+      existingRules = await fs17.readFile(rulesPath, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat ${client.id}: failed to read ${rulesPath} \u2014 ${err.message}`);
@@ -7674,11 +8118,11 @@ async function runEditorInstall(client, opts) {
     );
     return { exitCode: 0 };
   }
-  await fs16.mkdir(path17.dirname(mcpPath), { recursive: true });
-  await fs16.writeFile(mcpPath, mcp.text, "utf8");
+  await fs17.mkdir(path19.dirname(mcpPath), { recursive: true });
+  await fs17.writeFile(mcpPath, mcp.text, "utf8");
   if (hasRules) {
-    await fs16.mkdir(path17.dirname(rulesPath), { recursive: true });
-    await fs16.writeFile(rulesPath, newRules, "utf8");
+    await fs17.mkdir(path19.dirname(rulesPath), { recursive: true });
+    await fs17.writeFile(rulesPath, newRules, "utf8");
   }
   console.log(`neat ${client.id}: wired NEAT into ${client.label}`);
   console.log(`  MCP server: ${mcpPath} (${client.mcpContainerKey}.neat \u2192 npx -y @neat.is/mcp)`);
@@ -8178,7 +8622,7 @@ function sleep(ms, signal) {
 }
 
 // src/cli-verbs.ts
-import path18 from "path";
+import path20 from "path";
 async function resolveProjectEntry(opts) {
   const entries = await listProjects();
   if (opts.project) {
@@ -8188,7 +8632,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}${path18.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${path20.sep}`)) {
       return entry2;
     }
   }
@@ -8507,6 +8951,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.");
@@ -8765,7 +9211,7 @@ async function buildPatchSections(services, project) {
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await fs17.stat(opts.scanPath).catch(() => null);
+  const stat = await fs18.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat init: ${opts.scanPath} is not a directory`);
     return { exitCode: 2, writtenFiles: written };
@@ -8774,13 +9220,13 @@ async function runInit(opts) {
   printDiscoveryReport(opts, services);
   const sections = opts.noInstall ? [] : await buildPatchSections(services, opts.project);
   const patch = renderPatch(sections);
-  const patchPath = path19.join(opts.scanPath, "neat.patch");
+  const patchPath = path21.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await fs17.writeFile(patchPath, patch, "utf8");
+    await fs18.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = path19.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await fs17.stat(gitignorePath).then(() => true).catch(() => false);
+    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/)`);
     console.log("rerun without --dry-run to register and snapshot.");
@@ -8791,9 +9237,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    path19.join(opts.scanPath, "neat-out")
+    path21.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = path19.join(path19.dirname(opts.outPath), path19.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);
@@ -8802,15 +9248,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}`);
@@ -8819,20 +9263,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;
@@ -8872,7 +9302,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await fs17.writeFile(patchPath, patch, "utf8");
+      await fs18.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -8893,6 +9323,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 };
@@ -8913,9 +9345,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return path19.resolve(override);
+  if (override && override.length > 0) return path21.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path19.join(home, ".claude.json");
+  return path21.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -8927,7 +9359,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await fs17.readFile(target, "utf8"));
+      existing = JSON.parse(await fs18.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -8939,8 +9371,8 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await fs17.mkdir(path19.dirname(target), { recursive: true });
-    await fs17.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    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.");
     console.log("");
@@ -8989,6 +9421,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);
@@ -9061,12 +9508,12 @@ async function main() {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = path19.resolve(target);
+    const scanPath = path21.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : path19.basename(scanPath);
+    const projectName = projectExplicit ? project : path21.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, path19.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = path19.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,
@@ -9087,21 +9534,21 @@ async function main() {
       usage5();
       process.exit(2);
     }
-    const scanPath = path19.resolve(target);
-    const stat = await fs17.stat(scanPath).catch(() => null);
+    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, path19.join(scanPath, "neat-out"));
-    const outPath = path19.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = path19.resolve(
-      process.env.NEAT_ERRORS_PATH ?? path19.join(path19.dirname(outPath), path19.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 = path19.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? path19.join(path19.dirname(outPath), path19.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 ? path19.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,
@@ -9110,7 +9557,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 ? path19.resolve(process.env.NEAT_HOME) : path19.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),
@@ -9291,12 +9738,12 @@ async function main() {
   usage5();
   process.exit(1);
 }
-async function tryOrchestrator(cmd, parsed) {
-  const scanPath = path19.resolve(cmd);
-  const stat = await fs17.stat(scanPath).catch(() => null);
+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 : path19.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : path21.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -9304,14 +9751,31 @@ 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;
 }
 async function runWelcomeFlow(parsed) {
   return runWelcome({
     login: (loginArgv) => runLoginCommand(loginArgv),
-    orchestrator: async (cwd) => await tryOrchestrator(cwd, parsed) ?? 0
+    // 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). `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
   });
 }
 var QUERY_VERBS = /* @__PURE__ */ new Set([
@@ -9344,9 +9808,17 @@ var ProjectResolutionError = class extends Error {
   }
   exitCode;
 };
-async function resolveProjectForVerb(client, parsed) {
+function isLoopbackEndpoint(endpoint) {
+  try {
+    return isLoopbackHost(new URL(endpoint).hostname.replace(/^\[|\]$/g, ""));
+  } catch {
+    return false;
+  }
+}
+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;
@@ -9393,14 +9865,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}
@@ -9559,7 +10045,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");
@@ -9574,6 +10064,10 @@ async function runQueryVerb(cmd, parsed) {
       console.error(`neat ${cmd}: ${detail.trim()}`);
     } else if (err instanceof TransportError) {
       console.error(`neat ${cmd}: ${err.message}. Is the daemon running? (endpoint=${target.endpoint})`);
+      if (isLoopbackEndpoint(target.endpoint)) {
+        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}`);
     }
@@ -9582,9 +10076,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;
@@ -9592,7 +10090,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}`);
@@ -9616,11 +10118,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 {
@@ -9629,11 +10138,15 @@ export {
   QUERY_VERBS,
   UnknownProfileError,
   commandPrefix,
+  cwdProjectApplies,
+  isLoopbackEndpoint,
   isNpxInvocation,
   main,
   parseArgs,
   printBanner,
+  projectForCwd,
   readPackageVersion,
+  reportFatal,
   resolveClientTarget,
   resolveDaemonUrl,
   resolveProjectForVerb,