projectstore-claude 0.30.3 → 0.30.5

package/node_modules/projectstore/scripts/lib.mjs

@@ -24,12 +24,13 @@ import { join, dirname, basename, resolve, relative, isAbsolute } from "node:pat
 import { fileURLToPath } from "node:url";
 import { hostname, homedir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
-import { parseFrontmatter } from "./stages.mjs";
+import { parseFrontmatter, stageOf } from "./stages.mjs";
 import { storyKeyOf } from "./band-shared.mjs";
 import {
   projectRoot as harnessProjectRoot,
   pluginRoot as harnessPluginRoot,
   agentHome as harnessAgentHome,
+  harnessHome,
   configPath as harnessConfigPath,
   projectConfigDir as harnessProjectConfigDir,
   detectHarnessId,
@@ -52,6 +53,7 @@ import {
   packageCommand,
   whichOnPath,
   hostSessionId,
+  stopCarrier,
 } from "./harness.mjs";
 
 // ─── Paths ─────────────────────────────────────────────────────────────
@@ -183,6 +185,7 @@ export {
   overlayId,
   speakingHarness,
   whichOnPath,
+  stopCarrier,
 };
 
 // A hook's payload carries the `cwd` of the session that fired it, and on a
@@ -545,12 +548,18 @@ export function pidAlive(pid) {
 
 // ─── Installed-plugin resolution ───────────────────────────────────────
 
-// The harness's config directory. Almost always ~/.claude, but the harness's
-// home variable relocates it — and a consumer that hardcodes the default
-// silently resolves nothing for those users instead of failing loudly. The
-// name is kept for its callers; the variable comes from the manifest.
+// Claude Code's config directory. Almost always ~/.claude, but its home
+// variable relocates it — and a consumer that hardcodes the default silently
+// resolves nothing for those users instead of failing loudly. The variable
+// comes from the source harness's manifest, never the active harness's: with
+// another harness's home variable exported (CODEX_HOME), detection makes that
+// harness active in a directory with no harness folder, and every Claude Code
+// path used to follow it into the other home (the install spec, contract 6,
+// as amended 2026-10-14). The host this process runs in is harnessAgentHome's
+// question, asked by its own callers; it stands in here only if a manifest
+// ever named no home at all.
 export function claudeHome(home = homedir()) {
-  return harnessAgentHome(process.env, home);
+  return harnessHome(sourceHarness(), { env: process.env, home }) || harnessAgentHome(process.env, home);
 }
 
 // The release triple only: 0.28.0-rc.2 and 0.28.0 compare equal. Right for
@@ -633,9 +642,11 @@ export function pluginEnabled(key, home = homedir(), projectDir = null) {
     enabled = user.enabledPlugins[key] !== false;
   if (projectDir) {
     // The committed project file, then the checkout's local one over it — the
-    // host's own precedence (measured 2026-09-05, --scope local).
+    // host's own precedence (measured 2026-09-05, --scope local). Claude Code's
+    // project directory, whichever harness this process runs as.
+    const dir = harnessProjectConfigDir(process.env, sourceHarness());
     for (const f of ["settings.json", "settings.local.json"]) {
-      const proj = read(join(projectDir, harnessProjectConfigDir(), f));
+      const proj = read(join(projectDir, dir, f));
       if (proj && proj.enabledPlugins && Object.hasOwn(proj.enabledPlugins, key))
         enabled = proj.enabledPlugins[key] !== false;
     }
@@ -758,13 +769,17 @@ export function selectCopy(home = homedir(), projectDir, { harness = sourceHarne
   return { ...copy, bin, missing, channel: installChannel(copy.path, { home, harness }) };
 }
 
+// How a git-marketplace copy is updated, in its own channel: the one phrase
+// every advice about a kept or older copy quotes.
+export const COPY_UPDATE_STEPS = "in Claude Code: /plugin marketplace update, then /plugin update, then restart";
+
 // The advice for a marketplace copy that cannot run what is named for it, in
 // that copy's own channel: the host's update, then a restart. `cannot` says
 // what it cannot do, `then` what follows the update. One text for doctor's
 // layout remedy and the keep's skip row and DONE line.
 export function copyUpdateAdvice(copy, { cannot, then }) {
   const v = copy?.version ? ` (${copy.version})` : "";
-  return `This project's projectstore plugin${v} ${cannot}: update it first (in Claude Code: /plugin marketplace update, then /plugin update, then restart), ${then}`;
+  return `This project's projectstore plugin${v} ${cannot}: update it first (${COPY_UPDATE_STEPS}), ${then}`;
 }
 
 // The mark a channel switch leaves in this checkout's machine-local binding
@@ -1236,8 +1251,11 @@ export function statusLineIsOurWiring(cmd, projectDir, home = homedir(), root =
 // into state/<harness>/ made wrong; it is named instead, as plan() resolved
 // it — the same string the provenance line records, so an npx render and a
 // cache-install render stay byte-identical.
-export function renderStatusLineLauncher(tpl, root, projectDir = projectRoot(), env = process.env) {
-  const names = runtimeEnvNames(env);
+// `harness` is the one the launcher is FOR (the plan's harness), so a render
+// from a process another harness launched still bakes in Claude Code's names;
+// the SessionStart refresh passes none and renders for its own host.
+export function renderStatusLineLauncher(tpl, root, projectDir = projectRoot(), env = process.env, harness) {
+  const names = harness ? runtimeEnvNames(env, harness) : runtimeEnvNames(env);
   const subs = [
     ['"__PROJECTSTORE_ROOT__"', JSON.stringify(root)],
     ['"__PROJECTSTORE_HOME_ENV__"', JSON.stringify(names.home || "")],
@@ -1281,13 +1299,20 @@ export function writeStatusLineLauncher(projectDir, root) {
 // The command our entry should carry for this installation: the version-free
 // launcher for a marketplace-cache install, the plugin's own script for a dev
 // checkout (its path has no version to go stale). One resolver, shared by the
-// SessionStart refresh and the installer, so the two cannot disagree.
-export function desiredStatusLineCommand(projectDir, root = pluginRoot(), home = homedir()) {
+// SessionStart refresh and the installer, so the two cannot disagree. The
+// installer names the harness it plans (its launcher's state directory); the
+// refresh names none and means its own host.
+export function desiredStatusLineCommand(
+  projectDir,
+  root = pluginRoot(),
+  home = homedir(),
+  harnessId = activeHarnessId(),
+) {
   const launcher = isPluginCacheRoot(root, home);
   return {
     launcher,
     command: launcher
-      ? `node "${statusLineLauncherPath(projectDir)}"`
+      ? `node "${statusLineLauncherPath(projectDir, harnessId)}"`
       : `node "${join(root, "scripts", "statusline.mjs")}"`,
   };
 }
@@ -1416,6 +1441,19 @@ export function agentsBlockVersion(tmpl = null) {
   return m ? Number(m[1]) : null;
 }
 
+// A block whose marker is above this copy's template (the install spec,
+// contract 6, as amended 2026-10-14): the words every surface says it with.
+// Never "written by a newer projectstore" — a hand-edited marker reads the same.
+export function newerBlockWords(v, version) {
+  return `marked v${v}, newer than this copy's v${version}`;
+}
+
+// Whether a marker ranks above the template's. A template with no marker
+// (or a marker that is not a number) is never outranked.
+export function isNewerBlock(v, version) {
+  return Number.isInteger(v) && Number.isInteger(version) && v > version;
+}
+
 // The first block in `text`: its version, its span, whether it closes, and how
 // many open markers the file carries (more than one is a duplicate).
 export function findAgentsBlock(text) {
@@ -2545,10 +2583,16 @@ export async function gatherVaultFacts(cfg, opts = {}) {
       return;
     }
     const entries = await readActivityAsync(vault, sessionId, readFile);
-    const rel = entries
-      .filter((e) => e && typeof e.path === "string" && isInsideVault(e.path, vault))
-      .map((e) => e.path.slice(vault.length + 1))
-      .filter(Boolean);
+    // Through the vault's worktrees too: a worktree's copy reads as its path
+    // inside the vault, once, newest first.
+    const rel = [
+      ...new Set(
+        entries
+          .filter((e) => e && typeof e.path === "string")
+          .map((e) => vaultLocation(e.path, vault)?.rel)
+          .filter(Boolean),
+      ),
+    ];
     continuity.paths = rel;
     continuity.total = rel.length;
     continuity.artifact = resolveInFlightArtifact(entries, layout, vault);
@@ -2947,8 +2991,10 @@ export function resolveInFlightArtifact(activity, layout, vaultPath) {
   // the newest one — no sort, and no second definition of "newest".
   for (const e of activity) {
     if (!e || !e.path || !isWriteTool(e.tool)) continue;
-    if (!isInsideVault(e.path, root)) continue;
-    const rel = e.path.slice(root.length + 1);
+    // A worktree's copy counts as the vault, by its path inside that copy.
+    const loc = vaultLocation(e.path, root);
+    if (!loc || !loc.rel) continue;
+    const rel = loc.rel;
     if (folders.some((p) => rel === p || rel.startsWith(p + "/"))) return rel;
   }
   return null;
@@ -2960,6 +3006,132 @@ export function isInsideVault(filePath, vaultPath) {
   return norm === vaultPath || norm.startsWith(vaultPath + "/");
 }
 
+// ─── Where a path sits in the vault, worktrees included ────────────────
+//
+// (PS-PRESENCE: "A session working in a worktree of the vault gets its epic
+// and story on the band…", issue #87.) A vault edited only through git
+// worktrees — `<vault>/.worktrees/x/` or a checkout elsewhere — was invisible
+// to every check that matched a prefix on vault_path. vaultLocation answers
+// `{ root, rel }`: the copy of the vault that holds the file (the bound
+// checkout, or a worktree's copy) and the path inside it; null when the file
+// is not in the vault.
+//
+// The prefix still answers first and is never taken away: a path under
+// vault_path is in the vault as today, nested foreign repositories included.
+// The resolver only ADDS placements, by reading git's own files on disk — it
+// runs on every tool call, so it spawns nothing:
+//  * a `.git` directory is its own common dir;
+//  * a `.git` file says `gitdir: <path>` (relative to the file's directory for
+//    submodules and worktree.useRelativePaths); the gitdir's `commondir`
+//    (relative to the gitdir) names the common dir, and without one — a
+//    --separate-git-dir checkout, a submodule — the gitdir is the common dir;
+//  * both sides go through realpath: git writes /private/tmp where a vault may
+//    be bound as /tmp or through a symlink.
+// A worktree belongs to the vault when its common dir is the vault's AND the
+// file lies under the worktree's copy of the vault's place in its repository
+// (`vaultSub`): a vault kept as a folder of the project's repository shares
+// the project's common dir, and a project worktree's src/ is not the vault.
+// Anything unreadable answers with the prefix alone.
+
+const VAULT_REPO = new Map();
+export function resetVaultLocation() {
+  VAULT_REPO.clear();
+}
+
+function gitIdentity(entry) {
+  try {
+    if (statSync(entry).isDirectory()) {
+      const real = realpathSync(entry);
+      return { gitdir: real, common: real };
+    }
+    const m = readFileSync(entry, "utf8").match(/^gitdir:\s*(.+?)\s*$/m);
+    if (!m) return null;
+    const gitdir = resolve(dirname(entry), m[1]);
+    let common = gitdir;
+    try {
+      common = resolve(gitdir, readFileSync(join(gitdir, "commondir"), "utf8").trim());
+    } catch {}
+    return { gitdir: realpathSync(gitdir), common: realpathSync(common) };
+  } catch {
+    return null;
+  }
+}
+
+// The nearest directory at or above `start` holding a `.git` entry; with
+// `below`, only directories strictly inside it are considered.
+function nearestGit(start, below = null) {
+  let d = start;
+  for (;;) {
+    if (below !== null && !d.startsWith(below + "/")) return null;
+    if (existsSync(join(d, ".git"))) return d;
+    const up = dirname(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+
+function vaultRepo(vault) {
+  if (VAULT_REPO.has(vault)) return VAULT_REPO.get(vault);
+  let out = null;
+  try {
+    const real = realpathSync(vault);
+    const top = nearestGit(real);
+    const id = top ? gitIdentity(join(top, ".git")) : null;
+    if (id) out = { ...id, sub: real === top ? "" : real.slice(top.length + 1) };
+  } catch {}
+  VAULT_REPO.set(vault, out);
+  return out;
+}
+
+// The bound vault's path as the resolver compares it: no trailing slash (a
+// hand-edited binding may carry one).
+export function vaultRootOf(vaultPath) {
+  return vaultPath && vaultPath.length > 1 ? vaultPath.replace(/\/+$/, "") : vaultPath;
+}
+
+export function vaultLocation(filePath, vaultPath, { cwd } = {}) {
+  if (!filePath || !vaultPath) return null;
+  const vault = vaultRootOf(vaultPath);
+  // resolve() also folds `//` and `..`, so a root is always a clean path.
+  const norm = resolve(cwd || process.cwd(), filePath);
+  const under = (p, root) => p === root || p.startsWith(root + "/");
+  const relOf = (p, root) => (p === root ? "" : p.slice(root.length + 1));
+  const copyOf = (top, repo) => (repo.sub ? join(top, repo.sub) : top);
+
+  if (under(norm, vault)) {
+    // A worktree kept inside the vault folder answers for its own copy.
+    const top = nearestGit(dirname(norm), vault);
+    if (top) {
+      const repo = vaultRepo(vault);
+      const id = repo ? gitIdentity(join(top, ".git")) : null;
+      if (id && id.common === repo.common && id.gitdir !== repo.gitdir) {
+        const root = copyOf(top, repo);
+        if (under(norm, root)) return { root, rel: relOf(norm, root) };
+      }
+    }
+    return { root: vault, rel: relOf(norm, vault) };
+  }
+
+  // Outside the prefix: a new file's walk starts at its nearest existing parent.
+  let start = dirname(norm);
+  while (!existsSync(start)) {
+    const up = dirname(start);
+    if (up === start) return null;
+    start = up;
+  }
+  const top = nearestGit(start);
+  if (!top) return null;
+  const repo = vaultRepo(vault);
+  if (!repo) return null;
+  const id = gitIdentity(join(top, ".git"));
+  if (!id || id.common !== repo.common) return null;
+  const root = copyOf(top, repo);
+  if (!under(norm, root)) return null;
+  // The bound checkout spelled another way (/private/var for /var, a symlink).
+  if (id.gitdir === repo.gitdir) return { root: vault, rel: relOf(norm, root) };
+  return { root, rel: relOf(norm, root) };
+}
+
 // ─── Per-session project-side state (statusline pointer — ADR-006) ─────
 //
 // <project>/.claude/.projectstore/state/<session_id>.json holds this
@@ -3058,13 +3230,29 @@ export function writeSessionState(projectDir, sessionId, patch) {
 // written as null (every reader treats it as absent): a touch of another
 // epic clears the previous epic's story, and an unreadable story names no
 // stale title. Null when the file is not under an epic.
-export function pointerPatchFor(vaultPath, filePath, cur, read = (p) => readFileSync(p, "utf8")) {
-  const m = filePath.slice(vaultPath.length + 1).match(/^epics\/([^/]+)\/(.+)$/);
+//
+// The file may sit in a worktree of the vault (vaultLocation): the epic is
+// matched on its path inside that copy, epic.md is read from the same copy,
+// and `story_root` records the copy — null for the bound checkout — so the
+// band and SessionStart's refresh read the story where it lives. It is written
+// with the story fields: on a story touch, or when the epic changes. A touch
+// of the same epic's other files (reading the bound checkout's epic.md for
+// its goal) leaves it, or the band would look for the story where it is not.
+export function pointerPatchFor(
+  vaultPath,
+  filePath,
+  cur,
+  read = (p) => readFileSync(p, "utf8"),
+  { loc = vaultLocation(filePath, vaultPath) } = {},
+) {
+  if (!loc) return null;
+  const m = loc.rel.match(/^epics\/([^/]+)\/(.+)$/);
   if (!m) return null;
   const [, epicId, inEpic] = m;
+  const storyRoot = loc.root === vaultRootOf(vaultPath) ? null : loc.root;
   const patch = { active_epic: epicId };
   try {
-    const { data } = parseFrontmatter(read(join(vaultPath, "epics", epicId, "epic.md")));
+    const { data } = parseFrontmatter(read(join(loc.root, "epics", epicId, "epic.md")));
     if (data.title) patch.epic_title = String(data.title);
   } catch {}
   const key = storyKeyOf(inEpic);
@@ -3076,8 +3264,9 @@ export function pointerPatchFor(vaultPath, filePath, cur, read = (p) => readFile
     patch.active_story = key;
     patch.story_title = data && data.title ? String(data.title) : null;
     patch.story_status = data && data.status ? String(data.status) : null;
+    patch.story_root = storyRoot;
   } else if (!cur || cur.active_epic !== epicId) {
-    Object.assign(patch, { active_story: null, story_title: null, story_status: null });
+    Object.assign(patch, { active_story: null, story_title: null, story_status: null, story_root: storyRoot });
   }
   return patch;
 }
@@ -3104,12 +3293,14 @@ export function storyFileFor(vaultPath, epicId, key) {
 export function refreshSessionPointer(projectDir, cfg, path, { env = process.env } = {}) {
   const vault = cfg.vault_path;
   const abs = isAbsolute(path) ? resolve(path) : join(vault, path);
-  const rel = abs.startsWith(`${vault}/`) ? abs.slice(vault.length + 1) : null;
+  // A worktree of the vault is the vault too: a close made there refreshes.
+  const loc = vaultLocation(abs, vault);
+  const rel = loc && loc.rel ? loc.rel : null;
   if (!rel) return { refusal: { code: "NOT_IN_VAULT", message: `${path} is not inside the bound vault (${vault})` } };
   if (!existsSync(abs)) return { refusal: { code: "NOT_FOUND", message: `${rel} does not exist in the vault` } };
   const sessionId = hostSessionId(env);
   const cur = sessionId ? readSessionState(projectDir, sessionId) : null;
-  const patch = pointerPatchFor(vault, abs, cur);
+  const patch = pointerPatchFor(vault, abs, cur, undefined, { loc });
   if (!patch || !patch.active_story)
     return { refusal: { code: "NOT_A_STORY", message: `${rel} is not a story file under an epic` } };
   if (!sessionId) return { session: null, refreshed: false, reason: "no-session", path: rel };
@@ -3123,6 +3314,7 @@ export function refreshSessionPointer(projectDir, cfg, path, { env = process.env
       active_story: next.active_story ?? null,
       story_title: next.story_title ?? null,
       story_status: next.story_status ?? null,
+      story_root: next.story_root ?? null,
     },
   };
 }
@@ -3138,35 +3330,51 @@ export function refreshSessionPointer(projectDir, cfg, path, { env = process.env
 export async function refreshStoryPointer(projectDir, vaultPath, sessionId, opts = {}) {
   const cur = readSessionState(projectDir, sessionId);
   if (!cur || !cur.active_epic || !cur.active_story) return "unchanged";
-  const file = storyFileFor(vaultPath, cur.active_epic, cur.active_story);
-  if (!file && !existsSync(join(vaultPath, "epics", cur.active_epic, "epic.md"))) return "unknown";
-  let title = null;
-  let status = null;
-  if (file) {
+  // The copy the story was last touched in (a worktree of the vault), while it
+  // exists; a removed worktree falls back to the bound checkout.
+  const root =
+    typeof cur.story_root === "string" && cur.story_root && cur.story_root !== vaultRootOf(vaultPath)
+      ? cur.story_root
+      : null;
+  const rootLive = root ? existsSync(root) : false;
+  const mainFile = storyFileFor(vaultPath, cur.active_epic, cur.active_story);
+  const rootFile = rootLive ? storyFileFor(root, cur.active_epic, cur.active_story) : null;
+  let patch;
+  if (!mainFile && !rootFile) {
+    const epicIn = (r) => existsSync(join(r, "epics", cur.active_epic, "epic.md"));
+    if (!epicIn(vaultPath) && !(rootLive && epicIn(root))) return "unknown";
+    patch = { active_story: null, story_title: null, story_status: null, story_root: rootLive ? root : null };
+  } else {
     const readFile = opts.readFile || ((p) => readFileAsync(p, "utf8"));
     let timer = null;
     const deadline = new Promise((resolve) => {
       timer = setTimeout(() => resolve(null), opts.budgetMs ?? 200);
     });
-    let text;
+    const readOne = (f) =>
+      f
+        ? Promise.resolve()
+            .then(() => readFile(f))
+            .then(String, () => null)
+        : Promise.resolve("");
+    let texts;
     try {
-      text = await Promise.race([
-        Promise.resolve()
-          .then(() => readFile(file))
-          .then(String, () => null),
-        deadline,
-      ]);
+      texts = await Promise.race([Promise.all([readOne(mainFile), readOne(rootFile)]), deadline]);
     } finally {
       if (timer) clearTimeout(timer);
     }
-    if (text === null) return "unknown";
-    const { data } = parseFrontmatter(text);
-    title = data.title ? String(data.title) : null;
-    status = data.status ? String(data.status) : null;
-  }
-  const patch = file
-    ? { story_title: title, story_status: status }
-    : { active_story: null, story_title: null, story_status: null };
+    if (texts === null || texts.some((t) => t === null)) return "unknown";
+    const fields = (text) => {
+      const { data } = parseFrontmatter(text);
+      return { title: data.title ? String(data.title) : null, status: data.status ? String(data.status) : null };
+    };
+    const main = mainFile ? fields(texts[0]) : null;
+    const copy = rootFile ? fields(texts[1]) : null;
+    // A story closed on the bound checkout wins over a stale worktree copy
+    // (the merge brought `done`); otherwise the copy being worked wins.
+    const useMain = main && (!copy || stageOf(main.status) === "done");
+    const pick = useMain ? main : copy;
+    patch = { story_title: pick.title, story_status: pick.status, story_root: useMain ? null : root };
+  }
   const same = Object.entries(patch).every(([k, v]) => (cur[k] ?? null) === v);
   if (same) return "unchanged";
   writeSessionState(projectDir, sessionId, patch);
@@ -3254,7 +3462,6 @@ export const ENTRY_IGNORE = [
 
 export function isSourcePath(absPath, projectDir, vaultPath) {
   if (!absPath || !projectDir) return false;
-  if (vaultPath && isInsideVault(absPath, vaultPath)) return false;
   const root = projectDir.endsWith("/") ? projectDir.slice(0, -1) : projectDir;
   if (!absPath.startsWith(root + "/")) return false;
   // Matched project-relative, never absolute: SOURCE_IGNORE is
@@ -3262,7 +3469,10 @@ export function isSourcePath(absPath, projectDir, vaultPath) {
   // project that merely lives under a directory called `build`.
   const rel = absPath.slice(root.length + 1);
   if (!rel) return false;
-  return !ENTRY_IGNORE.some((re) => re.test(rel));
+  if (ENTRY_IGNORE.some((re) => re.test(rel))) return false;
+  // Last, because it walks the disk: a file in the vault — a worktree's copy
+  // of it included (contract 1, as amended 2026-10-15) — is never source.
+  return !(vaultPath && vaultLocation(absPath, vaultPath));
 }
 
 export function scoreDir(projectDir, sessionId) {
@@ -3347,7 +3557,14 @@ export function listVaultStoryFiles(vaultPath) {
 export async function resolveOpenStory(vaultPath, opts = {}) {
   const budgetMs = opts.budgetMs ?? 200;
   const readFile = opts.readFile || ((p) => readFileAsync(p, "utf8"));
-  const files = listVaultStoryFiles(vaultPath);
+  // The session's own worktree copy first (its pointer's story_root), then the
+  // bound checkout: a story open where this session works it counts as open.
+  const storyRoot = opts.storyRoot;
+  const own =
+    typeof storyRoot === "string" && storyRoot && storyRoot !== vaultRootOf(vaultPath) && existsSync(storyRoot)
+      ? listVaultStoryFiles(storyRoot)
+      : [];
+  const files = [...own, ...listVaultStoryFiles(vaultPath)];
   if (!files.length) return false;
 
   let timer = null;
@@ -3545,12 +3762,12 @@ export const ENTRY_THRESHOLD = 3;
 // Normative text. Three properties it must keep, whatever the wording: it shows
 // the evidence (the count), it names the action, and it grants the exit — so a
 // false positive costs a glance rather than an argument.
-export function entryReminderText(n) {
+export function entryReminderText(n, { env = process.env } = {}) {
   return [
     `**projectstore**: this session has written to ${n} source files and no story`,
     "is in progress. If this is feature-sized work, open it in the vault before",
-    `going further — \`${commandForm("story", { args: '<EPIC> "<title>"' })}\`, or`,
-    `\`${commandForm("epic")}\` if it needs a new one. If it is a one-off fix, carry`,
+    `going further — \`${commandForm("story", { args: '<EPIC> "<title>"', env })}\`, or`,
+    `\`${commandForm("epic", { env })}\` if it needs a new one. If it is a one-off fix, carry`,
     "on — this fires once.",
   ].join("\n");
 }
@@ -3871,7 +4088,7 @@ export function writeAnchorOffer(projectDir, sessionId, rec) {
 // within moments of each other both pass this check and both offer the same
 // name — the race is narrowed, not closed, and the ADR says so.
 export function liveSessionNames(selfSessionId, dir = null) {
-  const root = dir || join(claudeHome(), "sessions");
+  const root = dir || join(harnessAgentHome(process.env), "sessions");
   const out = [];
   let files;
   try {
@@ -3895,7 +4112,7 @@ export function liveSessionNames(selfSessionId, dir = null) {
 
 // What this session is currently called, if the harness has recorded a name.
 export function ownSessionName(selfSessionId, dir = null) {
-  const root = dir || join(claudeHome(), "sessions");
+  const root = dir || join(harnessAgentHome(process.env), "sessions");
   let files;
   try {
     files = readdirSync(root);

package/node_modules/projectstore/scripts/setup.mjs

@@ -64,7 +64,7 @@ import {
   languageNames,
 } from "./binding.mjs";
 import { analyseRegistration, analyseJsonEntry } from "./surfaces.mjs";
-import { runningCopies, coreCommand, channelChoices, pinFor } from "./convergence.mjs";
+import { runningCopies, coreCommand, channelChoices, pinFor, terminalRun } from "./convergence.mjs";
 import { runVerb, isInteractive, gateText, channelText, publicItem, planOptions } from "./install-harness.mjs";
 import { resolveBinding } from "./worktree.mjs";
 import * as term from "./term.mjs";
@@ -328,7 +328,9 @@ function factsOf(project, { env, home, root, version, interactive }) {
     sessionCopy = selectCopy(home, project, { harness: channelHarness });
   }
   const slotHarness = manifests.find((m) => statuslineOf(m)) || null;
-  const slot = slotHarness ? analyseJsonEntry(project, statuslineOf(slotHarness), { root, home }).state : null;
+  const slot = slotHarness
+    ? analyseJsonEntry(project, statuslineOf(slotHarness), { root, home, harness: slotHarness }).state
+    : null;
   // A worktree's main checkout (worktree.mjs): only where it can be offered —
   // at a terminal, unbound, in a linked worktree. Read for the project
   // answered, never from the git top, which --project leaves unread.
@@ -692,12 +694,12 @@ function doneLines(r, { project, runEnv, home, version, channel, vaultPlan, unde
     // Rule 13: `--channel npm` when that was the answer, and only for the
     // harness whose channel it is — setup refuses --channel in a run without
     // that harness (exit 2). A keep is not repeated: once recorded, it is the
-    // default already (rule 6).
-    const again = channel === "npm" && hostRegistrationOf(m) ? "--channel npm" : "";
+    // default already (rule 6). The deferred row's reason names the same
+    // command, from the same builder.
     if (left.length)
       blocks.push({
         lead: `Left for a terminal outside this ${m.display_name} session: ${left.join(", ")}. From a terminal in this project, run:`,
-        commands: [coreCommand("setup", { version, args: [`--harness ${id}`, again].filter(Boolean).join(" ") })],
+        commands: [terminalRun({ verb: "setup", harness: m, version, channel })],
         after: `then restart ${m.display_name}.`,
       });
   }