@delorenj/pjangler 1.5.39 → 1.5.41

package/dist/index.js

@@ -6064,8 +6064,8 @@ var init_capture = __esm({
 
 // src/index.ts
 import { spawnSync as spawnSync18 } from "node:child_process";
-import { existsSync as existsSync27, readdirSync as readdirSync13, readFileSync as readFileSync30, statSync as statSync9 } from "node:fs";
-import { basename as basename11, join as join35, resolve as resolve25 } from "node:path";
+import { existsSync as existsSync26, readdirSync as readdirSync14, readFileSync as readFileSync32, statSync as statSync9 } from "node:fs";
+import { basename as basename12, join as join37, resolve as resolve25 } from "node:path";
 import { Command as Command3, CommanderError, Option } from "commander";
 
 // src/recipes/Recipe.ts
@@ -20943,8 +20943,204 @@ async function loadScreen(relativeToDist, base) {
 init_boardQuery();
 init_style();
 import { spawnSync as spawnSync17 } from "node:child_process";
-import { readFileSync as readFileSync29 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync30, realpathSync as realpathSync12, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { dirname as dirname22, join as join35 } from "node:path";
+
+// src/crank/engine.ts
+import { closeSync as closeSync9, constants as constants7, fstatSync as fstatSync5, openSync as openSync9, readFileSync as readFileSync29, readSync as readSync5 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
 import { join as join34 } from "node:path";
+var ENGINE_DEFAULT_JOB_ID = "777c511a009c";
+var WINDOW_MS = 24 * 60 * 60 * 1e3;
+var TICK_MS = 5 * 60 * 1e3;
+var STALL_MS = 3 * TICK_MS;
+var ENGINE_AUDIT_TAIL_BYTES = 1024 * 1024;
+function unknownEngineStatus(nowMs, jobId = ENGINE_DEFAULT_JOB_ID) {
+  return { known: false, jobId, readAtMs: nowMs, outcome: "unknown", beats24h: 0, tokens24h: 0, tokenBlocked: false };
+}
+var FUTURE_SKEW_MS = 5 * 6e4;
+function parseAuditRows(text2, jobId) {
+  const rows = [];
+  for (const line of text2.split("\n")) {
+    const trimmed2 = line.trim();
+    if (!trimmed2) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed2);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+    const record3 = parsed;
+    if (String(record3.job_id ?? "") !== jobId) continue;
+    const ts = typeof record3.ts === "string" ? Date.parse(record3.ts) : Number.NaN;
+    if (!Number.isFinite(ts)) continue;
+    const tokens = Number(record3.total_tokens ?? 0);
+    const reasonRaw = record3.economics_reason ?? record3.error;
+    rows.push({
+      tsMs: ts,
+      status: typeof record3.status === "string" ? record3.status : "",
+      tokens: Number.isFinite(tokens) && tokens > 0 ? tokens : 0,
+      reason: typeof reasonRaw === "string" && reasonRaw.trim() ? reasonRaw.trim() : void 0
+    });
+  }
+  return rows.sort((a, b) => a.tsMs - b.tsMs);
+}
+function capFromReason(reason) {
+  const match = /daily token limit reached \(([\d,]+)\)/i.exec(reason ?? "");
+  if (!match) return void 0;
+  const n = Number.parseInt((match[1] ?? "").replace(/,/g, ""), 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function parseEngineStatus(auditText, input) {
+  const jobId = input.jobId ?? ENGINE_DEFAULT_JOB_ID;
+  try {
+    const rows = parseAuditRows(auditText, jobId).filter((r) => r.tsMs <= input.nowMs + FUTURE_SKEW_MS);
+    const last = rows.at(-1);
+    if (!last) return unknownEngineStatus(input.nowMs, jobId);
+    const windowStart = input.nowMs - WINDOW_MS;
+    const counted = rows.filter((r) => (r.status === "completed" || r.status === "started") && r.tsMs >= windowStart);
+    const tokens24h = counted.reduce((sum, r) => sum + r.tokens, 0);
+    const ran = last.status === "completed" || last.status === "started";
+    const refused = !ran && last.status !== "failed" && (last.status === "skipped" || last.status === "blocked" || !!last.reason);
+    const outcome = ran ? "cranked" : refused ? "refused" : "other";
+    const tokenBlocked = outcome === "refused" && /daily token limit/i.test(last.reason ?? "");
+    let refusedSinceMs;
+    if (outcome === "refused") {
+      refusedSinceMs = last.tsMs;
+      for (let i = rows.length - 2; i >= 0; i--) {
+        const r = rows[i];
+        if (!r) break;
+        if (r.status === "completed" || r.status === "started" || r.status === "failed") break;
+        refusedSinceMs = r.tsMs;
+      }
+    }
+    const cap = input.cap && input.cap > 0 ? input.cap : capFromReason(last.reason);
+    let resumeMs;
+    if (tokenBlocked && cap) {
+      let remaining = tokens24h;
+      resumeMs = remaining < cap ? input.nowMs : void 0;
+      for (const row of counted) {
+        if (remaining < cap) break;
+        remaining -= row.tokens;
+        if (remaining < cap) {
+          resumeMs = row.tsMs + WINDOW_MS;
+          break;
+        }
+      }
+    }
+    return {
+      known: true,
+      jobId,
+      readAtMs: input.nowMs,
+      outcome,
+      lastStatus: last.status || void 0,
+      lastTickMs: last.tsMs,
+      reason: outcome === "cranked" ? void 0 : last.reason,
+      refusedSinceMs,
+      beats24h: counted.length,
+      tokens24h,
+      cap,
+      tokenBlocked,
+      resumeMs
+    };
+  } catch {
+    return unknownEngineStatus(input.nowMs, jobId);
+  }
+}
+function readTail(path, maxBytes) {
+  const fd = openSync9(path, constants7.O_RDONLY | constants7.O_NONBLOCK);
+  try {
+    const stat = fstatSync5(fd);
+    if (!stat.isFile()) throw new Error(`${path} is not a regular file`);
+    const size = stat.size;
+    const length = Math.min(size, maxBytes);
+    const buffer = Buffer.alloc(length);
+    let read = 0;
+    while (read < length) {
+      const n = readSync5(fd, buffer, read, length - read, size - length + read);
+      if (n <= 0) break;
+      read += n;
+    }
+    const text2 = buffer.subarray(0, read).toString("utf8");
+    if (size <= maxBytes) return text2;
+    const newline = text2.indexOf("\n");
+    return newline === -1 ? "" : text2.slice(newline + 1);
+  } finally {
+    closeSync9(fd);
+  }
+}
+function engineSources(env2 = process.env) {
+  const cronDir = join34(homedir14(), ".hermes", "profiles", "33god-pm", "cron");
+  return {
+    auditPath: env2.PJ_CRANK_USAGE_AUDIT?.trim() || join34(cronDir, "usage_audit.jsonl"),
+    jobsPath: join34(cronDir, "jobs.json"),
+    jobId: env2.PJ_CRANK_JOB_ID?.trim() || ENGINE_DEFAULT_JOB_ID
+  };
+}
+function readCap(jobsPath, jobId) {
+  try {
+    const parsed = JSON.parse(readFileSync29(jobsPath, "utf8"));
+    const jobs = Array.isArray(parsed.jobs) ? parsed.jobs : [];
+    const job = jobs.find((j) => typeof j === "object" && j !== null && String(j.id ?? "") === jobId);
+    const economics = job?.economics;
+    if (typeof economics !== "object" || economics === null) return void 0;
+    const cap = Number(economics.max_daily_tokens);
+    return Number.isFinite(cap) && cap > 0 ? cap : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readEngineStatus(options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  const base = engineSources(options.env);
+  const sources = { ...base, ...options.sources };
+  try {
+    const text2 = readTail(sources.auditPath, options.tailBytes ?? ENGINE_AUDIT_TAIL_BYTES);
+    return parseEngineStatus(text2, { jobId: sources.jobId, cap: readCap(sources.jobsPath, sources.jobId), nowMs });
+  } catch {
+    return unknownEngineStatus(nowMs, sources.jobId);
+  }
+}
+function clockTime(ms) {
+  const d = new Date(ms);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function ago(thenMs, nowMs) {
+  const s = Math.max(0, Math.round((nowMs - thenMs) / 1e3));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m ago`;
+  return `${Math.floor(s / 86400)}d ${Math.floor(s % 86400 / 3600)}h ago`;
+}
+function compactTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${Math.round(n / 1e3)}k`;
+  return String(n);
+}
+function nextTickAtOrAfter(ms) {
+  return Math.ceil(ms / TICK_MS) * TICK_MS;
+}
+function engineStalled(status) {
+  return status.known && status.lastTickMs !== void 0 && status.readAtMs - status.lastTickMs > STALL_MS;
+}
+function engineSummary(status) {
+  if (!status.known || status.lastTickMs === void 0) return { text: "engine status unknown", tone: "unknown" };
+  const now = status.readAtMs;
+  const usage = `${status.beats24h} beat${status.beats24h === 1 ? "" : "s"} / ${compactTokens(status.tokens24h)} tokens in 24h${status.cap ? ` of ${compactTokens(status.cap)}` : ""}`;
+  const tick = `last tick ${ago(status.lastTickMs, now)}`;
+  const stalled = engineStalled(status) ? " - not ticking" : "";
+  if (status.outcome === "cranked") return { text: `${tick} (cranked)${stalled} \xB7 ${usage}`, tone: stalled ? "warn" : "ok" };
+  if (status.outcome === "refused") {
+    const since = status.refusedSinceMs !== void 0 && status.refusedSinceMs < status.lastTickMs ? ` since ${ago(status.refusedSinceMs, now)}` : "";
+    const resume = status.tokenBlocked && status.resumeMs !== void 0 ? ` \xB7 resumes \u2248 ${clockTime(nextTickAtOrAfter(status.resumeMs))}` : "";
+    return { text: `REFUSING${since}: ${status.reason ?? "refused"} \xB7 ${tick}${stalled} \xB7 ${usage}${resume}`, tone: "warn" };
+  }
+  return { text: `${tick} (${status.lastStatus ?? "other"}${status.reason ? `: ${status.reason}` : ""})${stalled} \xB7 ${usage}`, tone: "warn" };
+}
+
+// src/crank/index.ts
 var ZCRANK_REDIS_HOST = "127.0.0.1";
 var ZCRANK_REDIS_PORT = 6379;
 function redisEndpoint(env2 = process.env) {
@@ -20959,7 +21155,7 @@ var ZCRANK_LOG_CAP = 500;
 var TAB_STATUS_SUFFIX = /[\s🟢🟡🔴🔔⚫✳✻●·─]+$/u;
 var defaultShell = (command, args) => {
   const result2 = spawnSync17(command, args, { encoding: "utf8", timeout: 1e4 });
-  if (result2.error) return { stdout: "", status: 127 };
+  if (result2.error) return { stdout: "", status: result2.error.code === "ETIMEDOUT" ? 124 : 127 };
   return { stdout: result2.stdout ?? "", status: result2.status ?? 1, stderr: result2.stderr ?? "" };
 };
 function tabDisplay(name) {
@@ -21095,6 +21291,15 @@ function redis(deps = {}) {
     setTabEnabled: (tab, enabled2) => {
       run("HSET", `zcrank:tab:${tab}`, "enabled", enabled2 ? "1" : "0");
     },
+    /** HGET zcrank:tab:<tab> root -> the owning project identity, or undefined (legacy key / absent). */
+    tabRoot: (tab) => {
+      const v = run("HGET", `zcrank:tab:${tab}`, "root");
+      return v === "" || v == null ? void 0 : v;
+    },
+    /** HSET zcrank:tab:<tab> root <project identity> (PJAN-201). */
+    setTabRoot: (tab, root) => {
+      run("HSET", `zcrank:tab:${tab}`, "root", root);
+    },
     /** HGET zcrank:tab:<tab> interval -> a valid interval, else undefined (absent or garbage). */
     tabInterval: (tab) => parseInterval(run("HGET", `zcrank:tab:${tab}`, "interval")),
     /** HSET zcrank:tab:<tab> interval <5m|1h|6h|1d>. */
@@ -21165,11 +21370,188 @@ function liveTabs(deps = {}) {
   try {
     const parsed = JSON.parse(result2.stdout);
     if (!Array.isArray(parsed)) return [];
-    return parsed.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => ({ name: String(entry.name ?? ""), position: Number(entry.position ?? 0) }));
+    return parsed.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => {
+      const id = Number(entry.tab_id);
+      return {
+        name: String(entry.name ?? ""),
+        position: Number(entry.position ?? 0),
+        ...entry.tab_id !== void 0 && entry.tab_id !== null && Number.isInteger(id) ? { id } : {}
+      };
+    });
   } catch {
     return [];
   }
 }
+function parseListPanes(stdout) {
+  if (!stdout.trim()) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const panes = [];
+  for (const entry of parsed) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const e = entry;
+    const id = Number(e.id);
+    if (!Number.isFinite(id)) continue;
+    const tabId = Number(e.tab_id);
+    const tabPosition = Number(e.tab_position);
+    panes.push({
+      id,
+      tabId: e.tab_id !== void 0 && e.tab_id !== null && Number.isInteger(tabId) ? tabId : void 0,
+      tabPosition: e.tab_position !== void 0 && e.tab_position !== null && Number.isInteger(tabPosition) ? tabPosition : void 0,
+      tabName: String(e.tab_name ?? ""),
+      isPlugin: e.is_plugin === true,
+      cwd: typeof e.pane_cwd === "string" && e.pane_cwd.trim() ? e.pane_cwd : void 0,
+      title: typeof e.title === "string" ? e.title : null
+    });
+  }
+  return panes;
+}
+function runListPanes(session, shell) {
+  return shell("env", ["-u", "ZELLIJ", "-u", "ZELLIJ_SESSION_NAME", "timeout", "8s", "zellij", "-s", session, "action", "list-panes", "--json", "--all"]);
+}
+function livePanes(deps = {}) {
+  const shell = deps.shell ?? defaultShell;
+  const result2 = runListPanes(deps.session ?? ZCRANK_SESSION, shell);
+  if (result2.status !== 0) return [];
+  return (parseListPanes(result2.stdout) ?? []).map(({ title: _title, ...pane }) => pane);
+}
+function projectIdentity(dir, deps = {}) {
+  const target = (dir ?? "").trim();
+  if (!target) return void 0;
+  const cached = deps.cache?.get(target);
+  if (cached !== void 0) return cached ?? void 0;
+  if (deps.budget) {
+    deps.budget.untilMs ??= Date.now() + deps.budget.totalMs;
+    if (Date.now() > deps.budget.untilMs) return void 0;
+  }
+  const shell = deps.shell ?? defaultShell;
+  let identity2;
+  try {
+    const result2 = shell("timeout", ["2s", "git", "-C", target, "worktree", "list", "--porcelain"]);
+    if (result2.status === 0) {
+      const first = result2.stdout.split("\n").find((line) => line.startsWith("worktree "));
+      const path = first?.slice("worktree ".length).replace(/\r$/, "").trim();
+      if (path) identity2 = realpathSync12(path);
+    }
+  } catch {
+    identity2 = void 0;
+  }
+  deps.cache?.set(target, identity2 ?? null);
+  return identity2;
+}
+function withTabOwners(tabs, panes, identify, claimed = []) {
+  const claimedSet = new Set(claimed);
+  return tabs.map((tab) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const pane of panes) {
+      if (pane.isPlugin || !pane.cwd) continue;
+      const inTab = tab.id !== void 0 && pane.tabId !== void 0 ? pane.tabId === tab.id : pane.tabPosition === tab.position;
+      if (!inTab) continue;
+      const identity2 = identify(pane.cwd);
+      if (identity2) counts.set(identity2, (counts.get(identity2) ?? 0) + 1);
+    }
+    const ranked = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+    const tied = ranked.filter(([, n]) => n === ranked[0]?.[1]).map(([identity2]) => identity2);
+    const claimedTied = tied.filter((identity2) => claimedSet.has(identity2));
+    const owner = tied.length === 1 ? tied[0] : claimedTied.length === 1 ? claimedTied[0] : void 0;
+    const enriched = { ...tab };
+    if (owner) enriched.owner = owner;
+    if (ranked.length) enriched.ownedPanes = Object.fromEntries(ranked);
+    return enriched;
+  });
+}
+var PANE_CWD_TTL_SECONDS = 6 * 3600;
+function paneCwdCachePath(env2 = process.env) {
+  return env2.ZCRANK_CWD_CACHE?.trim() || join35(homedir15(), ".local/state/zcrank/pane-cwds.json");
+}
+function loadCwdCache(path) {
+  try {
+    const parsed = JSON.parse(readFileSync30(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveCwdCache(path, cache) {
+  try {
+    mkdirSync12(dirname22(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync15(tmp, JSON.stringify(cache));
+    renameSync10(tmp, path);
+  } catch {
+  }
+}
+function cwdEntryFresh(entry, nowSeconds) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return false;
+  const ts = Number(entry.ts ?? 0);
+  return Number.isFinite(ts) && nowSeconds - ts < PANE_CWD_TTL_SECONDS;
+}
+function resolvePaneCwds(fetch2, opts = {}) {
+  const now = (opts.nowMs ?? Date.now()) / 1e3;
+  const path = opts.cachePath ?? paneCwdCachePath();
+  const get = () => {
+    try {
+      const rows = fetch2();
+      return Array.isArray(rows) ? rows : [];
+    } catch {
+      return [];
+    }
+  };
+  const panes = get();
+  if (!panes.length) return panes;
+  const cache = loadCwdCache(path);
+  const sameTab = (entry, pane) => (entry.tab_id ?? null) === (pane.tabId ?? null);
+  const fill = () => {
+    let unknown2 = 0;
+    for (const pane of panes) {
+      if (pane.isPlugin) continue;
+      const key = String(pane.id);
+      if (pane.cwd) {
+        cache[key] = { cwd: pane.cwd, tab_id: pane.tabId ?? null, ts: now };
+        continue;
+      }
+      const entry = cache[key];
+      if (cwdEntryFresh(entry, now) && sameTab(entry, pane) && typeof entry.cwd === "string" && entry.cwd) {
+        pane.cwd = entry.cwd;
+      } else {
+        unknown2++;
+      }
+    }
+    return unknown2;
+  };
+  let unknown = fill();
+  for (let attempt = 0; attempt < (opts.retries ?? 0) && unknown; attempt++) {
+    const again = new Map(get().filter((pane) => pane.cwd).map((pane) => [pane.id, pane.cwd]));
+    for (const pane of panes) {
+      const cwd = again.get(pane.id);
+      if (!pane.isPlugin && !pane.cwd && cwd) pane.cwd = cwd;
+    }
+    unknown = fill();
+  }
+  const live = new Set(panes.filter((pane) => !pane.isPlugin).map((pane) => String(pane.id)));
+  for (const key of Object.keys(cache)) {
+    if (!live.has(key) || !cwdEntryFresh(cache[key], now)) delete cache[key];
+  }
+  saveCwdCache(path, cache);
+  return panes;
+}
+function liveTabsWithOwners(deps = {}) {
+  const tabs = liveTabs(deps);
+  if (!tabs.length) return tabs;
+  const cache = /* @__PURE__ */ new Map();
+  const budget = { totalMs: IDENTITY_BUDGET_MS };
+  const panes = resolvePaneCwds(() => livePanes(deps), { retries: deps.retries ?? 1, nowMs: deps.nowMs, cachePath: deps.cachePath });
+  return withTabOwners(tabs, panes, (cwd) => projectIdentity(cwd, { shell: deps.shell, cache, budget }), deps.claimed ?? []);
+}
+function claimedRoots(store, keys = storedTabKeys(store)) {
+  return [...new Set(Object.values(storedTabRoots(store, keys)))].sort();
+}
+var IDENTITY_BUDGET_MS = 2e4;
 function candidateNames(project) {
   const out = [project.name.trim()].filter(Boolean);
   for (const agent of project.agents) {
@@ -21182,13 +21564,41 @@ function candidateNames(project) {
   }
   return out;
 }
-function resolveTabForProject(project, live, storedTabs) {
+function keyForLiveTab(tab, storedTabs) {
+  const display = tabDisplay(tab.name);
+  if (storedTabs.includes(display)) return display;
+  return storedTabs.find((s) => canon(s) && canon(s) === canon(display)) ?? display;
+}
+function ownerOfLiveTab(live, liveTab) {
+  if (liveTab === void 0) return void 0;
+  return live.find((tab) => tabDisplay(tab.name) === liveTab)?.owner;
+}
+function resolveTabForProject(project, live, storedTabs, scope = {}) {
+  const byCwd = resolveByCwd(project, live, storedTabs, scope);
+  if (byCwd) return byCwd;
+  const resolution = resolveByName(project, live, storedTabs);
+  const tabOwner = ownerOfLiveTab(live, resolution.liveTab);
+  return tabOwner ? { ...resolution, tabOwner } : resolution;
+}
+function resolveByCwd(project, live, storedTabs, scope) {
+  const identity2 = scope.identity;
+  if (!identity2) return void 0;
+  const owned = live.filter((tab2) => tab2.owner === identity2);
+  if (!owned.length) return void 0;
+  const candidateCanons = new Set(candidateNames(project).map((name) => canon(name)).filter(Boolean));
+  const ranked = [...owned].sort((a, b) => Number(candidateCanons.has(canon(b.name))) - Number(candidateCanons.has(canon(a.name))) || (b.ownedPanes?.[identity2] ?? 0) - (a.ownedPanes?.[identity2] ?? 0) || a.position - b.position);
+  const tab = ranked[0];
+  if (!tab) return void 0;
+  let key = keyForLiveTab(tab, storedTabs);
+  if (!storedTabs.includes(key)) {
+    const rooted = storedTabs.find((stored) => scope.roots?.[stored] === identity2);
+    if (rooted !== void 0) key = rooted;
+  }
+  return { tab: key, source: "live-cwd", matched: identity2, storedAsIs: false, liveTab: tabDisplay(tab.name), tabOwner: identity2 };
+}
+function resolveByName(project, live, storedTabs) {
   const candidates = candidateNames(project);
-  const keyFor = (tab) => {
-    const display = tabDisplay(tab.name);
-    if (storedTabs.includes(display)) return display;
-    return storedTabs.find((s) => canon(s) && canon(s) === canon(display)) ?? display;
-  };
+  const keyFor = (tab) => keyForLiveTab(tab, storedTabs);
   const sideSets = [
     (tab) => [tab.name],
     (tab) => tabDisplay(tab.name).split(":")
@@ -21224,7 +21634,7 @@ function resolveTabForProject(project, live, storedTabs) {
 function projectNameFor(handle, registryName) {
   if (registryName && registryName.trim()) return registryName.trim();
   try {
-    const manifest = JSON.parse(readFileSync29(join34(handle.root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync30(join35(handle.root, ".project.json"), "utf8"));
     const name = manifest.project_name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
@@ -21235,7 +21645,7 @@ function projectAgentsFor(handle, registryAgents) {
   const fromRecord = Object.entries(registryAgents ?? {}).map(([agentHandle, value]) => ({ handle: agentHandle, role: String(value?.role ?? "") }));
   if (fromRecord.length) return fromRecord;
   try {
-    const manifest = JSON.parse(readFileSync29(join34(handle.root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync30(join35(handle.root, ".project.json"), "utf8"));
     const agents = manifest.agents;
     if (agents && typeof agents === "object" && !Array.isArray(agents)) {
       return Object.entries(agents).map(([agentHandle, value]) => ({ handle: agentHandle, role: typeof value?.role === "string" ? value.role : "" }));
@@ -21244,17 +21654,22 @@ function projectAgentsFor(handle, registryAgents) {
   }
   return [];
 }
-function keysNamingTab(tab, storedKeys) {
+function keysNamingTab(tab, storedKeys, scope = {}) {
   const c = canon(tab);
   const out = [];
   if (storedKeys.includes(tab)) out.push(tab);
   for (const key of storedKeys) {
     if (key !== tab && c && canon(key) === c) out.push(key);
   }
+  if (scope.owner) {
+    for (const key of storedKeys) {
+      if (scope.roots?.[key] === scope.owner && !out.includes(key)) out.push(key);
+    }
+  }
   return out;
 }
-function snapshotCrank(store, tab, storedKeys, nowMs, beatLimit = 5) {
-  const keys = keysNamingTab(tab, storedKeys);
+function snapshotCrank(store, tab, storedKeys, nowMs, beatLimit = 5, scope = {}) {
+  const keys = keysNamingTab(tab, storedKeys, scope);
   const readKeys = keys.length ? keys : [tab];
   const enabledValues = keys.map((key) => store.tabEnabled(key)).filter((v) => v !== void 0);
   const enabled2 = enabledValues.length ? keys.length > 0 && keys.every((key) => store.tabEnabled(key) === "1") : void 0;
@@ -21280,12 +21695,13 @@ function snapshotCrank(store, tab, storedKeys, nowMs, beatLimit = 5) {
 }
 function planRenameMigration(input) {
   const target = input.resolution.liveTab;
-  if (!target || input.resolution.source !== "live-exact" && input.resolution.source !== "live-prefix") return void 0;
+  if (!target || input.resolution.source !== "live-exact" && input.resolution.source !== "live-prefix" && input.resolution.source !== "live-cwd") return void 0;
   const targetCanon = canon(target);
   const wanted = new Set([targetCanon, ...input.candidates.map((name) => canon(name))].filter(Boolean));
   const otherLive = new Set(input.live.map((tab) => canon(tab.name)).filter((c) => c && c !== targetCanon));
   const oldKeys = [...new Set(input.storedKeys)].filter((key) => {
     if (key === target) return false;
+    if (input.identity && input.roots?.[key] === input.identity) return true;
     const c = canon(key);
     return c !== "" && wanted.has(c) && !otherLive.has(c);
   });
@@ -21316,12 +21732,36 @@ function applyRenameMigration(store, plan) {
     store.deleteKeys(`zcrank:tab:${old}`, ...oldPanes, `zcrank:log:${old}`);
   }
 }
-function buildCrankContext(project, live, storedKeys) {
-  return { resolution: resolveTabForProject(project, live, storedKeys), candidates: candidateNames(project), live, storedKeys };
+function buildCrankContext(project, live, storedKeys, scope = {}) {
+  const roots = scope.roots ?? {};
+  return {
+    resolution: resolveTabForProject(project, live, storedKeys, { identity: scope.identity, roots }),
+    candidates: candidateNames(project),
+    live,
+    storedKeys,
+    identity: scope.identity,
+    roots
+  };
+}
+function keyScopeOf(ctx) {
+  return { owner: ctx.resolution.tabOwner, roots: ctx.roots };
 }
 function storedTabKeys(store) {
   return store.tabKeys().map((key) => key.split(":").slice(2).join(":"));
 }
+function storedTabRoots(store, keys) {
+  const roots = {};
+  for (const key of keys) {
+    let root;
+    try {
+      root = store.tabRoot(key);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.startsWith("Redis error reply")) throw error;
+    }
+    if (root) roots[key] = root;
+  }
+  return roots;
+}
 function enableCrank(store, ctx, options = {}) {
   const now = options.now ?? /* @__PURE__ */ new Date();
   const ts = crankTimestamp(now);
@@ -21331,16 +21771,20 @@ function enableCrank(store, ctx, options = {}) {
     storedKeys: ctx.storedKeys,
     live: ctx.live,
     intervals: (key) => store.tabInterval(key),
-    chosenInterval: options.interval
+    chosenInterval: options.interval,
+    identity: ctx.identity,
+    roots: ctx.roots
   });
   const tab = plan?.target ?? ctx.resolution.tab;
   store.setTabEnabled(tab, true);
+  writeRoot(store, tab, ctx.identity);
   if (options.interval) store.setTabInterval(tab, options.interval);
   if (plan) applyRenameMigration(store, plan);
   else {
-    for (const sibling of keysNamingTab(tab, ctx.storedKeys)) {
+    for (const sibling of keysNamingTab(tab, ctx.storedKeys, keyScopeOf(ctx))) {
       if (sibling === tab) continue;
       store.setTabEnabled(sibling, true);
+      writeRoot(store, sibling, ctx.identity);
       if (options.interval) store.clearTabInterval(sibling);
     }
   }
@@ -21350,42 +21794,54 @@ function enableCrank(store, ctx, options = {}) {
   for (const { from, to } of renamed) store.pushLog(tab, "renamed", `pj crank enable: ${from} -> ${to}`, ts);
   return { tab, renamed, interval: options.interval ?? plan?.carryInterval };
 }
-function disableCrank(store, tab, now = /* @__PURE__ */ new Date()) {
+function writeRoot(store, tab, root) {
+  if (root) store.setTabRoot(tab, root);
+}
+function disableCrank(store, tab, now = /* @__PURE__ */ new Date(), root) {
   store.setTabEnabled(tab, false);
+  writeRoot(store, tab, root);
   store.pushLog(tab, "disabled", "pj crank disable", crankTimestamp(now));
 }
-function setCrankInterval(store, tab, storedKeys, interval, now = /* @__PURE__ */ new Date()) {
-  for (const key of keysNamingTab(tab, storedKeys)) {
+function setCrankInterval(store, tab, storedKeys, interval, now = /* @__PURE__ */ new Date(), scope = {}) {
+  for (const key of keysNamingTab(tab, storedKeys, scope)) {
     if (key !== tab) store.clearTabInterval(key);
   }
   if (interval) store.setTabInterval(tab, interval);
   else store.clearTabInterval(tab);
+  writeRoot(store, tab, scope.root);
   const action = interval ? `pj crank tui: interval ${interval}` : `pj crank tui: interval reset to global (${store.globalInterval()})`;
   store.pushLog(tab, "interval", action, crankTimestamp(now));
 }
 function buildCrankList(input) {
   const global = input.globalInterval ?? ZCRANK_DEFAULT_INTERVAL;
-  const intervalOf = (tab) => effectiveInterval(
-    (keysNamingTab(tab, input.storedTabs).length ? keysNamingTab(tab, input.storedTabs) : [tab]).map((key) => input.tabInterval?.(key)),
-    global
-  );
+  const roots = input.roots ?? {};
+  const intervalOf = (tab, owner) => {
+    const keys = keysNamingTab(tab, input.storedTabs, { owner, roots });
+    return effectiveInterval((keys.length ? keys : [tab]).map((key) => input.tabInterval?.(key)), global);
+  };
   const rows = [];
   const consumed = /* @__PURE__ */ new Set();
+  const consumedKeys = /* @__PURE__ */ new Set();
   for (const project of input.projects) {
-    const resolution = resolveTabForProject(project, input.live, input.storedTabs);
+    const identity2 = project.repoPath ? input.identityOf?.(project.repoPath) : void 0;
+    const resolution = resolveTabForProject(project, input.live, input.storedTabs, { identity: identity2, roots });
     consumed.add(canon(resolution.tab));
-    const enabled2 = input.tabEnabled(resolution.tab);
+    const keys = keysNamingTab(resolution.tab, input.storedTabs, { owner: resolution.tabOwner, roots });
+    for (const key of keys) consumedKeys.add(key);
+    const values = (keys.length ? keys : [resolution.tab]).map((key) => input.tabEnabled(key)).filter((v) => v !== void 0);
+    const enabled2 = values.length ? values.every((v) => v === "1") ? "1" : "0" : void 0;
     rows.push({
       slug: project.slug,
       name: project.name,
       tab: resolution.tab,
       crank: enabled2 === "1" ? "ON" : enabled2 === "0" ? "OFF" : "\u2014",
       source: resolution.source,
-      ...intervalOf(resolution.tab)
+      ...resolution.liveTab !== void 0 ? { liveTab: resolution.liveTab } : {},
+      ...intervalOf(resolution.tab, resolution.tabOwner)
     });
   }
-  const orphans = input.storedTabs.filter((stored) => !consumed.has(canon(stored))).map((stored) => ({ tab: stored, enabled: input.tabEnabled(stored) === "1", ...intervalOf(stored) }));
-  return { rows, orphans };
+  const orphans = input.storedTabs.filter((stored) => !consumed.has(canon(stored)) && !consumedKeys.has(stored)).map((stored) => ({ tab: stored, enabled: input.tabEnabled(stored) === "1", ...intervalOf(stored) }));
+  return { engine: input.engine, rows, orphans };
 }
 function crankTimestamp(now = /* @__PURE__ */ new Date()) {
   return now.toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -21401,17 +21857,25 @@ function renderLogRow(raw) {
     return null;
   }
 }
+function tabCell(row) {
+  if (row.source !== "live-cwd" || row.liveTab === void 0) return row.tab;
+  return canon(row.tab) === canon(row.liveTab) ? row.liveTab : `${row.liveTab} (key ${row.tab})`;
+}
 function formatCrankList(report) {
   const lines = [""];
   lines.push(`  ${heading("Crank by project")}`);
+  if (report.engine) {
+    const summary = engineSummary(report.engine);
+    lines.push(summary.tone === "unknown" ? `  ${dim(summary.text)}` : `  ${summary.tone === "ok" ? green("Engine") : yellow("Engine")} ${summary.tone === "warn" ? yellow(summary.text) : dim(summary.text)}`);
+  }
   lines.push("");
   const slugWidth = Math.max("PROJECT".length, ...report.rows.map((row) => row.slug.length));
-  const tabWidth = Math.max("TAB".length, ...report.rows.map((row) => row.tab.length), ...report.orphans.map((orphan) => orphan.tab.length));
+  const tabWidth = Math.max("TAB".length, ...report.rows.map((row) => tabCell(row).length), ...report.orphans.map((orphan) => orphan.tab.length));
   const intervalCell = (row) => row.inherited ? dim(`${row.interval} (global)`) : row.interval;
   lines.push(`  ${"PROJECT".padEnd(slugWidth)}  ${"TAB".padEnd(tabWidth)}  ${"CRANK".padEnd(5)}  INTERVAL`);
   for (const row of report.rows) {
     const state = row.crank === "ON" ? green("ON") : row.crank === "OFF" ? dim("OFF") : dim("\u2014");
-    lines.push(`  ${cyan(row.slug.padEnd(slugWidth))}  ${row.tab.padEnd(tabWidth)}  ${state}${" ".repeat(Math.max(0, 5 - (row.crank === "ON" ? 2 : row.crank === "OFF" ? 3 : 1)))}  ${intervalCell(row)}`);
+    lines.push(`  ${cyan(row.slug.padEnd(slugWidth))}  ${tabCell(row).padEnd(tabWidth)}  ${state}${" ".repeat(Math.max(0, 5 - (row.crank === "ON" ? 2 : row.crank === "OFF" ? 3 : 1)))}  ${intervalCell(row)}`);
   }
   if (report.orphans.length) {
     lines.push("");
@@ -21426,34 +21890,492 @@ function formatCrankList(report) {
 
 // src/crank/controller.ts
 var LIVE_TABS_TTL_MS = 3e4;
+var LIVE_OWNERS_TTL_MS = 3e5;
+function ownerMemoReader(deps = {}) {
+  const clock = deps.clock ?? Date.now;
+  const read = deps.read ?? ((claimed) => liveTabsWithOwners({ claimed }));
+  const listTabs = deps.tabs ?? (() => liveTabs());
+  const readClaimed = () => {
+    try {
+      return deps.claimed?.() ?? [];
+    } catch {
+      return [];
+    }
+  };
+  let memo;
+  return () => {
+    const now = clock();
+    const tabs = listTabs();
+    const claimed = readClaimed();
+    const claimedSig = claimed.join("\n");
+    if (memo && memo.claimed === claimedSig && now - memo.at <= LIVE_OWNERS_TTL_MS && tabs.length && tabs.every((tab) => tab.id !== void 0 && memo?.byId.has(tab.id))) {
+      const known = memo.byId;
+      return tabs.map((tab) => ({ ...tab, ...known.get(tab.id) }));
+    }
+    const full = read(claimed);
+    memo = full.length && full.every((tab) => tab.id !== void 0) ? { at: now, claimed: claimedSig, byId: new Map(full.map((tab) => [tab.id, { owner: tab.owner, ownedPanes: tab.ownedPanes }])) } : void 0;
+    return full;
+  };
+}
 function createCrankController(deps) {
   const clock = deps.clock ?? Date.now;
-  const readLive = deps.live ?? (() => liveTabs());
+  const readLive = deps.live ?? ownerMemoReader({ clock, claimed: () => claimedRoots(deps.store) });
+  const readEngine = (nowMs) => {
+    try {
+      return (deps.engine ?? ((now) => readEngineStatus({ nowMs: now })))(nowMs);
+    } catch {
+      return unknownEngineStatus(nowMs);
+    }
+  };
   let cachedLive;
   const live = (fresh) => {
     const now = clock();
     if (fresh || !cachedLive || now - cachedLive.at > LIVE_TABS_TTL_MS) cachedLive = { at: now, tabs: readLive() };
     return cachedLive.tabs;
   };
-  const context = (fresh) => buildCrankContext(deps.project, live(fresh), storedTabKeys(deps.store));
+  const context = (fresh) => {
+    const keys = storedTabKeys(deps.store);
+    return buildCrankContext(deps.project, live(fresh), keys, { identity: deps.identity, roots: storedTabRoots(deps.store, keys) });
+  };
   return {
     slug: deps.slug,
     name: deps.project.name,
     read(nowMs = clock()) {
       const ctx = context(false);
-      return { slug: deps.slug, name: deps.project.name, resolution: ctx.resolution, snapshot: snapshotCrank(deps.store, ctx.resolution.tab, ctx.storedKeys, nowMs) };
+      return {
+        slug: deps.slug,
+        name: deps.project.name,
+        resolution: ctx.resolution,
+        snapshot: snapshotCrank(deps.store, ctx.resolution.tab, ctx.storedKeys, nowMs, 5, keyScopeOf(ctx)),
+        engine: readEngine(nowMs)
+      };
     },
     enable: () => enableCrank(deps.store, context(true), { now: new Date(clock()) }),
     disable() {
-      disableCrank(deps.store, context(true).resolution.tab, new Date(clock()));
+      const ctx = context(true);
+      disableCrank(deps.store, ctx.resolution.tab, new Date(clock()), ctx.identity);
     },
     setInterval(interval) {
       const ctx = context(true);
-      setCrankInterval(deps.store, ctx.resolution.tab, ctx.storedKeys, interval, new Date(clock()));
+      setCrankInterval(deps.store, ctx.resolution.tab, ctx.storedKeys, interval, new Date(clock()), { ...keyScopeOf(ctx), root: ctx.identity });
     }
   };
 }
 
+// src/crank/panes.ts
+import { readFileSync as readFileSync31, readdirSync as readdirSync13, readlinkSync as readlinkSync9 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { basename as basename11, join as join36 } from "node:path";
+var AGENT_CLIS = [
+  "claude",
+  "codex",
+  "copilot",
+  "opencode",
+  "aider",
+  "hermes",
+  "agy",
+  "kimi-code",
+  "kimi-co",
+  "gemini",
+  "openclaw",
+  // Not in Deckard's list: the Kimi binary on the operator box is `~/.kimi-code/bin/kimi` (argv[0]
+  // basename `kimi`), which neither `kimi-code` nor `kimi-co` prefixes. Listed after them so the
+  // reported name stays `kimi-code` where Deckard would say it.
+  "kimi"
+];
+function agentCli(exe, argv) {
+  if (argv.includes("mcp-server") || argv.includes(" mcp ")) return null;
+  const byName = AGENT_CLIS.find((pat) => exe === pat || exe.startsWith(pat));
+  if (byName) return byName;
+  const tokens = argv.split(" ").filter(Boolean);
+  if (INTERPRETER.test(exe)) {
+    const program2 = interpretedProgram(exe, tokens);
+    if (!program2) return null;
+    if (program2.module) {
+      const top = (program2.module.split(".")[0] ?? "").replace(/_/g, "-");
+      return AGENT_CLIS.find((pat) => top === pat || PATH_SUFFIXES.some((suffix) => top === `${pat}-${suffix}`)) ?? null;
+    }
+    return PATH_PASS.find(([, re]) => re.test(program2.script))?.[0] ?? null;
+  }
+  const versioned = /\/([^/]+)\/versions\/[^/]+$/.exec(tokens[0] ?? "");
+  return versioned ? AGENT_CLIS.find((pat) => versioned[1] === pat) ?? null : null;
+}
+var INTERPRETER = /^(?:node(?:js)?|bun|deno|tsx|python[\d.]*|ruby|perl|bash|sh|zsh|dash|fish|ksh)$/;
+var SHELL = /^(?:bash|sh|zsh|dash|fish|ksh)$/;
+var PYTHON = /^python[\d.]*$/;
+var VALUE_OPTIONS = [
+  [/^(?:node(?:js)?|bun|deno|tsx)$/, /* @__PURE__ */ new Set(["-r", "--require", "--import", "--loader", "--experimental-loader", "-C", "--conditions", "--inspect-port", "--debug-port", "--input-type", "--title", "--env-file", "--disable-warning", "--watch-path", "--stack-size", "--max-old-space-size", "--redirect-warnings", "--openssl-config", "--icu-data-dir", "--tls-cipher-list", "--secure-heap", "--diagnostic-dir", "--report-dir", "--cpu-prof-dir", "--heap-prof-dir"])],
+  [PYTHON, /* @__PURE__ */ new Set(["-W", "-X", "-Q", "--check-hash-based-pycs"])],
+  [SHELL, /* @__PURE__ */ new Set(["-o", "+o", "-O", "+O", "--rcfile", "--init-file"])]
+];
+function interpretedProgram(exe, tokens) {
+  const takesValue = VALUE_OPTIONS.find(([re]) => re.test(exe))?.[1] ?? /* @__PURE__ */ new Set();
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === "-m" || PYTHON.test(exe) && /^-[BEIOPRSbdhiqsuvx]*m$/.test(token)) return tokens[i + 1] ? { module: tokens[i + 1], script: "" } : null;
+    if (token === "-e" || token === "-p" || token === "-pe" || token === "-ep" || token === "--eval" || token === "--print") return null;
+    if (SHELL.test(exe) && /^-[a-zA-Z]*c[a-zA-Z]*$/.test(token)) return null;
+    if (PYTHON.test(exe) && /^-[BEIOPRSbdhiqsuvx]*c$/.test(token)) return null;
+    if (token.startsWith("-") || token.startsWith("+")) {
+      if (takesValue.has(token)) i++;
+      continue;
+    }
+    return { script: token };
+  }
+  return null;
+}
+var PATH_SUFFIXES = ["code", "cli", "agent"];
+var PATH_PASS = AGENT_CLIS.map((pat) => {
+  const name = pat.replace(/[-]/g, "\\-");
+  const end = "(?=$|[ /.])";
+  return [pat, new RegExp(`/${name}(?:${end}|-(?:${PATH_SUFFIXES.join("|")})${end})`)];
+});
+function parseProcStat(text2) {
+  const close = text2.lastIndexOf(")");
+  const open = text2.indexOf("(");
+  if (close < 0 || open < 0 || open > close) return null;
+  const comm = text2.slice(open + 1, close);
+  const fields = text2.slice(close + 1).trim().split(/\s+/);
+  const state = fields[0];
+  const ppid = Number(fields[1]);
+  const pgrp = Number(fields[2]);
+  const ttyNr = Number(fields[4]);
+  const tpgid = Number(fields[5]);
+  const startTime = fields[19];
+  if (!state || !startTime || ![ppid, pgrp, ttyNr, tpgid].every(Number.isInteger)) return null;
+  return { comm, state, ppid, pgrp, ttyNr, tpgid, startTime };
+}
+function readProcStat(pid) {
+  try {
+    return parseProcStat(readFileSync31(`/proc/${pid}/stat`, "latin1"));
+  } catch {
+    return null;
+  }
+}
+function readTag(pid) {
+  let raw;
+  try {
+    raw = readFileSync31(`/proc/${pid}/environ`);
+  } catch {
+    return null;
+  }
+  let paneId = null;
+  let session = null;
+  let start = 0;
+  while (start <= raw.length) {
+    let end = raw.indexOf(0, start);
+    if (end < 0) end = raw.length;
+    const eq = raw.indexOf(61, start);
+    if (eq >= 0 && eq < end) {
+      const key = raw.toString("latin1", start, eq);
+      if (key === "ZELLIJ_PANE_ID") {
+        const value = raw.toString("utf8", eq + 1, end);
+        paneId = /^\d+$/.test(value) ? Number(value) : null;
+      } else if (key === "ZELLIJ_SESSION_NAME") {
+        session = raw.toString("utf8", eq + 1, end);
+      }
+    }
+    start = end + 1;
+  }
+  return paneId === null ? null : { paneId, session };
+}
+function readArgv(pid) {
+  try {
+    const parts = readFileSync31(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
+    return { argv: parts.join(" "), exe: parts[0] ? basename11(parts[0]) : "" };
+  } catch {
+    return { argv: "", exe: "" };
+  }
+}
+var ProcScanner = class {
+  known = /* @__PURE__ */ new Map();
+  enumerate;
+  /**
+   * `pids` replaces the enumeration of /proc: the scanner then looks at exactly those pids and no
+   * others. Production never passes it (the default reads every pid of the box, which is the
+   * point). A test that spawns its own processes passes its own pids, so that processes OTHER
+   * tests or agents have on the box (session-less tagged ones are visible to every scan by
+   * design) cannot change its answer.
+   */
+  constructor(options = {}) {
+    this.enumerate = options.pids;
+  }
+  /** How many pids the cache holds (negatives included). For the cost report and tests. */
+  cached() {
+    return this.known.size;
+  }
+  /** Is `pid` in the cache, as a tagged process or a remembered negative? */
+  has(pid) {
+    return this.known.has(pid);
+  }
+  /**
+   * Every process in `session` that carries a pane tag. A process whose ZELLIJ_SESSION_NAME names
+   * a DIFFERENT session is dropped; one with no session name at all is kept (`session: null`),
+   * because zellij has not always set it and dropping it would lose real agents (Deckard's rule).
+   * That also keeps processes some other tool started under `env -u ZELLIJ_SESSION_NAME` (e.g.
+   * a `zellij action list-panes` run from a pane): they carry a pane id and no session, and are
+   * not agents, so classification discards them.
+   */
+  scan(session) {
+    let pids;
+    if (this.enumerate) {
+      pids = [...this.enumerate()];
+    } else {
+      try {
+        pids = readdirSync13("/proc").filter((name) => /^\d+$/.test(name)).map(Number);
+      } catch {
+        return [];
+      }
+    }
+    const alive = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const pid of pids) {
+      alive.add(pid);
+      const stat = readProcStat(pid);
+      if (!stat) continue;
+      let slot = this.known.get(pid);
+      if (!slot || slot.startTime !== stat.startTime || slot.comm !== stat.comm) {
+        const tag2 = readTag(pid);
+        slot = { startTime: stat.startTime, comm: stat.comm, tag: tag2, ...tag2 ? readArgv(pid) : { argv: "", exe: "" } };
+        this.known.set(pid, slot);
+      } else if (slot.tag && stat.state !== "Z") {
+        Object.assign(slot, readArgv(pid));
+      }
+      const tag = slot.tag;
+      if (!tag) continue;
+      if (tag.session !== null && tag.session !== session) continue;
+      let cwd = null;
+      try {
+        cwd = readlinkSync9(`/proc/${pid}/cwd`);
+      } catch {
+      }
+      out.push({ pid, paneId: tag.paneId, session: tag.session, argv: slot.argv, exe: slot.exe, cwd, stat });
+    }
+    for (const pid of this.known.keys()) if (!alive.has(pid)) this.known.delete(pid);
+    return out.sort((a, b) => a.pid - b.pid);
+  }
+};
+var PANE_STATUSES = ["busy", "idle", "shell"];
+function claudeSessionsDir(env2 = process.env) {
+  const override = env2.PJ_CLAUDE_SESSIONS_DIR?.trim();
+  return override || join36(homedir16(), ".claude", "sessions");
+}
+function readClaudeSession(pid, stat, dir = claudeSessionsDir()) {
+  const none = (reason) => ({ kind: null, sessionId: null, reason, status: "unknown", statusUpdatedAt: null });
+  let raw;
+  try {
+    raw = readFileSync31(join36(dir, `${pid}.json`), "utf8");
+  } catch {
+    return none("no-session-file");
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return none("unreadable-session-file");
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return none("unreadable-session-file");
+  const file = data;
+  const procStart = file.procStart === void 0 || file.procStart === null ? "" : String(file.procStart);
+  if (!stat || !procStart || procStart !== stat.startTime) return none("stale-session-file");
+  const sessionId = typeof file.sessionId === "string" && file.sessionId ? file.sessionId : null;
+  const status = typeof file.status === "string" && PANE_STATUSES.includes(file.status) ? file.status : "unknown";
+  const at = Number(file.statusUpdatedAt);
+  return {
+    kind: typeof file.kind === "string" ? file.kind : null,
+    sessionId,
+    reason: sessionId ? null : "no-session-id",
+    status,
+    statusUpdatedAt: file.statusUpdatedAt !== void 0 && file.statusUpdatedAt !== null && Number.isFinite(at) ? at : null
+  };
+}
+function listPanesFailure(session, result2) {
+  const said = (result2.stderr ?? "").trim().split("\n")[0]?.trim();
+  if (result2.status === 127) return `zellij is not installed or not on PATH (exit 127)${said ? `: ${said}` : ""}`;
+  if (result2.status === 124) return `zellij list-panes for session "${session}" timed out (exit 124): the zellij server may be wedged`;
+  if (said && /not found|no active session|no session/i.test(said)) return `zellij has no session "${session}" (exit ${result2.status}): ${said}`;
+  return `zellij list-panes for session "${session}" failed (exit ${result2.status})${said ? `: ${said}` : ""}`;
+}
+function readPaneTable(session, shell = defaultShell) {
+  const panes = /* @__PURE__ */ new Map();
+  const result2 = runListPanes(session, shell);
+  if (result2.status !== 0) return { ok: false, error: listPanesFailure(session, result2), panes };
+  const listed = parseListPanes(result2.stdout);
+  if (!listed) return { ok: false, error: `zellij list-panes for session "${session}" printed no pane list`, panes };
+  if (!listed.length) return { ok: false, error: `zellij list-panes for session "${session}" listed no panes at all: not a live session`, panes };
+  for (const pane of listed) {
+    if (pane.isPlugin || !Number.isInteger(pane.id)) continue;
+    panes.set(pane.id, { tabId: pane.tabId ?? null, tabPosition: pane.tabPosition ?? null, tabName: pane.tabName, title: pane.title });
+  }
+  return { ok: true, error: null, panes };
+}
+var IDENTITY_BUDGET_MS2 = 2e4;
+function paneTerminal(inPane, serverParent) {
+  const live = inPane.filter((p) => p.stat.state !== "Z");
+  const pidsInPane = new Set(live.map((p) => p.pid));
+  const roots = live.filter((p) => !pidsInPane.has(p.stat.ppid));
+  const underServer = roots.filter((p) => serverParent(p.stat.ppid));
+  const ttys = new Set((underServer.length ? underServer : roots).map((p) => p.stat.ttyNr).filter((tty) => tty > 0));
+  return ttys.size === 1 ? [...ttys][0] : null;
+}
+function chooseCandidate(candidates) {
+  const start = (c) => Number(c.proc.stat.startTime);
+  const trusted = (c) => c.claude?.sessionId ? 1 : 0;
+  const background = (c) => c.claude?.kind === "bg" ? 1 : 0;
+  return [...candidates].sort(
+    (a, b) => Number(b.foreground) - Number(a.foreground) || background(a) - background(b) || (a.foreground && b.foreground ? trusted(b) - trusted(a) : 0) || start(b) - start(a) || b.proc.pid - a.proc.pid
+  )[0];
+}
+function inventoryPanes(options = {}) {
+  const fromOption = options.session?.trim();
+  const fromEnv = process.env.ZELLIJ_SESSION_NAME?.trim();
+  const session = fromOption || fromEnv || ZCRANK_SESSION;
+  const sessionSource = fromOption ? "option" : fromEnv ? "ZELLIJ_SESSION_NAME" : "default";
+  const shell = options.shell ?? defaultShell;
+  const sessionsDir = options.sessionsDir ?? claudeSessionsDir();
+  const scanner = options.scanner ?? new ProcScanner();
+  const identityCache = options.identityCache ?? /* @__PURE__ */ new Map();
+  const budget = { totalMs: IDENTITY_BUDGET_MS2 };
+  const procs = scanner.scan(session);
+  const table = readPaneTable(session, shell);
+  if (!table.ok) {
+    return { session, sessionSource, zellijReadable: false, error: table.error, unmappedPaneIds: [], panes: [] };
+  }
+  const taggedByPane = /* @__PURE__ */ new Map();
+  for (const proc of procs) {
+    const list = taggedByPane.get(proc.paneId);
+    if (list) list.push(proc);
+    else taggedByPane.set(proc.paneId, [proc]);
+  }
+  const serverMemo = /* @__PURE__ */ new Map();
+  const isZellijServer = (pid) => {
+    let known = serverMemo.get(pid);
+    if (known === void 0) {
+      const { exe, argv } = readArgv(pid);
+      known = exe === "zellij" && argv.includes(" --server");
+      serverMemo.set(pid, known);
+    }
+    return known;
+  };
+  const byPane = /* @__PURE__ */ new Map();
+  for (const [paneId, inPane] of taggedByPane) {
+    const tty = paneTerminal(inPane, isZellijServer);
+    for (const proc of inPane) {
+      if (proc.stat.state === "Z") continue;
+      const agent = agentCli(proc.exe, proc.argv);
+      if (!agent) continue;
+      const claude = agent === "claude" ? readClaudeSession(proc.pid, proc.stat, sessionsDir) : null;
+      const foreground = tty !== null && proc.stat.ttyNr === tty && proc.stat.tpgid > 0 && proc.stat.pgrp === proc.stat.tpgid;
+      const candidate = { proc, agent, foreground, claude };
+      const list = byPane.get(paneId);
+      if (list) list.push(candidate);
+      else byPane.set(paneId, [candidate]);
+    }
+  }
+  const rows = [];
+  const unmappedPaneIds = [];
+  for (const [paneId, candidates] of byPane) {
+    if (!table.panes.has(paneId)) {
+      unmappedPaneIds.push(paneId);
+      continue;
+    }
+    const chosen = chooseCandidate(candidates);
+    const entry = table.panes.get(paneId);
+    const cwd = chosen.proc.cwd;
+    const info = chosen.claude ?? { kind: null, sessionId: null, reason: "unresolved", status: "unknown", statusUpdatedAt: null };
+    rows.push({
+      position: entry?.tabPosition ?? Number.MAX_SAFE_INTEGER,
+      row: {
+        session,
+        tabId: entry?.tabId ?? null,
+        tabName: entry?.tabName ?? null,
+        paneId,
+        paneTitle: entry?.title ?? null,
+        pid: chosen.proc.pid,
+        agent: chosen.agent,
+        cwd,
+        project: (cwd ? projectIdentity(cwd, { shell, cache: identityCache, budget }) : void 0) ?? null,
+        sessionId: info.sessionId,
+        sessionReason: info.sessionId ? null : info.reason,
+        status: info.status,
+        statusUpdatedAt: info.statusUpdatedAt,
+        nested: candidates.filter((c) => c !== chosen).map((c) => ({ pid: c.proc.pid, agent: c.agent })).sort((a, b) => a.pid - b.pid)
+      }
+    });
+  }
+  if (options.all) {
+    for (const [paneId, entry] of table.panes) {
+      if (byPane.has(paneId)) continue;
+      rows.push({
+        position: entry.tabPosition ?? Number.MAX_SAFE_INTEGER,
+        row: {
+          session,
+          tabId: entry.tabId,
+          tabName: entry.tabName,
+          paneId,
+          paneTitle: entry.title,
+          pid: null,
+          agent: null,
+          cwd: null,
+          project: null,
+          sessionId: null,
+          sessionReason: null,
+          status: "unknown",
+          statusUpdatedAt: null,
+          nested: []
+        }
+      });
+    }
+  }
+  rows.sort((a, b) => a.position - b.position || a.row.paneId - b.row.paneId);
+  return { session, sessionSource, zellijReadable: true, error: null, unmappedPaneIds: unmappedPaneIds.sort((a, b) => a - b), panes: rows.map((r) => r.row) };
+}
+function tilde(path) {
+  if (!path) return "-";
+  const home = homedir16();
+  return path === home ? "~" : path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+function displayWidth(text2) {
+  let width = 0;
+  for (const { segment } of new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text2)) width += clusterWidth(segment);
+  return width;
+}
+var EMOJI_PRESENTATION = /^\p{Emoji_Presentation}/u;
+var EMOJI_BASE = /^\p{Emoji}/u;
+var REGIONAL_INDICATOR = /^\p{Regional_Indicator}/u;
+var ZERO_WIDTH_ONLY = /^[\p{Mn}\p{Me}\p{Cf}\p{Cc}]+$/u;
+function clusterWidth(cluster) {
+  if (ZERO_WIDTH_ONLY.test(cluster)) return 0;
+  const cp = cluster.codePointAt(0);
+  if (REGIONAL_INDICATOR.test(cluster)) return [...cluster].length >= 2 ? 2 : 1;
+  if (EMOJI_PRESENTATION.test(cluster)) return 2;
+  if (cluster.includes("\uFE0F") && EMOJI_BASE.test(cluster)) return 2;
+  const wide = cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp >= 11904 && cp <= 42191 && cp !== 12351 || // CJK, kana, Yi
+  cp >= 44032 && cp <= 55203 || // Hangul syllables
+  cp >= 63744 && cp <= 64255 || // CJK compatibility
+  cp >= 65072 && cp <= 65135 || // CJK compatibility forms
+  cp >= 65280 && cp <= 65376 || // fullwidth forms
+  cp >= 65504 && cp <= 65510 || cp >= 131072 && cp <= 262141;
+  return wide ? 2 : 1;
+}
+function formatPaneTable(inventory) {
+  const header = ["TAB", "PANE", "PID", "AGENT", "PROJECT", "STATUS", "SESSION", "NESTED"];
+  const rows = inventory.panes.map((p) => [
+    p.tabName ?? "-",
+    String(p.paneId),
+    p.pid === null ? "-" : String(p.pid),
+    p.agent ?? "(no agent)",
+    tilde(p.project ?? p.cwd),
+    p.agent ? p.status : "-",
+    p.sessionId ?? (p.agent ? `- (${p.sessionReason})` : "-"),
+    p.nested.length ? p.nested.map((n) => `${n.agent}:${n.pid}`).join(",") : "-"
+  ]);
+  const widths = header.map((h, i) => Math.max(displayWidth(h), ...rows.map((r) => displayWidth(r[i] ?? ""))));
+  const line = (cells) => cells.map((c, i) => c + " ".repeat(Math.max(0, (widths[i] ?? 0) - displayWidth(c)))).join("  ").trimEnd();
+  return [line(header), ...rows.map(line)].join("\n");
+}
+
 // src/crank/cli.ts
 var loadCrankScreens = () => loadScreen("./crank/tui.js", import.meta.url);
 var xmark = `${red(glyph.fail)}`;
@@ -21470,13 +22392,20 @@ function currentProjectNames() {
     names: {
       name: projectNameFor(handle, record3?.name),
       agents: projectAgentsFor(handle, record3?.agents)
-    }
+    },
+    // PJAN-201: where the project lives (its main worktree), independent of any tab name.
+    identity: projectIdentity(handle.root)
   };
 }
+function contextFor(project, store) {
+  const keys = storedTabKeys(store);
+  const roots = storedTabRoots(store, keys);
+  return buildCrankContext(project.names, liveTabsWithOwners({ claimed: Object.values(roots) }), keys, { identity: project.identity, roots });
+}
 function resolveCurrentTab() {
   const project = currentProjectNames();
   const store = redis();
-  const ctx = buildCrankContext(project.names, liveTabs(), storedTabKeys(store));
+  const ctx = contextFor(project, store);
   return { slug: project.slug, tab: ctx.resolution.tab, storedAsIs: ctx.resolution.storedAsIs };
 }
 function registerCrankCli(program2) {
@@ -21490,6 +22419,9 @@ function registerCrankCli(program2) {
   crankCmd.command("tui").description("Full-screen crank dashboard: toggle, interval, last runs, countdown to the next run, log").action(async () => {
     await runTui();
   });
+  crankCmd.command("panes").description("Read-only inventory of the live agent panes in this zellij session: pane -> pid -> agent CLI -> session id/status (from /proc, not tab names)").option("--json", "Emit the inventory as JSON").option("--all", "Also list terminal panes that run no agent").action((options) => {
+    runPanes(options);
+  });
   crankCmd.command("list").description("Every registry project with crank ON/OFF and its resolved tab, plus orphan zcrank keys").action(() => {
     try {
       const store = redis();
@@ -21507,12 +22439,16 @@ function registerCrankCli(program2) {
           role: String(value?.role ?? "")
         }))
       }));
-      const live = liveTabs();
       const storedTabs = storedTabKeys(store);
+      const live = liveTabsWithOwners({ claimed: Object.values(storedTabRoots(store, storedTabs)) });
+      const identityCache = /* @__PURE__ */ new Map();
       const report = buildCrankList({
         projects,
         live,
         storedTabs,
+        identityOf: (repoPath) => projectIdentity(repoPath, { cache: identityCache }),
+        roots: storedTabRoots(store, storedTabs),
+        engine: readEngineStatus(),
         tabEnabled: (tab) => store.tabEnabled(tab),
         tabInterval: (tab) => store.tabInterval(tab),
         globalInterval: store.globalInterval()
@@ -21576,9 +22512,9 @@ async function runEnable(options) {
     }
     const project = currentProjectNames();
     const store = liveStore();
-    const ctx = buildCrankContext(project.names, liveTabs(), storedTabKeys(store));
+    const ctx = contextFor(project, store);
     if (!chosen && isInteractive()) {
-      const snap = snapshotCrank(store, ctx.resolution.tab, ctx.storedKeys, Date.now());
+      const snap = snapshotCrank(store, ctx.resolution.tab, ctx.storedKeys, Date.now(), 5, keyScopeOf(ctx));
       const screens = await loadCrankScreens();
       const picked = await screens.pickInterval({ slug: project.slug, tab: ctx.resolution.liveTab ?? ctx.resolution.tab, effective: snap.interval, inherited: snap.inherited, global: snap.global });
       if (!picked) {
@@ -21592,7 +22528,8 @@ async function runEnable(options) {
     for (const { from, to } of result2.renamed) {
       console.log(`  ${yellow(glyph.warn)} tab renamed ${dim(glyph.dot)} ${from} ${dim(glyph.pointer)} ${bold(to)} ${dim("(old key merged into the new one and removed)")}`);
     }
-    const live = snapshotCrank(store, result2.tab, storedTabKeys(store), Date.now());
+    const afterKeys = storedTabKeys(store);
+    const live = snapshotCrank(store, result2.tab, afterKeys, Date.now(), 5, { owner: ctx.resolution.tabOwner, roots: storedTabRoots(store, afterKeys) });
     console.log(`  ${dim("interval")} ${live.interval}${live.inherited ? dim(` (inherits global ${live.global})`) : ""}`);
     if (ctx.resolution.storedAsIs) {
       console.log(`  ${yellow(glyph.warn)} ${dim(`no live zellij tab or zcrank key matches "${project.names.name}" \u2014 stored under the project name as-is`)}`);
@@ -21605,8 +22542,8 @@ function runDisable() {
   try {
     const project = currentProjectNames();
     const store = liveStore();
-    const ctx = buildCrankContext(project.names, liveTabs(), storedTabKeys(store));
-    disableCrank(store, ctx.resolution.tab);
+    const ctx = contextFor(project, store);
+    disableCrank(store, ctx.resolution.tab, /* @__PURE__ */ new Date(), ctx.identity);
     console.log(`  ${dim("OFF")}  ${cyan(project.slug)} ${dim(glyph.pointer)} ${bold(ctx.resolution.tab)}`);
     if (ctx.resolution.storedAsIs) {
       console.log(`  ${yellow(glyph.warn)} ${dim(`no live zellij tab or zcrank key matches "${project.names.name}" \u2014 stored under the project name as-is`)}`);
@@ -21615,6 +22552,34 @@ function runDisable() {
     fail(error, "crank");
   }
 }
+function runPanes(options) {
+  try {
+    const inventory = inventoryPanes({ all: options.all === true });
+    const sessionNote = inventory.sessionSource === "default" ? `not inside zellij ($ZELLIJ_SESSION_NAME is unset): using the default session "${inventory.session}"` : inventory.sessionSource === "ZELLIJ_SESSION_NAME" ? `session "${inventory.session}" (from $ZELLIJ_SESSION_NAME)` : `session "${inventory.session}"`;
+    if (options.json) {
+      console.log(JSON.stringify(inventory, null, 2));
+    }
+    if (!inventory.zellijReadable) {
+      console.error(`${xmark} ${inventory.error ?? "zellij is unreadable"} \u2014 ${sessionNote}`);
+      process.exit(1);
+    }
+    if (options.json) {
+      if (inventory.unmappedPaneIds.length) console.error(`  ${dim(`${inventory.unmappedPaneIds.length} pane id(s) with agent processes are not listed by zellij: ${inventory.unmappedPaneIds.join(", ")}`)}`);
+      return;
+    }
+    if (inventory.sessionSource === "default") console.error(`  ${yellow(glyph.warn)} ${dim(sessionNote)}`);
+    if (inventory.unmappedPaneIds.length) {
+      console.error(`  ${dim(`ignored ${inventory.unmappedPaneIds.length} pane id(s) with agent processes that zellij does not list (a closed pane, a pane that closed during the scan, or a stale daemon environment): ${inventory.unmappedPaneIds.join(", ")}`)}`);
+    }
+    if (!inventory.panes.length) {
+      console.log(`  ${dim(`no live agent panes in session ${inventory.session}`)}`);
+      return;
+    }
+    console.log(formatPaneTable(inventory));
+  } catch (error) {
+    fail(error, "crank panes");
+  }
+}
 async function runTui() {
   try {
     if (!isInteractive()) {
@@ -21623,7 +22588,7 @@ async function runTui() {
     }
     const project = currentProjectNames();
     const store = liveStore();
-    const controller = createCrankController({ slug: project.slug, project: project.names, store });
+    const controller = createCrankController({ slug: project.slug, project: project.names, store, identity: project.identity });
     const screens = await loadCrankScreens();
     await screens.runCrankDashboard(controller);
   } catch (error) {
@@ -21658,9 +22623,9 @@ async function promptForRuleIds(rules) {
   return selected;
 }
 function readJson2(path) {
-  if (!existsSync27(path)) return void 0;
+  if (!existsSync26(path)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync30(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -21677,9 +22642,9 @@ function packageNameToProjectName(value) {
   return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()).trim();
 }
 function deriveProjectDefaults(targetDir) {
-  const manifest = readJson2(join35(targetDir, ".project.json"));
-  const pkg = readJson2(join35(targetDir, "package.json"));
-  const name = String(manifest?.project_name ?? "").trim() || packageNameToProjectName(typeof pkg?.name === "string" ? pkg.name : void 0) || packageNameToProjectName(basename11(targetDir)) || "Project";
+  const manifest = readJson2(join37(targetDir, ".project.json"));
+  const pkg = readJson2(join37(targetDir, "package.json"));
+  const name = String(manifest?.project_name ?? "").trim() || packageNameToProjectName(typeof pkg?.name === "string" ? pkg.name : void 0) || packageNameToProjectName(basename12(targetDir)) || "Project";
   const ticketProvider = manifest?.ticket_provider && typeof manifest.ticket_provider === "object" ? manifest.ticket_provider : {};
   return {
     name,
@@ -21753,7 +22718,7 @@ function actionNeedsRun(plan, kind, syncMode) {
     if (!action || action.kind !== "project.write-manifest") return false;
     const next = `${JSON.stringify(action.manifest, null, 2)}
 `;
-    return !existsSync27(action.path) || readFileSync30(action.path, "utf8") !== next;
+    return !existsSync26(action.path) || readFileSync32(action.path, "utf8") !== next;
   }
   if (kind === "copier.copy.commonproject") return true;
   if (kind === "ticket-provider.create-or-link") return plan.actions.some((action) => action.kind === kind && action.enabled);
@@ -21810,28 +22775,28 @@ async function resolveProjectInitTarget(name, options) {
   if (!targetDir && cwdGitRoot) {
     targetDir = cwdGitRoot;
   }
-  if (!targetDir && !name && existsSync27(join35(cwd, ".project.json"))) {
+  if (!targetDir && !name && existsSync26(join37(cwd, ".project.json"))) {
     targetDir = cwd;
   }
   if (!targetDir && interactive) {
-    const promptedName = await promptTextValue("Project name", packageNameToProjectName(basename11(cwd)));
+    const promptedName = await promptTextValue("Project name", packageNameToProjectName(basename12(cwd)));
     targetDir = resolve25(await promptTextValue("Project directory", projectTargetDirUnder(promptedName, cwd)));
     name = promptedName;
   }
   if (!targetDir) {
     throw new Error("Project name or --target-dir is required when project init is not run inside a git repo or a directory carrying .project.json");
   }
-  const targetExists = existsSync27(targetDir);
+  const targetExists = existsSync26(targetDir);
   if (targetExists && !statSync9(targetDir).isDirectory()) throw new Error(`Target path is not a directory: ${targetDir}`);
   const targetGitRoot = targetExists ? findGitRoot(targetDir) : void 0;
-  const alreadyScaffolded = targetExists && (existsSync27(join35(targetDir, ".project.json")) || existsSync27(join35(targetDir, ".copier-answers.yml")));
+  const alreadyScaffolded = targetExists && (existsSync26(join37(targetDir, ".project.json")) || existsSync26(join37(targetDir, ".copier-answers.yml")));
   const syncMode = Boolean(
     targetGitRoot && resolve25(targetGitRoot) === resolve25(targetDir) || alreadyScaffolded
   );
-  if (targetExists && !syncMode && !options.force && readdirSync13(targetDir).length > 0) {
+  if (targetExists && !syncMode && !options.force && readdirSync14(targetDir).length > 0) {
     throw new Error(`Target already exists and is not empty: ${targetDir} (pass --force to render over it)`);
   }
-  const defaults = targetExists ? deriveProjectDefaults(targetDir) : { name: packageNameToProjectName(basename11(targetDir)) ?? "Project", description: "" };
+  const defaults = targetExists ? deriveProjectDefaults(targetDir) : { name: packageNameToProjectName(basename12(targetDir)) ?? "Project", description: "" };
   if (!name && interactive && !syncMode) {
     name = await promptTextValue("Project name", defaults.name);
   }
@@ -22346,7 +23311,7 @@ program.command("reindex").argument("[project-id]", "Canonical project ID (defau
     else if (options.all) result2 = registryRequest(location, "POST", "/v1/reindex", {});
     else {
       const repo = projectId ? getProject(loadProjectRegistry(location), projectId).repo_path : resolveProject(process.cwd()).root;
-      result2 = registryRequest(location, "POST", "/v1/index", { manifest_path: join35(repo, ".project.json") });
+      result2 = registryRequest(location, "POST", "/v1/index", { manifest_path: join37(repo, ".project.json") });
     }
     const statuses = result2.__registry_status;
     const stale = Object.entries(statuses ?? {}).filter(([, item]) => item.status !== "ok");