@delorenj/pjangler 1.5.40 → 1.5.42

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 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 { 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
@@ -21155,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) {
@@ -21382,48 +21382,43 @@ function liveTabs(deps = {}) {
     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 [];
+function parseListPanes(stdout) {
+  if (!stdout.trim()) return null;
+  let parsed;
   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;
+    parsed = JSON.parse(stdout);
   } catch {
-    return [];
+    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();
@@ -21967,6 +21962,420 @@ function createCrankController(deps) {
   };
 }
 
+// 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)}`;
@@ -22010,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();
@@ -22140,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()) {
@@ -22185,7 +22625,7 @@ async function promptForRuleIds(rules) {
 function readJson2(path) {
   if (!existsSync26(path)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync31(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -22202,9 +22642,9 @@ function packageNameToProjectName(value) {
   return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()).trim();
 }
 function deriveProjectDefaults(targetDir) {
-  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 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,
@@ -22278,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 !existsSync26(action.path) || readFileSync31(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);
@@ -22335,11 +22775,11 @@ async function resolveProjectInitTarget(name, options) {
   if (!targetDir && cwdGitRoot) {
     targetDir = cwdGitRoot;
   }
-  if (!targetDir && !name && existsSync26(join36(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;
   }
@@ -22349,14 +22789,14 @@ async function resolveProjectInitTarget(name, options) {
   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 && (existsSync26(join36(targetDir, ".project.json")) || existsSync26(join36(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);
   }
@@ -22871,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: join36(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");

package/package.json

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