@nolto/cli 0.7.0 → 0.8.0

package/README.md

@@ -42,12 +42,20 @@ nolto whoami               # Show resolved auth/config state and project count
 
 ```bash
 nolto link <projectId>     # Write or update nolto.json at the repository root
-nolto link --show          # Show the current binding and its source
+nolto link --show          # Show the current binding, source, and repository identity
+nolto link --rebind        # Rebind the project to this repository (owner only)
 nolto link --unlink        # Remove projectId from nolto.json
 ```
 
 Commit `nolto.json` so everyone working in the repository targets the same Nolto
-project.
+project. A Nolto project is bound to the first repository identity it syncs from.
+The identity is the normalized `origin` remote, or a machine ID plus path when no
+remote is available. Syncing from a different repository fails with
+`409 repo_mismatch`. An owner can run `nolto link --rebind` in the correct
+repository to change the binding, at most once every seven days.
+
+CLI versions older than 0.8.0 do not send a repository identity and receive
+`426`; run `nolto update` before syncing.
 
 ### Roadmap Sync
 

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import path13 from "path";
+import path15 from "path";
 import { CommanderError } from "commander";
 
 // src/config.ts
@@ -36,6 +36,38 @@ function mapHttpStatusToCliError(status, opts = {}) {
       status
     );
   }
+  if (status === 426) {
+    return new CliError(
+      opts.serverMessage ?? "Nolto CLI is outdated.",
+      2,
+      "Run `nolto update`, then retry.",
+      status
+    );
+  }
+  if (status === 409 && opts.serverError === "repo_unbound") {
+    return new CliError(
+      opts.serverMessage ?? "This project is not bound to a repository.",
+      2,
+      "Ask the project owner to run nolto sync in the correct repository first.",
+      status
+    );
+  }
+  if (status === 409 && opts.serverError === "repo_mismatch") {
+    return new CliError(
+      opts.serverMessage ?? "This project is bound to a different repository.",
+      2,
+      "Owner: run `nolto link --rebind` inside the repository that should own this project.",
+      status
+    );
+  }
+  if (status === 429 && opts.serverError === "rebind_cooldown") {
+    return new CliError(
+      opts.serverMessage ?? "Rebind cooldown active.",
+      4,
+      void 0,
+      status
+    );
+  }
   if (status === 402) {
     const hint = opts.upgradeUrl != null ? `Upgrade: ${opts.upgradeUrl}` : void 0;
     return new CliError(
@@ -157,9 +189,9 @@ async function mergeJsonFile(filePath, patch) {
     }
   }
   const merged = { ...existing, ...patch };
-  const { chmod } = await import("fs/promises");
+  const { chmod: chmod2 } = await import("fs/promises");
   await writeFile(filePath, JSON.stringify(merged, null, 2) + "\n", { mode: 420 });
-  await chmod(filePath, 420);
+  await chmod2(filePath, 420);
 }
 async function writeRepoBinding(root, projectId) {
   await mergeJsonFile(path.join(root, "nolto.json"), { projectId });
@@ -282,11 +314,11 @@ function maskToken(token) {
 function createHttpClient(opts) {
   const { baseUrl, version, token } = opts;
   const base = baseUrl.replace(/\/+$/, "");
-  async function request(method, path14, body) {
-    if (!path14.startsWith("/api/")) {
-      throw new CliError(`HTTP client path must start with /api/, got: ${path14}`, 2);
+  async function request(method, path16, body) {
+    if (!path16.startsWith("/api/")) {
+      throw new CliError(`HTTP client path must start with /api/, got: ${path16}`, 2);
     }
-    const url = `${base}${path14}`;
+    const url = `${base}${path16}`;
     const headers = {
       "Content-Type": "application/json",
       "User-Agent": `${CLI_USER_AGENT_NAME}/${version}`
@@ -345,11 +377,11 @@ import { Command } from "commander";
 import readline from "readline/promises";
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path6 from "path";
+import path8 from "path";
 import fs from "fs";
 
 // src/commands/link.ts
-import path2 from "path";
+import path5 from "path";
 import { statSync as statSync2 } from "fs";
 
 // src/output.ts
@@ -403,6 +435,316 @@ function formatValue(value) {
   return JSON.stringify(value, null, 2);
 }
 
+// src/registry.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rename, unlink } from "fs/promises";
+import { randomUUID } from "crypto";
+import path2 from "path";
+import { z as z2 } from "zod";
+var registrySchema = z2.object({
+  schemaVersion: z2.literal(1),
+  repos: z2.array(z2.object({ root: z2.string().min(1) }).passthrough())
+}).passthrough();
+function getRegistryPath(env) {
+  return path2.join(getConfigDir(env), "registry.json");
+}
+async function loadRegistry(filePath) {
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf8");
+  } catch (err) {
+    const code = err != null && typeof err === "object" && "code" in err ? err.code : "";
+    if (code === "ENOENT") {
+      return { schemaVersion: 1, repos: [] };
+    }
+    throw new CliError(`Cannot read registry: ${filePath}: ${String(err)}`, 2);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliError(`Malformed JSON in ${filePath}. Fix or remove the file.`, 2);
+  }
+  const result = registrySchema.safeParse(parsed);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const fieldPath = issue?.path.join(".") ?? "";
+    throw new CliError(
+      `Invalid registry at ${filePath}: ${fieldPath.length > 0 ? `field "${fieldPath}" \u2014 ` : ""}${issue?.message ?? "validation failed"}`,
+      2
+    );
+  }
+  return result.data;
+}
+async function addRepoToRegistry(filePath, repoRoot) {
+  const registry = await loadRegistry(filePath);
+  if (registry.repos.some((repo) => repo.root === repoRoot)) {
+    return { added: false, registry };
+  }
+  const updated = { ...registry, repos: [...registry.repos, { root: repoRoot }] };
+  await mkdir2(path2.dirname(filePath), { recursive: true, mode: 448 });
+  const tempPath = `${filePath}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    await writeFile2(tempPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    await rename(tempPath, filePath);
+  } catch (err) {
+    await unlink(tempPath).catch(() => void 0);
+    throw err;
+  }
+  return { added: true, registry: updated };
+}
+
+// src/repo-identity.ts
+import { execFile } from "child_process";
+import { realpathSync } from "fs";
+import path4 from "path";
+
+// ../roadmap-schema/src/repo-identity.ts
+var HOSTED_LOWERCASE_PATH = /* @__PURE__ */ new Set(["github.com", "gitlab.com", "bitbucket.org"]);
+function normalizeRemote(raw) {
+  let s = raw.trim();
+  if (s.length === 0) return null;
+  if (s.startsWith("file://") || s.startsWith("/") || s.startsWith(".") || /^[A-Za-z]:[\\/]/.test(s)) return null;
+  const scheme = /^[a-z][a-z0-9+.-]*:\/\//i.exec(s);
+  const hadScheme = scheme !== null;
+  if (scheme !== null) s = s.slice(scheme[0].length);
+  const authorityEnd = s.indexOf("/");
+  const lastAt = s.lastIndexOf("@", authorityEnd === -1 ? s.length - 1 : authorityEnd - 1);
+  if (lastAt !== -1) s = s.slice(lastAt + 1);
+  const scpLike = hadScheme ? null : /^([^/:]+):(.+)$/.exec(s);
+  if (scpLike !== null) {
+    s = `${scpLike[1]}/${scpLike[2]}`;
+  }
+  const firstSlash = s.indexOf("/");
+  if (firstSlash <= 0) return null;
+  let host = s.slice(0, firstSlash).toLowerCase();
+  let path16 = s.slice(firstSlash + 1);
+  if (hadScheme) host = host.replace(/:\d+$/, "");
+  path16 = path16.replace(/\/+/g, "/").replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "").replace(/\/+$/, "");
+  if (path16.length === 0) return null;
+  if (HOSTED_LOWERCASE_PATH.has(host)) path16 = path16.toLowerCase();
+  return `${host}/${path16}`;
+}
+
+// ../roadmap-schema/src/index.ts
+var STATUSES = /* @__PURE__ */ new Set(["todo", "in-progress", "done", "blocked"]);
+var ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+var ALLOWED_KEYS = {
+  roadmap: /* @__PURE__ */ new Set(["schemaVersion", "project", "updatedAt", "currentTaskId", "summary", "phases"]),
+  project: /* @__PURE__ */ new Set(["id", "name", "repository"]),
+  phase: /* @__PURE__ */ new Set(["id", "title", "status", "plan", "tasks"]),
+  task: /* @__PURE__ */ new Set(["id", "title", "status", "startedAt", "completedAt", "note", "dependsOn", "plan"])
+};
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function checkKeys(value, allowed, at, errors) {
+  if (!isRecord(value)) return;
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) errors.push(`${at} contains unsupported property "${key}".`);
+  }
+}
+function checkPlan(value, at, errors) {
+  if (value === void 0) return;
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push(`${at}.plan must be a non-empty string.`);
+  }
+}
+function derivePhaseStatus(phase) {
+  if (phase.tasks.length > 0 && phase.tasks.every((task) => task.status === "done")) return "done";
+  if (phase.tasks.some((task) => task.status === "in-progress")) return "in-progress";
+  if (phase.tasks.some((task) => task.status === "blocked")) return "blocked";
+  if (phase.tasks.some((task) => task.status === "done")) return "in-progress";
+  return "todo";
+}
+function validateRoadmap(value) {
+  const errors = [];
+  const warnings = [];
+  if (!isRecord(value)) return { errors: ["Root must be an object."], warnings };
+  checkKeys(value, ALLOWED_KEYS.roadmap, "roadmap", errors);
+  if (value["schemaVersion"] !== 1 && value["schemaVersion"] !== 2) {
+    errors.push("schemaVersion must be 1 or 2.");
+  } else if (value["schemaVersion"] === 1) {
+    warnings.push("schemaVersion 1 is legacy; the next roadmap-progress mutation migrates this file to 2.");
+  }
+  const project = value["project"];
+  checkKeys(project, ALLOWED_KEYS.project, "project", errors);
+  const projectRecord = isRecord(project) ? project : {};
+  if (!ID_PATTERN.test(String(projectRecord["id"] ?? ""))) errors.push("project.id is invalid.");
+  if (projectRecord["name"] == null || projectRecord["name"] === "") errors.push("project.name is required.");
+  if (projectRecord["repository"] == null || projectRecord["repository"] === "") errors.push("project.repository is required.");
+  if (Number.isNaN(Date.parse(String(value["updatedAt"])))) errors.push("updatedAt must be a valid date-time.");
+  if (typeof value["summary"] !== "string") errors.push("summary must be a string.");
+  if (!Array.isArray(value["phases"])) errors.push("phases must be an array.");
+  const allIds = /* @__PURE__ */ new Set();
+  const tasks = /* @__PURE__ */ new Map();
+  const phases = Array.isArray(value["phases"]) ? value["phases"] : [];
+  for (const [phaseIndex, rawPhase] of phases.entries()) {
+    const at = `phases[${phaseIndex}]`;
+    checkKeys(rawPhase, ALLOWED_KEYS.phase, at, errors);
+    const phase = isRecord(rawPhase) ? rawPhase : {};
+    const phaseId = String(phase["id"] ?? "");
+    if (!ID_PATTERN.test(phaseId)) errors.push(`${at}.id is invalid.`);
+    if (allIds.has(phaseId)) errors.push(`Duplicate id "${phaseId}".`);
+    allIds.add(phaseId);
+    if (phase["title"] == null || phase["title"] === "") errors.push(`${at}.title is required.`);
+    if (!STATUSES.has(String(phase["status"]))) errors.push(`${at}.status is invalid.`);
+    checkPlan(phase["plan"], at, errors);
+    if (!Array.isArray(phase["tasks"])) errors.push(`${at}.tasks must be an array.`);
+    const rawTasks = Array.isArray(phase["tasks"]) ? phase["tasks"] : [];
+    for (const [taskIndex, rawTask] of rawTasks.entries()) {
+      const taskAt = `${at}.tasks[${taskIndex}]`;
+      checkKeys(rawTask, ALLOWED_KEYS.task, taskAt, errors);
+      const task = isRecord(rawTask) ? rawTask : {};
+      const taskId = String(task["id"] ?? "");
+      if (!ID_PATTERN.test(taskId)) errors.push(`${taskAt}.id is invalid.`);
+      if (allIds.has(taskId)) errors.push(`Duplicate id "${taskId}".`);
+      allIds.add(taskId);
+      tasks.set(taskId, task);
+      if (task["title"] == null || task["title"] === "") errors.push(`${taskAt}.title is required.`);
+      if (!STATUSES.has(String(task["status"]))) errors.push(`${taskAt}.status is invalid.`);
+      checkPlan(task["plan"], taskAt, errors);
+      if (task["status"] === "done" && task["completedAt"] == null) warnings.push(`${taskId} is done without completedAt.`);
+      if (task["status"] === "in-progress" && task["startedAt"] == null) warnings.push(`${taskId} is in-progress without startedAt.`);
+      if (task["dependsOn"] !== void 0 && !Array.isArray(task["dependsOn"])) errors.push(`${taskAt}.dependsOn must be an array.`);
+    }
+    if (Array.isArray(phase["tasks"]) && STATUSES.has(String(phase["status"]))) {
+      const expected = derivePhaseStatus({ ...phase, tasks: rawTasks });
+      if (phase["status"] !== expected) warnings.push(`${phaseId} status is ${String(phase["status"])}; task states derive ${expected}.`);
+    }
+  }
+  for (const task of tasks.values()) {
+    for (const dependency of task.dependsOn ?? []) {
+      if (!tasks.has(dependency)) warnings.push(`${task.id} depends on unknown task ${dependency}.`);
+      if (task.id === dependency) errors.push(`${task.id} cannot depend on itself.`);
+    }
+  }
+  const currentTaskId = value["currentTaskId"];
+  if (currentTaskId !== null && currentTaskId !== void 0) {
+    const current = tasks.get(String(currentTaskId));
+    if (current == null) errors.push(`currentTaskId ${String(currentTaskId)} does not exist.`);
+    else if (current.status !== "in-progress") warnings.push(`currentTaskId ${String(currentTaskId)} is not in-progress.`);
+  }
+  return { errors, warnings };
+}
+function deriveTaskStats(roadmap) {
+  let done = 0;
+  let blocked = 0;
+  let inProgress = 0;
+  let todo = 0;
+  for (const phase of roadmap.phases) {
+    for (const task of phase.tasks) {
+      if (task.status === "done") done += 1;
+      else if (task.status === "blocked") blocked += 1;
+      else if (task.status === "in-progress") inProgress += 1;
+      else todo += 1;
+    }
+  }
+  const total = done + blocked + inProgress + todo;
+  return {
+    total,
+    done,
+    blocked,
+    inProgress,
+    todo,
+    progressPct: total > 0 ? Math.round(done / total * 100) : 0
+  };
+}
+
+// src/machine-id.ts
+import { chmod, mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import path3 from "path";
+var inFlightByConfigDir = /* @__PURE__ */ new Map();
+function parseMachineId(raw, file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliError(`Malformed JSON in ${file}. Remove the file to regenerate it.`, 2);
+  }
+  const id = parsed?.machineId;
+  if (typeof id !== "string" || id.length === 0) {
+    throw new CliError(`Invalid ${file}: missing machineId. Remove the file to regenerate it.`, 2);
+  }
+  return id;
+}
+async function loadOrCreate(configDir) {
+  const file = path3.join(configDir, "machine.json");
+  let raw = null;
+  try {
+    raw = await readFile3(file, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      throw new CliError(`Cannot read ${file}: ${String(err)}`, 2);
+    }
+  }
+  if (raw !== null) {
+    return parseMachineId(raw, file);
+  }
+  const machineId = randomUUID2();
+  await mkdir3(configDir, { recursive: true, mode: 448 });
+  try {
+    await writeFile3(file, `${JSON.stringify({ machineId }, null, 2)}
+`, {
+      flag: "wx",
+      mode: 384
+    });
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      return parseMachineId(await readFile3(file, "utf8"), file);
+    }
+    throw new CliError(`Cannot write ${file}: ${String(err)}`, 2);
+  }
+  await chmod(file, 384);
+  return machineId;
+}
+function loadOrCreateMachineId(configDir) {
+  const key = path3.resolve(configDir);
+  const existing = inFlightByConfigDir.get(key);
+  if (existing !== void 0) return existing;
+  const pending = loadOrCreate(key).finally(() => {
+    if (inFlightByConfigDir.get(key) === pending) inFlightByConfigDir.delete(key);
+  });
+  inFlightByConfigDir.set(key, pending);
+  return pending;
+}
+
+// src/repo-identity.ts
+function defaultGetRemoteUrl(root) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      ["-C", root, "remote", "get-url", "origin"],
+      { timeout: 5e3 },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        const line = stdout.split(/\r?\n/)[0]?.trim() ?? "";
+        resolve(line.length > 0 ? line : null);
+      }
+    );
+  });
+}
+async function resolveRepoIdentity(root, deps) {
+  const remote = await deps.getRemoteUrl(root);
+  const normalized = remote === null ? null : normalizeRemote(remote);
+  if (normalized !== null) return { kind: "remote", value: normalized };
+  const machineId = await deps.machineId();
+  let canonicalRoot;
+  try {
+    canonicalRoot = realpathSync(root);
+  } catch {
+    canonicalRoot = path4.resolve(root);
+  }
+  return { kind: "local", value: `${machineId}:${canonicalRoot}` };
+}
+function makeRepoIdentityResolver(deps) {
+  return deps.repoIdentity ?? ((root) => resolveRepoIdentity(root, {
+    getRemoteUrl: defaultGetRemoteUrl,
+    machineId: () => loadOrCreateMachineId(getConfigDir(process.env))
+  }));
+}
+
 // src/commands/link.ts
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function resolveStartDir(env, cwd) {
@@ -411,7 +753,7 @@ function resolveStartDir(env, cwd) {
 }
 function dirHasGit(dir) {
   try {
-    statSync2(path2.join(dir, ".git"));
+    statSync2(path5.join(dir, ".git"));
     return true;
   } catch {
     return false;
@@ -423,18 +765,23 @@ function findRepoRoot(startDir, hasGit = dirHasGit) {
     if (hasGit(current)) {
       return { root: current, foundGit: true };
     }
-    const parent = path2.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return { root: startDir, foundGit: false };
 }
 async function handleShow(deps, projectBindingPath, mode2) {
+  const startDir = resolveStartDir(process.env, process.cwd());
+  const root = findRepoRoot(startDir).root;
+  const repoIdentity = await makeRepoIdentityResolver(deps)(root);
   if (projectBindingPath == null) {
     if (mode2 === "json") {
-      printResult({ bound: false, projectBindingPath: null }, mode2);
+      printResult({ bound: false, projectBindingPath: null, repoIdentity }, mode2);
     } else {
       process.stdout.write("No nolto.json binding found in this directory tree.\n");
+      process.stdout.write(`repoIdentity : ${repoIdentity.kind}:${repoIdentity.value}
+`);
     }
     return;
   }
@@ -447,7 +794,8 @@ async function handleShow(deps, projectBindingPath, mode2) {
       bound: binding != null,
       projectId: binding?.projectId ?? null,
       projectBindingPath,
-      source: deps.settings.source.project === "repo" ? "repo" : "file"
+      source: deps.settings.source.project === "repo" ? "repo" : "file",
+      repoIdentity
     }, mode2);
   } else {
     if (binding == null) {
@@ -460,15 +808,33 @@ async function handleShow(deps, projectBindingPath, mode2) {
 `);
       const active = deps.settings.source.project === "repo" ? "repo (active)" : "repo (not active \u2014 overridden)";
       process.stdout.write(`source       : ${active}
+`);
+      process.stdout.write(`repoIdentity : ${repoIdentity.kind}:${repoIdentity.value}
 `);
     }
   }
 }
+async function handleRebind(deps, projectId, root, mode2) {
+  if (!UUID_RE.test(projectId)) {
+    throw new CliError(
+      `Invalid project ID: "${projectId}". Must be a UUID (e.g. 00000000-0000-0000-0000-000000000001).`,
+      2
+    );
+  }
+  const repoIdentity = await makeRepoIdentityResolver(deps)(root);
+  await deps.http.post(`/api/projects/${projectId}/repo-binding`, { repoIdentity });
+  if (mode2 === "json") {
+    printResult({ rebound: true, projectId, repoIdentity }, mode2);
+  } else {
+    process.stdout.write(`Rebound project ${projectId} to ${repoIdentity.kind}:${repoIdentity.value}.
+`);
+  }
+}
 async function handleUnlink(projectBindingPath, mode2) {
-  const { readFile: readFile7, writeFile: writeFile6, chmod } = await import("fs/promises");
+  const { readFile: readFile8, writeFile: writeFile7, chmod: chmod2 } = await import("fs/promises");
   let existing = {};
   try {
-    const raw = await readFile7(projectBindingPath, "utf8");
+    const raw = await readFile8(projectBindingPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
       throw new CliError(
@@ -483,8 +849,8 @@ async function handleUnlink(projectBindingPath, mode2) {
   }
   const { projectId: _removed, ...rest } = existing;
   void _removed;
-  await writeFile6(projectBindingPath, JSON.stringify(rest, null, 2) + "\n", { mode: 420 });
-  await chmod(projectBindingPath, 420);
+  await writeFile7(projectBindingPath, JSON.stringify(rest, null, 2) + "\n", { mode: 420 });
+  await chmod2(projectBindingPath, 420);
   if (mode2 === "json") {
     printResult({ unlinked: true, projectBindingPath }, mode2);
   } else {
@@ -538,21 +904,38 @@ Proceeding anyway \u2014 verify the ID is correct.
     );
   }
   await writeRepoBinding(root, projectId);
-  const writtenPath = path2.join(root, "nolto.json");
+  const writtenPath = path5.join(root, "nolto.json");
+  let registryAdded = false;
+  try {
+    registryAdded = (await addRepoToRegistry(getRegistryPath(process.env), root)).added;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Warning: could not update watch registry: ${message}
+`);
+  }
   if (mode2 === "json") {
-    printResult({ linked: true, projectId, projectBindingPath: writtenPath }, mode2);
+    printResult({
+      linked: true,
+      projectId,
+      projectBindingPath: writtenPath,
+      registryAdded
+    }, mode2);
   } else {
     process.stdout.write(
       `Linked this repo to project ${projectId} (wrote ${writtenPath}).
 Commit nolto.json to share the binding with your team.
 `
     );
+    if (registryAdded) {
+      process.stdout.write(`watch registry: added ${root}
+`);
+    }
   }
 }
 function register(program, deps) {
   const cmd = program.command("link [projectId]").description(
-    "Bind this repository to a Nolto project.\nWrites nolto.json at the repo root. Commit it to share the binding with your team.\n\nExamples:\n  nolto link <uuid>      Write / update nolto.json\n  nolto link --show      Show the current binding\n  nolto link --unlink    Remove the projectId from nolto.json"
-  ).option("--show", "Show the current repo binding (path + projectId + source)").option("--unlink", "Remove the projectId key from nolto.json");
+    "Bind this repository to a Nolto project.\nWrites nolto.json at the repo root. Commit it to share the binding with your team.\n\nExamples:\n  nolto link <uuid>      Write / update nolto.json\n  nolto link --show      Show the current binding\n  nolto link --rebind    Rebind the project to this repository\n  nolto link --unlink    Remove the projectId from nolto.json"
+  ).option("--show", "Show the current repo binding (path + projectId + source)").option("--rebind", "Rebind the project to this repository (owner only, once per 7 days)").option("--unlink", "Remove the projectId key from nolto.json");
   cmd.action(async (projectId) => {
     const { output } = deps;
     const projectBindingPath = deps.repoBinding?.path ?? deps.projectBindingPath ?? null;
@@ -572,12 +955,23 @@ function register(program, deps) {
       await handleUnlink(projectBindingPath, mode2);
       return;
     }
+    if (cmd.opts()["rebind"]) {
+      const boundProjectId = deps.repoBinding?.binding?.projectId;
+      const effectiveProjectId = projectId ?? boundProjectId;
+      if (effectiveProjectId == null) {
+        throw new CliError("No project binding. Run `nolto link <projectId>` first.", 2);
+      }
+      const startDir = resolveStartDir(process.env, process.cwd());
+      const root = findRepoRoot(startDir).root;
+      await handleRebind(deps, effectiveProjectId, root, mode2);
+      return;
+    }
     if (projectId == null || projectId.trim().length === 0) {
       if (bindingError != null) {
         throw invalidBindingError(projectBindingPath, bindingError);
       }
       throw new CliError(
-        "Usage: nolto link <projectId>  (provide a UUID)\nOr use --show to view the current binding, --unlink to remove it.",
+        "Usage: nolto link <projectId>  (provide a UUID)\nOr use --show to view the current binding, --rebind to rebind it, --unlink to remove it.",
         2
       );
     }
@@ -592,32 +986,32 @@ function invalidBindingError(projectBindingPath, error) {
 }
 
 // src/skill-install.ts
-import { cp, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, rm } from "fs/promises";
+import { cp, mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4, rm } from "fs/promises";
 import { existsSync } from "fs";
-import path3 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
 function resolveSkillSourceDir() {
   const candidates = [
-    path3.resolve(__dirname, "skill/roadmap-progress"),
+    path6.resolve(__dirname, "skill/roadmap-progress"),
     // bundled: dist/skill/...
-    path3.resolve(__dirname, "../../../skills/roadmap-progress")
+    path6.resolve(__dirname, "../../../skills/roadmap-progress")
     // source:  <repo>/skills/...
   ];
   for (const candidate of candidates) {
-    if (existsSync(path3.join(candidate, "SKILL.md"))) return candidate;
+    if (existsSync(path6.join(candidate, "SKILL.md"))) return candidate;
   }
   throw new Error("Bundled roadmap-progress skill not found. Reinstall @nolto/cli.");
 }
 var VERSION_MARKER = ".nolto-skill-version";
 async function installSkill(args) {
-  const targetDir = path3.join(args.skillsParentDir, "roadmap-progress");
-  const markerPath = path3.join(targetDir, VERSION_MARKER);
+  const targetDir = path6.join(args.skillsParentDir, "roadmap-progress");
+  const markerPath = path6.join(targetDir, VERSION_MARKER);
   const dirExists = existsSync(targetDir);
   let installedVersion = null;
   if (dirExists) {
     try {
-      installedVersion = (await readFile2(markerPath, "utf8")).trim();
+      installedVersion = (await readFile4(markerPath, "utf8")).trim();
     } catch {
       installedVersion = null;
     }
@@ -626,79 +1020,29 @@ async function installSkill(args) {
     return { action: "skipped", targetDir };
   }
   await rm(targetDir, { recursive: true, force: true });
-  await mkdir2(args.skillsParentDir, { recursive: true });
+  await mkdir4(args.skillsParentDir, { recursive: true });
   await cp(args.sourceDir, targetDir, { recursive: true });
-  await writeFile2(markerPath, args.version + "\n", "utf8");
+  await writeFile4(markerPath, args.version + "\n", "utf8");
   return { action: dirExists ? "updated" : "installed", targetDir };
 }
 
-// src/registry.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import path4 from "path";
-import { z as z2 } from "zod";
-var registrySchema = z2.object({
-  schemaVersion: z2.literal(1),
-  repos: z2.array(z2.object({ root: z2.string().min(1) }).passthrough())
-}).passthrough();
-function getRegistryPath(env) {
-  return path4.join(getConfigDir(env), "registry.json");
-}
-async function loadRegistry(filePath) {
-  let raw;
-  try {
-    raw = await readFile3(filePath, "utf8");
-  } catch (err) {
-    const code = err != null && typeof err === "object" && "code" in err ? err.code : "";
-    if (code === "ENOENT") {
-      return { schemaVersion: 1, repos: [] };
-    }
-    throw new CliError(`Cannot read registry: ${filePath}: ${String(err)}`, 2);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new CliError(`Malformed JSON in ${filePath}. Fix or remove the file.`, 2);
-  }
-  const result = registrySchema.safeParse(parsed);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    const fieldPath = issue?.path.join(".") ?? "";
-    throw new CliError(
-      `Invalid registry at ${filePath}: ${fieldPath.length > 0 ? `field "${fieldPath}" \u2014 ` : ""}${issue?.message ?? "validation failed"}`,
-      2
-    );
-  }
-  return result.data;
-}
-async function addRepoToRegistry(filePath, repoRoot) {
-  const registry = await loadRegistry(filePath);
-  if (registry.repos.some((repo) => repo.root === repoRoot)) {
-    return { added: false, registry };
-  }
-  const updated = { ...registry, repos: [...registry.repos, { root: repoRoot }] };
-  await mkdir3(path4.dirname(filePath), { recursive: true, mode: 448 });
-  await writeFile3(filePath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  return { added: true, registry: updated };
-}
-
 // src/roadmap-scaffold.ts
-import { mkdir as mkdir4, readdir, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readdir, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path5 from "path";
+import path7 from "path";
 function slugifyProjectId(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^[^a-z0-9]+/, "").replace(/[-_.]+$/, "");
   return slug.length > 0 ? slug : "project";
 }
 async function scaffoldRoadmap(args) {
-  const repoBasename = path5.basename(args.repoRoot);
-  const dir = path5.join(args.repoRoot, ".nolto", "roadmaps");
-  const filePath = path5.join(dir, `${slugifyProjectId(repoBasename)}.json`);
-  const legacyPath = path5.join(args.repoRoot, ".roadmap", "roadmap.json");
+  const repoBasename = path7.basename(args.repoRoot);
+  const dir = path7.join(args.repoRoot, ".nolto", "roadmaps");
+  const filePath = path7.join(dir, `${slugifyProjectId(repoBasename)}.json`);
+  const legacyPath = path7.join(args.repoRoot, ".roadmap", "roadmap.json");
   try {
     const existing = (await readdir(dir)).sort();
     if (existing.length > 0) {
-      return { created: false, path: path5.join(dir, existing[0]) };
+      return { created: false, path: path7.join(dir, existing[0]) };
     }
   } catch (err) {
     if (err == null || typeof err !== "object" || !("code" in err) || err.code !== "ENOENT") {
@@ -720,19 +1064,19 @@ async function scaffoldRoadmap(args) {
     summary: "",
     phases: []
   };
-  await mkdir4(dir, { recursive: true });
-  await writeFile4(filePath, JSON.stringify(roadmap, null, 2) + "\n", "utf8");
+  await mkdir5(dir, { recursive: true });
+  await writeFile5(filePath, JSON.stringify(roadmap, null, 2) + "\n", "utf8");
   return { created: true, path: filePath };
 }
 
 // src/commands/init.ts
-var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
 var _require = createRequire(import.meta.url);
 function getCliVersion() {
   const candidates = [
-    path6.resolve(__dirname2, "../package.json"),
+    path8.resolve(__dirname2, "../package.json"),
     // bundled: dist/../package.json
-    path6.resolve(__dirname2, "../../package.json")
+    path8.resolve(__dirname2, "../../package.json")
     // source:  src/commands/../../package.json
   ];
   for (const pkgPath of candidates) {
@@ -860,20 +1204,21 @@ Set up this repository (${root}) for roadmap sync? [Y/n] `);
               );
             }
             await writeRepoBinding(root, defaultProjectId);
-            process.stdout.write(`binding:        wrote ${path6.join(root, "nolto.json")}
+            process.stdout.write(`binding:        wrote ${path8.join(root, "nolto.json")}
 `);
             const sourceDir = resolveSkillSourceDir();
             const version = getCliVersion();
             const claudeInstall = await installSkill({
-              skillsParentDir: path6.join(root, ".claude", "skills"),
+              skillsParentDir: path8.join(root, ".claude", "skills"),
               sourceDir,
               version
             });
             process.stdout.write(`skill (claude): ${claudeInstall.action} ${claudeInstall.targetDir}
 `);
-            if (fs.existsSync(path6.join(root, ".agents")) || fs.existsSync(path6.join(root, ".codex"))) {
+            const usesAgentsTooling = fs.existsSync(path8.join(root, ".agents")) || fs.existsSync(path8.join(root, ".codex")) || fs.existsSync(path8.join(root, "AGENTS.md"));
+            if (usesAgentsTooling) {
               const agentsInstall = await installSkill({
-                skillsParentDir: path6.join(root, ".agents", "skills"),
+                skillsParentDir: path8.join(root, ".agents", "skills"),
                 sourceDir,
                 version
               });
@@ -882,7 +1227,7 @@ Set up this repository (${root}) for roadmap sync? [Y/n] `);
             }
             const scaffold = await scaffoldRoadmap({
               repoRoot: root,
-              projectName: defaultProjectName ?? path6.basename(root)
+              projectName: defaultProjectName ?? path8.basename(root)
             });
             process.stdout.write(
               scaffold.created ? `roadmap:        created ${scaffold.path}
@@ -1119,142 +1464,15 @@ function register4(program, deps) {
 }
 
 // src/commands/sync.ts
-import { copyFile, mkdir as mkdir5, readFile as readFile4, readdir as readdir2, rename, rmdir, unlink } from "fs/promises";
+import { copyFile, mkdir as mkdir6, readFile as readFile5, readdir as readdir2, rename as rename2, rmdir, unlink as unlink2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 
 // src/sync-repo.ts
-import path8 from "path";
+import path10 from "path";
 
 // src/sync-core.ts
 import { createHash } from "crypto";
-import path7 from "path";
-
-// ../roadmap-schema/src/index.ts
-var STATUSES = /* @__PURE__ */ new Set(["todo", "in-progress", "done", "blocked"]);
-var ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
-var ALLOWED_KEYS = {
-  roadmap: /* @__PURE__ */ new Set(["schemaVersion", "project", "updatedAt", "currentTaskId", "summary", "phases"]),
-  project: /* @__PURE__ */ new Set(["id", "name", "repository"]),
-  phase: /* @__PURE__ */ new Set(["id", "title", "status", "plan", "tasks"]),
-  task: /* @__PURE__ */ new Set(["id", "title", "status", "startedAt", "completedAt", "note", "dependsOn", "plan"])
-};
-function isRecord(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-function checkKeys(value, allowed, at, errors) {
-  if (!isRecord(value)) return;
-  for (const key of Object.keys(value)) {
-    if (!allowed.has(key)) errors.push(`${at} contains unsupported property "${key}".`);
-  }
-}
-function checkPlan(value, at, errors) {
-  if (value === void 0) return;
-  if (typeof value !== "string" || value.length === 0) {
-    errors.push(`${at}.plan must be a non-empty string.`);
-  }
-}
-function derivePhaseStatus(phase) {
-  if (phase.tasks.length > 0 && phase.tasks.every((task) => task.status === "done")) return "done";
-  if (phase.tasks.some((task) => task.status === "in-progress")) return "in-progress";
-  if (phase.tasks.some((task) => task.status === "blocked")) return "blocked";
-  if (phase.tasks.some((task) => task.status === "done")) return "in-progress";
-  return "todo";
-}
-function validateRoadmap(value) {
-  const errors = [];
-  const warnings = [];
-  if (!isRecord(value)) return { errors: ["Root must be an object."], warnings };
-  checkKeys(value, ALLOWED_KEYS.roadmap, "roadmap", errors);
-  if (value["schemaVersion"] !== 1 && value["schemaVersion"] !== 2) {
-    errors.push("schemaVersion must be 1 or 2.");
-  } else if (value["schemaVersion"] === 1) {
-    warnings.push("schemaVersion 1 is legacy; the next roadmap-progress mutation migrates this file to 2.");
-  }
-  const project = value["project"];
-  checkKeys(project, ALLOWED_KEYS.project, "project", errors);
-  const projectRecord = isRecord(project) ? project : {};
-  if (!ID_PATTERN.test(String(projectRecord["id"] ?? ""))) errors.push("project.id is invalid.");
-  if (projectRecord["name"] == null || projectRecord["name"] === "") errors.push("project.name is required.");
-  if (projectRecord["repository"] == null || projectRecord["repository"] === "") errors.push("project.repository is required.");
-  if (Number.isNaN(Date.parse(String(value["updatedAt"])))) errors.push("updatedAt must be a valid date-time.");
-  if (typeof value["summary"] !== "string") errors.push("summary must be a string.");
-  if (!Array.isArray(value["phases"])) errors.push("phases must be an array.");
-  const allIds = /* @__PURE__ */ new Set();
-  const tasks = /* @__PURE__ */ new Map();
-  const phases = Array.isArray(value["phases"]) ? value["phases"] : [];
-  for (const [phaseIndex, rawPhase] of phases.entries()) {
-    const at = `phases[${phaseIndex}]`;
-    checkKeys(rawPhase, ALLOWED_KEYS.phase, at, errors);
-    const phase = isRecord(rawPhase) ? rawPhase : {};
-    const phaseId = String(phase["id"] ?? "");
-    if (!ID_PATTERN.test(phaseId)) errors.push(`${at}.id is invalid.`);
-    if (allIds.has(phaseId)) errors.push(`Duplicate id "${phaseId}".`);
-    allIds.add(phaseId);
-    if (phase["title"] == null || phase["title"] === "") errors.push(`${at}.title is required.`);
-    if (!STATUSES.has(String(phase["status"]))) errors.push(`${at}.status is invalid.`);
-    checkPlan(phase["plan"], at, errors);
-    if (!Array.isArray(phase["tasks"])) errors.push(`${at}.tasks must be an array.`);
-    const rawTasks = Array.isArray(phase["tasks"]) ? phase["tasks"] : [];
-    for (const [taskIndex, rawTask] of rawTasks.entries()) {
-      const taskAt = `${at}.tasks[${taskIndex}]`;
-      checkKeys(rawTask, ALLOWED_KEYS.task, taskAt, errors);
-      const task = isRecord(rawTask) ? rawTask : {};
-      const taskId = String(task["id"] ?? "");
-      if (!ID_PATTERN.test(taskId)) errors.push(`${taskAt}.id is invalid.`);
-      if (allIds.has(taskId)) errors.push(`Duplicate id "${taskId}".`);
-      allIds.add(taskId);
-      tasks.set(taskId, task);
-      if (task["title"] == null || task["title"] === "") errors.push(`${taskAt}.title is required.`);
-      if (!STATUSES.has(String(task["status"]))) errors.push(`${taskAt}.status is invalid.`);
-      checkPlan(task["plan"], taskAt, errors);
-      if (task["status"] === "done" && task["completedAt"] == null) warnings.push(`${taskId} is done without completedAt.`);
-      if (task["status"] === "in-progress" && task["startedAt"] == null) warnings.push(`${taskId} is in-progress without startedAt.`);
-      if (task["dependsOn"] !== void 0 && !Array.isArray(task["dependsOn"])) errors.push(`${taskAt}.dependsOn must be an array.`);
-    }
-    if (Array.isArray(phase["tasks"]) && STATUSES.has(String(phase["status"]))) {
-      const expected = derivePhaseStatus({ ...phase, tasks: rawTasks });
-      if (phase["status"] !== expected) warnings.push(`${phaseId} status is ${String(phase["status"])}; task states derive ${expected}.`);
-    }
-  }
-  for (const task of tasks.values()) {
-    for (const dependency of task.dependsOn ?? []) {
-      if (!tasks.has(dependency)) warnings.push(`${task.id} depends on unknown task ${dependency}.`);
-      if (task.id === dependency) errors.push(`${task.id} cannot depend on itself.`);
-    }
-  }
-  const currentTaskId = value["currentTaskId"];
-  if (currentTaskId !== null && currentTaskId !== void 0) {
-    const current = tasks.get(String(currentTaskId));
-    if (current == null) errors.push(`currentTaskId ${String(currentTaskId)} does not exist.`);
-    else if (current.status !== "in-progress") warnings.push(`currentTaskId ${String(currentTaskId)} is not in-progress.`);
-  }
-  return { errors, warnings };
-}
-function deriveTaskStats(roadmap) {
-  let done = 0;
-  let blocked = 0;
-  let inProgress = 0;
-  let todo = 0;
-  for (const phase of roadmap.phases) {
-    for (const task of phase.tasks) {
-      if (task.status === "done") done += 1;
-      else if (task.status === "blocked") blocked += 1;
-      else if (task.status === "in-progress") inProgress += 1;
-      else todo += 1;
-    }
-  }
-  const total = done + blocked + inProgress + todo;
-  return {
-    total,
-    done,
-    blocked,
-    inProgress,
-    todo,
-    progressPct: total > 0 ? Math.round(done / total * 100) : 0
-  };
-}
-
-// src/sync-core.ts
+import path9 from "path";
 function sha256Hex(content) {
   return "sha256:" + createHash("sha256").update(content, "utf8").digest("hex");
 }
@@ -1275,10 +1493,10 @@ function collectPlanRefs(roadmap) {
   }
   return refs;
 }
-async function loadValidRoadmap(filePath, readFile7) {
+async function loadValidRoadmap(filePath, readFile8) {
   let raw;
   try {
-    raw = await readFile7(filePath);
+    raw = await readFile8(filePath);
   } catch {
     throw new CliError(`No roadmap found at ${filePath}. Run \`nolto init\` first.`, 2);
   }
@@ -1301,7 +1519,7 @@ async function loadValidRoadmap(filePath, readFile7) {
 async function buildSyncBody(args) {
   const planDocuments = [];
   for (const ref of collectPlanRefs(args.roadmap)) {
-    const absolute = path7.join(args.repoRoot, ref.path);
+    const absolute = path9.join(args.repoRoot, ref.path);
     if (!args.deps.fileExists(absolute)) {
       args.deps.warn(`plan file not found, skipping: ${ref.path}`);
       continue;
@@ -1314,12 +1532,13 @@ async function buildSyncBody(args) {
       contentHash: sha256Hex(content)
     });
   }
-  return { roadmap: args.roadmap, planDocuments };
+  return { roadmap: args.roadmap, planDocuments, repoIdentity: args.repoIdentity };
 }
 async function runSync(args, deps) {
   const body = await buildSyncBody({
     roadmap: args.roadmap,
     repoRoot: args.repoRoot,
+    repoIdentity: args.repoIdentity,
     deps
   });
   const response = await deps.http.put(
@@ -1347,7 +1566,7 @@ async function listRoadmapFiles(roadmapsDir, io) {
   }
 }
 async function migrateLegacyRoadmap(args) {
-  const targetPath = path8.join(args.roadmapsDir, `${args.slug}.json`);
+  const targetPath = path10.join(args.roadmapsDir, `${args.slug}.json`);
   await args.io.mkdir(args.roadmapsDir);
   try {
     await args.io.rename(args.legacyPath, targetPath);
@@ -1356,7 +1575,7 @@ async function migrateLegacyRoadmap(args) {
     await args.io.unlink(args.legacyPath);
   }
   try {
-    await args.io.rmdir(path8.dirname(args.legacyPath));
+    await args.io.rmdir(path10.dirname(args.legacyPath));
   } catch {
   }
   args.io.log(
@@ -1365,14 +1584,14 @@ async function migrateLegacyRoadmap(args) {
   return `${args.slug}.json`;
 }
 async function syncRepo(args, io) {
-  const bindingPath = path8.join(args.root, "nolto.json");
+  const bindingPath = path10.join(args.root, "nolto.json");
   const binding = await loadRepoBinding(bindingPath);
   const projectId = binding?.projectId ?? args.defaultProjectId;
   if (projectId == null) {
     throw new CliError("No project binding. Run `nolto init` or `nolto link <projectId>`.", 2);
   }
-  const roadmapsDir = path8.join(args.root, ".nolto", "roadmaps");
-  const legacyPath = path8.join(args.root, ".roadmap", "roadmap.json");
+  const roadmapsDir = path10.join(args.root, ".nolto", "roadmaps");
+  const legacyPath = path10.join(args.root, ".roadmap", "roadmap.json");
   let roadmapFiles = await listRoadmapFiles(roadmapsDir, io);
   if (roadmapFiles.length > 0) {
     if (io.fileExists(legacyPath)) {
@@ -1381,7 +1600,7 @@ async function syncRepo(args, io) {
       );
     }
   } else if (io.fileExists(legacyPath)) {
-    const migrationSlug = binding?.roadmapSlug ?? slugifyProjectId(path8.basename(args.root));
+    const migrationSlug = binding?.roadmapSlug ?? slugifyProjectId(path10.basename(args.root));
     roadmapFiles = [
       await migrateLegacyRoadmap({
         slug: migrationSlug,
@@ -1405,21 +1624,22 @@ async function syncRepo(args, io) {
           2
         );
       }
-      const filePath = path8.join(roadmapsDir, fileName);
+      const filePath = path10.join(roadmapsDir, fileName);
       return { slug, roadmap: await loadValidRoadmap(filePath, io.readFile) };
     })
   );
   const planAbsPaths = /* @__PURE__ */ new Set();
   for (const { roadmap } of roadmaps) {
     for (const ref of collectPlanRefs(roadmap)) {
-      planAbsPaths.add(path8.join(args.root, ref.path));
+      planAbsPaths.add(path10.join(args.root, ref.path));
     }
   }
   const results = [];
+  const repoIdentity = await io.repoIdentity(args.root);
   for (const { slug, roadmap } of roadmaps) {
     results.push(
       await runSync(
-        { repoRoot: args.root, projectId, slug, roadmap },
+        { repoRoot: args.root, projectId, slug, roadmap, repoIdentity },
         { http: io.http, readFile: io.readFile, fileExists: io.fileExists, log: io.log, warn: io.warn }
       )
     );
@@ -1438,38 +1658,46 @@ function register5(program, deps) {
     if (!foundGit) {
       throw new CliError("No git repository found. Run inside a repo set up with `nolto init`.", 2);
     }
-    const http = createHttpClient({
-      baseUrl: deps.settings.baseUrl,
-      version: deps.version,
-      token: deps.settings.token
-    });
+    const http = deps.http;
     const response = await syncRepo(
       { root, defaultProjectId: deps.settings.defaultProjectId },
       {
-        readFile: (p) => readFile4(p, "utf8"),
+        readFile: (p) => readFile5(p, "utf8"),
         fileExists: (p) => existsSync3(p),
         listDir: (p) => readdir2(p),
-        rename,
+        rename: rename2,
         copyFile,
-        mkdir: (p) => mkdir5(p, { recursive: true }).then(() => void 0),
-        unlink,
+        mkdir: (p) => mkdir6(p, { recursive: true }).then(() => void 0),
+        unlink: unlink2,
         rmdir,
+        repoIdentity: makeRepoIdentityResolver(deps),
         http,
         log: (line) => process.stdout.write(line + "\n"),
         warn: (line) => process.stderr.write("Warning: " + line + "\n")
       }
     );
+    let registryAdded = false;
+    try {
+      registryAdded = (await addRepoToRegistry(getRegistryPath(process.env), root)).added;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Warning: could not update watch registry: ${message}
+`);
+    }
     if (deps.output.mode === "json") {
       const { planAbsPaths: _planAbsPaths, ...publicResponse } = response;
-      printResult(publicResponse, "json");
+      printResult({ ...publicResponse, registryAdded }, "json");
+    } else if (registryAdded) {
+      process.stdout.write(`watch registry: added ${root}
+`);
     }
   });
 }
 
 // src/commands/watch.ts
-import { copyFile as copyFile2, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, rename as rename2, rmdir as rmdir2, unlink as unlink2 } from "fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile6, readdir as readdir3, rename as rename3, rmdir as rmdir2, unlink as unlink3 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path10 from "path";
+import path12 from "path";
 import chokidar from "chokidar";
 
 // src/watch-core.ts
@@ -1575,7 +1803,7 @@ var RepoWatch = class {
 };
 
 // src/service-install.ts
-import path9 from "path";
+import path11 from "path";
 import os2 from "os";
 function buildUnitFile(args) {
   return [
@@ -1595,8 +1823,8 @@ function buildUnitFile(args) {
 }
 function getUnitPath(env) {
   const xdg = env["XDG_CONFIG_HOME"];
-  const base = xdg != null && xdg.length > 0 ? xdg : path9.join(os2.homedir(), ".config");
-  return path9.join(base, "systemd", "user", "nolto-watch.service");
+  const base = xdg != null && xdg.length > 0 ? xdg : path11.join(os2.homedir(), ".config");
+  return path11.join(base, "systemd", "user", "nolto-watch.service");
 }
 async function installServiceWith(deps) {
   if (deps.platform !== "linux") {
@@ -1607,7 +1835,7 @@ async function installServiceWith(deps) {
     );
   }
   const unitPath = getUnitPath(deps.env);
-  await deps.mkdir(path9.dirname(unitPath));
+  await deps.mkdir(path11.dirname(unitPath));
   await deps.writeFile(unitPath, buildUnitFile({ nodePath: deps.nodePath, scriptPath: deps.scriptPath }));
   deps.log(`Wrote ${unitPath}`);
   const reload = await deps.exec(["systemctl", "--user", "daemon-reload"]);
@@ -1621,18 +1849,18 @@ async function installServiceWith(deps) {
   deps.log("Service nolto-watch enabled and started. Logs: journalctl --user -u nolto-watch -f");
 }
 async function installService() {
-  const { writeFile: writeFile6, mkdir: mkdir8 } = await import("fs/promises");
-  const { execFile: execFile2 } = await import("child_process");
+  const { writeFile: writeFile7, mkdir: mkdir9 } = await import("fs/promises");
+  const { execFile: execFile3 } = await import("child_process");
   const { promisify: promisify2 } = await import("util");
-  const execFileAsync = promisify2(execFile2);
+  const execFileAsync = promisify2(execFile3);
   await installServiceWith({
     platform: process.platform,
     env: process.env,
     nodePath: process.execPath,
-    scriptPath: path9.resolve(process.argv[1] ?? ""),
-    writeFile: (p, content) => writeFile6(p, content, "utf8"),
+    scriptPath: path11.resolve(process.argv[1] ?? ""),
+    writeFile: (p, content) => writeFile7(p, content, "utf8"),
     mkdir: async (p) => {
-      await mkdir8(p, { recursive: true });
+      await mkdir9(p, { recursive: true });
     },
     exec: async (cmd) => {
       try {
@@ -1686,14 +1914,14 @@ async function uninstallServiceWith(deps) {
   deps.log("Service nolto-watch stopped, disabled, and removed.");
 }
 async function uninstallService() {
-  const { unlink: unlink3 } = await import("fs/promises");
-  const { execFile: execFile2 } = await import("child_process");
+  const { unlink: unlink4 } = await import("fs/promises");
+  const { execFile: execFile3 } = await import("child_process");
   const { promisify: promisify2 } = await import("util");
-  const execFileAsync = promisify2(execFile2);
+  const execFileAsync = promisify2(execFile3);
   await uninstallServiceWith({
     platform: process.platform,
     env: process.env,
-    unlink: unlink3,
+    unlink: unlink4,
     exec: async (cmd) => {
       try {
         await execFileAsync(cmd[0], cmd.slice(1));
@@ -1746,25 +1974,26 @@ function register6(program, deps) {
       token: deps.settings.token
     });
     const startRepo = (root) => {
-      const roadmapsPath = path10.join(root, ".nolto", "roadmaps");
-      const legacyRoadmapPath = path10.join(root, ".roadmap", "roadmap.json");
+      const roadmapsPath = path12.join(root, ".nolto", "roadmaps");
+      const legacyRoadmapPath = path12.join(root, ".roadmap", "roadmap.json");
       const watcher = chokidar.watch([roadmapsPath, legacyRoadmapPath], { ignoreInitial: true });
       const repoWatch = new RepoWatch(root, {
         sync: () => syncRepo(
           { root, defaultProjectId: deps.settings.defaultProjectId },
           {
-            readFile: (p) => readFile5(p, "utf8"),
+            readFile: (p) => readFile6(p, "utf8"),
             fileExists: (p) => existsSync4(p),
             listDir: (p) => readdir3(p),
-            rename: rename2,
+            rename: rename3,
             copyFile: copyFile2,
-            mkdir: (p) => mkdir6(p, { recursive: true }).then(() => void 0),
-            unlink: unlink2,
+            mkdir: (p) => mkdir7(p, { recursive: true }).then(() => void 0),
+            unlink: unlink3,
             rmdir: rmdir2,
+            repoIdentity: makeRepoIdentityResolver(deps),
             http,
-            log: (line) => process.stdout.write(`[${path10.basename(root)}] ${line}
+            log: (line) => process.stdout.write(`[${path12.basename(root)}] ${line}
 `),
-            warn: (line) => process.stderr.write(`Warning: [${path10.basename(root)}] ${line}
+            warn: (line) => process.stderr.write(`Warning: [${path12.basename(root)}] ${line}
 `)
           }
         ),
@@ -1820,18 +2049,18 @@ function register6(program, deps) {
 }
 
 // src/update-cli.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { realpath } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import path12 from "path";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { promisify } from "util";
 
 // src/update-notifier.ts
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir7 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir8 } from "fs/promises";
 import https from "https";
-import path11 from "path";
+import path13 from "path";
 var PACKAGE = "@nolto/cli";
 var CACHE_FILE = "update-check.json";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -1855,7 +2084,7 @@ Update available: ${current} \u2192 ${latest}  \xB7  run \`nolto update\`
 function isDisabled(env) {
   return env["NO_UPDATE_NOTIFIER"] === "1" || env["NODE_ENV"] === "test" || Boolean(env["CI"]);
 }
-function fetchLatestFromRegistry(timeoutMs = REQUEST_TIMEOUT_MS) {
+function fetchLatestFromRegistry(timeoutMs = REQUEST_TIMEOUT_MS, opts = {}) {
   return new Promise((resolve) => {
     const req = https.get(
       `https://registry.npmjs.org/${PACKAGE}/latest`,
@@ -1878,7 +2107,9 @@ function fetchLatestFromRegistry(timeoutMs = REQUEST_TIMEOUT_MS) {
         });
       }
     );
-    req.on("socket", (s) => s.unref());
+    if (opts.unrefSocket ?? true) {
+      req.on("socket", (s) => s.unref());
+    }
     req.on("timeout", () => {
       req.destroy();
       resolve(null);
@@ -1887,9 +2118,9 @@ function fetchLatestFromRegistry(timeoutMs = REQUEST_TIMEOUT_MS) {
   });
 }
 async function writeUpdateCache(cachePath, now, latest) {
-  await mkdir7(path11.dirname(cachePath), { recursive: true });
+  await mkdir8(path13.dirname(cachePath), { recursive: true });
   const payload = { checkedAt: now, latest };
-  await writeFile5(cachePath, JSON.stringify(payload), { mode: 384 });
+  await writeFile6(cachePath, JSON.stringify(payload), { mode: 384 });
 }
 async function refreshCache(cachePath, now, fetchLatest) {
   const latest = await fetchLatest();
@@ -1898,10 +2129,10 @@ async function refreshCache(cachePath, now, fetchLatest) {
 }
 async function checkForUpdate(opts) {
   if (isDisabled(opts.env)) return null;
-  const cachePath = path11.join(opts.configDir, CACHE_FILE);
+  const cachePath = path13.join(opts.configDir, CACHE_FILE);
   let cache = {};
   try {
-    cache = JSON.parse(await readFile6(cachePath, "utf8"));
+    cache = JSON.parse(await readFile7(cachePath, "utf8"));
   } catch {
   }
   if (typeof cache.checkedAt !== "number" || opts.now - cache.checkedAt > CACHE_TTL_MS) {
@@ -1932,6 +2163,7 @@ async function notifyUpdate(opts) {
 var PACKAGE2 = "@nolto/cli";
 var UPDATE_CACHE_FILE = "update-check.json";
 var UPDATE_REQUEST_TIMEOUT_MS = 1e4;
+var UPDATE_FETCH_OPTIONS = { unrefSocket: false };
 function isNpxPath(scriptPath) {
   return /[\\/]_npx[\\/]/.test(scriptPath);
 }
@@ -2005,7 +2237,7 @@ async function updateCliWith(deps) {
   }
   deps.log(`Updated ${PACKAGE2} ${deps.currentVersion} \u2192 ${latest}.`);
   await deps.writeCache(
-    path12.join(deps.configDir, UPDATE_CACHE_FILE),
+    path14.join(deps.configDir, UPDATE_CACHE_FILE),
     deps.now,
     latest
   ).catch(() => void 0);
@@ -2036,17 +2268,17 @@ async function updateCliWith(deps) {
   };
 }
 function getCurrentVersion() {
-  const dirname = path12.dirname(fileURLToPath3(import.meta.url));
+  const dirname = path14.dirname(fileURLToPath3(import.meta.url));
   const require3 = createRequire2(import.meta.url);
   try {
-    const pkg = require3(path12.resolve(dirname, "../package.json"));
+    const pkg = require3(path14.resolve(dirname, "../package.json"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 async function updateCli(opts = {}) {
-  const execFileAsync = promisify(execFile);
+  const execFileAsync = promisify(execFile2);
   const scriptPath = await realpath(process.argv[1] ?? "");
   return updateCliWith({
     currentVersion: getCurrentVersion(),
@@ -2069,7 +2301,7 @@ async function updateCli(opts = {}) {
       }
     },
     realpath,
-    fetchLatest: () => fetchLatestFromRegistry(UPDATE_REQUEST_TIMEOUT_MS),
+    fetchLatest: () => fetchLatestFromRegistry(UPDATE_REQUEST_TIMEOUT_MS, UPDATE_FETCH_OPTIONS),
     writeCache: writeUpdateCache,
     unitExists: existsSync5,
     log: opts.quiet === true ? () => void 0 : (line) => process.stdout.write(line + "\n"),
@@ -2114,11 +2346,11 @@ function buildProgram(deps) {
 }
 
 // src/index.ts
-var __dirname3 = path13.dirname(fileURLToPath4(import.meta.url));
+var __dirname3 = path15.dirname(fileURLToPath4(import.meta.url));
 var require2 = createRequire3(import.meta.url);
 function getVersion() {
   try {
-    const pkgPath = path13.resolve(__dirname3, "../package.json");
+    const pkgPath = path15.resolve(__dirname3, "../package.json");
     const pkg = require2(pkgPath);
     return pkg.version ?? "0.0.0";
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolto/cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "CLI for syncing repository roadmaps with Nolto.",
   "license": "MIT",
   "type": "module",