projectstore-claude 0.30.2 → 0.30.4

package/node_modules/projectstore/scripts/install-harness.mjs

@@ -193,6 +193,9 @@ import {
   npmRowBeside,
   pinFor,
   coreCommand,
+  terminalRun,
+  copyBehind,
+  behindAdvice,
   DEFAULT_REGISTRY,
   NOTICE_BUDGET_MS,
   READ_TIMEOUT_MS,
@@ -235,6 +238,7 @@ import {
   removeTreeUnder,
   projectDirRefusal,
   fromTerminalIn,
+  newerBlockWords,
   registrationProvenance,
   envFlag,
   selectCopy,
@@ -461,12 +465,27 @@ function planAgentsBlock(ctx, key, s) {
     return items;
   }
 
-  const entry = `projectstore:agents v${a.version}`;
   const current = a.current;
+  // A block marked above this copy's template is never rendered down (the
+  // install spec, contracts 4, 6 and 9, as amended 2026-10-14): a move, a
+  // migration or a dedupe carries its own bytes, stamped with its own marker.
+  const newer = a.newer || null;
+  const words = newer ? newerBlockWords(newer.block.v, a.version) : null;
+  const body = newer ? newer.block.block : a.desired;
+  const entry = `projectstore:agents v${newer ? newer.block.v : a.version}`;
   // Two files, one block each: resolve in favour of the preferred file —
   // register migrates, never duplicates (ADR-002 decision 3).
   for (const e of a.duplicates || [])
-    items.push(removal(e, { state: "ours-stale", reason: `duplicate of the block in ${current.file}` }));
+    items.push(
+      removal(e, {
+        state: "ours-stale",
+        reason:
+          newer === e
+            ? `carries v${e.block.v}, newer than this copy's v${a.version}; its text replaces the block in ${current.file}`
+            : `duplicate of the block in ${current.file}`,
+      }),
+    );
+  let newerInPlace = null;
 
   if (!current) {
     const target = preferred;
@@ -501,10 +520,43 @@ function planAgentsBlock(ctx, key, s) {
       entry,
       state: "ours-absent",
       action: preferred.present ? "add" : "create",
-      reason: ctx.readers && !current.own ? a.reason : `migrated from ${current.file}`,
+      reason:
+        ctx.readers && !current.own
+          ? a.reason
+          : `migrated from ${current.file}${newer ? ` with its own text (${words})` : ""}`,
       before: preferred.present ? preferred.text : null,
-      after: replaceAgentsBlock(preferred.present ? preferred.text : "", a.desired),
+      after: replaceAgentsBlock(preferred.present ? preferred.text : "", body),
+    });
+  } else if (newer && newer !== current) {
+    // The duplicate carries the higher marker: its text replaces the stayer's.
+    items.push({
+      surface: key,
+      kind: "shared",
+      path: current.path,
+      entry,
+      state: "ours-stale",
+      action: "replace-entry",
+      reason: `its text is replaced by ${newer.file}'s, which carries v${newer.block.v}, newer than this copy's v${a.version}`,
+      before: current.text,
+      after: replaceAgentsBlock(current.text, body),
     });
+  } else if (newer) {
+    // It stays as it is; a named run with nothing else to place overwrites it,
+    // decided once the imports are known (below).
+    newerInPlace = {
+      surface: key,
+      kind: "shared",
+      path: current.path,
+      entry,
+      state: "ours-newer",
+      action: "skip",
+      reason: `${words}: left as it is — ${
+        ctx.takesSurface === false
+          ? `to write this copy's v${a.version} over it: ${coreCommand("install", { args: `--harness ${ctx.harness.id} --surface ${key}` })}`
+          : `name --surface ${key} to write this copy's v${a.version} over it`
+      }`,
+    };
+    items.push(newerInPlace);
   } else if (current.block.v === a.version && current.block.block === a.desired) {
     items.push({
       surface: key,
@@ -590,6 +642,23 @@ function planAgentsBlock(ctx, key, s) {
         after,
       });
   }
+  // Naming the surface confirms the overwrite only when the run has nothing
+  // else to do for the block: it is the only block and every import it needs
+  // is in place. Doctor's placement remedies name the surface too, and they
+  // must never downgrade (contract 9 as amended 2026-10-14).
+  if (
+    newerInPlace &&
+    (ctx.surfaces || []).includes(key) &&
+    !(a.duplicates || []).length &&
+    !items.some((i) => i.surface === `${key}_import`)
+  )
+    Object.assign(newerInPlace, {
+      entry: `projectstore:agents v${a.version}`,
+      action: "replace-entry",
+      reason: `v${current.block.v} → v${a.version}: ${words}, and --surface ${key} names it`,
+      before: current.text,
+      after: replaceAgentsBlock(current.text, a.desired),
+    });
   return items;
 }
 
@@ -758,7 +827,7 @@ function planPortableRegistration(ctx, key, s) {
     // registration's removal decides them.
     if (registrationDeferred(env, harness)) {
       ctx.incomplete = true;
-      return [{ ...base, action: "skip", deferred: true, reason: deferralReason(harness, env) }];
+      return [{ ...base, action: "skip", deferred: true, ...deferredRun(ctx, deferralReason(harness, env)) }];
     }
     const steps = [];
     if (a.installed) steps.push(hostStep(a, s, "uninstall", fill, `explicit global removal forgets ${a.id}`));
@@ -827,7 +896,7 @@ function planPortableRegistration(ctx, key, s) {
         ...base,
         action: "skip",
         deferred: true,
-        reason: `${a.reason ? a.reason + "; " : ""}${deferralReason(harness, env)}`,
+        ...deferredRun(ctx, `${a.reason ? a.reason + "; " : ""}${deferralReason(harness, env)}`),
       },
     ];
   }
@@ -932,6 +1001,29 @@ function deferralReason(harness, env) {
   return `this runs inside a ${harness.display_name} session (${variable} is set), and the host's CLI would change the configuration that session runs on — run it from a terminal outside the session`;
 }
 
+// A deferral names its run (the install spec, contract 6, as amended
+// 2026-10-14): the prose as before, byte for byte, then where to run it and
+// the run's own command alone on its line — a way out, as the presentation
+// spec's contract 6 gives them, so `--json` carries it in `reason` and an
+// agent relaying the envelope relays the command.
+function deferredRun(ctx, prose) {
+  // The prose already says "outside the session"; the lead adds only where.
+  const where = fromTerminalIn(ctx.projectDir);
+  return advised(prose, [
+    {
+      lead: `${where.charAt(0).toUpperCase()}${where.slice(1)}:`,
+      command: terminalRun({
+        verb: ctx.verb,
+        harness: ctx.harness,
+        version: ctx.version,
+        surfaces: ctx.surfaces,
+        globalRemoval: ctx.globalRemoval,
+        channel: ctx.channel,
+      }),
+    },
+  ]);
+}
+
 function planRegistration(ctx, key, s) {
   const { projectDir, mode, root, home, env, harness } = ctx;
   const a = analyseRegistration(projectDir, s, { root, home, harness, env });
@@ -977,7 +1069,7 @@ function planRegistration(ctx, key, s) {
     }
     if (deferred) {
       ctx.incomplete = true;
-      return [{ ...base, action: "skip", reason: inSession }];
+      return [{ ...base, action: "skip", ...deferredRun(ctx, inSession) }];
     }
     const steps = [];
     if (a.installed)
@@ -1109,7 +1201,14 @@ function planRegistration(ctx, key, s) {
   }
   if (needsHost && deferred) {
     ctx.incomplete = true;
-    return [{ ...base, action: "skip", deferred: true, reason: `${a.reason ? a.reason + "; " : ""}${inSession}` }];
+    return [
+      {
+        ...base,
+        action: "skip",
+        deferred: true,
+        ...deferredRun(ctx, `${a.reason ? a.reason + "; " : ""}${inSession}`),
+      },
+    ];
   }
   // Our directory newer than this package and damaged (the converge story's
   // rule 6): never rewritten from the older package — this checkout and every
@@ -1392,6 +1491,11 @@ function keepTarget(projectDir, ids, { root, home, env }) {
 function keepEnv(env, { harness, projectDir, copyRoot, harnessHome }) {
   const out = childEnv(env);
   for (const m of loadHarnesses().values()) if (m.runtime?.plugin_root_env) delete out[m.runtime.plugin_root_env];
+  // An override this run inherited names THIS process's harness; in the copy
+  // it would turn the copy's own home and directory reads to another harness.
+  // The copy knows itself by the project-dir variable written below (the
+  // install spec, contract 21, as amended 2026-10-14).
+  delete out.PROJECTSTORE_HARNESS;
   const r = harness.runtime || {};
   if (r.plugin_root_env) out[r.plugin_root_env] = copyRoot;
   if (r.project_dir_env) out[r.project_dir_env] = projectDir;
@@ -1410,7 +1514,9 @@ const KEEP_SURFACE = "channel";
 // (keepArgv), its touches the writes the copy's own plan listed (`read`, made
 // by the prepare step) less the agents block's rows, which this run's one
 // block item writes before it (the story "One run plans the agents block
-// once…", rule 1). No write left: no item. The other rows it can be:
+// once…", rule 1). No write left: no item — unless the copy is behind the
+// running package, when a skip carries that line (contract 21, rule 9, as
+// amended 2026-10-14), as the update row does. The other rows it can be:
 // - a copy that cannot run the form (lib's capability read): skip, with the
 //   update in its channel — in the row's reason, since DONE never prints when
 //   nothing else writes, and as DONE's next line;
@@ -1547,11 +1653,29 @@ function planKeep(ctx, target, read) {
       }),
     ];
   }
-  if (!writes.length)
+  // A copy behind the running package says so (the install spec, contract
+  // 21, rule 9, as amended 2026-10-14): with no write left, a skip whose
+  // reason is that line — neither deferred nor incomplete, so a re-run stays
+  // zero-change; with writes, a line on the update row and in DONE.
+  const behind = copyBehind(copy, ctx.version);
+  if (!writes.length) {
+    if (behind) {
+      const line = behindAdvice(copy, ctx.version);
+      return [item({ action: "skip", ...advised(line, besides) }, [{ lead: line }])];
+    }
     return beside ? [item({ action: "skip", ...advised(`${named} has nothing to change here`, besides) })] : [];
+  }
+  const note = behind ? [{ lead: behindAdvice(copy, ctx.version, { step: true }) }] : [];
   if (insideHostSession(env, harness)) {
     ctx.incomplete = true;
-    return [item({ action: "skip", deferred: true, ...advised(`${kept}; ${inSessionReason(harness)}`, besides) })];
+    const prose = `${kept}; ${inSessionReason(harness)}`;
+    return [
+      item({
+        action: "skip",
+        deferred: true,
+        ...advised(prose, [...note, ...deferredRun(ctx, prose).advice.blocks, ...besides]),
+      }),
+    ];
   }
   const step = {
     kind: "host",
@@ -1560,7 +1684,7 @@ function planKeep(ctx, target, read) {
     why: `the kept copy's own upgrade, from its own bin without registering (the layout remedy's form), read back as JSON; it re-plans from the files as they stand then, after the agents block above`,
     touches: writes,
   };
-  return [item({ action: "update", ...advised(kept, besides), steps: [step] })];
+  return [item({ action: "update", ...advised(kept, [...note, ...besides]), steps: [step] }, note)];
 }
 
 // The mark (the converge story's rule 2), for the channel "npm" only: one
@@ -1889,7 +2013,7 @@ function planJsonEntry(ctx, key, s) {
       },
     ];
   }
-  const a = analyseJsonEntry(projectDir, s, { root, home, renderRoot });
+  const a = analyseJsonEntry(projectDir, s, { root, home, renderRoot, harness: ctx.harness });
   if (a.state === "unparseable")
     return [
       { surface: key, kind: "shared", path, entry: entryKey, state: "unparseable", action: "refuse", reason: a.reason },
@@ -2165,6 +2289,7 @@ export function plan(
     ensureState = false,
     recordKeep = false,
     takesSurface = true,
+    verb = null,
   } = {},
 ) {
   projectDir = resolve(projectDir);
@@ -2409,7 +2534,17 @@ export function plan(
           ? blockRun.map((m) => ({ display: m.display_name, files: agentsBlockRow(m)[1].files || [] }))
           : null;
       blockItems = planAgentsBlock(
-        { projectDir, mode, root, harness: owner, run: blockRun, readers, layout, surfaces: surfaces || [] },
+        {
+          projectDir,
+          mode,
+          root,
+          harness: owner,
+          run: blockRun,
+          readers,
+          layout,
+          surfaces: surfaces || [],
+          takesSurface,
+        },
         key,
         { ...s, files: commonBlockFiles(blockRun) },
       );
@@ -2469,6 +2604,9 @@ export function plan(
       channelFacts: null,
       refusals: [],
       takesSurface,
+      // The verb a deferral repeats (the install spec, contract 6, as amended
+      // 2026-10-14): the run's own — upgrade and setup plan in install mode.
+      verb: verb || mode,
     };
     // The keep (rule 5): the run's one block first — over the whole run set,
     // this harness included — then the keep's one item, and none of this
@@ -2630,11 +2768,40 @@ export function plan(
   placeBlock();
   for (const item of moved.last) out.items.push({ harness: layoutHarness.id, ...item });
   out.items.push(...marks);
+  oneAddPerFile(out.items);
   if (out.items.some((i) => i.action === "refuse")) out.ok = false;
   if (out.refusals.length) out.ok = false;
   return out;
 }
 
+// One add per file (the presentation spec, contract 7 as amended 2026-10-14):
+// within one plan, a file an earlier item creates is added once. A later
+// `create` or `add` on that path changes the file the run has just made, so it
+// reads `update`; its state, steps and detail stay. Each item is planned
+// against the tree before the run, so the binding the vault item writes was
+// "absent" to the status-line flag and the channel mark, and all three read
+// "add". A creator is an earlier `create` or `add` item that is neither a
+// registration (its host-owned files are the host CLI's) nor a binding row (it
+// never makes the binding: apply skips it on an unbound project, and the vault
+// item or the layout move makes the file), counted for the paths absent at
+// plan time: its own and each step's `path` — never a move step's `to`, so a
+// migrating project's binding rows keep `add`. An entry row on a file that was
+// there keeps `add`.
+function oneAddPerFile(items) {
+  const created = new Set();
+  const writes = (i) => i.action === "create" || i.action === "add";
+  for (const item of items) {
+    if (!writes(item) || item.kind === "registration") continue;
+    if (item.path && created.has(resolve(item.path))) {
+      item.action = "update";
+      continue;
+    }
+    if (item.kind === "binding") continue;
+    for (const p of [item.path, ...(item.steps || []).map((s) => s.path)])
+      if (p && !existsSync(p)) created.add(resolve(p));
+  }
+}
+
 // ─── the layout migration (the layout ADR; layout spec contract 6) ──────
 //
 // Two items, kind `layout`. The FIRST moves what only we read — the legacy
@@ -5229,6 +5396,7 @@ export async function runVerb(verb, projectDir, opts = {}) {
       plan(projectDir, {
         ...opts,
         mode,
+        verb,
         state: verb === "upgrade" || setup || (verb === "uninstall" && !opts.globalRemoval),
         version: prep.version,
         payloadRoots: prep.payloadRoots,

package/node_modules/projectstore/scripts/lib.mjs

@@ -30,6 +30,7 @@ import {
   projectRoot as harnessProjectRoot,
   pluginRoot as harnessPluginRoot,
   agentHome as harnessAgentHome,
+  harnessHome,
   configPath as harnessConfigPath,
   projectConfigDir as harnessProjectConfigDir,
   detectHarnessId,
@@ -196,9 +197,11 @@ export { adoptHookInput, resetHookInput };
 // ─── Harness overlays (the layout ADR decision 3; layout spec contracts 2–4) ──
 //
 // <project>/.projectstore/harness/<id>.json carries ONE thing: the agents block
-// for that harness — agents.default.model and agents.per_agent.<name>.model.
-// Every other key is ignored on read and named for doctor (rejected). The
-// binding never carries agents: ADR-008's two-term chain is read from here.
+// for that harness — agents.default.model, agents.default.effort,
+// agents.per_agent.<name>.model and agents.per_agent.<name>.effort (the effort
+// ADR, decision 1). Every other key is ignored on read and named for doctor
+// (rejected). The binding never carries agents: ADR-008's two-term chain is
+// read from here, once per field.
 export function readOverlayAt(projectDir, id = overlayId()) {
   // No id (no manifest at all): nothing is read, and the writer below refuses
   // the same id rather than inventing a file name for it.
@@ -209,6 +212,7 @@ export function readOverlayAt(projectDir, id = overlayId()) {
     present: Boolean(path) && existsSync(path),
     unparseable: false,
     agents: { default: null, per_agent: {} },
+    efforts: { default: null, per_agent: {} },
     rejected: [],
     raw: null,
   };
@@ -235,8 +239,10 @@ export function readOverlayAt(projectDir, id = overlayId()) {
   for (const k of Object.keys(a)) if (k !== "default" && k !== "per_agent") out.rejected.push(`agents.${k}`);
   if (a.default !== undefined) {
     if (a.default && typeof a.default === "object") {
-      for (const k of Object.keys(a.default)) if (k !== "model") out.rejected.push(`agents.default.${k}`);
+      for (const k of Object.keys(a.default))
+        if (k !== "model" && k !== "effort") out.rejected.push(`agents.default.${k}`);
       if (typeof a.default.model === "string" && a.default.model) out.agents.default = a.default.model;
+      if (typeof a.default.effort === "string" && a.default.effort) out.efforts.default = a.default.effort;
     } else out.rejected.push("agents.default");
   }
   if (a.per_agent !== undefined) {
@@ -246,8 +252,10 @@ export function readOverlayAt(projectDir, id = overlayId()) {
           out.rejected.push(`agents.per_agent.${name}`);
           continue;
         }
-        for (const k of Object.keys(v)) if (k !== "model") out.rejected.push(`agents.per_agent.${name}.${k}`);
+        for (const k of Object.keys(v))
+          if (k !== "model" && k !== "effort") out.rejected.push(`agents.per_agent.${name}.${k}`);
         if (typeof v.model === "string" && v.model) out.agents.per_agent[name] = v.model;
+        if (typeof v.effort === "string" && v.effort) out.efforts.per_agent[name] = v.effort;
       }
     } else out.rejected.push("agents.per_agent");
   }
@@ -264,9 +272,22 @@ export function resolveAgentModel(projectDir, name, { harness = overlayId() } =
   return { name, model: null, source: null, overlay: o.path, harness };
 }
 
+// The same two terms for effort, on their own (the effort ADR, decision 1): an
+// agent's own model does not stop it taking the default's effort. Null passes
+// nothing: the frontmatter's effort, or the harness's own default, runs.
+export function resolveAgentEffort(projectDir, name, { harness = overlayId() } = {}) {
+  const o = readOverlayAt(projectDir, harness);
+  const per = o.efforts.per_agent[name];
+  if (per) return { name, effort: per, source: "per_agent", overlay: o.path, harness };
+  if (o.efforts.default) return { name, effort: o.efforts.default, source: "default", overlay: o.path, harness };
+  return { name, effort: null, source: null, overlay: o.path, harness };
+}
+
 // The one writer of an overlay: rewrites its agents block, keeps any other key
 // as it found it (doctor names them; this never silently drops a user's key).
-export function writeOverlayAt(projectDir, id, agents) {
+// `efforts` left out keeps the efforts the file holds, so a caller that
+// changes models only never drops one.
+export function writeOverlayAt(projectDir, id, agents, efforts) {
   if (!id) throw new Error("writeOverlayAt: the overlay's harness id is required");
   const path = layoutPaths(projectDir).overlay(id);
   let raw = {};
@@ -274,10 +295,13 @@ export function writeOverlayAt(projectDir, id, agents) {
     raw = JSON.parse(readFileSync(path, "utf8"));
   } catch {}
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) raw = {};
+  const e = efforts === undefined ? readOverlayAt(projectDir, id).efforts : efforts;
+  const pair = (model, effort) => ({ ...(model ? { model } : {}), ...(effort ? { effort } : {}) });
   const block = {};
-  if (agents.default) block.default = { model: agents.default };
-  const names = Object.keys(agents.per_agent || {}).sort();
-  if (names.length) block.per_agent = Object.fromEntries(names.map((n) => [n, { model: agents.per_agent[n] }]));
+  if (agents.default || e.default) block.default = pair(agents.default, e.default);
+  const names = [...new Set([...Object.keys(agents.per_agent || {}), ...Object.keys(e.per_agent || {})])].sort();
+  if (names.length)
+    block.per_agent = Object.fromEntries(names.map((n) => [n, pair(agents.per_agent?.[n], e.per_agent?.[n])]));
   const next = { ...raw };
   if (Object.keys(block).length) next.agents = block;
   else delete next.agents;
@@ -522,12 +546,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
@@ -610,9 +640,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;
     }
@@ -735,13 +767,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
@@ -1213,8 +1249,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 || "")],
@@ -1258,13 +1297,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")}"`,
   };
 }
@@ -1393,6 +1439,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) {
@@ -3848,7 +3907,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 {
@@ -3872,7 +3931,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/menu.mjs

@@ -12,7 +12,11 @@
 //
 // A group is { title, footer, description, items }. An item is
 //   { id, label, kind: "choice" | "text" | "info", toggle, value,
-//     display(v), tag, describe(v, changed), options(), caption() }
+//     display(v), tag, describe(v, changed), options(), caption(),
+//     indent, path }
+// where `indent` draws the label that many columns in, under the row it
+// belongs to (an agent's effort under its model), and `path` names the item
+// where its label alone would not: a frame's title and the path line.
 // where options() answers the values, each
 //   { value, label, note, description, tag, section, kind: "value" | "text" | "refresh" }
 // and caption() the values frame's footer, { text, busy } or null. A value
@@ -390,13 +394,13 @@ function valueSegs(c, m, it, mode, room) {
 }
 
 function itemRows(c, m, g, cur, mode, w) {
-  const lw = Math.max(...g.items.map((it) => wlen(it.label))) + 1;
+  const lw = Math.max(...g.items.map((it) => (it.indent || 0) + wlen(it.label))) + 1;
   const room = w - 4 - 3 - lw - 1;
   return g.items.map((it, k) => [
     cursorSeg(c, k === cur, mode),
     S(m.changed(it) ? icon(c, "update") : " ", "action"),
     S(" "),
-    S(padTo(G(c, it.label), lw), labelRole(k === cur, mode)),
+    S(padTo(" ".repeat(it.indent || 0) + G(c, it.label), lw), labelRole(k === cur, mode)),
     S(" "),
     ...valueSegs(c, m, it, mode, room),
   ]);
@@ -488,7 +492,7 @@ function detailFrame(c, m, it, fr, w, h, focus) {
   }
   const cap = focus && it.caption ? it.caption() : null;
   return frame(c, {
-    title: it.label,
+    title: it.path || it.label,
     rows,
     w,
     h,
@@ -644,7 +648,7 @@ export function renderMenu(m, { caps: c, columns = 100, rows = 30, head = "proje
   const wideEnough = columns >= STAIRCASE.min;
   if (!wideEnough) {
     // One frame: the one the keys act on, under the whole path.
-    const names = ["Settings", ...(level >= 1 ? [g.title] : []), ...(level >= 2 ? [it.label] : [])];
+    const names = ["Settings", ...(level >= 1 ? [g.title] : []), ...(level >= 2 ? [it.path || it.label] : [])];
     out([
       S(`${icon(c, "ask")} `, "action"),
       S(names.slice(0, -1).join(sep) + (names.length > 1 ? sep : ""), "explanation"),