pi-odd-worktree 1.1.1 → 1.2.0

package/README.md

@@ -34,7 +34,6 @@ interchangeably by `worktree_close`, and by `/warp`.
 | --- | --- |
 | Pi (`@earendil-works/pi-coding-agent`, `@earendil-works/pi-tui`) | Peer dependencies at `*`, supplied by the host. The package installs no runtime dependencies. |
 | Node.js >= 18 and `git` | `engines` declares 18 as the floor, and every repository operation is a git child process. |
-| `herdr` — optional | Not required: only `worktree_create` tries a Herdr workspace association, and it falls back to plain `git`. |
 | `gh`, authenticated (`gh auth login`) | `/issues` only. Without it the command stays registered, says once per session what is missing, and never opens. |
 | `codegraph` — optional | Keeps each checkout's index fresh: `codegraph init` when a checkout is created, and a background `codegraph sync` after edits and writes. Absent, both stay off for the whole session. |
 | Gentle Shell — recommended | Supplies the presence and transport records the deletion guard reads to see sessions other than this one. |
@@ -154,6 +153,24 @@ Removal is `git worktree remove <absolute path>`, with `--force` only when the
 caller asked for it. The branch is kept, and **no Herdr workspace is closed,
 opened or removed** on any path.
 
+### A warp waits for this session's own agent tasks
+
+A warp never lands while this session still has running or queued agent tasks.
+The `worktree_warp` tool refuses **before** it queues anything, and `/warp`
+gives the published counters a bounded chance to drain (`ODD_WORKTREE_WARP_BUSY_WAIT_MS`,
+60 s by default) before it refuses: the session stays where it is and the notice
+says how many tasks are running. The counters are read from Gentle Shell's
+presence header for this session, through the same bounded reader the deletion
+guard uses.
+
+That check is **best effort, and it does not see background jobs**:
+
+- Agents publish their task counters in the presence header; a heartbeat older
+  than 15 s is not evidence, and an absent or unreadable store blocks nothing.
+- `bash_background` and `monitor` jobs live in Gentle Shell's in-memory job
+  registry, which publishes nothing durable and is not exposed by the Pi host,
+  so no warp can observe them. Confirm a job finished before warping.
+
 ### `/issues` pins the repository
 
 The repository identity (`<host>/<owner>/<repo>`) is pinned when the list loads,
@@ -238,7 +255,7 @@ This package is the worktree / ODD / issues surface only: no customize panel, no
 plugin-tools toggles, no Herdr plugin management, and no worktree↔issue
 association. There is nothing to configure, and `/warp`, `/odd-list` and
 `/issues` are always on (the three `/codegraph-*` commands follow the CLI).
-Paths, branches and arguments reach `git`, `herdr` and `gh` as fixed argv arrays,
+Paths, branches and arguments reach `git` and `gh` as fixed argv arrays,
 never as a shell string.
 
 ## Tests

package/extensions/odd-worktree-tools.ts

@@ -14,8 +14,7 @@
 // worktree_warp. Create and close prompt for approval when the host offers
 // dialog UI; list never mutates anything; warp hands the move to /warp.
 //
-// Herdr is optional, never required: every Herdr call is attempted first and
-// falls back to plain git, so the package works in Pi alone.
+// Worktree creation and removal use git; no Herdr workspace is opened.
 //
 // The file is plain JavaScript with a .ts extension (// @ts-nocheck, no type
 // annotations), so the test copy-to-.mjs loading pattern keeps working under
@@ -69,54 +68,6 @@ function setWarpTuiLoader(loader) {
   warpTuiLoader = loader;
 }
 
-// The herdr binary honors the documented HERDR_BIN_PATH override (tests),
-// else `herdr` on PATH.
-//
-// lib/worktree-git.js `resolveHerdrBinary` is the SINGLE authority and its
-// answer is propagated verbatim, including its refusal: under the test harness
-// (GENTLE_WORKTREE_LIB_DIR, set only by the test loaders) a value that may be
-// the live binary is refused unless the CURRENT test opted in with
-// GENTLE_WORKTREE_ALLOW_LIVE_HERDR=1. A `catch {}` around that call used to
-// swallow the refusal and then re-apply an inherited HERDR_BIN_PATH here, which
-// handed a test process exactly the live binary the authority had just refused
-// (a real Herdr workspace, created from a test). No fallback in this file may
-// re-decide the binary: the only remaining branch is for a lib that is missing
-// entirely, and it fails closed under the harness.
-function herdrBinary() {
-  let git = null;
-  try {
-    git = libRequire("worktree-git.js");
-  } catch {
-    git = null;
-  }
-  if (git && typeof git.resolveHerdrBinary === "function") {
-    return git.resolveHerdrBinary(process.env);
-  }
-  const harness = process.env.GENTLE_WORKTREE_LIB_DIR;
-  if (typeof harness === "string" && harness.length > 0) {
-    throw new Error(
-      "refusing to run live herdr from a test harness: herdr binary cannot be resolved "
-      + "(lib/worktree-git.js is unavailable, so no binary is injected)",
-    );
-  }
-  const bin = process.env.HERDR_BIN_PATH;
-  if (typeof bin === "string" && bin.length > 0) return bin;
-  return "herdr";
-}
-
-// The texts the authority (and the missing-lib branch above) use to refuse.
-// Matching on text keeps the boundary between lib and extension small: a
-// refusal is a resolved STATE, not an error class shared across it.
-const HERDR_REFUSAL_PATTERN = /refusing to run live herdr|herdr binary is not injected/;
-
-function isHerdrRefusal(err) {
-  return !!(
-    err
-    && typeof err.message === "string"
-    && HERDR_REFUSAL_PATTERN.test(err.message)
-  );
-}
-
 function toolCwd(ctx) {
   if (ctx && typeof ctx.cwd === "string" && ctx.cwd.length > 0) return ctx.cwd;
   return process.cwd();
@@ -543,12 +494,6 @@ function withWorktreeCardRenderer(tool) {
   // Model text and visual cards are independent presentation layers. Keep
   // backend helpers unchanged so runtime callers retain their raw contract.
   //
-  // The same seam turns a herdr resolution REFUSAL into an error result: the
-  // guard's refusal (a test harness handing over a possible live binary, or a
-  // harness with no binary injected) says the resolution failed, not that the
-  // tool crashed. Letting it escape would be an uncaught throw out of a tool
-  // handler, so every refusal is answered with its own text and `isError`, and
-  // every other exception is re-thrown untouched.
   const execute = tool.execute;
   let format = null;
   try {
@@ -559,13 +504,7 @@ function withWorktreeCardRenderer(tool) {
   }
   if (typeof execute === "function") {
     tool.execute = async function (...args) {
-      let result;
-      try {
-        result = await execute.apply(this, args);
-      } catch (err) {
-        if (!isHerdrRefusal(err)) throw err;
-        result = errorResult(`${tool.name}: ${err.message}`, { tool: tool.name, herdrRefused: true });
-      }
+      const result = await execute.apply(this, args);
       if (!format) return result;
       try {
         return format(tool.name, result);
@@ -703,7 +642,7 @@ async function awaitPendingCreationSetups() {
   }
 }
 
-// Core of `worktree_create`: validation (S2, S3) then herdr-first creation
+// Core of `worktree_create`: validation (S2, S3) then git creation
 // with a git fallback. Exported for unit tests; the registered tool calls
 // it with the live Pi context. It only ever CREATES: the branch plus the
 // `changes` selection (S3/S4), and no issue or ODD association is verified,
@@ -711,15 +650,6 @@ async function awaitPendingCreationSetups() {
 async function executeWorktreeCreate(params, ctx, opts) {
   const git = libRequire("worktree-git.js");
   const registry = libRequire("worktree-registry.js");
-  // S53 git-only route (create-from-warp): the wizard creates a plain
-  // git checkout plus the registry row and nothing else — never a Herdr
-  // workspace (`herdr worktree create/open` is what materialized the
-  // stray Herdr worktree the user never asked for). The route reuses
-  // every validation and the registry machinery below; only the
-  // backends change. Subprocesses run through the async runner here so
-  // a hanging child aborts on its bound instead of freezing the
-  // interactive session on the main thread.
-  const gitOnly = !!(opts && opts.gitOnly === true);
   // `backgroundHooks` is the INTERACTIVE create's speed contract: the checkout
   // plus its registry row are all the warp needs, so the slow half of the hooks
   // (install, codegraph) is handed to a tracked background task instead of
@@ -1112,24 +1042,12 @@ async function executeWorktreeCreate(params, ctx, opts) {
   // EXISTING branch with `git worktree add <target> <branch>` — no `-b`,
   // no base, the ref never created, rewritten or deleted — and the result
   // reports `branchCreated: false` plus a warning naming the adopted
-  // branch. Herdr's `worktree create` cannot adopt an existing branch, so
-  // the adopt case goes through git and then associates the Herdr
-  // workspace BEST-EFFORT via `herdr worktree open --path <path>
-  // --cwd <root>`; the checkout succeeding never depends on herdr.
-  // When the ref does not exist, creation keeps the herdr-first path
-  // with a `git worktree add -b` fallback and reports `branchCreated:
-  // true`. Fixed argv only, values as separate elements (herdr rejects
-  // --flag=value). Never --focus, never --trust-repository: trusting a
-  // repository is a human decision these tools never take. The base is
-  // LOCAL MAIN (S2), resolved in (d1) before anything was written: a session
-  // working inside a linked worktree can never seed the new branch with its
-  // own unmerged commits, and a repository without a local `main` was already
-  // refused there instead of falling back to the invoking HEAD.
+  // branch. New branches start at local main; existing branches are adopted
+  // unchanged. Both tool and panel creation use git only.
   const base = baseInfo !== null ? baseInfo.commit : null;
   let createdBy = null;
   let createError = null;
   let branchCreated = null;
-  let herdrAssociated = null;
   const adoptWarnings = [];
   if (branchExists) {
     // Adopt: check out the existing branch at the fresh path. No `-b`
@@ -1142,45 +1060,9 @@ async function executeWorktreeCreate(params, ctx, opts) {
       adoptWarnings.push(
         `adopted existing branch '${branch}' at ${target}: the worktree checks out that branch as-is, the branch ref was left untouched`,
       );
-      // Best-effort Herdr workspace association: reported, never fatal.
-      // Skipped on the git-only route: that checkout is git plus the
-      // registry row by design, so no association is expected.
-      if (!gitOnly) {
-      try {
-        const opened = await runGit(herdrBinary(), git.herdrArgv("open", { cwd: repo.root, path: target }), {
-          cwd: repo.root,
-          timeoutMs: 60000,
-        });
-        herdrAssociated = opened.status === 0;
-      } catch (err) {
-        herdrAssociated = false;
-      }
-      if (herdrAssociated !== true) {
-        adoptWarnings.push(
-          `herdr workspace association failed for ${target} ('herdr worktree open' did not succeed): the checkout itself is fine, associate it by hand when needed`,
-        );
-      }
-      }
     } else {
       createError = ((adopted.stderr || adopted.error || "unknown error") + "").trim();
     }
-  } else {
-  // The git-only route skips the herdr-first attempt outright: no
-  // `herdr worktree create` runs, so no Herdr workspace is ever
-  // materialized from the wizard. The tool path keeps herdr-first
-  // with the git fallback below, byte-identical.
-  let herdrRes = null;
-  if (!gitOnly) {
-  const createParams = { cwd: repo.root, branch, path: target };
-  if (base) createParams.base = base;
-  herdrRes = await runGit(herdrBinary(), git.herdrArgv("create", createParams), {
-    cwd: repo.root,
-    timeoutMs: 120000,
-  });
-  }
-  if (herdrRes !== null && herdrRes.status === 0) {
-    createdBy = "herdr";
-    branchCreated = true;
   } else {
     const fallbackArgv = ["worktree", "add", "-b", branch, target];
     if (base) fallbackArgv.push(base);
@@ -1212,10 +1094,9 @@ async function executeWorktreeCreate(params, ctx, opts) {
       }
     }
   }
-  }
   if (!createdBy) {
     return errorResult(
-      `failed to create worktree for branch '${branch}': ${createError || "herdr and git both failed"}`,
+      `failed to create worktree for branch '${branch}': ${createError || "git failed"}`,
       { branch, path: target, pruned: prunedStale },
     );
   }
@@ -1519,11 +1400,8 @@ async function executeWorktreeCreate(params, ctx, opts) {
   // S6: the ONE CodeGraph fact of this create, read from the hooks that just
   // ran (never re-run, never inferred).
   const codegraph = codegraphStatus(hooks);
-  // S20 adoption reporting: whether the branch was created or adopted,
-  // and (adopt case only) whether the best-effort Herdr workspace
-  // association happened. The checkout succeeding never depends on herdr.
+  // Report whether the branch was created or adopted.
   const adoptionDetails = { branchCreated };
-  if (herdrAssociated !== null) adoptionDetails.herdrAssociated = herdrAssociated;
   // (l) T41/S50 changes registration: register the checkout just
   // created on the CURRENT session through gentle-shell's
   // `session_worktree_register` host tool, but ONLY when that tool is
@@ -3787,6 +3665,17 @@ async function executeWorktreeWarpTool(params, ctx, opts) {
   // `fromName`/`name`/`path`/`branch`), so the card falls back to that line
   // instead of painting a move that has not happened. The one visible "moved"
   // card comes from the switched-to session once the move is real.
+  // S4: this session's own background work is a refusal, not a queue. The
+  // command that performs the move waits for idle — and a session with running
+  // agent tasks IS idle — so queueing here would move the session out from
+  // under work that is still running. Nothing is queued when this refuses.
+  const toolBusy = await warpSessionActivity(ctx);
+  if (toolBusy && toolBusy.busy === true) {
+    return errorResult(`worktree warp: ${warpBusyText(toolBusy)}`, {
+      tool: "worktree_warp", name: displayName, path: targetCwd, branch: displayBranch,
+      kind: resolved.kind, busy: true,
+    });
+  }
   const handoffDispatched = dispatchWarpHandoff(prepareWarpHandoff({
     name: displayName,
     target: targetCwd,
@@ -4203,6 +4092,62 @@ async function sessionManagerClassFor(ctx) {
   return null;
 }
 
+// S4: THIS session's own agent-task counters, read from the presence store the
+// close guard already consumes (lib/worktree-warp-busy.js). Best effort: an
+// absent module or store answers null and blocks nothing. Background jobs are
+// NOT covered — gentle-shell keeps them in memory and publishes no durable
+// evidence — so nothing here claims to see one.
+async function warpSessionActivity(ctx) {
+  let lib = null;
+  try {
+    lib = libRequire("worktree-warp-busy.js");
+  } catch {
+    return null;
+  }
+  if (!lib || typeof lib.sessionActivity !== "function") return null;
+  const sessionId = closeSessionString(ctx, "getSessionId");
+  try {
+    return await lib.sessionActivity({ sessionId });
+  } catch {
+    return null;
+  }
+}
+
+// The one refusal sentence, from the same module that produced the counters. A
+// missing module falls back to a shorter sentence that still names agent tasks
+// only.
+function warpBusyText(activity) {
+  try {
+    const lib = libRequire("worktree-warp-busy.js");
+    if (lib && typeof lib.busyText === "function") return lib.busyText(activity);
+  } catch {
+    // fall through to the fixed sentence
+  }
+  return "this session still has running agent tasks: the warp waits for them to finish (as of the last published heartbeat); background jobs are not visible here, so confirm they finished too";
+}
+
+// The COMMAND front's bounded wait: a warp lands after this turn settles, so it
+// gives the published counters a chance to drain before it refuses. Null when
+// the module or the session identity is unavailable (best effort, blocks
+// nothing).
+async function warpWaitForIdleSession(ctx) {
+  let lib = null;
+  try {
+    lib = libRequire("worktree-warp-busy.js");
+  } catch {
+    return null;
+  }
+  if (!lib || typeof lib.waitForSessionActivity !== "function") return null;
+  const sessionId = closeSessionString(ctx, "getSessionId");
+  try {
+    // The budget travels through the environment so a session can bound its own
+    // wait (ODD_WORKTREE_WARP_BUSY_WAIT_MS); the default keeps a warp short.
+    return await lib.waitForSessionActivity({ sessionId, env: process.env });
+  } catch {
+    return null;
+  }
+}
+
 function warpFail(text, details) {
   return { text, details: details || {}, isError: true };
 }
@@ -4545,6 +4490,17 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
     );
   }
   await ctx.waitForIdle();
+  // S4: a session with running agent tasks is IDLE for the host, so the wait
+  // above does not wait for that work. This front gives the published counters
+  // a bounded chance to drain and then refuses instead of moving the session
+  // out from under a task that is still running. A store that is absent or
+  // unreadable blocks nothing.
+  const busyWait = await warpWaitForIdleSession(ctx);
+  if (busyWait && busyWait.activity && busyWait.activity.busy === true) {
+    return warpFail(`worktree warp: ${warpBusyText(busyWait.activity)}`, {
+      name, alreadyThere: false, cancelled: false, busy: true,
+    });
+  }
   const fromCwd = typeof ctx.cwd === "string" && ctx.cwd.length > 0 ? ctx.cwd : process.cwd();
   // S21: the same awaited preflight reads as the tool, so a slow repository
   // never freezes the session that is being moved.
@@ -5975,8 +5931,8 @@ async function warpCreateAndEnter(ctx, git, notify) {
     return { closed: true, created: false, cancelled: true };
   }
   createParams.changes = pending.copy ? 'all' : 'none';
-  // S53: the git-only route — a plain git checkout plus the registry row,
-  // never a Herdr workspace — reusing the same creation path (validations,
+  // S53: the panel's create — a plain git checkout plus the registry row —
+  // reusing the same creation path (validations,
   // refusals, registration), which never prompts. The layout is
   // principal-anchored (S56): the new checkout lands beside the PRINCIPAL
   // checkout even when the panel runs inside a linked worktree, while the
@@ -5989,7 +5945,6 @@ async function warpCreateAndEnter(ctx, git, notify) {
   // can move, or the human would switch into a checkout that is missing the
   // work they just asked to carry.
   const created = await executeWorktreeCreate(createParams, ctx, {
-    gitOnly: true,
     principalLayout: true,
     backgroundHooks: true,
     ...(typeof notify === 'function' ? { notify } : {}),

package/lib/worktree-git.js

@@ -3,8 +3,7 @@
 //
 // Every external process is spawned with a fixed argv array — no shell
 // string is ever built, so branch names and paths cannot inject commands.
-// `listWorktrees` parses `git worktree list --porcelain -z` itself instead
-// of trusting Herdr JSON output.
+// `listWorktrees` parses `git worktree list --porcelain -z` itself.
 
 const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
@@ -564,193 +563,7 @@ function matchesAnyCheckout(identity, resolved, entries) {
   return false;
 }
 
-// Closed union of herdr operations with a per-operation flag allowlist,
-// mirroring the installed CLI surface (herdr 0.9.4, verified read-only
-// against `herdr worktree list|create|open --help`, `herdr pane list
-// --help` and `herdr agent start|get|list --help`: every flag below
-// exists there with the shape used here). Every value travels as its own
-// argv element because herdr rejects `--flag=value`. Unknown operations
-// or flags throw. `--trust-repository` is deliberately absent everywhere:
-// trusting a repository is a human decision these tools never take.
-// `--focus` stays opt-in for the worktree create/open calls that predate
-// the session tool; the session tool itself only ever passes `--no-focus`.
-const HERDR_ALLOWLIST = {
-  list: ['cwd'],
-  create: ['cwd', 'branch', 'base', 'path', 'label', 'focus'],
-  open: ['cwd', 'path', 'branch', 'noFocus', 'focus'],
-  remove: ['workspace', 'force'],
-  'pane-list': ['workspace'],
-  'agent-start': ['name', 'kind', 'pane', 'timeout', 'agentArgs'],
-  'agent-get': ['target'],
-  'agent-list': [],
-};
-
-const HERDR_FLAG = {
-  cwd: '--cwd',
-  workspace: '--workspace',
-  branch: '--branch',
-  base: '--base',
-  path: '--path',
-  label: '--label',
-  focus: '--focus',
-  noFocus: '--no-focus',
-  force: '--force',
-  kind: '--kind',
-  pane: '--pane',
-  timeout: '--timeout',
-};
 
-// Build the fixed argv for a herdr operation. Worktree operations produce
-// `herdr worktree <op> ...`; the session composition additionally needs
-// `herdr pane list`, `herdr agent start <NAME> ... -- [AGENT_ARG]...`,
-// `herdr agent get <target>` and `herdr agent list`, each with its own
-// fixed shape below so no caller hand-builds herdr argv.
-function herdrArgv(operation, params = {}) {
-  const allowed = HERDR_ALLOWLIST[operation];
-  if (!allowed) throw new Error(`unknown herdr operation: ${operation}`);
-  for (const key of Object.keys(params)) {
-    if (!allowed.includes(key)) throw new Error(`flag not allowed for herdr ${operation}: ${key}`);
-  }
-  // `herdr agent start <NAME> --kind <KIND> --pane <ID> --timeout <MS>
-  // -- [AGENT_ARG]...`: the agent name is positional and always first,
-  // the Pi argv travels after a `--` separator. Fixed order, values as
-  // separate elements, never `--flag=value`.
-  if (operation === 'agent-start') {
-    const { name, kind, pane, timeout, agentArgs } = params;
-    if (typeof name !== 'string' || name === '') throw new Error('invalid value for herdr agent-start name');
-    for (const [key, value] of [['kind', kind], ['pane', pane], ['timeout', timeout]]) {
-      if (typeof value !== 'string' || value === '') throw new Error(`invalid value for herdr agent-start ${key}`);
-    }
-    if (!Array.isArray(agentArgs) || agentArgs.some((entry) => typeof entry !== 'string')) {
-      throw new Error('invalid value for herdr agent-start agentArgs');
-    }
-    return ['agent', 'start', name,
-      '--kind', kind, '--pane', pane, '--timeout', timeout,
-      '--', ...agentArgs];
-  }
-  // `herdr agent get <target>`: the target is positional.
-  if (operation === 'agent-get') {
-    const { target } = params;
-    if (typeof target !== 'string' || target === '') throw new Error('invalid value for herdr agent-get target');
-    return ['agent', 'get', target];
-  }
-  // `herdr agent list` takes no flags.
-  if (operation === 'agent-list') return ['agent', 'list'];
-  // `herdr pane list [--workspace <ID>]`.
-  if (operation === 'pane-list') {
-    const argv = ['pane', 'list'];
-    if (params.workspace !== undefined) {
-      if (typeof params.workspace !== 'string' || params.workspace === '') {
-        throw new Error('invalid value for herdr pane-list workspace');
-      }
-      argv.push('--workspace', params.workspace);
-    }
-    return argv;
-  }
-  const argv = ['worktree', operation];
-  for (const key of Object.keys(params)) {
-    if (!allowed.includes(key)) throw new Error(`flag not allowed for herdr ${operation}: ${key}`);
-    const value = params[key];
-    if (typeof value === 'boolean') {
-      if (value) argv.push(HERDR_FLAG[key]);
-      continue;
-    }
-    if (typeof value !== 'string' || value === '') throw new Error(`invalid value for herdr ${operation} ${key}`);
-    argv.push(HERDR_FLAG[key], value);
-  }
-  return argv;
-}
-
-// Where the herdr binary comes from. Production honors the documented
-// HERDR_BIN_PATH override (tests), else `herdr` on PATH — the same
-// convention lib/gentle-diagnostics.js uses. Production (no harness
-// marker) keeps that historical behavior untouched.
-//
-// The test harness (GENTLE_WORKTREE_LIB_DIR, set only by the test loaders
-// that import the extension copy) is resolved FIRST, before the override is
-// trusted: an exported HERDR_BIN_PATH is inherited by every test process, so
-// honoring it first let a test run spawn the developer's LIVE herdr and
-// create real Herdr workspaces. Under the harness, therefore:
-//
-// - no binary at all still fails closed with the same refusal as before;
-// - a binary is honored only when the path itself proves it cannot be the
-//   live one (`isProvablyNotLiveHerdr`, which decides from the filesystem and
-//   never executes anything);
-// - a possible live herdr is refused unless the CURRENT test opts in with the
-//   dedicated flag below. The flag is the test's own declaration, so it must
-//   be set deliberately rather than inherited along with the path.
-const LIVE_HERDR_OPT_IN = 'GENTLE_WORKTREE_ALLOW_LIVE_HERDR';
-
-function realPathOrNull(target) {
-  try {
-    return fs.realpathSync(target);
-  } catch {
-    return null;
-  }
-}
-
-function isInsideDir(candidate, dir) {
-  if (candidate === dir) return true;
-  return candidate.startsWith(dir.endsWith(path.sep) ? dir : dir + path.sep);
-}
-
-// The scratch locations this repository's tests build their stub binaries in.
-// os.tmpdir() is the convention every fixture follows (`fs.mkdtempSync(
-// path.join(os.tmpdir(), ...))`), and no live Herdr install lives there.
-function testScratchRoots() {
-  const roots = [];
-  for (const candidate of [os.tmpdir(), path.resolve(os.tmpdir())]) {
-    const real = realPathOrNull(candidate) || candidate;
-    if (!roots.includes(real)) roots.push(real);
-  }
-  return roots;
-}
-
-// Can this path be PROVEN not to be a live herdr? Only filesystem facts are
-// used — the binary is never executed and nothing is spawned, so the answer
-// costs one realpath plus one stat and cannot reach a Herdr session.
-//
-// Proven not live: an absolute path that does not exist (a spawn of it fails),
-// that is not a regular file, that is not executable (a spawn of it fails),
-// or whose realpath is inside the test scratch directory. Everything else —
-// a relative or bare value (PATH/cwd resolved) and an existing executable
-// outside scratch — could be the live binary and is left unproven.
-function isProvablyNotLiveHerdr(bin) {
-  if (typeof bin !== 'string' || !path.isAbsolute(bin)) return false;
-  const real = realPathOrNull(bin);
-  if (real === null) return true;
-  let stat;
-  try {
-    stat = fs.statSync(real);
-  } catch {
-    return true;
-  }
-  if (!stat.isFile()) return true;
-  try {
-    fs.accessSync(real, fs.constants.X_OK);
-  } catch {
-    return true;
-  }
-  return testScratchRoots().some((root) => isInsideDir(real, root));
-}
-
-function resolveHerdrBinary(env = {}) {
-  const source = env || {};
-  const bin = source.HERDR_BIN_PATH;
-  const injected = typeof bin === 'string' && bin.length > 0;
-  const harness = source.GENTLE_WORKTREE_LIB_DIR;
-  const inHarness = typeof harness === 'string' && harness.length > 0;
-  if (!inHarness) return injected ? bin : 'herdr';
-  if (source[LIVE_HERDR_OPT_IN] === '1') return injected ? bin : 'herdr';
-  if (!injected) {
-    throw new Error('herdr binary is not injected: set HERDR_BIN_PATH in tests (refusing to run live herdr)');
-  }
-  if (isProvablyNotLiveHerdr(bin)) return bin;
-  throw new Error(
-    `refusing to run live herdr from a test harness: HERDR_BIN_PATH=${bin} can execute a live herdr; `
-    + `inject a scratch stub inside the OS temp directory, or set ${LIVE_HERDR_OPT_IN}=1 in the test that needs a live session`,
-  );
-}
 
 // ---------------------------------------------------------------------
 // Commits ahead of / behind a base branch (warp-popup W1).
@@ -1043,6 +856,4 @@ module.exports = {
   listWorktreesAsync,
   isPathInAnyCheckout,
   isPathInAnyCheckoutAsync,
-  herdrArgv,
-  resolveHerdrBinary,
 };

package/lib/worktree-hooks.js

@@ -8,7 +8,7 @@
 //   (b) dependency install by lockfile-detected stack,
 //   (c) `codegraph init` when the CLI is available.
 //
-// Both `worktree_upsert` (sync runner) and the wizard's gitOnly path (async
+// Both `worktree_upsert` (sync runner) and the panel create path (async
 // twin) reach these hooks, so the link policy is applied by ONE shared
 // implementation in `lib/worktree-symlinks.js` and both creation routes
 // behave identically.
@@ -394,7 +394,7 @@ async function runCreationHooksAsync(opts = {}) {
 
   // (a2) Link git-ignored principal entries: the async twin of the sync
   // step, sharing the one classifier in lib/worktree-symlinks.js so the tool
-  // path and the gitOnly/wizard path cannot disagree. The git reads and the
+  // path and the panel create path cannot disagree. The git reads and the
   // link writes are awaited, so the event loop keeps running.
   //
   // Policy (round-3 S3/L4): `.agents`, `.pi`, `.claude` and `odd` become

package/lib/worktree-session-guard.js

@@ -362,6 +362,14 @@ async function readGentlePresence(options = {}) {
         incarnation: header.incarnation,
         label: header.label,
         heartbeat: header.heartbeat,
+        // Published task counters, validated above and passed through
+        // unchanged: the warp guard reads this session's own workload.
+        counts: {
+          running: header.counts.running,
+          queued: header.counts.queued,
+          waiting: header.counts.waiting,
+          finished: header.counts.finished,
+        },
         recent: now >= header.heartbeat && now - header.heartbeat <= PRESENCE_FRESH_MS,
         workspace,
         unknown: workspace === null,