npm - agent-dag - Versions diffs - 1.34.6 → 1.35.1 - Mend

agent-dag 1.34.6 → 1.35.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +22 -1
package/bin/deck.js +74 -10
package/dist/web/assets/index-BWurW9Rz.js +70 -0
package/dist/web/index.html +1 -1
package/hook/hook.js +64 -21
package/package.json +1 -1
package/src/server/claude-dir.mjs +191 -7
package/src/server/index.mjs +52 -2
package/src/server/log-writer.mjs +34 -19
package/src/server/quota.mjs +7 -39
package/dist/web/assets/index-G1Xt6iC6.js +0 -70

package/dist/web/index.html CHANGED Viewed

@@ -40,7 +40,7 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-G1Xt6iC6.js"></script>
+    <script type="module" crossorigin src="/assets/index-BWurW9Rz.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CRPobBZf.css">
   </head>
   <body>

package/hook/hook.js CHANGED Viewed

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 // agent-dag hook forwarder. Invoked by Claude Code or Codex CLI as a command
 // hook. Reads stdin (event JSON), tags it with the provider passed via
-// `--provider <name>`, finds the matching agent-dag server via per-workspace
-// discovery files in <claude config dir>/agent-dag/, makes that server prove it
-// is the deck the file describes, and POSTs the payload. Dead instances are
-// cleaned up.
+// `--provider <name>`, finds every agent-dag server whose workspace contains the
+// session — via the discovery files in <claude config dir>/agent-dag/ — makes
+// each one prove it is the deck its file describes, and POSTs the payload. Dead
+// instances are cleaned up.
 "use strict";
 const fs = require("fs");
@@ -86,6 +86,36 @@ function cwdInWorkspace(cwd, workspace, platform = process.platform) {
   return a.startsWith(b.endsWith(p.sep) ? b : b + p.sep);
 }
+/**
+ * Does a deck scoped to `workspace` capture a session running in `cwd`? This is
+ * the whole of what `--workspace` means, and it is a question about ONE deck: it
+ * asks nothing about the others that may also be up, so a deck's answer never
+ * depends on who else is running.
+ *
+ * An empty workspace is the default — machine-wide — and captures everything.
+ * It is answered before cwdInWorkspace rather than passed to it because
+ * p.resolve("") is the resolving process's own cwd, which here is the agent's,
+ * so an unscoped deck would be silently scoped to whatever directory the user
+ * happened to run their agent in.
+ *
+ * A session that never said where it runs is inside no workspace, so only an
+ * unscoped deck sees it. Unreachable from main(), which exits before this on a
+ * payload with no cwd — it is here because the rule has to be stated the same
+ * way on both sides to be pinned against the other one.
+ *
+ * src/server/log-writer.mjs answers this same question, for the sessions the
+ * server builds itself out of Codex's rollout files, under the name
+ * codexCwdInWorkspace — this script is copied out of the package and run
+ * standalone, so it cannot import that copy. A test walks one table of paths
+ * through both: a disagreement between them is `--workspace` meaning two
+ * different things depending on which CLI produced the session.
+ */
+function capturesSession(cwd, workspace, platform = process.platform) {
+  if (!workspace || typeof workspace !== "string") return true;
+  if (!cwd || typeof cwd !== "string") return false;
+  return cwdInWorkspace(cwd, workspace, platform);
+}
 function isAlive(pid) {
   try { process.kill(pid, 0); return true; }
   catch (e) { return e && e.code === "EPERM"; }
@@ -315,7 +345,24 @@ function main() {
     } catch { return process.exit(0); }
     if (!files.length) return process.exit(0);
-    const matches = [];
+    // Every deck whose workspace contains this cwd, and nothing else decides it.
+    //
+    // This used to sort the matches by how long each deck's workspace path was
+    // and deliver only to the longest — so a deck scoped to /Users/x/proj TOOK
+    // that tree's sessions away from a machine-wide deck, which then sat there
+    // showing nothing while `--all` promised it captured every session on this
+    // machine. Nothing documented that, and the server's own Codex capture never
+    // did it: each deck tails the rollout files itself and evaluates its own
+    // workspace, so a Codex session inside a scoped tree appeared on both decks
+    // while the Claude session beside it appeared on one. One flag, one path,
+    // two answers.
+    //
+    // The fan-out is the documented meaning and the one kept: `--workspace` says
+    // which sessions a deck captures, not which sessions it takes from the decks
+    // around it. It is also what electWriters below already assumes — several
+    // decks drawing one event is the case it exists to keep from being written
+    // to one log several times.
+    const targets = [];
     for (const file of files) {
       let d;
       try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), "utf8")); } catch { continue; }
@@ -329,29 +376,25 @@ function main() {
         continue;
       }
-      if (d.workspace === "") {
-        matches.push({ d, wsLen: 0 });
-        continue;
-      }
-      const ws = normPath(d.workspace);
-      if (cwdInWorkspace(resolvedCwd, ws)) {
-        matches.push({ d, wsLen: ws.length });
-      }
+      // "" is machine-wide and must never reach normPath: resolving it would
+      // produce this hook's own cwd — the agent's — and scope a deck that asked
+      // for no scope at all. Any other spelling is canonicalized here, which is
+      // now a second pass over a path bin/deck.js already canonicalized before
+      // publishing it — kept because a deck old enough to have published a
+      // relative one is still entitled to its events.
+      const ws = d.workspace === "" ? "" : normPath(d.workspace);
+      if (capturesSession(resolvedCwd, ws)) targets.push(d);
     }
-    if (!matches.length) return process.exit(0);
-    matches.sort((a, b) => b.wsLen - a.wsLen);
-    const bestLen = matches[0].wsLen;
-    const targets = matches.filter(m => m.wsLen === bestLen);
+    if (!targets.length) return process.exit(0);
     // One deck per events log records this event; the others only draw it.
-    const writers = electWriters(targets.map(m => m.d));
+    const writers = electWriters(targets);
     let pending = targets.length;
     const done = () => { if (--pending <= 0) process.exit(0); };
-    for (const { d } of targets) deliver(d, taggedInput, writers.has(d), done);
+    for (const d of targets) deliver(d, taggedInput, writers.has(d), done);
   });
 }
@@ -360,5 +403,5 @@ function main() {
 // require() it exports the rules it decides by — matching, election, the
 // handshake — and starts nothing, which is what lets them be tested without a
 // 1.5s exit timer in the test runner.
-module.exports = { cwdInWorkspace, foldsCase, electWriters, challengeProof, requiresProof };
+module.exports = { capturesSession, cwdInWorkspace, foldsCase, electWriters, challengeProof, requiresProof };
 if (require.main === module) main();

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.34.6",
+  "version": "1.35.1",
   "description": "Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.",
   "type": "module",
   "bin": {

package/src/server/claude-dir.mjs CHANGED Viewed

@@ -1,5 +1,5 @@
-// Where Claude Code keeps its configuration — and therefore where the
-// settings.json our hooks have to be registered in actually lives.
+// Where Claude Code lives on this machine: its configuration directory, its
+// binary, and the question of whether it is here at all.
 //
 // CLAUDE_CONFIG_DIR relocates that directory wholesale; it is a replacement for
 // ~/.claude, not an overlay, so on a machine where it is set there is nothing in
@@ -12,11 +12,195 @@
 // reads another. hook/hook.js repeats the rule inline rather than importing it:
 // it is copied out of the package and run standalone by the host CLI, so it has
 // no way back to this module, but it has to resolve the same directory.
+//
+// The binary list and the presence test moved in beside it for the same reason.
+// The list used to sit in quota.mjs under the name quotaClaudeCandidates, where
+// it read as a detail of one poller; it is nothing of the kind. It is the answer
+// to "where does the `claude` command live", and the deck now asks that question
+// at boot, before any quota exists, to decide whether this is a Claude machine
+// at all. One list, one caller-visible name, no second spelling to drift.
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, posix as posixPath, win32 as winPath } from "node:path";
+/**
+ * Absolute path of the Claude Code config dir: $CLAUDE_CONFIG_DIR or ~/.claude.
+ *
+ * The environment and the home directory are parameters purely so callers that
+ * are already working from an injected environment can stay consistent with it;
+ * every caller in the deck passes nothing and gets the real machine's answer.
+ */
+export function claudeConfigDir(env = process.env, home = homedir()) {
+  const override = env.CLAUDE_CONFIG_DIR?.trim();
+  return override ? resolve(override) : join(home, ".claude");
+}
+/**
+ * Every place the `claude` CLI is known to live, in the order to try them.
+ *
+ * Pure, and the platform, environment and home directory are parameters, so the
+ * Windows list can be checked from a Mac — which is the only way this list stays
+ * right, since it exists entirely for machines the author is not sitting at.
+ */
+export function claudeCliCandidates(platform = process.platform, env = process.env, home = homedir()) {
+  // The path flavour follows the PLATFORM ARGUMENT, not the host: node's `join`
+  // would emit forward slashes when the Windows list is built on a Mac.
+  const { join } = platform === "win32" ? winPath : posixPath;
+  if (platform !== "win32") {
+    return [
+      "claude",
+      join(home, ".local", "bin", "claude"),
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+    ];
+  }
+  return [
+    // The native installer, which ships a bare claude.exe and NO .cmd shim. It
+    // was the one install this branch could not reach: the npm path below does
+    // not exist on such a machine, and the bare-name fallback used to be spelled
+    // `claude.cmd`, which cmd.exe cannot resolve to an .exe — PATHEXT supplies a
+    // missing extension, it never substitutes one that is already there.
+    join(home, ".local", "bin", "claude.exe"),
+    // `npm i -g @anthropic-ai/claude-code`. npm's global prefix is %APPDATA%\npm
+    // — Roaming rather than Local, deliberately, since it follows the user
+    // between machines — and APPDATA is read from the environment because a
+    // roaming profile puts it on a network share, not under the home directory.
+    join(env.APPDATA || join(home, "AppData", "Roaming"), "npm", "claude.cmd"),
+    // Last resort: the bare name, which cmd.exe resolves through PATH + PATHEXT
+    // and so finds claude.exe and claude.cmd alike.
+    "claude",
+  ];
+}
+/**
+ * The names Claude Code itself writes inside its config dir, and the deck never
+ * does. Presence of any one of them is proof Claude Code has actually run here.
+ *
+ * The exclusions are the entire point. `settings.json` and `agent-dag/` are OURS
+ * — installHooks writes the first and keepDiscovery creates the second — so a
+ * test that accepted them would answer "Claude is installed" on any machine this
+ * deck had ever been started on, including the Codex-only one this whole check
+ * exists to recognise. That is not a hypothetical: every Codex-only machine that
+ * ran an earlier ccdeck already has both sitting in a ~/.claude the deck created
+ * for itself.
+ *
+ * `.credentials.json` is in the list but cannot carry it alone: macOS keeps the
+ * OAuth token in the Keychain and writes no such file, so on the platform where
+ * a credentials test is most tempting it is always negative (see #360). It earns
+ * its place as one more way to say yes on Linux and Windows, never as the test.
+ */
+const CLAUDE_USE_MARKERS = [
+  "projects",         // one directory per cwd, written from the first session on
+  "history.jsonl",    // the prompt history, appended to on the first prompt
+  "statsig",          // written at first launch, before any session completes
+  "todos",
+  "shell-snapshots",
+  "ide",
+  "plugins",
+  ".credentials.json", // Linux + Windows OAuth store; absent on macOS by design
+  ".claude.json",      // Claude Code's own state file, when the config dir moved
+];
+/**
+ * Whether the `claude` binary is on this machine — on PATH, or in one of the
+ * places its installers are known to put it.
+ *
+ * `run()` in exec.mjs can afford to hand a bare name to spawn and let the OS
+ * resolve it. This cannot: it has to answer without launching anything. Boot is
+ * the wrong place to spend a `claude --version` child process (quota.mjs
+ * measured those at ~3.0s each), and a spawn probe would also have to decide
+ * what a non-zero exit means, which is a question with no good answer. So the
+ * PATH walk is done by hand, with PATHEXT applied on Windows exactly as cmd.exe
+ * would — a `claude.cmd` shim from npm and a bare `claude.exe` from the native
+ * installer both have to count, and neither is spelled `claude`.
+ */
+export function claudeCliOnDisk({
+  platform = process.platform,
+  env = process.env,
+  home = homedir(),
+  exists = existsSync,
+} = {}) {
+  const path = platform === "win32" ? winPath : posixPath;
+  const bare = [];
+  for (const candidate of claudeCliCandidates(platform, env, home)) {
+    // A full path is worth a single stat; a bare name means "ask PATH", which
+    // is the walk below. Same split quotaClaudeBin makes, for the same reason.
+    if (candidate.includes(path.sep)) { if (exists(candidate)) return true; }
+    else bare.push(candidate);
+  }
+  if (bare.length === 0) return false;
+  // process.env is case-insensitive on Windows, but an injected plain object in
+  // a test is not, and %Path% is how the variable is actually spelled there.
+  const rawPath = env.PATH ?? env.Path ?? env.path ?? "";
+  // The empty extension stays in the list: a Git-Bash or WSL-style shim on
+  // Windows can be an extensionless file, and on POSIX it is the only entry.
+  const exts = platform === "win32"
+    ? ["", ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map(e => e.trim()).filter(Boolean)]
+    : [""];
+  for (const entry of String(rawPath).split(path.delimiter)) {
+    // Windows PATH entries are routinely quoted, and an empty entry means the
+    // current directory — which is not a place to go looking for a CLI.
+    const dir = entry.trim().replace(/^"+|"+$/g, "");
+    if (dir === "") continue;
+    for (const name of bare) {
+      for (const ext of exts) if (exists(path.join(dir, name + ext))) return true;
+    }
+  }
+  return false;
+}
-/** Absolute path of the Claude Code config dir: $CLAUDE_CONFIG_DIR or ~/.claude. */
-export function claudeConfigDir() {
-  const override = process.env.CLAUDE_CONFIG_DIR?.trim();
-  return override ? resolve(override) : join(homedir(), ".claude");
+/**
+ * Whether this machine has Claude Code at all — the mirror of hasCodexInstalled().
+ *
+ * README offers "Claude Code CLI or OpenAI Codex CLI (or both)", and until now
+ * nothing anywhere asked which. A Codex-only machine got a Python
+ * account-switcher installed for a CLI it does not have, an accounts panel open
+ * on first run, and a banner telling it to sign into that CLI (#402).
+ *
+ * WHY TWO KINDS OF EVIDENCE, OR'd. Neither half is sufficient on its own:
+ *
+ *   - The binary alone misses the user whose `claude` lives somewhere no list
+ *     knows (nvm, mise, volta, a corporate wrapper) and whose deck was launched
+ *     from a desktop shortcut with a PATH that never sourced their shell rc.
+ *     That user has run Claude Code for months; the config dir proves it.
+ *   - The config dir alone misses the machine where Claude Code is installed and
+ *     has never been launched, which is exactly the moment somebody installs
+ *     both CLIs and starts the deck first. It also cannot be the test on its own
+ *     for the opposite reason: THE DECK CREATES THAT DIRECTORY ITSELF. Hence
+ *     CLAUDE_USE_MARKERS above, which is a list of things only Claude Code puts
+ *     there.
+ *
+ * WHY NOT CREDENTIALS. A credentials file is not a presence test on macOS at
+ * all — the token is in the Keychain and no file exists (#360) — so a machine
+ * with Claude Code, signed in and in daily use, would read as Codex-only.
+ *
+ * WHY NOT "a Claude session was seen". It is the most direct evidence there is,
+ * and it arrives far too late: the decision this answers is made at boot, before
+ * the server is listening, and a machine whose first session has not started yet
+ * would install nothing and show no panel until a restart.
+ *
+ * The bias is deliberate and one-way. A false yes leaves a Claude-only surface
+ * on a Codex machine — today's bug, visible, and the user can pass --no-claude.
+ * A false no takes the hooks away from somebody who has Claude Code, which is a
+ * deck that stays empty forever. So every check here is generous, the banner
+ * says out loud which way it went, and --claude overrides it.
+ */
+export function hasClaudeInstalled({
+  platform = process.platform,
+  env = process.env,
+  home = homedir(),
+  configDir = claudeConfigDir(env, home),
+  exists = existsSync,
+} = {}) {
+  if (claudeCliOnDisk({ platform, env, home, exists })) return true;
+  const path = platform === "win32" ? winPath : posixPath;
+  for (const marker of CLAUDE_USE_MARKERS) {
+    if (exists(path.join(configDir, marker))) return true;
+  }
+  // ~/.claude.json is Claude Code's own state file on every install that never
+  // moved the config dir, and it sits BESIDE the home directory rather than
+  // inside ~/.claude — so the loop above cannot reach it there.
+  return exists(path.join(home, ".claude.json"));
 }

package/src/server/index.mjs CHANGED Viewed

@@ -2,7 +2,7 @@
 // Single-file pure Node HTTP server, zero deps.
 import { createServer } from "node:http";
 import { readFile, stat, mkdir, appendFile, open, truncate, readdir, unlink } from "node:fs/promises";
-import { createReadStream, existsSync, readFileSync } from "node:fs";
+import { createReadStream, existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join, resolve, dirname as pdirname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -1918,6 +1918,52 @@ async function handleSoundHookSet(req, res) {
 // can read before a single event has arrived.
 let _workspace = "";
+// Which CLIs this deck is actually watching. Decided in bin/deck.js — from
+// whether each one is on the machine, and from --claude/--no-claude and
+// --codex/--no-codex — and passed in here, because the browser had no way to
+// learn it and so drew both sides of the UI on every machine.
+//
+// That is the whole of #402 and its mirror. A Codex-only machine got the
+// accounts panel open on first run, telling it to sign into a CLI it does not
+// have; a Claude-only machine permanently carried "Quota unavailable. / Run
+// codex login to authenticate." Same missing fact, two directions.
+//
+// Defaults are both true, which is what an older deck effectively reported by
+// saying nothing — and the browser reads a missing field as "could not say" and
+// shows both, so the two agree.
+let _providers = { claude: true, codex: true };
+/**
+ * The one spelling of `--workspace` everything downstream compares against.
+ * Empty — including a value that is nothing but spaces — stays empty, which is
+ * how every reader of it says "machine-wide".
+ *
+ * Called once, in bin/deck.js, where the flag arrives: that process's cwd is the
+ * shell the user typed the command in, and it is the only process on either
+ * capture path whose cwd is the one a relative `--workspace ./sub` was written
+ * against. The raw string used to go straight into the discovery file, and
+ * hook.js resolved it inside its own process — which the host CLI runs with the
+ * AGENT's cwd — so `--workspace ./sub` scoped Claude sessions to a `sub`
+ * directory under whatever the agent happened to be working in, a different
+ * directory per agent and none of them the one asked for. The Codex path
+ * resolved the same string in the server process and was right. Resolving here
+ * makes both of them right, and for the same reason bin/deck.js already resolves
+ * the events log before publishing it: what goes in the discovery file is read
+ * by other processes that cannot reconstruct the context it was written in.
+ *
+ * Symlinks are resolved too, because a process's cwd — which is what both
+ * providers report — comes from getcwd() and has none left in it. Without this,
+ * `--workspace /tmp/proj` on a Mac is scoped to /tmp/proj while every session
+ * inside it reports /private/tmp/proj, and the deck stays empty. A path that
+ * does not exist yet keeps its resolved form rather than failing: scoping a deck
+ * to a directory you are about to create is not an error.
+ */
+export function canonicalWorkspace(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") return "";
+  const abs = resolve(raw);
+  try { return realpathSync(abs); } catch { return abs; }
+}
 function handleHealth(_req, res) {
   send(res, 200, {
     ok: true,
@@ -1926,6 +1972,7 @@ function handleHealth(_req, res) {
     clients: sseClients.size,
     uptimeMs: Math.round(process.uptime() * 1000),
     workspace: _workspace,
+    providers: _providers,
   });
 }
@@ -2312,10 +2359,13 @@ let _onRestart = null;
 // ask; the second ask must not re-enter the shutdown.
 let _restarting = false;
-export async function startServer({ port = 4317, host = "127.0.0.1", persist = null, portRange = [4318, 4400], workspace = "", codex = true, onRestart = null } = {}) {
+export async function startServer({ port = 4317, host = "127.0.0.1", persist = null, portRange = [4318, 4400], workspace = "", codex = true, claude = true, onRestart = null } = {}) {
   _onRestart = typeof onRestart === "function" ? onRestart : null;
   _canRestart = _onRestart != null && persist != null;
   _workspace = typeof workspace === "string" ? workspace : "";
+  // `!== false` rather than a cast: a caller that omits the field means "yes",
+  // which is how every embedder that predates this option keeps working.
+  _providers = { claude: claude !== false, codex: codex !== false };
   const removed = await sweepStaleDiscovery();
   if (removed > 0) console.log(`  swept ${removed} stale discovery file(s)`);
   if (persist) {

package/src/server/log-writer.mjs CHANGED Viewed

@@ -73,17 +73,29 @@ export function electWriters(decks, platform = process.platform) {
 /**
  * Would a deck scoped to `workspace` capture a rollout running in `cwd`? An
- * empty workspace is unscoped and captures every session.
+ * empty workspace is unscoped and captures every session; a rollout that never
+ * said where it runs is inside no workspace, so only an unscoped deck draws it.
  *
- * Case is folded on every platform here, which the hook's own cwdInWorkspace
- * deliberately does not do. That stays as it was, because this predicate now
- * answers two questions with one function: whether THIS deck tails a rollout,
- * and whether another deck tails it too. Model the other deck's capture with a
- * rule stricter than the one it actually runs and the election covers the wrong
- * set — a deck that writes without being elected, or an elected deck that never
- * saw the file. Being wrong in the over-matching direction on Linux costs a deck
- * a sibling tree it was not scoped to; being wrong in either direction here
- * costs a duplicated log line or a lost one.
+ * This answers two questions with one function — whether THIS deck tails a
+ * rollout, and whether another deck tails it too — and that is only sound while
+ * the rule below is the rule every deck actually runs. Model another deck's
+ * capture with anything else and the election covers the wrong set: a deck that
+ * writes without being elected, or an elected deck that never opened the file.
+ *
+ * It is also the rule hook/hook.js runs for the sessions it delivers, under the
+ * name capturesSession — that script is copied out of the package and run
+ * standalone, so the two are written twice and pinned equal by a test walking
+ * one table of paths through both. They were not equal: case was folded here on
+ * every platform, so on Linux a deck scoped to /srv/proj captured Codex sessions
+ * from /srv/Proj and Claude sessions from neither. Those are two real
+ * directories there, and the hook's own comment says what folding them together
+ * costs — a deck handed the events of a tree it was not scoped to. So the fold
+ * is per-platform on both sides now, and `--workspace` means one thing.
+ *
+ * (The narrow window that opens: two decks on Linux whose workspaces differ only
+ * in case, one of them old enough to still fold, both containing one rollout's
+ * cwd. Each models the other as tailing the file; one of them is wrong, and the
+ * cost is a single log line written twice.)
  *
  * The platform is a parameter, following the hook's cwdInWorkspace and
  * spawnSpec in src/server/exec.mjs, so the Windows separator is testable from a
@@ -93,8 +105,9 @@ export function codexCwdInWorkspace(cwd, workspace, platform = process.platform)
   if (!workspace || typeof workspace !== "string") return true;
   if (!cwd || typeof cwd !== "string") return false;
   const p = platform === "win32" ? win32 : posix;
-  const a = p.resolve(cwd).toLowerCase();
-  const b = p.resolve(workspace).toLowerCase();
+  const fold = s => (foldsCase(platform) ? s.toLowerCase() : s);
+  const a = fold(p.resolve(cwd));
+  const b = fold(p.resolve(workspace));
   if (a === b) return true;
   // A root ("C:\", "/") already ends in the separator; appending a second one
   // would match nothing.
@@ -106,13 +119,15 @@ export function codexCwdInWorkspace(cwd, workspace, platform = process.platform)
  * it? `decks` is every deck registered right now, `pid` identifies this one
  * among them, and `cwd` is the workspace the rollout is running in.
  *
- * The group is every deck that tails this same rollout — the hook's targets are
- * narrowed to the longest workspace match, but nothing narrows these: each deck
- * decides for itself, so all of them whose workspace contains the cwd read the
- * file and all of them would write it. A deck started with `--no-codex` tails
- * nothing and is left out; electing it would mean the rollout's events reach no
- * log at all. A deck too old to say either way is assumed to be tailing, which
- * is what it was doing before this field existed.
+ * The group is every deck that tails this same rollout: each deck decides for
+ * itself, so all of them whose workspace contains the cwd read the file and all
+ * of them would write it. The hook builds the same group the same way for the
+ * events it delivers — it used to narrow them to the longest workspace match
+ * first, which is the asymmetry the predicate above describes the end of. A deck
+ * started with `--no-codex` tails nothing and is left out; electing it would
+ * mean the rollout's events reach no log at all. A deck too old to say either
+ * way is assumed to be tailing, which is what it was doing before this field
+ * existed.
  */
 export function writesCodexLog({ decks, pid, cwd, platform = process.platform }) {
   const live = Array.isArray(decks) ? decks : [];

package/src/server/quota.mjs CHANGED Viewed

@@ -28,11 +28,11 @@
 // 2 and 3 are rate-floored (SELF_POLL_MS) and gated behind the same 429
 // cooldown; 1 is not, because it is a local file read.
 import { activeAccountUsage, requestCollection } from "./claude-accounts.mjs";
-import { claudeConfigDir } from "./claude-dir.mjs";
+import { claudeCliCandidates, claudeConfigDir } from "./claude-dir.mjs";
 import { run } from "./exec.mjs";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join, posix as posixPath, win32 as winPath } from "node:path";
+import { join } from "node:path";
 import { homedir } from "node:os";
 import { PRODUCT } from "./brand.mjs";
@@ -334,42 +334,10 @@ function parseUsageText(raw) {
   return Object.keys(result).length > 0 ? result : null;
 }
-/**
- * Every place the `claude` CLI is known to live, in the order to try them.
- *
- * Pure, and the platform, environment and home directory are parameters, so the
- * Windows list can be checked from a Mac — which is the only way this list stays
- * right, since it exists entirely for machines the author is not sitting at.
- */
-export function quotaClaudeCandidates(platform = process.platform, env = process.env, home = homedir()) {
-  // The path flavour follows the PLATFORM ARGUMENT, not the host: node's `join`
-  // would emit forward slashes when the Windows list is built on a Mac.
-  const { join } = platform === "win32" ? winPath : posixPath;
-  if (platform !== "win32") {
-    return [
-      "claude",
-      join(home, ".local", "bin", "claude"),
-      "/usr/local/bin/claude",
-      "/opt/homebrew/bin/claude",
-    ];
-  }
-  return [
-    // The native installer, which ships a bare claude.exe and NO .cmd shim. It
-    // was the one install this branch could not reach: the npm path below does
-    // not exist on such a machine, and the bare-name fallback used to be spelled
-    // `claude.cmd`, which cmd.exe cannot resolve to an .exe — PATHEXT supplies a
-    // missing extension, it never substitutes one that is already there.
-    join(home, ".local", "bin", "claude.exe"),
-    // `npm i -g @anthropic-ai/claude-code`. npm's global prefix is %APPDATA%\npm
-    // — Roaming rather than Local, deliberately, since it follows the user
-    // between machines — and APPDATA is read from the environment because a
-    // roaming profile puts it on a network share, not under the home directory.
-    join(env.APPDATA || join(home, "AppData", "Roaming"), "npm", "claude.cmd"),
-    // Last resort: the bare name, which cmd.exe resolves through PATH + PATHEXT
-    // and so finds claude.exe and claude.cmd alike.
-    "claude",
-  ];
-}
+// Where the `claude` CLI can be. The list moved to claude-dir.mjs, which is the
+// module that owns every "where does Claude Code live" answer the deck has —
+// the config dir was already there, and the boot-time presence check that reads
+// this same list had no business importing a quota poller to get at it.
 /** Which `claude` to run for `--print /usage`: the first candidate that exists.
  *
@@ -396,7 +364,7 @@ export function quotaClaudeBin(platform = process.platform, env = process.env,
   // A bare name is left to spawn's own PATH lookup (and, on Windows, to the
   // PATHEXT walk exec.mjs does by hand); a full path is only worth naming when
   // it is actually there.
-  return quotaClaudeCandidates(platform, env, home)
+  return claudeCliCandidates(platform, env, home)
     .find(c => !c.includes(sep) || exists(c)) ?? "claude";
 }