projectstore-claude 0.30.2 → 0.30.4

package/node_modules/projectstore/scripts/agents-change.mjs

@@ -7,9 +7,20 @@ import { harnessForOverlay } from "./harness.mjs";
 
 // What a change would write. `before` is readOverlayAt's read; `roster` the
 // layout's agent names (null when no layout loads); `agents` the
-// `<name>=<model>` specs. A malformed spec or a name outside the roster comes
-// back as `usage`, with nothing planned.
-export function planAgentsChange({ before, harness, layout, roster, defaultModel, agents = [], reset = false }) {
+// `<name>=<model>` specs; `defaultEffort` and `efforts` (`<name>=<level>`)
+// the same for effort (the effort ADR, decision 8). A malformed spec or a name
+// outside the roster comes back as `usage`, with nothing planned.
+export function planAgentsChange({
+  before,
+  harness,
+  layout,
+  roster,
+  defaultModel,
+  agents = [],
+  defaultEffort,
+  efforts = [],
+  reset = false,
+}) {
   // --reset empties the block first; --default and --agent then apply on top of
   // the emptied block — "reset, then set" is one call, and nothing given is
   // silently dropped.
@@ -27,6 +38,22 @@ export function planAgentsChange({ before, harness, layout, roster, defaultModel
     if (m[2]) next.per_agent[m[1]] = m[2];
     else delete next.per_agent[m[1]];
   }
+  // Efforts, field by field beside the models: a run that names none keeps
+  // every effort the overlay holds, and --reset empties them with the models.
+  const beforeEfforts = before.efforts || { default: null, per_agent: {} };
+  const baseEfforts = reset ? { default: null, per_agent: {} } : beforeEfforts;
+  const nextEfforts = {
+    default: defaultEffort !== undefined ? defaultEffort || null : baseEfforts.default,
+    per_agent: { ...baseEfforts.per_agent },
+  };
+  for (const spec of efforts) {
+    const m = /^([a-z][a-z0-9-]*)=(.*)$/.exec(spec);
+    if (!m) return { usage: `an effort takes <name>=<level>, got ${spec}` };
+    if (roster && !roster.includes(m[1]))
+      return { usage: `no agent named ${m[1]} in the ${layout} roster — known: ${roster.join(", ")}` };
+    if (m[2]) nextEfforts.per_agent[m[1]] = m[2];
+    else delete nextEfforts.per_agent[m[1]];
+  }
   // The clerk transcribes; a strong default must not lift it (commands/agents.md,
   // ADR-008). WHICH model it is pinned to is the harness's vocabulary, so the
   // manifest names it and this file does not: pinning every harness to
@@ -49,12 +76,29 @@ export function planAgentsChange({ before, harness, layout, roster, defaultModel
       pinnedClerk = true;
     } else clerkPinUnavailable = true;
   }
-  // Keys inside the agents block that the allowlist rejected (an `effort`, a
-  // stray shape) are rewritten out by the write and announced here; keys
-  // outside the block are kept, and stay doctor's to name.
+  // The clerk's effort, pinned the same way while a default effort stands
+  // (the effort ADR, decision 6), where the harness names a cheap level; a
+  // harness that names none pins nothing and says nothing, because its clerk
+  // already runs at its frontmatter's level.
+  let pinnedClerkEffort = false;
+  const clerkEffortAsked = efforts.some((s) => s.startsWith("clerk="));
+  if (nextEfforts.default && !nextEfforts.per_agent.clerk && !clerkEffortAsked) {
+    const cheap = harnessForOverlay(harness)?.agent_translation?.effort?.cheap || null;
+    if (cheap) {
+      nextEfforts.per_agent.clerk = cheap;
+      pinnedClerkEffort = true;
+    }
+  }
+  // Keys inside the agents block that the allowlist rejected (a stray shape)
+  // are rewritten out by the write and announced here; keys outside the block
+  // are kept, and stay doctor's to name.
   const dropped = before.rejected.filter((k) => k.startsWith("agents."));
+  const sameEfforts =
+    JSON.stringify({ d: beforeEfforts.default, p: beforeEfforts.per_agent }) ===
+    JSON.stringify({ d: nextEfforts.default, p: nextEfforts.per_agent });
   const same =
     !dropped.length &&
+    sameEfforts &&
     JSON.stringify({ d: before.agents.default, p: before.agents.per_agent }) ===
       JSON.stringify({ d: next.default, p: next.per_agent });
   const preview = [
@@ -72,13 +116,23 @@ export function planAgentsChange({ before, harness, layout, roster, defaultModel
     preview.push(
       `  clerk: takes the default — ${harness} declares no cheap model to pin it to, so name one with --agent clerk=<model>`,
     );
+  // Effort lines only where an effort is held or asked for, so a run over an
+  // overlay of models alone previews exactly as it did before efforts.
+  if (beforeEfforts.default || nextEfforts.default)
+    preview.push(`  default effort: ${beforeEfforts.default || "—"} → ${nextEfforts.default || "—"}`);
+  const effortNames = new Set([...Object.keys(beforeEfforts.per_agent), ...Object.keys(nextEfforts.per_agent)]);
+  for (const n of [...effortNames].sort())
+    preview.push(
+      `  ${n} effort: ${beforeEfforts.per_agent[n] || "—"} → ${nextEfforts.per_agent[n] || "—"}${pinnedClerkEffort && n === "clerk" ? " (pinned: the clerk stays cheap under a strong default)" : ""}`,
+    );
   if (dropped.length)
-    preview.push(`  drops from the agents block (an overlay carries only models): ${dropped.join(", ")}`);
-  return { next, pinnedClerk, clerkPinUnavailable, dropped, same, preview };
+    preview.push(`  drops from the agents block (an overlay carries only models and efforts): ${dropped.join(", ")}`);
+  return { next, nextEfforts, pinnedClerk, pinnedClerkEffort, clerkPinUnavailable, dropped, same, preview };
 }
 
 // Writes a planned change through the overlay's one writer and reads it back.
-export function applyAgentsChange(projectDir, harness, next) {
-  const path = writeOverlayAt(projectDir, harness, next);
+// `nextEfforts` left out keeps the efforts the file holds.
+export function applyAgentsChange(projectDir, harness, next, nextEfforts) {
+  const path = writeOverlayAt(projectDir, harness, next, nextEfforts);
   return { path, after: readOverlayAt(projectDir, harness) };
 }

package/node_modules/projectstore/scripts/build-adapters.mjs

@@ -102,7 +102,7 @@ function skill(name, description, body, { runtime = true } = {}) {
 const COMMAND_OVERRIDES = {
   agents: {
     description:
-      "Register or remove ProjectStore's shared agents block, inspect its Codex model overlay, or configure per-role models. Arguments: <register | unregister | status | configure>.",
+      "Register or remove ProjectStore's shared agents block, inspect its Codex model overlay, or configure per-role models and efforts. Arguments: <register | unregister | status | configure>.",
     body: `You are managing ProjectStore's Codex agent integration. Require a bound project.
 
 ## register / unregister
@@ -117,19 +117,22 @@ report the envelope's result. Never edit the managed block by hand.
 
 Run \`plan --json --harness codex --surface agents_block --project "$PWD"\`,
 then \`agents show --json --project "$PWD"\`. Report the block state and each
-role's resolved model and source. The active overlay path returned by the core
-is authoritative.
+role's resolved model and effort, each with its source. The active overlay path
+returned by the core is authoritative.
 
 ## configure
 
-Ask for a default model and optional per-role model ids. Use actual Codex model
-ids supplied by the user or visible in the current host; do not translate model
-names from another harness. Preview the exact argv, ask for approval, then run
-\`agents configure --harness codex [--default <model>] [--agent
-<role>=<model> ...] --project "$PWD"\`. The core is the only writer. Do not pass
-an effort override: per-role effort is outside this integration's current
-contract. A configured model is consumed by the role-orchestration skills on
-their next spawn; no restart is needed.`,
+Ask for a default model and optional per-role model ids, then a default effort
+and optional per-role efforts. Use actual Codex model ids and levels supplied by
+the user or visible in the current host; do not translate model names from
+another harness. Preview the exact argv, ask for approval, then run
+\`configure --set agents.default=<model> --set agents.default.effort=<level>
+[--set agents.<role>=<model>] [--set agents.<role>.effort=<level>] ... --harness
+codex --project "$PWD"\`, after the same command with \`--dry-run\` showed its
+plan. \`-\` as a value clears one. The core is the only writer; a level the
+role's model does not list is written with a note in the plan. A configured
+model and effort are consumed by the role-orchestration skills on their next
+spawn; no restart is needed.`,
   },
   bind: {
     description:
@@ -232,13 +235,25 @@ function renderPassive(file) {
   return [join("skills", name, "SKILL.md"), skill(name, data.description || name, body)];
 }
 
+// The spawn's effort parameter is the target manifest's vocabulary: a
+// manifest without it cannot render a role that passes one, and says so
+// rather than guessing a name (as the clerk pin refuses a literal model).
+function effortParam() {
+  const p = TARGET.agent_translation?.effort?.spawn_param;
+  if (!p)
+    throw new Error(
+      `${TARGET.id}: agent_translation.effort.spawn_param is missing; a role skill cannot name the effort`,
+    );
+  return p;
+}
+
 function renderRole(file) {
   const { data, body } = frontmatter(read(file), file);
   const role = file.split("/").pop().replace(/\.md$/, "");
   const name = renderedName("agents", role);
-  const orchestration = `## Codex orchestration\n\nThis is a role-orchestration skill, not a native agent registration. Resolve the\nrole model by running:\n\n\`\`\`bash\nnode "\${PROJECTSTORE_CORE_ROOT}/bin/projectstore.mjs" agents model ${role} --json --project "$PWD"\n\`\`\`\n\nSpawn a collaboration agent for the bounded task. If the result names a model,\npass that model and use an empty or bounded context fork; otherwise inherit the\ncurrent model. Do not pass a reasoning-effort override: per-role effort belongs\nto a separate accepted story. Give the spawned agent the role contract below\nand the exact artifact/diff it must inspect. Wait for its final result.\n\n## Role contract\n\n`;
+  const orchestration = `## Codex orchestration\n\nThis is a role-orchestration skill, not a native agent registration. Resolve the\nrole's model and effort by running:\n\n\`\`\`bash\nnode "\${PROJECTSTORE_CORE_ROOT}/bin/projectstore.mjs" agents model ${role} --json --project "$PWD"\n\`\`\`\n\nSpawn a collaboration agent for the bounded task. If the result names a model,\npass that model and use an empty or bounded context fork; otherwise inherit the\ncurrent model. If the result names an effort, pass it as \`${effortParam()}\`,\nwith or without a model; otherwise pass none. Give the spawned agent the role\ncontract below and the exact artifact/diff it must inspect. Wait for its final\nresult.\n\n## Role contract\n\n`;
   const description = (data.description || `Run the ProjectStore ${role} role in a fresh collaboration agent.`).replace(
-    /^(?:Opus|Sonnet) \(max-effort\)\s+/,
+    /^(?:Opus|Sonnet) \([a-z]+-effort\)\s+/,
     "",
   );
   return [join("skills", name, "SKILL.md"), skill(name, description, orchestration + body)];

package/node_modules/projectstore/scripts/cli.mjs

@@ -71,6 +71,7 @@ import {
   readConfigAt,
   readOverlayAt,
   resolveAgentModel,
+  resolveAgentEffort,
   overlayId,
   layoutRoster,
   commandForm,
@@ -1407,8 +1408,9 @@ async function runScaffold(ctx) {
   return emit(true, scaffoldResult(plan, done), renderScaffoldPlan(plan, done, { env }), 0);
 }
 
-// agents model <name> — the model a plugin surface passes for that agent, from
-// the active harness's overlay (ADR-008's two terms); agents show — the overlay
+// agents model <name> — the model and effort a plugin surface passes for that
+// agent, from the active harness's overlay (ADR-008's two terms, once per
+// field; the effort ADR, decision 2); agents show — the overlay
 // as read, with the keys the allowlist rejected; agents configure — the one
 // writer, behind the same gate as install: naming --harness is the
 // confirmation, a bare non-TTY call refuses (layout spec, contracts 2–4).
@@ -1439,11 +1441,15 @@ async function runAgents(ctx) {
     const name = positionals[1];
     if (!name) return usage("agents model takes the agent's bare name (critic, planner, …)");
     const r = resolveAgentModel(project, name, { harness });
+    const e = resolveAgentEffort(project, name, { harness });
+    // The effort clause only when one resolves, so the line reads as it did
+    // for an overlay of models alone.
+    const effortText = e.effort ? `; effort ${e.effort} (${e.source})` : "";
     return emit(
       "agents model",
       true,
-      r,
-      `${name}: ${r.model ? `${r.model} (${r.source}, ${r.overlay})` : "no model configured — the agent's frontmatter decides"}\n`,
+      { ...r, effort: e.effort, effort_source: e.source },
+      `${name}: ${r.model ? `${r.model} (${r.source}, ${r.overlay})` : "no model configured — the agent's frontmatter decides"}${effortText}\n`,
     );
   }
   const before = readOverlayAt(project, harness);
@@ -1451,22 +1457,28 @@ async function runAgents(ctx) {
   if (sub === "show") {
     // Resolved per roster agent (per configured name when no layout loads), so
     // a reader reports what would run without restating the two-term rule.
-    const names = [...new Set([...(roster || []), ...Object.keys(before.agents.per_agent)])].sort();
+    const configured = [
+      ...new Set([...Object.keys(before.agents.per_agent), ...Object.keys(before.efforts.per_agent)]),
+    ];
+    const names = [...new Set([...(roster || []), ...configured])].sort();
     const resolved = Object.fromEntries(
       names.map((n) => {
         const r = resolveAgentModel(project, n, { harness });
-        return [n, { model: r.model, source: r.source }];
+        const e = resolveAgentEffort(project, n, { harness });
+        return [n, { model: r.model, source: r.source, effort: e.effort, effort_source: e.source }];
       }),
     );
-    const unknown = roster ? Object.keys(before.agents.per_agent).filter((n) => !roster.includes(n)) : [];
+    const unknown = roster ? configured.filter((n) => !roster.includes(n)) : [];
     const lines = [
       `overlay: ${before.path || "(none: no harness detected and none named)"}${before.path && !before.present ? " (absent)" : ""}`,
     ];
     if (before.unparseable) lines.push("  not valid JSON");
     if (before.agents.default) lines.push(`  default: ${before.agents.default}`);
+    if (before.efforts.default) lines.push(`  default effort: ${before.efforts.default}`);
+    const effortOf = (n) => (resolved[n].effort ? `, effort ${resolved[n].effort} (${resolved[n].effort_source})` : "");
     for (const n of names)
       lines.push(
-        `  ${n}: ${resolved[n].model ? `${resolved[n].model} (${resolved[n].source})` : "— (the agent's frontmatter)"}${unknown.includes(n) ? " — not in the roster: nothing runs under this name" : ""}`,
+        `  ${n}: ${resolved[n].model ? `${resolved[n].model} (${resolved[n].source})` : "— (the agent's frontmatter)"}${effortOf(n)}${unknown.includes(n) ? " — not in the roster: nothing runs under this name" : ""}`,
       );
     if (before.rejected.length) lines.push(`  ignored (not an overlay key): ${before.rejected.join(", ")}`);
     if (inBinding) lines.push("  the binding still carries an agents block — a pre-0.28 leftover; run upgrade");
@@ -1479,6 +1491,7 @@ async function runAgents(ctx) {
         present: before.present,
         unparseable: before.unparseable,
         agents: before.agents,
+        efforts: before.efforts,
         resolved,
         roster,
         unknown,
@@ -1535,7 +1548,16 @@ async function runAgents(ctx) {
       { harness, path: before.path, wrote: false, declined: true, agents: next, dropped },
       preview.join("\n") + "\n  nothing written.\n",
     );
-  const { path, after } = applyAgentsChange(project, harness, next);
+  const { path, after } = applyAgentsChange(project, harness, next, change.nextEfforts);
+  // Efforts join the envelope only where the overlay holds one, so a run over
+  // models alone answers exactly as it did before efforts existed.
+  const withEfforts =
+    after.efforts.default ||
+    Object.keys(after.efforts.per_agent).length ||
+    before.efforts.default ||
+    Object.keys(before.efforts.per_agent).length
+      ? { efforts: after.efforts, pinnedClerkEffort: change.pinnedClerkEffort }
+      : {};
   return emit(
     "agents configure",
     true,
@@ -1544,6 +1566,7 @@ async function runAgents(ctx) {
       path,
       wrote: true,
       agents: after.agents,
+      ...withEfforts,
       pinnedClerk,
       clerkPinUnavailable,
       dropped,

package/node_modules/projectstore/scripts/configure-menu.mjs

@@ -16,12 +16,15 @@
 
 import * as term from "./term.mjs";
 import { createMenu, renderMenu, seg, SMALLEST } from "./menu.mjs";
-import { knownModels, readLive } from "./models.mjs";
+import { knownModels, readLive, effortSpec, effortLevels } from "./models.mjs";
 import { loadHarness } from "./harness.mjs";
 import { readOverlayAt } from "./lib.mjs";
 
 const CLEAR = "-";
 
+// What an effort row sets: the settings panel's first sentence for it.
+const EFFORT = "How long the agent thinks before it answers: a higher level is slower and costs more.";
+
 // What each agent of the roster does: the settings panel's first sentence.
 const ROLE = Object.freeze({
   default: "The model for every agent that has none of its own.",
@@ -264,15 +267,17 @@ function agentsGroup(f, id, list, catalogs, { menu, now, caps: c }) {
     return d ? (menu?.() ? menu().eff(d) : d.value) : null;
   };
   for (const s of list) {
-    const name = s.key.slice(7);
+    const isEffort = s.rail === "effort";
+    const name = isEffort ? s.key.slice(7, -7) : s.key.slice(7);
     const isDefault = name === "default";
     if (s.source === "unparseable") {
       items.push({
         id: `${id}:${s.key}`,
         key: s.key,
         harness: id,
-        label: name,
-        title: `${display} · ${name}`,
+        label: isEffort ? "effort" : name,
+        ...(isEffort ? { indent: 2, path: `${name} · effort` } : {}),
+        title: `${display} · ${name}${isEffort ? " · effort" : ""}`,
         kind: "info",
         value: null,
         tag: SOURCE.unparseable,
@@ -280,6 +285,10 @@ function agentsGroup(f, id, list, catalogs, { menu, now, caps: c }) {
       });
       continue;
     }
+    if (isEffort) {
+      items.push(effortItem(h, display, id, s, name, isDefault, o, items, catalogs, { defaultNow, menu, now }));
+      continue;
+    }
     const item = {
       id: `${id}:${s.key}`,
       key: s.key,
@@ -314,11 +323,127 @@ function agentsGroup(f, id, list, catalogs, { menu, now, caps: c }) {
   return {
     title: `Agents · ${display}`,
     footer: file.split("/").pop(),
-    description: `Which model each projectstore agent runs on in ${display}${h?.agent_translation?.models?.spawn_takes === "id" ? `, in ${display}'s own model names` : ""}. A model set here goes to ${file}, which is committed, so it applies to everyone on this project. default covers every agent without a model of its own.`,
+    description: `Which model each projectstore agent runs on in ${display}${h?.agent_translation?.models?.spawn_takes === "id" ? `, in ${display}'s own model names` : ""}, and at what effort. A model or an effort set here goes to ${file}, which is committed, so it applies to everyone on this project. default covers every agent without one of its own.`,
     items,
   };
 }
 
+// An agent's effort row (the effort ADR, decision 4): under its model row,
+// its value its own level, else the default's, else what the harness does
+// with none; its values the levels of the model it will run on, a model
+// change waiting in the menu counted.
+function effortItem(h, display, id, s, name, isDefault, o, items, catalogs, { defaultNow, menu, now }) {
+  const es = effortSpec(h);
+  const own = isDefault ? o.efforts.default || null : o.efforts.per_agent[name] || null;
+  const eff = (it) => (it ? (menu?.() ? menu().eff(it) : it.value) : null);
+  const modelItem = items.find((x) => x.key === (isDefault ? "agents.default" : `agents.${name}`));
+  const defaultEffortItem = () => items.find((x) => x.key === "agents.default.effort");
+  // The model this agent will run on: its own, else the default's.
+  const runModel = () => eff(modelItem) || (isDefault ? null : defaultNow()) || null;
+  const defaultEffortNow = () => (isDefault ? null : eff(defaultEffortItem()));
+  const levelsNow = () => effortLevels(h, runModel(), catalogs[id]?.known || null);
+  // What runs when nothing is configured: the frontmatter's level, or, where
+  // a passed model's own default runs, that level when its list names it.
+  const unsetText = () => {
+    const m = runModel();
+    const d = es.unset.model_default && m ? levelsNow()?.default : null;
+    return d ? `${d} (${m}'s default)` : es.unset.value;
+  };
+  const unsetMeaning = es.unset.model_default
+    ? "each agent runs at its model's own default level"
+    : "each agent runs at its frontmatter's effort";
+  const item = {
+    id: `${id}:${s.key}`,
+    key: s.key,
+    harness: id,
+    label: "effort",
+    indent: 2,
+    path: `${name} · effort`,
+    title: `${display} · ${name} · effort`,
+    kind: "choice",
+    value: own,
+    tag: own ? (isDefault ? SOURCE.overlay : SOURCE.per_agent) : isDefault ? SOURCE.default : "",
+    display: (v) => {
+      if (v) return v;
+      const d = defaultEffortNow();
+      return d ? `${d} (default)` : unsetText();
+    },
+  };
+  item.describe = (v, changed) => {
+    if (changed) return `${EFFORT} In the file: ${item.display(item.value)}. After the change: ${item.display(v)}.`;
+    if (isDefault)
+      return `${EFFORT} ${v ? `Now: ${v}, for every agent without its own.` : `Now: not set, so ${unsetMeaning}.`}`;
+    if (v) return `${EFFORT} Now: ${v}, its own.`;
+    const d = defaultEffortNow();
+    return `${EFFORT} ${d ? `Now: ${d}, from default.` : `Now: ${item.display(null)}.`}`;
+  };
+  item.options = () =>
+    effortOptions(es, display, item, name, isDefault, levelsNow(), runModel(), defaultEffortNow(), menu);
+  item.caption = () => {
+    const l = levelsNow();
+    if (!l) return null;
+    if (l.from === "catalog")
+      return {
+        text: `levels of ${l.model}${l.source ? ` · ${l.source}` : ""}${l.at ? ` · checked ${checkedWhen(l.at, now())}` : ""}`,
+      };
+    return { text: `${display}'s levels` };
+  };
+  return item;
+}
+
+// An effort row's values: the levels, the value in the file when the list
+// lacks it, then the way back to the default. No free text and no refresh:
+// the levels come with the model list, whose frame refreshes it.
+function effortOptions(es, display, item, name, isDefault, levels, model, d, menu) {
+  const opts = (levels?.levels || []).map((l, i) => ({
+    value: l.id,
+    label: l.id,
+    kind: "value",
+    note: l.id === levels.default ? "default" : "",
+    section: i === 0 ? (levels.from === "catalog" ? `levels of ${model}` : `${display}'s levels`) : undefined,
+    description: [
+      l.description ? (/[.!?]$/.test(l.description) ? l.description : `${l.description}.`) : "",
+      l.id === levels.default ? `${model}'s own default.` : "",
+    ]
+      .filter(Boolean)
+      .join(" "),
+  }));
+  const m = menu?.();
+  for (const v of [item.value, m ? m.eff(item) : null])
+    if (v && !opts.some((o) => o.value === v))
+      opts.push({
+        value: v,
+        label: v,
+        note: "not in the list",
+        kind: "value",
+        section: opts.length ? undefined : "",
+        description: model
+          ? `Not a level ${model} lists. It is kept as it is.`
+          : `Not one of ${display}'s levels. It is kept as it is.`,
+      });
+  const meaning = es.unset.model_default ? "its model's own default level" : "its frontmatter's effort";
+  opts.push(
+    isDefault
+      ? {
+          value: null,
+          label: es.unset.row,
+          kind: "value",
+          section: "",
+          description: `Drops the default effort: each agent without its own runs at ${meaning}.`,
+        }
+      : {
+          value: null,
+          label: "use the default",
+          kind: "value",
+          section: "",
+          description: d
+            ? `Drops ${name}'s own effort: it runs at the default, ${d}.`
+            : `Drops ${name}'s own effort: it runs at ${meaning}.`,
+        },
+  );
+  return opts;
+}
+
 // The values frame's footer: the list's source and age, the host being
 // asked, or why nothing can be asked (the ADR, decisions 3 and 6).
 function caption(cat, now) {
@@ -502,8 +627,10 @@ export async function runMenu(ctx) {
   menu = createMenu({
     groups,
     onRefresh: (it) => it.harness && read(it.harness),
+    // A list is read from a model's frame only: an effort frame shows what is
+    // known, and its levels follow when a model's list is refreshed.
     onOpen: (it) => {
-      const cat = it.harness ? catalogs[it.harness] : null;
+      const cat = it.harness && !it.key?.endsWith(".effort") ? catalogs[it.harness] : null;
       if (cat?.known?.stale) read(it.harness);
     },
   });