projectstore-claude 0.30.4 → 0.30.6

package/node_modules/projectstore/scripts/convergence.mjs

@@ -20,6 +20,10 @@
 //   newerCopyDeferral({ copy, running, decision, harness, pin })
 //                                     → a newer copy not switched off: { reason, advice }
 //   switchConsequence()               → a switch row's consequence line (rule 2)
+//   directoryConsequence(display), directoryKeepConsequence(display, key)
+//                                     → an npm registration over a directory copy,
+//                                       and the keep of that copy (PS-DIRECTORY)
+//   copyOrigin(copy), DIRECTORY        → where a kept or competing copy comes from
 //   switchReason({ copy, running, runs, decision, unbound })
 //                                     → what a switch row adds under the channel "npm"
 //   noCopyToKeep({ harness, surface, off }) → the channel "git" with nothing to keep
@@ -57,6 +61,8 @@ import {
   envFlag,
   isEphemeralRoot,
   COPY_UPDATE_STEPS,
+  SYNCED_UPDATE_STEPS,
+  isSyncedCopy,
 } from "./lib.mjs";
 import { loadHarness, loadHarnesses } from "./harness.mjs";
 import { analysePortableRegistration, portableRegistrationPaths } from "./portable-registration.mjs";
@@ -120,7 +126,9 @@ const within = (root, dir) => {
 // Doctor keeps installChannel's answers; only these two checks read this.
 export function hostCopyRoot(root, { home = homedir(), env = process.env } = {}) {
   if (!root) return false;
-  if (["registration", "marketplace"].includes(installChannel(root, { home }))) return true;
+  // A copy synced from claude.ai (Anthropic's directory) is one too: claude.ai
+  // updates it (the install spec, contract 21, rule 2).
+  if (["registration", "marketplace", "synced"].includes(installChannel(root, { home }))) return true;
   for (const m of loadHarnesses().values()) {
     for (const s of Object.values(m.surfaces || {})) {
       if (s?.kind !== "registration") continue;
@@ -153,7 +161,9 @@ export const updateCheckOff = (env) => envFlag(env, NO_CHECK_ENV);
 // - a host plugin registration: contract 12's rows, one per key — the row the
 //   host loads here (lib's projectCopiesByKey, the same rows the registration's
 //   competing copies are read from) — of any marketplace: the npm
-//   registration's row and a git-marketplace copy alike. Under channel "git"
+//   registration's row and a git-marketplace copy alike, and a copy synced
+//   from claude.ai (Anthropic's directory) while no copy of another origin is
+//   enabled here — Claude Code loads any of them over it. Under channel "git"
 //   none: that run renders nothing for it;
 // - a portable registration: the global registration's recorded version,
 //   when it is effectively enabled for this project.
@@ -170,7 +180,10 @@ export function runningCopies(
       if (key.startsWith("_") || s?.kind !== "registration") continue;
       if (s.format === "host-plugin-registration") {
         if (channel === "git") continue;
-        for (const e of projectCopiesByKey(home, projectDir)) {
+        const rows = projectCopiesByKey(home, projectDir);
+        const shadowed = rows.some((e) => !e.synced);
+        for (const e of rows) {
+          if (e.synced && shadowed) continue;
           if (typeof e.version === "string" && e.version)
             out.push({ harness: id, key: e.key, version: e.version, path: e.path, scope: e.scope, own: e.own });
         }
@@ -437,17 +450,22 @@ export function pinFor(root, version) {
 // npm` and `--channel git`, each alone on its line (a `|` copied into a shell
 // is a pipe). Each names `@<version>` when the pin says so (pinFor), and
 // never --project (the ADR's decision 5).
-// - `gate` ({ args: { harnesses }, keys, version }): the channel gate's text
-//   (rule 2), for a switch planned under no channel answer without a
-//   terminal, the run's own --harness repeated in each command. setup takes
-//   no --surface, so a narrowed run's --surface is not repeated. A block with
-//   no lead follows the one before it.
+// - `gate` ({ args: { harnesses }, keys, directory, version }): the channel
+//   gate's text (rule 2), for a switch planned under no channel answer
+//   without a terminal, the run's own --harness repeated in each command.
+//   `keys` are the git-marketplace copies a switch turns off, `directory` the
+//   synced copies an npm registration loads over (PS-DIRECTORY): each named
+//   by where it comes from. setup takes no --surface, so a narrowed run's
+//   --surface is not repeated. A block with no lead follows the one before it.
 // - otherwise, a newer copy that is not switched off (rule 6), for `harness`:
 //   keeping it lets that copy write this project's surfaces (the keep), and
 //   switching runs this older package — both named, after the terminal run.
 export function channelChoices({ harness = null, copy = null, running = null, gate = null, pin = null } = {}) {
   if (gate) {
-    const from = gate.keys?.length ? ` (${gate.keys.join(", ")})` : "";
+    const named = (where, keys) => (keys?.length ? `${where} (${keys.join(", ")})` : null);
+    const from =
+      [named("the git marketplace", gate.keys), named(DIRECTORY, gate.directory)].filter(Boolean).join(" and ") ||
+      "the git marketplace";
     const run = (extra = "") =>
       coreCommand("setup", {
         version: gate.version || null,
@@ -455,7 +473,7 @@ export function channelChoices({ harness = null, copy = null, running = null, ga
       });
     return [
       {
-        lead: `Nothing written: this project loads ${PACKAGE} from the git marketplace${from}, and moving it to the npm install is a choice made at a terminal in this project:`,
+        lead: `Nothing written: this project loads ${PACKAGE} from ${from}, and moving it to the npm install is a choice made at a terminal in this project:`,
         command: run(),
       },
       { lead: "Without a terminal, name the channel:", command: run("--channel npm") },
@@ -482,7 +500,8 @@ export function channelChoices({ harness = null, copy = null, running = null, ga
 // The rows name both versions and the case, then the ways out.
 export function newerCopyDeferral({ copy, running, decision, harness, pin = null }) {
   const c = proceedCase(decision, copy.version);
-  const text = `this project runs a newer copy (${copy.key} ${copy.version}) than this package (${running}), so it is not switched off${c ? ` — ${c}` : ""}.`;
+  const not = isSyncedCopy(copy) ? "the npm install is not registered over it" : "it is not switched off";
+  const text = `this project runs a newer copy (${copy.key} ${copy.version}) than this package (${running}), so ${not}${c ? ` — ${c}` : ""}.`;
   return advised(text, channelChoices({ harness, copy, running, pin }));
 }
 
@@ -493,7 +512,23 @@ export function newerCopyDeferral({ copy, running, decision, harness, pin = null
 // setup's, in the core form and unpinned (the setup story, rule 17): what
 // updates the project from now on is whichever version runs it next.
 export function switchConsequence() {
-  return `this project stops loading the git-marketplace copy, and /plugin update no longer reaches it — from now on it is updated by ${coreCommand("setup")}`;
+  return `this project stops loading the git-marketplace copy, and that copy's updates no longer reach it — from now on it is updated by ${coreCommand("setup")}`;
+}
+
+// Where a copy of ours from another channel comes from, in a person's words.
+export const DIRECTORY = "Anthropic's directory";
+export const copyOrigin = (copy) => (isSyncedCopy(copy) ? DIRECTORY : "the git marketplace");
+
+// The consequence line of an npm registration over a copy synced from
+// claude.ai (PS-DIRECTORY, "Setup and install keep a directory copy…",
+// decision 4): never a switch — Claude Code loads the installed copy over the
+// synced one by its own precedence, so nothing is turned off — and of the keep
+// of that copy, setup's other answer (decision 6). `display`: the host's name.
+export function directoryConsequence(display) {
+  return `${display} then loads the npm copy here, and reports the directory copy as not loaded`;
+}
+export function directoryKeepConsequence(display, key) {
+  return `${display} keeps loading ${key}, updated from claude.ai; setup refreshes this project's files through that copy`;
 }
 
 // The words a switch row adds under the channel "npm" (rules 2 and 6): over a
@@ -501,6 +536,7 @@ export function switchConsequence() {
 // found, and that the project will run the older one; for a project not bound
 // yet, that the switch is recorded once it is.
 export function switchReason({ copy, running, runs = running, decision, unbound = false }) {
+  const off = isSyncedCopy(copy) ? "loading the npm copy over it" : "turning it off";
   const parts = [];
   // Against what the project runs once the copy is off (`runs`: the shared
   // directory's version when another checkout wrote a newer one), not against
@@ -509,7 +545,7 @@ export function switchReason({ copy, running, runs = running, decision, unbound
   if (copy && typeof copy.version === "string" && runs && cmpPrecedence(copy.version, runs) > 0) {
     const c = proceedCase(decision, copy.version);
     parts.push(
-      `${copy.key} ${copy.version} is newer than this package (${running})${c ? ` — ${c}` : ""}; turning it off runs this project on the older ${runs}`,
+      `${copy.key} ${copy.version} is newer than this package (${running})${c ? ` — ${c}` : ""}; ${off} runs this project on the older ${runs}`,
     );
   }
   if (unbound) parts.push("the project is not bound yet: the switch is recorded in its binding once it is");
@@ -655,14 +691,21 @@ export function behindAdvice(copy, version, { step = false } = {}) {
   const middle = step
     ? `its own upgrade runs after this run's agents block and may plan the block back to its own version; until it updates, its doctor may call the block stale, and the next run may plan the block again`
     : `until it updates, the agents block and anything else this run writes for the project are at ${version}, and its own doctor may call the block stale`;
-  return `${head}: ${middle}. Update it (${COPY_UPDATE_STEPS}).`;
+  const update = isSyncedCopy(copy)
+    ? `${SYNCED_UPDATE_STEPS[0].toUpperCase()}${SYNCED_UPDATE_STEPS.slice(1)}.`
+    : `Update it (${COPY_UPDATE_STEPS}).`;
+  return `${head}: ${middle}. ${update}`;
 }
 
 // This checkout's npm registration enabled beside the kept copy: the keep
 // changes no registration, so it stays; its uninstall (rule 4) drops it.
-export function npmRowBeside({ harness, id, surface }) {
+// A kept directory copy does not load while it stays: the installed copy wins.
+export function npmRowBeside({ harness, id, surface, copy = null }) {
+  const stays = isSyncedCopy(copy)
+    ? `stays enabled, and ${harness.display_name} loads it over the kept directory copy until it goes`
+    : "stays enabled beside the kept copy";
   return {
-    lead: `This checkout's npm registration (${id}) stays enabled beside the kept copy. To drop it, from a terminal in this project:`,
+    lead: `This checkout's npm registration (${id}) ${stays}. To drop it, from a terminal in this project:`,
     command: coreCommand("uninstall", { args: runArgs({ harnesses: [harness.id], surfaces: [surface] }) }),
   };
 }

package/node_modules/projectstore/scripts/doctor.mjs

@@ -80,6 +80,8 @@ import {
   readOverlayAt,
   layoutRoster,
   installChannel,
+  updateHint,
+  syncedPluginEntries,
   cmpPrecedence,
   cmpVersion,
   blockVisibleTo,
@@ -90,6 +92,7 @@ import {
   bindInherits,
   doctorFallbackText,
   fromTerminalIn,
+  COPY_UPDATE_STEPS,
 } from "./lib.mjs";
 import {
   agentOverrides,
@@ -102,8 +105,13 @@ import {
   packageCommand,
   invocation,
   harnessForOverlay,
+  activeHarness,
+  hostRegistry,
+  autoUpdateDefault,
 } from "./harness.mjs";
-import { effortSpec } from "./models.mjs";
+// The pure reader, never models.mjs: that file holds a fetch, and the
+// SessionStart hook imports this one (the portability suite's hook fence).
+import { effortSpec } from "./model-spec.mjs";
 
 // A remedy used to interpolate the surface's harness variable here. It cannot:
 // measured 2026-09-06, NO harness gives its Bash tool that variable, and a
@@ -409,6 +417,7 @@ export function checkStatusline(cfg, proj, home = homedir(), harness = speakingH
       const m = curCmd.match(/"([^"]+statusline\.mjs)"/) || curCmd.match(/(\S+statusline\.mjs)/);
       const wiredRoot = m ? dirname(dirname(m[1])) : null;
       const isLauncher = m ? isLauncherPath(m[1]) : false;
+      const gone = isLauncher ? vanishedSyncedRoot(m[1], proj, home) : null;
       if (m && !existsSync(m[1])) {
         out.push(
           finding(
@@ -420,6 +429,21 @@ export function checkStatusline(cfg, proj, home = homedir(), harness = speakingH
               : `statusLine points at a missing script (stale plugin path?): ${m[1]}`,
           ),
         );
+      } else if (gone) {
+        // A launcher written from a copy synced from claude.ai renders that
+        // copy; with sync turned off the host moves it to its trash folder,
+        // and the launcher falls back to the person's own status line.
+        const src = sourceHarness();
+        const r = hostRegistry(src) || {};
+        const trash = `~/${src.runtime?.home_default}/${(r.trash_dir || []).join("/")}/`;
+        out.push(
+          finding(
+            "install",
+            "warn",
+            "statusline",
+            `The status line launcher renders the copy from Anthropic's directory at ${gone}, and that copy is gone: the host moves a synced plugin to ${trash} when it is turned off on claude.ai, or when "${r.sync_setting}": false is in your user settings. Until a copy is back the launcher runs your own status line, or none. Two ways back: turn it on again (on claude.ai, or remove "${r.sync_setting}": false) and restart, or install projectstore through a channel of ours, ${fromTerminalIn(proj)}:\n${packageCommand([], "setup")}`,
+          ),
+        );
       } else if (m && isPluginCacheRoot(wiredRoot, home)) {
         // Only a versioned cache path can go stale this way. The launcher
         // carries no version, and a dev checkout is wired deliberately and
@@ -513,6 +537,27 @@ export function checkStatusline(cfg, proj, home = homedir(), harness = speakingH
   return out;
 }
 
+// The root a launcher of ours falls back to, when that root is a copy synced
+// from claude.ai that is no longer on disk and no other synced copy is: the
+// launcher then has nothing of ours to render. Null otherwise.
+// A synced copy vanishes into the host's trash folder (sync turned off, or
+// the plugin turned off on claude.ai). With no trash folder there is nothing
+// to name, and the launcher is not read: one existsSync on every SessionStart,
+// not a file read (the B review, 2026-10-15).
+function vanishedSyncedRoot(launcher, proj, home) {
+  const r = hostRegistry(sourceHarness());
+  if (!r?.trash_dir || !existsSync(join(claudeHome(home), ...r.trash_dir))) return null;
+  let root;
+  try {
+    root = JSON.parse(readFileSync(launcher, "utf8").match(/const FALLBACK_ROOT = ("(?:[^"\\]|\\.)*");/)[1]);
+  } catch {
+    return null;
+  }
+  if (installChannel(root, { home, harness: sourceHarness() }) !== "synced") return null;
+  if (existsSync(join(root, "scripts", "statusline.mjs"))) return null;
+  return syncedPluginEntries(home, proj).length ? null : root;
+}
+
 // The one-time offer after a plugin update (the story "Seamless upgrade from
 // 0.27.1 to 0.28"): a launcher we wrote before file stamps existed still
 // renders, but its embedded fallback root is frozen at the old version until
@@ -943,17 +988,22 @@ export function checkOverlays(cfg, proj, { root = pluginRoot(), home = homedir()
     // 2026-10-03 amendment, finding 7).
     const remedy = layoutRemedy(proj, { root, home });
     // The block and its move are the source harness's — a pre-0.28 binding
-    // and that harness's command — so its fact under any other listener.
+    // and that harness's command — so its fact under any other listener. The
+    // move writes the source harness's overlay, whoever listens: since the
+    // overlay follows the shell that bundles the core (layout spec, contract 2,
+    // as amended 2026-10-15), the listener's `where` would name another file.
+    const src = sourceHarness();
+    const dest = relative(proj, layoutPaths(proj).overlay(src?.runtime?.overlay || src?.id));
     out.push(
       aboutHarness(
         finding(
           "install",
           "warn",
           "agents-in-binding",
-          `${b} still carries an agents block — since 0.28 the models live in ${where} (the layout ADR); nothing reads it there. ${remedyWords(remedy, proj, "Move it")}`,
+          `${b} still carries an agents block — since 0.28 the models live in ${dest} (the layout ADR); nothing reads it there. ${remedyWords(remedy, proj, "Move it")}`,
           b,
         ),
-        sourceHarness(),
+        src,
         speaker,
       ),
     );
@@ -1117,7 +1167,7 @@ export function checkPluginRegistration(
             "info",
             "plugin-registration",
             [
-              `${key} (${row.version || "no version recorded"}) is off for this checkout: the npm registration turned it off when it registered, so the checkout no longer loads that copy and a /plugin update no longer reaches the project. ${old ? "Update that copy first — 0.27.x reads a moved project as unbound. " : ""}To go back to it, ${fromTerminalIn(proj)}, outside the session:`,
+              `${key} (${row.version || "no version recorded"}) is off for this checkout: the npm registration turned it off when it registered, so the checkout no longer loads that copy and its updates no longer reach the project. ${old ? "Update that copy first — 0.27.x reads a moved project as unbound. " : ""}To go back to it, ${fromTerminalIn(proj)}, outside the session:`,
               packageCommand(h, "uninstall", { version: s.pkg || "latest", args: `--surface ${s.surface}` }),
               "Restart, then in the session:",
               invocation(loadHarness(h.id) || speaker, "doctor", { args: "--fix" }),
@@ -1222,7 +1272,10 @@ export function checkVersionDrift(home = homedir(), states = [], proj = null, {
     // A disabled registration is not a copy anyone runs (contract 17, amended 2026-09-05).
     if (e.version && e.present && e.enabled !== false)
       seen.push({
-        source: `registry ${e.key}${e.scope ? " (" + e.scope + ")" : ""} at ${e.path}`,
+        // A synced copy has no registry row: its version is its own plugin.json's.
+        source: e.synced
+          ? `synced copy ${e.key} at ${e.path}`
+          : `registry ${e.key}${e.scope ? " (" + e.scope + ")" : ""} at ${e.path}`,
         version: e.version,
         harness: registryOf,
       });
@@ -1257,6 +1310,44 @@ export function checkVersionDrift(home = homedir(), states = [], proj = null, {
   ];
 }
 
+// A copy from Anthropic's directory that does not load (the PS-DIRECTORY
+// story "A copy installed from Anthropic's directory…", decision 5): Claude
+// Code loads an enabled copy of the same name from any other origin over a
+// synced one (the loading reference, "Name conflicts", item 5). Named with the
+// copy that loads and the way back, which is to turn that copy off, in its own
+// channel: the npm registration's uninstall, the host's disable for any other.
+// A checkout whose binding records the switch (`channel_switch`, written by
+// setup's npm answer) chose the npm copy over it: no info, as the git
+// copy's silenced-copy info goes under the mark (the B2 review).
+export function checkSyncedCopy(
+  proj,
+  { home = homedir(), harness = sourceHarness(), speaker = speakingHarness(), cfg = null } = {},
+) {
+  const r = hostRegistry(harness);
+  if (!r?.synced_dir || channelMark(cfg)) return [];
+  const copies = projectCopies(home, proj);
+  const synced = copies.find((e) => e.synced);
+  const loads = copies.find((e) => !e.synced);
+  if (!synced || !loads) return [];
+  const v = (e) => (e.version ? ` ${e.version}` : "");
+  const back =
+    installChannel(loads.path, { home, harness }) === "registration"
+      ? `remove the npm registration, ${fromTerminalIn(proj)}, outside the session:\n${packageCommand(harness, "uninstall", { version: "latest", args: `--surface ${r.surface}` })}`
+      : `turn ${loads.key} off in the session: /plugin → Installed, then disable ${loads.key}. Claude Code loads the directory copy at the next start.`;
+  return [
+    aboutHarness(
+      finding(
+        "install",
+        "info",
+        "synced-copy",
+        `${synced.key}${v(synced)}, from Anthropic's directory (${synced.path}), is not loaded in this project: Claude Code loads ${loads.key}${v(loads)} over it. To use the directory copy instead, ${back}`,
+      ),
+      harness,
+      speaker,
+    ),
+  ];
+}
+
 export function checkOverrideCopies(proj, home = homedir(), harness = speakingHarness()) {
   const out = [];
   // Copies of our agents a host loads from its own agents directory: a fact
@@ -1362,10 +1453,15 @@ export function checkOverrideCopies(proj, home = homedir(), harness = speakingHa
 // The variable names come from the manifest (runtime.agent_overrides); the
 // overlay is read only when one is set, so a clean startup reads nothing.
 export function checkEnvEffort(proj = null) {
+  // The variable is the active harness's (agentOverrides keys on detection), so
+  // the overlay it outranks is that harness's too — not the listener's, which
+  // in a shell's tree can be another harness (layout spec, contract 2, as
+  // amended 2026-10-15).
+  const h = activeHarness();
   return agentOverrides()
     .filter((o) => o.kind === "effort")
     .map((o) => {
-      const ov = proj ? readOverlayAt(proj) : null;
+      const ov = proj ? readOverlayAt(proj, h?.runtime?.overlay || h?.id) : null;
       const set = ov
         ? [
             ...(ov.efforts.default ? ["agents.default.effort"] : []),
@@ -1529,13 +1625,16 @@ export function layoutRemedy(
   });
   const channel = installChannel(root, { home, harness });
   if (channel === "registration") return npm(pluginVersion(root));
-  if (channel === "marketplace") return own(root);
+  // A copy synced from claude.ai runs its own bin too (contract 12, item 1, as
+  // widened by the PS-DIRECTORY story "A copy installed from Anthropic's
+  // directory…"): its channel is claude.ai's, never npm's.
+  if (channel === "marketplace" || channel === "synced") return own(root);
   // The selection is lib's selectCopy: this checkout's row first, then
   // user-scope rows by recency, never another checkout's.
   const copy = selectCopy(home, proj, { harness });
   if (copy) {
     const v = copy.version ? ` (${copy.version})` : "";
-    const then = "and the startup line names the command";
+    const then = "and the next session's startup line names the command";
     if (copy.missing === "bin")
       return { advice: copyUpdateAdvice(copy, { cannot: "predates the move and cannot run it", then }) };
     // Chosen first, gated after: the copy is what the project runs, so an
@@ -1698,16 +1797,34 @@ export function checkVaultGit(cfg) {
   ];
 }
 
-// Marketplace auto-update (maintainer request 2026-07-03): third-party
-// marketplaces do NOT auto-update by default, so a stale plugin looks like
-// "the feature is broken". Read the real registries and, when the flag is
-// off, tell the user the exact correct values.
-export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
+// Marketplace auto-update (maintainer request 2026-07-03): a marketplace whose
+// auto-update is off leaves a stale plugin looking like "the feature is
+// broken". Read the real registries and, when the flag is off, tell the user
+// the exact correct values.
+export function checkAutoUpdate(home = homedir(), harness = speakingHarness(), { root = pluginRoot() } = {}) {
   const out = [];
   // Auto-update is a toggle of the host's own plugin marketplace. A harness
   // whose registration is not the host's plugin system (Codex's is a portable
   // marketplace driven by our shell) has no such toggle to report on.
   if (harness?.surfaces?.plugin?.format !== "host-plugin-registration") return out;
+  const reg = hostRegistry(harness) || {};
+  const at = (parts) => `~/${harness.runtime?.home_default || ".claude"}/${parts.join("/")}`;
+  // A copy synced from claude.ai (Anthropic's directory) has no marketplace and
+  // no install record: claude.ai updates it. One info, from the manifest's
+  // update hint, and never another copy's install record, which would
+  // describe a copy this session does not run (the PS-DIRECTORY story "A copy
+  // installed from Anthropic's directory…", decision 5).
+  if (installChannel(root, { home, harness }) === "synced") {
+    out.push(
+      finding(
+        "install",
+        "info",
+        "auto-update",
+        `This session runs projectstore from Anthropic's directory (${root}), so no marketplace auto-update applies to it. ${updateHint({ root, home }).line}`,
+      ),
+    );
+    return out;
+  }
   // Two corrections over the first version of this check, both found by running
   // doctor straight out of a checkout (2026-08-05):
   //
@@ -1725,7 +1842,7 @@ export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
       .replace(/\\/g, "/")
       .match(/\/plugins\/(?:cache|marketplaces)\/([^/]+)(?:\/|$)/) || [])[1] || null;
   const inst = installedPluginRoot(home);
-  const marketplace = marketplaceOf(pluginRoot()) || marketplaceOf(inst && inst.path);
+  const marketplace = marketplaceOf(root) || marketplaceOf(inst && inst.path);
   if (!marketplace) {
     out.push(
       finding(
@@ -1738,9 +1855,13 @@ export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
     return out;
   }
 
+  // A marketplace added from claude.ai is recorded in a registry file of its
+  // own, and is added again from the host's list, never by a source.
+  const claudeai = Boolean(reg.claudeai_prefix) && marketplace.startsWith(reg.claudeai_prefix);
+  const file = (claudeai && reg.marketplaces_claudeai) || reg.marketplaces || ["plugins", "known_marketplaces.json"];
   let registry = null;
   try {
-    registry = JSON.parse(readFileSync(join(claudeHome(home), "plugins", "known_marketplaces.json"), "utf8"));
+    registry = JSON.parse(readFileSync(join(claudeHome(home), ...file), "utf8"));
   } catch {}
   const entry = registry ? registry[marketplace] : null;
   // A directory marketplace — the package's own registration — has no remote
@@ -1753,29 +1874,42 @@ export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
         "install",
         "warn",
         "auto-update",
-        `Marketplace "${marketplace}" is missing from ~/.claude/plugins/known_marketplaces.json — updates cannot be tracked. Re-add it: /plugin marketplace add <owner/repo>.`,
+        `Marketplace "${marketplace}" is missing from ${at(file)} — updates cannot be tracked. ` +
+          (claudeai
+            ? "Add it again from /plugin → Marketplaces, where claude.ai lists it."
+            : "Re-add it: /plugin marketplace add <owner/repo>."),
       ),
     );
     return out;
   }
 
-  let enabled = entry.autoUpdate === true;
-  if (!enabled) {
-    try {
-      const s = JSON.parse(readFileSync(join(claudeHome(home), "settings.json"), "utf8"));
-      if (s?.extraKnownMarketplaces?.[marketplace]?.autoUpdate === true) enabled = true;
-    } catch {}
-  }
+  // Claude Code's documented order (the loading reference, "Which marketplaces
+  // and plugins auto-update"): the settings entry first, then the registry
+  // entry, then the marketplace's default (registry.auto_update) — on for
+  // Anthropic's official marketplaces and claude.ai's, off for every other.
+  const userSettings = reg.user_settings || ["settings.json"];
+  let set;
+  try {
+    set = JSON.parse(readFileSync(join(claudeHome(home), ...userSettings), "utf8"))?.extraKnownMarketplaces?.[
+      marketplace
+    ]?.autoUpdate;
+  } catch {}
+  const [enabled, why] =
+    typeof set === "boolean"
+      ? [set, `set to false in ${at(userSettings)} → extraKnownMarketplaces, which wins over the registry`]
+      : typeof entry.autoUpdate === "boolean"
+        ? [entry.autoUpdate, `set to false in ${at(file)}`]
+        : [autoUpdateDefault(harness, marketplace) === true, "off by default for this marketplace"];
   if (!enabled) {
     out.push(
       finding(
         "install",
         "warn",
         "auto-update",
-        `Auto-update is OFF for marketplace "${marketplace}" — new projectstore releases will not be noticed. ` +
-          `Correct values: "autoUpdate": true on the "${marketplace}" entry in ~/.claude/plugins/known_marketplaces.json ` +
-          `(set via /plugin → Marketplaces → ${marketplace} → toggle auto-update), or in ~/.claude/settings.json → ` +
-          `extraKnownMarketplaces.${marketplace}.autoUpdate: true. Manual path: /plugin marketplace update ${marketplace}, then /reload-plugins.`,
+        `Auto-update is OFF for marketplace "${marketplace}" (${why}) — new projectstore releases will not be noticed. ` +
+          `Correct values: "autoUpdate": true on the "${marketplace}" entry in ${at(file)} ` +
+          `(set via /plugin → Marketplaces → ${marketplace} → toggle auto-update), or in ${at(userSettings)} → ` +
+          `extraKnownMarketplaces.${marketplace}.autoUpdate: true, which wins where that entry exists. Manual path, ${COPY_UPDATE_STEPS}.`,
       ),
     );
   }
@@ -1787,14 +1921,14 @@ export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
   // On the fallback path our own script is a checkout, so pluginRoot() and
   // pluginVersion() describe the checkout, not the install — reporting that as
   // the running version is the very confusion this check was just fixed for.
-  const named = marketplaceOf(pluginRoot()) ? { path: pluginRoot(), version: null } : inst;
+  const named = marketplaceOf(root) ? { path: root, version: null } : inst;
   try {
-    const root = (named && named.path) || pluginRoot();
-    const name = JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"), "utf8")).name;
+    const from = (named && named.path) || root;
+    const name = JSON.parse(readFileSync(join(from, ".claude-plugin", "plugin.json"), "utf8")).name;
     const catalog = JSON.parse(readFileSync(join(entry.installLocation, ".claude-plugin", "marketplace.json"), "utf8"));
     const latest = (catalog.plugins || []).find((p) => p.name === name)?.version;
     const running =
-      (named && named.version) || JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"), "utf8")).version;
+      (named && named.version) || JSON.parse(readFileSync(join(from, ".claude-plugin", "plugin.json"), "utf8")).version;
     // Precedence, not the triple: a session on 0.28.0-rc.3 hears that 0.28.0 is out.
     if (latest && running && cmpPrecedence(latest, running) > 0) {
       out.push(
@@ -1802,7 +1936,7 @@ export function checkAutoUpdate(home = homedir(), harness = speakingHarness()) {
           "install",
           "warn",
           "auto-update",
-          `A newer ${name} is available: v${latest} (running v${running}) — run /plugin marketplace update ${marketplace}, then /reload-plugins.`,
+          `A newer ${name} is available: v${latest} (running v${running}) — ${COPY_UPDATE_STEPS}.`,
         ),
       );
     }
@@ -1839,19 +1973,47 @@ export function checkMcpRegistration(root = pluginRoot(), harness = speakingHarn
       finding("install", "issue", "mcp", `.mcp.json at the plugin root is not valid JSON: ${e.message}`, ".mcp.json"),
     ];
   }
+  // What it must launch is the manifest's entry (scripts/mcp-server.mjs, the
+  // PS-DIRECTORY story "The MCP server's entry reaches no install verb…"),
+  // checked as a path and a file, never imported: mcp.mjs on SessionStart's
+  // path would load the server's whole graph into the hook.
+  // The entry is the checked copy's own: a root that carries its own manifest
+  // says what it launches, and one whose manifest names no entry (0.30.5 and
+  // older) launches `bin/projectstore.mjs mcp`, which serves — a newer doctor
+  // run against such a copy must not call it broken (the E2b review). A root
+  // with no manifest of its own is held to this doctor's.
+  let entry = mcp.entry || "scripts/mcp-server.mjs";
+  let verbArg = null;
+  try {
+    const own = JSON.parse(readFileSync(join(root, "harnesses", `${harness.id}.json`), "utf8"));
+    const e = own?.surfaces?.mcp?.entry;
+    if (typeof e === "string" && e) entry = e;
+    else [entry, verbArg] = ["bin/projectstore.mjs", "mcp"];
+  } catch {}
   const server = reg && reg.mcpServers && reg.mcpServers.projectstore;
   const args = server && Array.isArray(server.args) ? server.args : [];
-  if (!server || !args.some((a) => String(a).endsWith("/bin/projectstore.mjs")) || !args.includes("mcp")) {
+  const launches = args.some((a) => String(a).endsWith(`/${entry}`)) && (!verbArg || args.includes(verbArg));
+  if (!server || !launches) {
     return [
       finding(
         "install",
         "issue",
         "mcp",
-        ".mcp.json at the plugin root does not launch bin/projectstore.mjs mcp — the MCP read tools will not answer.",
+        `.mcp.json at the plugin root does not launch ${entry} — the MCP read tools will not answer.`,
         ".mcp.json",
       ),
     ];
   }
+  if (!existsSync(join(root, entry)))
+    return [
+      finding(
+        "install",
+        "issue",
+        "mcp",
+        `.mcp.json launches ${entry}, which is not in the plugin root — the MCP read tools will not answer; this install is incomplete.`,
+        ".mcp.json",
+      ),
+    ];
   return [
     finding(
       "install",
@@ -3059,7 +3221,8 @@ export async function runInstallChecks(cfg, proj, opts = {}) {
     ...checkHostIgnored(proj, { env: opts.env }),
     ...checkTrackedRuntime(proj),
     ...checkVaultGit(cfg),
-    ...checkAutoUpdate(),
+    ...checkAutoUpdate(opts.home, undefined, { root: opts.root }),
+    ...checkSyncedCopy(proj, { home: opts.home, cfg }),
     ...checkMcpRegistration(),
     ...checkLayout(proj, undefined, opts),
     ...checkOverlays(cfg, proj, opts),