@nolto/cli 0.7.1 → 0.8.1

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,13 @@ import { Command } from "commander";
 import readline from "readline/promises";
 import { createRequire } from "module";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path6 from "path";
+import os3 from "os";
+import path8 from "path";
 import fs from "fs";
 
 // src/commands/link.ts
-import path2 from "path";
+import os2 from "os";
+import path5 from "path";
 import { statSync as statSync2 } from "fs";
 
 // src/output.ts
@@ -403,6 +437,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 +755,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 +767,26 @@ 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 };
 }
+function isHomeDirectory(dir, home = os2.homedir()) {
+  return path5.resolve(dir) === path5.resolve(home);
+}
 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 +799,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 +813,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 +854,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 +909,43 @@ 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;
+  if (isHomeDirectory(root)) {
+    process.stderr.write(`Warning: refusing to add home directory ${root} to the watch registry.
+`);
+  } else {
+    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 +965,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,113 +996,87 @@ 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 checkSkillVersionDrift(repoRoot, cliVersion) {
+  const skillDirs = [
+    path6.join(repoRoot, ".claude", "skills", "roadmap-progress"),
+    path6.join(repoRoot, ".agents", "skills", "roadmap-progress")
+  ];
+  const drifted = [];
+  for (const dir of skillDirs) {
+    if (!existsSync(dir)) continue;
+    let installed;
+    try {
+      const marker = (await readFile4(path6.join(dir, VERSION_MARKER), "utf8")).trim();
+      installed = marker.length > 0 ? marker : null;
+    } catch {
+      installed = null;
+    }
+    if (installed !== cliVersion) drifted.push({ dir, installed });
+  }
+  return drifted;
+}
+function formatSkillVersionDriftWarning(repoRoot, cliVersion, drifted) {
+  const dirs = drifted.map(({ dir }) => path6.relative(repoRoot, dir).split(path6.sep).join("/")).join(", ");
+  const installed = [...new Set(drifted.map((entry) => entry.installed ?? "unknown"))].join(", ");
+  return `roadmap-progress skill is outdated in ${dirs} (installed ${installed}, CLI ${cliVersion}). Run \`nolto init\` in this repo to update it.`;
+}
 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;
     }
   }
-  if (dirExists && installedVersion === args.version && args.force !== true) {
-    return { action: "skipped", targetDir };
-  }
-  await rm(targetDir, { recursive: true, force: true });
-  await mkdir2(args.skillsParentDir, { recursive: true });
-  await cp(args.sourceDir, targetDir, { recursive: true });
-  await writeFile2(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 };
+  if (dirExists && installedVersion === args.version && args.force !== true) {
+    return { action: "skipped", targetDir };
+  }
+  await rm(targetDir, { recursive: true, force: true });
+  await mkdir4(args.skillsParentDir, { recursive: true });
+  await cp(args.sourceDir, targetDir, { recursive: true });
+  await writeFile4(markerPath, args.version + "\n", "utf8");
+  return { action: dirExists ? "updated" : "installed", targetDir };
 }
 
 // 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 +1098,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) {
@@ -746,160 +1124,212 @@ function getCliVersion() {
   }
   return "0.0.0";
 }
+async function pickProject(rl, http, projects, promptText) {
+  if (projects.length > 0) {
+    process.stdout.write("\nProjects:\n");
+    projects.forEach((project, index) => {
+      process.stdout.write(`  (${index + 1}) ${project.name} \u2014 ${project.id}
+`);
+    });
+  } else {
+    process.stdout.write("\nNo projects yet.\n");
+  }
+  const pick = await rl.question(promptText);
+  const trimmedPick = pick.trim().toLowerCase();
+  if (trimmedPick === "c") {
+    const name = await rl.question("New project name: ");
+    if (name.trim().length === 0) {
+      throw new CliError("Project name is required.", 2);
+    }
+    const created = await http.post(
+      "/api/projects",
+      { name: name.trim() }
+    );
+    if (created.project?.id == null) {
+      throw new CliError("Project API did not return a project id.", 2);
+    }
+    const project = {
+      id: created.project.id,
+      name: created.project.name ?? name.trim()
+    };
+    process.stdout.write(`Created project ${project.name} (${project.id})
+`);
+    return project;
+  }
+  const num = parseInt(trimmedPick, 10);
+  if (!isNaN(num) && num >= 1 && num <= projects.length) {
+    return projects[num - 1];
+  }
+  return void 0;
+}
 function register2(program, deps) {
   program.command("init").description("Interactive setup: configure token, base URL, and default project.").option("--force", "Overwrite existing config without prompting").action(async (opts) => {
     const configPath = deps.configPath;
-    if (!opts.force) {
-      let existing = null;
-      try {
-        existing = await loadConfigFile(configPath);
-      } catch {
-      }
-      if (existing != null) {
-        const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
-        try {
-          const answer = await rl2.question(`Config already exists at ${configPath}. Overwrite? [y/N] `);
-          if (answer.trim().toLowerCase() !== "y") {
-            process.stdout.write("Cancelled.\n");
-            return;
-          }
-        } finally {
-          rl2.close();
-        }
-      }
-    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    let token = "";
     try {
-      const rawUrl = await rl.question(`Base URL [${DEFAULT_BASE_URL}]: `);
-      const baseUrl = rawUrl.trim() || DEFAULT_BASE_URL;
-      const currentToken = deps.settings.token;
-      const tokenPrompt = currentToken != null ? "API token [press Enter to keep current token]: " : "API token: ";
-      const enteredToken = await promptHidden(rl, tokenPrompt);
-      token = enteredToken.length > 0 ? enteredToken : currentToken ?? "";
-      if (token.length === 0) {
-        throw new CliError("Token is required.", 2);
-      }
-      const http = createHttpClient({
-        baseUrl,
-        token,
-        version: getCliVersion()
-      });
-      let projects = [];
-      try {
-        const result = await http.get("/api/projects");
-        projects = Array.isArray(result.projects) ? result.projects : [];
-      } catch (err) {
-        if (err instanceof CliError && err.exitCode === 3) {
-          throw new CliError(`Token rejected by ${baseUrl}`, 3, "Check that your token is valid and has not been revoked.");
+      let configureGlobal = opts.force === true;
+      if (!configureGlobal) {
+        let existing = null;
+        try {
+          existing = await loadConfigFile(configPath);
+        } catch {
+        }
+        if (existing == null || deps.settings.token == null) {
+          configureGlobal = true;
+        } else {
+          const answer = await rl.question(
+            `Config already exists at ${configPath}. Reconfigure token and base URL? [y/N] `
+          );
+          configureGlobal = answer.trim().toLowerCase() === "y";
         }
-        throw err;
       }
-      let defaultProjectId;
+      let token = deps.settings.token ?? "";
+      let baseUrl = deps.settings.baseUrl;
+      let defaultProjectId = deps.settings.defaultProjectId;
       let defaultProjectName;
-      if (projects.length > 0) {
-        process.stdout.write("\nProjects:\n");
-        projects.forEach((p, i) => {
-          process.stdout.write(`  (${i + 1}) ${p.name} \u2014 ${p.id}
-`);
+      let http;
+      let projects;
+      if (configureGlobal) {
+        const rawUrl = await rl.question(`Base URL [${DEFAULT_BASE_URL}]: `);
+        baseUrl = rawUrl.trim() || DEFAULT_BASE_URL;
+        const currentToken = deps.settings.token;
+        const tokenPrompt = currentToken != null ? "API token [press Enter to keep current token]: " : "API token: ";
+        const enteredToken = await promptHidden(rl, tokenPrompt);
+        token = enteredToken.length > 0 ? enteredToken : currentToken ?? "";
+        if (token.length === 0) {
+          throw new CliError("Token is required.", 2);
+        }
+        http = createHttpClient({
+          baseUrl,
+          token,
+          version: getCliVersion()
         });
-      } else {
-        process.stdout.write("\nNo projects yet.\n");
-      }
-      const pick = await rl.question("Default project number, 'c' to create new (or Enter to skip): ");
-      const trimmedPick = pick.trim().toLowerCase();
-      if (trimmedPick === "c") {
-        const name = await rl.question("New project name: ");
-        if (name.trim().length === 0) {
-          throw new CliError("Project name is required.", 2);
+        try {
+          const result = await http.get("/api/projects");
+          projects = Array.isArray(result.projects) ? result.projects : [];
+        } catch (err) {
+          if (err instanceof CliError && err.exitCode === 3) {
+            throw new CliError(`Token rejected by ${baseUrl}`, 3, "Check that your token is valid and has not been revoked.");
+          }
+          throw err;
         }
-        const created = await http.post(
-          "/api/projects",
-          { name: name.trim() }
+        const selected = await pickProject(
+          rl,
+          http,
+          projects,
+          "Default project number, 'c' to create new (or Enter to skip): "
         );
-        if (created.project?.id == null) {
-          throw new CliError("Project API did not return a project id.", 2);
-        }
-        defaultProjectId = created.project.id;
-        defaultProjectName = created.project.name ?? name.trim();
-        process.stdout.write(`Created project ${defaultProjectName} (${defaultProjectId})
-`);
-      } else {
-        const num = parseInt(trimmedPick, 10);
-        if (!isNaN(num) && num >= 1 && num <= projects.length) {
-          defaultProjectId = projects[num - 1].id;
-          defaultProjectName = projects[num - 1].name;
-        }
-      }
-      await saveConfigFile(configPath, {
-        token,
-        baseUrl: baseUrl !== DEFAULT_BASE_URL ? baseUrl : void 0,
-        defaultProjectId
-      });
-      const projectDisplay = defaultProjectId != null ? `${defaultProjectName ?? ""} (${defaultProjectId})` : "not set";
-      process.stdout.write(`
+        defaultProjectId = selected?.id;
+        defaultProjectName = selected?.name;
+        await saveConfigFile(configPath, {
+          token,
+          baseUrl: baseUrl !== DEFAULT_BASE_URL ? baseUrl : void 0,
+          defaultProjectId
+        });
+        const projectDisplay = defaultProjectId != null ? `${defaultProjectName ?? ""} (${defaultProjectId})` : "not set";
+        process.stdout.write(`
 Saved ${configPath}
 `);
-      process.stdout.write(`baseUrl:          ${baseUrl}
+        process.stdout.write(`baseUrl:          ${baseUrl}
 `);
-      process.stdout.write(`token:            ${maskToken(token)}  (verified)
+        process.stdout.write(`token:            ${maskToken(token)}  (verified)
 `);
-      process.stdout.write(`defaultProject:   ${projectDisplay}
+        process.stdout.write(`defaultProject:   ${projectDisplay}
 `);
-      if (defaultProjectId != null) {
-        const startDir = resolveStartDir(process.env, process.cwd());
-        const { root, foundGit } = findRepoRoot(startDir);
-        if (foundGit) {
-          const setup = await rl.question(`
+      } else {
+        const projectDisplay = defaultProjectId ?? "not set";
+        process.stdout.write(
+          `Using existing config: baseUrl=${baseUrl}, token=${maskToken(token)}, defaultProject=${projectDisplay}
+`
+        );
+      }
+      const startDir = resolveStartDir(process.env, process.cwd());
+      const { root, foundGit } = findRepoRoot(startDir);
+      if (!foundGit) {
+        process.stdout.write("\nNo git repository found here \u2014 skipped repo setup. Run `nolto init` inside a repo to set up roadmap sync.\n");
+        return;
+      }
+      if (isHomeDirectory(root)) {
+        process.stderr.write(
+          `Refusing to set up your home directory as a repository root (found ${path8.join(os3.homedir(), ".git")}). Run nolto init inside a project repository.
+`
+        );
+        return;
+      }
+      const existingBinding = deps.repoBinding?.error == null ? deps.repoBinding?.binding ?? null : null;
+      let repoProject = existingBinding != null ? { id: existingBinding.projectId, name: path8.basename(root) } : defaultProjectId != null ? { id: defaultProjectId, name: defaultProjectName ?? path8.basename(root) } : void 0;
+      if (repoProject == null) {
+        http ??= createHttpClient({ baseUrl, token, version: getCliVersion() });
+        if (projects == null) {
+          const result = await http.get("/api/projects");
+          projects = Array.isArray(result.projects) ? result.projects : [];
+        }
+        repoProject = await pickProject(
+          rl,
+          http,
+          projects,
+          "Project number for this repository, 'c' to create new (or Enter to skip): "
+        );
+      }
+      if (repoProject == null) {
+        process.stdout.write("Skipped repo setup (no project selected).\n");
+        return;
+      }
+      const setup = await rl.question(`
 Set up this repository (${root}) for roadmap sync? [Y/n] `);
-          if (setup.trim().toLowerCase() !== "n") {
-            if (deps.repoBinding?.error != null) {
-              process.stderr.write(
-                `Warning: existing nolto.json is invalid (${deps.repoBinding.error.message}). Overwriting it to repair.
+      if (setup.trim().toLowerCase() === "n") {
+        process.stdout.write("Skipped repo setup.\n");
+        return;
+      }
+      const bindingPath = deps.repoBinding?.path ?? path8.join(root, "nolto.json");
+      if (existingBinding != null) {
+        process.stdout.write(`binding:        kept ${bindingPath} (${existingBinding.projectId})
+`);
+      } else {
+        if (deps.repoBinding?.error != null) {
+          process.stderr.write(
+            `Warning: existing nolto.json is invalid (${deps.repoBinding.error.message}). Overwriting it to repair.
 `
-              );
-            }
-            await writeRepoBinding(root, defaultProjectId);
-            process.stdout.write(`binding:        wrote ${path6.join(root, "nolto.json")}
+          );
+        }
+        await writeRepoBinding(root, repoProject.id);
+        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"),
-              sourceDir,
-              version
-            });
-            process.stdout.write(`skill (claude): ${claudeInstall.action} ${claudeInstall.targetDir}
+      }
+      const sourceDir = resolveSkillSourceDir();
+      const version = getCliVersion();
+      const claudeInstall = await installSkill({
+        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 agentsInstall = await installSkill({
-                skillsParentDir: path6.join(root, ".agents", "skills"),
-                sourceDir,
-                version
-              });
-              process.stdout.write(`skill (agents): ${agentsInstall.action} ${agentsInstall.targetDir}
+      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: path8.join(root, ".agents", "skills"),
+          sourceDir,
+          version
+        });
+        process.stdout.write(`skill (agents): ${agentsInstall.action} ${agentsInstall.targetDir}
 `);
-            }
-            const scaffold = await scaffoldRoadmap({
-              repoRoot: root,
-              projectName: defaultProjectName ?? path6.basename(root)
-            });
-            process.stdout.write(
-              scaffold.created ? `roadmap:        created ${scaffold.path}
+      }
+      const scaffold = await scaffoldRoadmap({
+        repoRoot: root,
+        projectName: repoProject.name
+      });
+      process.stdout.write(
+        scaffold.created ? `roadmap:        created ${scaffold.path}
 ` : `roadmap:        exists ${scaffold.path}
 `
-            );
-            const registryResult = await addRepoToRegistry(getRegistryPath(process.env), root);
-            process.stdout.write(
-              registryResult.added ? `watch registry: added ${root}
+      );
+      const registryResult = await addRepoToRegistry(getRegistryPath(process.env), root);
+      process.stdout.write(
+        registryResult.added ? `watch registry: added ${root}
 ` : `watch registry: already registered
 `
-            );
-          }
-        } else {
-          process.stdout.write("\nNo git repository found here \u2014 skipped repo setup. Run `nolto init` inside a repo to set up roadmap sync.\n");
-        }
-      }
+      );
     } finally {
       rl.close();
     }
@@ -1119,142 +1549,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 +1578,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 +1604,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 +1617,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 +1651,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 +1660,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 +1669,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 +1685,13 @@ async function syncRepo(args, io) {
       );
     }
   } else if (io.fileExists(legacyPath)) {
-    const migrationSlug = binding?.roadmapSlug ?? slugifyProjectId(path8.basename(args.root));
+    if (args.migrateLegacy !== true) {
+      io.warn(
+        "legacy .roadmap/roadmap.json found \u2014 run `nolto sync` once to migrate it to .nolto/roadmaps/ (watch does not migrate automatically)"
+      );
+      return { results: [], planAbsPaths: [] };
+    }
+    const migrationSlug = binding?.roadmapSlug ?? slugifyProjectId(path10.basename(args.root));
     roadmapFiles = [
       await migrateLegacyRoadmap({
         slug: migrationSlug,
@@ -1405,21 +1715,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 +1749,61 @@ 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 warn = (line) => {
+      process.stderr.write("Warning: " + line + "\n");
+    };
     const response = await syncRepo(
-      { root, defaultProjectId: deps.settings.defaultProjectId },
+      { root, defaultProjectId: deps.settings.defaultProjectId, migrateLegacy: true },
       {
-        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")
+        warn
       }
     );
+    try {
+      const drifted = await checkSkillVersionDrift(root, deps.version);
+      if (drifted.length > 0) {
+        warn(formatSkillVersionDriftWarning(root, deps.version, drifted));
+      }
+    } catch {
+    }
+    let registryAdded = false;
+    if (isHomeDirectory(root)) {
+      process.stderr.write(`Warning: refusing to add home directory ${root} to the watch registry.
+`);
+    } else {
+      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,8 +1909,8 @@ var RepoWatch = class {
 };
 
 // src/service-install.ts
-import path9 from "path";
-import os2 from "os";
+import path11 from "path";
+import os4 from "os";
 function buildUnitFile(args) {
   return [
     "[Unit]",
@@ -1595,8 +1929,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(os4.homedir(), ".config");
+  return path11.join(base, "systemd", "user", "nolto-watch.service");
 }
 async function installServiceWith(deps) {
   if (deps.platform !== "linux") {
@@ -1607,7 +1941,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 +1955,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 +2020,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,26 +2080,31 @@ 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 warn = (line) => {
+        process.stderr.write(`Warning: [${path12.basename(root)}] ${line}
+`);
+      };
       const watcher = chokidar.watch([roadmapsPath, legacyRoadmapPath], { ignoreInitial: true });
       const repoWatch = new RepoWatch(root, {
         sync: () => syncRepo(
-          { root, defaultProjectId: deps.settings.defaultProjectId },
+          // #316: watch must warn about legacy roadmaps without migrating them.
+          { root, defaultProjectId: deps.settings.defaultProjectId, migrateLegacy: false },
           {
-            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
           }
         ),
         watcher,
@@ -1776,6 +2115,12 @@ function register6(program, deps) {
         warn: (line) => process.stderr.write(line + "\n")
       });
       watcher.on("all", (_event, filePath) => repoWatch.handleEvent(filePath));
+      void checkSkillVersionDrift(root, deps.version).then((drifted) => {
+        if (drifted.length > 0) {
+          warn(formatSkillVersionDriftWarning(root, deps.version, drifted));
+        }
+      }).catch(() => {
+      });
       void repoWatch.flush();
       return { stop: () => watcher.close() };
     };
@@ -1820,18 +2165,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;
@@ -1889,9 +2234,9 @@ function fetchLatestFromRegistry(timeoutMs = REQUEST_TIMEOUT_MS, opts = {}) {
   });
 }
 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();
@@ -1900,10 +2245,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) {
@@ -2008,7 +2353,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);
@@ -2039,17 +2384,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(),
@@ -2117,11 +2462,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 {