@delorenj/pjangler 1.5.38 → 1.5.40

package/dist/crank/tui.js

@@ -213,6 +213,59 @@ var PJANGLER_VERSION = (() => {
   return "0.0.0";
 })();
 
+// src/crank/engine.ts
+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;
+var FUTURE_SKEW_MS = 5 * 6e4;
+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 engineBlockedLabel(status) {
+  if (!status.known) return void 0;
+  if (engineStalled(status) && status.lastTickMs !== void 0) return `blocked: engine not ticking (last tick ${ago(status.lastTickMs, status.readAtMs)})`;
+  if (status.outcome !== "refused") return void 0;
+  if (status.tokenBlocked) {
+    const resume = status.resumeMs !== void 0 ? ` \u2014 resumes \u2248 ${clockTime(nextTickAtOrAfter(status.resumeMs))}` : "";
+    return `blocked: daily token cap${resume}`;
+  }
+  return `blocked: ${status.reason ?? "engine refused the last tick"}`;
+}
+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_INTERVALS = ["5m", "1h", "6h", "1d"];
 var INTERVAL_SECONDS = { "5m": 300, "1h": 3600, "6h": 21600, "1d": 86400 };
@@ -239,6 +292,7 @@ function formatAge(thenMs, nowMs) {
   if (s < 60) return `${s}s ago`;
   return `${formatDuration(s)} ago`;
 }
+var PANE_CWD_TTL_SECONDS = 6 * 3600;
 function renderLogRow(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -294,10 +348,6 @@ async function pickInterval(props, run = {}) {
   const choice = await runInk((finish) => /* @__PURE__ */ jsx3(IntervalPicker, { ...props, onDone: finish }), run);
   return choice ?? null;
 }
-function clockTime(ms) {
-  const d = new Date(ms);
-  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
-}
 function describeMatch(view) {
   const { resolution } = view;
   if (resolution.storedAsIs) return `no live tab or key matches "${view.name}" - stored under the project name`;
@@ -346,6 +396,9 @@ function CrankDashboard({ controller, refreshMs = 5e3, clock = Date.now, onQuit
   });
   const onInterval = (interval) => act(`interval ${interval}`, () => controller.setInterval(interval));
   const next = nextRunMs({ enabled: isOn, interval: snap.interval, lastRun: snap.lastRunMs, nowMs: now });
+  const engineLine = engineSummary(view.engine);
+  const blocked = isOn ? engineBlockedLabel(view.engine) : void 0;
+  const engineColor = engineLine.tone === "ok" ? themeColor("ok") : engineLine.tone === "warn" ? themeColor("warn") : themeColor("muted");
   const logRows = Math.max(3, (rows || 24) - 19);
   const tail = snap.log.slice(-logRows);
   return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
@@ -390,7 +443,7 @@ function CrankDashboard({ controller, refreshMs = 5e3, clock = Date.now, onQuit
     ] }),
     /* @__PURE__ */ jsxs3(Text3, { children: [
       /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Next run   " }),
-      next === void 0 ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "off" }) : /* @__PURE__ */ jsxs3(Text3, { children: [
+      next === void 0 ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "off" }) : blocked ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("warn"), children: blocked }) : /* @__PURE__ */ jsxs3(Text3, { children: [
         next <= now ? "now" : `in ${formatDuration((next - now) / 1e3)}`,
         " ",
         /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
@@ -400,8 +453,12 @@ function CrankDashboard({ controller, refreshMs = 5e3, clock = Date.now, onQuit
         ] })
       ] })
     ] }),
+    /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate-end", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Engine     " }),
+      /* @__PURE__ */ jsx3(Text3, { color: engineColor, children: engineLine.text })
+    ] }),
     /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Last runs" }),
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Last runs of this tab (beats that touched it, not engine ticks)" }),
       snap.beats.length === 0 ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "  none yet" }) : snap.beats.map((beat, i) => /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate-end", children: [
         "  ",
         formatAge(beat.tsMs, now).padEnd(10),

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 readdirSync13, readFileSync as readFileSync31, statSync as statSync9 } from "node:fs";
+import { basename as basename11, join as join36, 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) {
@@ -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,193 @@ 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 livePanes(deps = {}) {
+  const shell = deps.shell ?? defaultShell;
+  const result2 = shell("env", [
+    "-u",
+    "ZELLIJ",
+    "-u",
+    "ZELLIJ_SESSION_NAME",
+    "timeout",
+    "8s",
+    "zellij",
+    "-s",
+    ZCRANK_SESSION,
+    "action",
+    "list-panes",
+    "--json",
+    "--all"
+  ]);
+  if (result2.status !== 0 || !result2.stdout.trim()) return [];
+  try {
+    const parsed = JSON.parse(result2.stdout);
+    if (!Array.isArray(parsed)) return [];
+    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
+      });
+    }
+    return panes;
   } catch {
     return [];
   }
 }
+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 +21569,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 +21639,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 +21650,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 +21659,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 +21700,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 +21737,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 +21776,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 +21799,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 +21862,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,30 +21895,74 @@ 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 });
     }
   };
 }
@@ -21470,13 +21983,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) {
@@ -21507,12 +22027,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 +22100,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 +22116,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 +22130,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`)}`);
@@ -21623,7 +22148,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 +22183,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(readFileSync31(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -21677,8 +22202,8 @@ 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 manifest = readJson2(join36(targetDir, ".project.json"));
+  const pkg = readJson2(join36(targetDir, "package.json"));
   const name = String(manifest?.project_name ?? "").trim() || packageNameToProjectName(typeof pkg?.name === "string" ? pkg.name : void 0) || packageNameToProjectName(basename11(targetDir)) || "Project";
   const ticketProvider = manifest?.ticket_provider && typeof manifest.ticket_provider === "object" ? manifest.ticket_provider : {};
   return {
@@ -21753,7 +22278,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) || readFileSync31(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,7 +22335,7 @@ async function resolveProjectInitTarget(name, options) {
   if (!targetDir && cwdGitRoot) {
     targetDir = cwdGitRoot;
   }
-  if (!targetDir && !name && existsSync27(join35(cwd, ".project.json"))) {
+  if (!targetDir && !name && existsSync26(join36(cwd, ".project.json"))) {
     targetDir = cwd;
   }
   if (!targetDir && interactive) {
@@ -21821,10 +22346,10 @@ async function resolveProjectInitTarget(name, options) {
   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(join36(targetDir, ".project.json")) || existsSync26(join36(targetDir, ".copier-answers.yml")));
   const syncMode = Boolean(
     targetGitRoot && resolve25(targetGitRoot) === resolve25(targetDir) || alreadyScaffolded
   );
@@ -22346,7 +22871,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: join36(repo, ".project.json") });
     }
     const statuses = result2.__registry_status;
     const stale = Object.entries(statuses ?? {}).filter(([, item]) => item.status !== "ok");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delorenj/pjangler",
-  "version": "1.5.38",
+  "version": "1.5.40",
   "description": "Project subsystem bootstrapper CLI",
   "type": "module",
   "main": "dist/index.js",