projectstore-claude 0.30.1 → 0.30.3

package/node_modules/projectstore/scripts/doctor.mjs

@@ -60,6 +60,7 @@ import {
   statusLineLauncherPath,
   LAUNCHER_HEADER,
   installedPluginEntries,
+  projectCopies,
   selectCopy,
   takesNoRegister,
   copyUpdateAdvice,
@@ -98,7 +99,9 @@ import {
   configPath as harnessConfigPath,
   packageCommand,
   invocation,
+  harnessForOverlay,
 } from "./harness.mjs";
+import { effortSpec } from "./models.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
@@ -891,7 +894,7 @@ export function checkOverlays(cfg, proj, { root = pluginRoot(), home = homedir()
         "install",
         "issue",
         "overlay-forbidden-key",
-        `${where} carries \`${k}\`, which an overlay may not: only agents.default.model and agents.per_agent.<name>.model are read; the key is ignored.`,
+        `${where} carries \`${k}\`, which an overlay may not: only agents.default.model, agents.default.effort, agents.per_agent.<name>.model and agents.per_agent.<name>.effort are read; the key is ignored.`,
         where,
       ),
     );
@@ -953,19 +956,42 @@ export function checkOverlays(cfg, proj, { root = pluginRoot(), home = homedir()
       }
     }
   }
-  // A configured name no roster agent carries runs nothing: the model never
-  // applies. A warn, not an issue — a newer package's agent is a legitimate
-  // reason for a committed overlay to name one this copy does not ship.
+  // A configured name no roster agent carries runs nothing: what it
+  // configures never applies. A warn, not an issue — a newer package's agent
+  // is a legitimate reason for a committed overlay to name one this copy does
+  // not ship.
+  // An effort the harness's levels lack fails at spawn on a harness whose
+  // spawn takes those levels only, and is the harness's to judge elsewhere:
+  // a warn names it either way (the effort ADR, decision 7). Read against the
+  // manifest's floor alone: doctor reads no model catalog.
+  const levels = effortSpec(harnessForOverlay(o.id))?.levels?.map((l) => l.id) || null;
+  if (levels) {
+    const set = [
+      ...(o.efforts.default ? [["agents.default.effort", o.efforts.default]] : []),
+      ...Object.entries(o.efforts.per_agent).map(([n, v]) => [`agents.per_agent.${n}.effort`, v]),
+    ];
+    for (const [k, v] of set)
+      if (!levels.includes(v))
+        out.push(
+          finding(
+            "install",
+            "warn",
+            "overlay-unknown-effort",
+            `${where} sets \`${k}\` to ${v}, which is not one of ${harnessForOverlay(o.id)?.display_name || o.id}'s effort levels (${levels.join(", ")}) — a spawn may refuse it.`,
+            where,
+          ),
+        );
+  }
   const roster = layoutRoster(cfg);
   if (roster) {
-    for (const n of Object.keys(o.agents.per_agent)) {
+    for (const n of new Set([...Object.keys(o.agents.per_agent), ...Object.keys(o.efforts.per_agent)])) {
       if (!roster.includes(n))
         out.push(
           finding(
             "install",
             "warn",
             "overlay-unknown-agent",
-            `${where} configures \`${n}\`, which is not in the ${cfg.layout} roster (${roster.join(", ")}) — no agent by that name runs, so the model never applies. A typo, or an agent this package does not ship yet.`,
+            `${where} configures \`${n}\`, which is not in the ${cfg.layout} roster (${roster.join(", ")}) — no agent by that name runs, so what it configures never applies. A typo, or an agent this package does not ship yet.`,
             where,
           ),
         );
@@ -1148,7 +1174,16 @@ export function checkVersionDrift(home = homedir(), states = [], proj = null, {
   const seen = [];
   // The registry read here is the source harness's own.
   const registryOf = sourceHarness()?.id || null;
-  for (const e of installedPluginEntries(home, proj)) {
+  // The copies the host loads for this project (contract 17, amended
+  // 2026-10-14): this checkout's own row or a user-scope row, never another
+  // project's — the registry keeps every project's local rows, and another
+  // checkout's old copy is not a drift here. Every row, not one per key: this
+  // project's own row against a user-scope row is the drift contract 17 names.
+  // Without a project, the user-scope rows alone.
+  const rows = proj
+    ? projectCopies(home, proj)
+    : installedPluginEntries(home).filter((e) => e.present && e.enabled !== false && !e.projectPath);
+  for (const e of rows) {
     // 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({
@@ -1284,24 +1319,32 @@ export function checkOverrideCopies(proj, home = homedir(), harness = speakingHa
   return out;
 }
 
-// ADR-008 made `effort` unconfigurable per project, which promotes this env var
-// from a curiosity to the ONLY thing that can move our agents off `effort: max`.
-// It beats frontmatter, so a value set for cost or latency silently drops all
-// five agents below the quality floor the plugin advertises — exactly the class
-// of silent downgrade doctor exists to name.
+// The variable outranks every effort projectstore passes at spawn and the
+// bundled agents' frontmatter effort: with it set, the spawn offers no effort
+// parameter at all (the effort ADR, decision 7). So a value set for cost or
+// latency silently replaces the efforts the overlay configures — exactly the
+// class of "the value configured is not the value that runs" doctor names.
 // The variable names come from the manifest (runtime.agent_overrides); the
-// wording is projectstore's, because the claim — ADR-008's quality floor — is.
-export function checkEnvEffort() {
+// overlay is read only when one is set, so a clean startup reads nothing.
+export function checkEnvEffort(proj = null) {
   return agentOverrides()
     .filter((o) => o.kind === "effort")
-    .map((o) =>
-      finding(
+    .map((o) => {
+      const ov = proj ? readOverlayAt(proj) : null;
+      const set = ov
+        ? [
+            ...(ov.efforts.default ? ["agents.default.effort"] : []),
+            ...Object.keys(ov.efforts.per_agent).map((n) => `agents.per_agent.${n}.effort`),
+          ]
+        : [];
+      const where = set.length ? ` (${relative(proj, ov.path) || ov.path} sets ${set.join(", ")})` : "";
+      return finding(
         "install",
         "warn",
         "env-effort",
-        `${o.env}=${o.value} is set — it overrides the bundled agents' "effort: max" frontmatter, so every projectstore agent runs at "${o.value}". Effort is not configurable per project (ADR-008); unset the variable to restore the quality floor.`,
-      ),
-    );
+        `${o.env}=${o.value} is set — it outranks every effort projectstore passes at spawn${where} and the bundled agents' frontmatter, so every projectstore agent runs at "${o.value}". Unset it for the configured efforts to run.`,
+      );
+    });
 }
 
 export function checkEnvModel() {
@@ -1538,28 +1581,48 @@ export function checkGitignore(proj) {
       }
     }
   }
-  if (!existsSync(join(proj, ".git"))) return out;
+  // The host's settings file is checkHostIgnored's (the layout spec, contract 9
+  // as amended 2026-10-14): only git knows every rule that ignores it, and this
+  // function runs in the SessionStart subset, whose budget forbids a subprocess.
+  return out;
+}
+
+// The line read the host-file check used before it asked git, and still uses
+// when git cannot answer: the project's own .gitignore, exact lines only.
+function hostIgnoreLineMissing(proj, env) {
   let lines = [];
   try {
     lines = readFileSync(join(proj, ".gitignore"), "utf8")
       .split("\n")
       .map((l) => l.trim());
   } catch {}
-  const coveredAll = lines.includes(".claude/") || lines.includes(".claude");
-  if (coveredAll) return out;
-  // Our own files are self-ignored inside .projectstore/; what is left is the host's.
-  const wanted = [relative(proj, hostSettingsPath(proj))];
-  const missing = wanted.filter((w) => !lines.includes(w));
-  if (!missing.length) return out;
-  out.push(
+  if (lines.includes(".claude/") || lines.includes(".claude")) return [];
+  return [relative(proj, hostSettingsPath(proj, env))].filter((w) => !lines.includes(w));
+}
+
+// Whether git ignores the host's machine-local settings file (the layout spec,
+// contract 9 as amended 2026-10-14). Our own files are self-ignored inside
+// .projectstore/; what is left is the host's. Git's answer covers every rule
+// it applies — nested .gitignore files, .git/info/exclude, core.excludesFile
+// and its XDG default — where the line read saw only the project's exact
+// lines. --no-index keeps this about rules: a tracked file with a matching rule
+// is quiet here (tracking is checkTrackedRuntime's). Exit 0 is ignored, 1 is
+// not; anything else — no git on PATH, an error, a timeout — falls back to the
+// line read. Full report only: a subprocess, like checkTrackedRuntime.
+export function checkHostIgnored(proj, { env = process.env } = {}) {
+  if (!existsSync(join(proj, ".git"))) return [];
+  const file = relative(proj, hostSettingsPath(proj, env));
+  const r = spawnSync("git", ["check-ignore", "-q", "--no-index", "--", file], { cwd: proj, env, timeout: 5000 });
+  const missing = r.status === 0 ? [] : r.status === 1 ? [file] : hostIgnoreLineMissing(proj, env);
+  if (!missing.length) return [];
+  return [
     finding(
       "install",
       "warn",
       "gitignore",
       `Machine-specific files not gitignored: ${missing.join(", ")} (or ignore ".claude/" wholesale).`,
     ),
-  );
-  return out;
+  ];
 }
 
 // An ignore line never untracks a file already in the index, so the project
@@ -2956,8 +3019,9 @@ export async function runInstallChecks(cfg, proj, opts = {}) {
     ...checkAgentsBlock(proj, { env: opts.env, root: opts.root }),
     ...checkOverrideCopies(proj),
     ...checkEnvModel(),
-    ...checkEnvEffort(),
+    ...checkEnvEffort(proj),
     ...checkGitignore(proj),
+    ...checkHostIgnored(proj, { env: opts.env }),
     ...checkTrackedRuntime(proj),
     ...checkVaultGit(cfg),
     ...checkAutoUpdate(),
@@ -3042,7 +3106,7 @@ export function runStartupChecks(cfg, proj, budgetMs = 150) {
         restamp: findings.some((f) => f.level === "info" && f.check === "upgrade"),
       }),
     () => checkEnvModel(),
-    () => checkEnvEffort(),
+    () => checkEnvEffort(proj),
   ];
   for (const step of steps) {
     if (Date.now() - started > budgetMs) return { skipped: true, count: 0, findings: foldIntoMove(findings) };

package/node_modules/projectstore/scripts/harness.mjs

@@ -302,9 +302,7 @@ export function hostPresence(manifest, { env = process.env, home = homedir() } =
         x.cli.bin,
     )?.[1] || null;
   const bin = s ? s.cli.bin : null;
-  const r = manifest?.runtime || {};
-  const fromEnv = r.home_env && env ? env[r.home_env] : null;
-  const homeDir = fromEnv || (home && r.home_default ? join(home, r.home_default) : null);
+  const homeDir = harnessHome(manifest, { env, home });
   let present = false;
   if (homeDir) {
     try {
@@ -314,6 +312,15 @@ export function hostPresence(manifest, { env = process.env, home = homedir() } =
   return { cli: bin ? whichOnPath(bin, env || {}) : null, home: present ? homeDir : null, bin, homeDir };
 }
 
+// A harness's own home directory, as the harness resolves it: its home
+// variable (runtime.home_env) when set, else home_default under the home
+// directory, else null. Whether it exists is the caller's question.
+export function harnessHome(manifest, { env = process.env, home = homedir() } = {}) {
+  const r = manifest?.runtime || {};
+  const fromEnv = r.home_env && env ? env[r.home_env] : null;
+  return fromEnv || (home && r.home_default ? join(home, r.home_default) : null);
+}
+
 // The agents block of a RUN (the story "One run plans the agents block once,
 // and a bare uninstall selects every harness the project uses", rules 1–2):
 // the files every manifest of the run names for it, in the FIRST manifest's
@@ -703,6 +710,9 @@ export function cachePaths({ env = process.env, home = homedir() } = {}) {
     fetch: root ? join(root, "fetch") : null,
     fetchRun: (id) => (root ? join(root, "fetch", id) : null),
     registry: root ? join(root, "registry.json") : null,
+    // A harness's model list, as its last live read answered (the ADR "Agent
+    // model lists are read from each harness's own catalog…", decision 4).
+    models: (id) => (root && id ? join(root, "models", `${id}.json`) : null),
     from: fromEnv ? variable : "the home directory",
     variable,
   };

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

@@ -2630,11 +2630,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

package/node_modules/projectstore/scripts/lib.mjs

@@ -196,9 +196,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 +211,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 +238,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 +251,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 +271,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 +294,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;