geneseed 3.20.0 → 4.1.0

package/js/inspect/checks-authoring.mjs

@@ -25,9 +25,88 @@ import {
 import { constitutionProblems, leanBlockProblems } from './checks-constitution.mjs';
 import { countTableProblems } from './checks-counts.mjs';
 import { catalogProblems } from '../loop/catalog.mjs';
-import { globSorted, isDir } from './scan.mjs';
+import { blankCodeSpans, globSorted, isDir, isFile, rglob } from './scan.mjs';
 import { spawnSync } from 'node:child_process';
 
+// The four harness ids `js/web/docs.mjs`'s `HARNESS_OPEN_RE` accepts, comma-separated, in its
+// own `HARNESSES` constant. Not imported: `js/web/docs.mjs` pulls in the web daemon's CLI
+// reference, status and update modules, and `inspect/` has no existing import from `web/` to
+// extend — paying that weight on every `doctor --all` for one id list is not "cheap" reuse.
+// Inlined instead, so it must be kept in step by hand if `HARNESSES` ever changes.
+const HARNESS_IDS = 'opencode|claude|openclaude|bob';
+
+/**
+ * The comment bodies (trimmed) that are known to be FUNCTIONAL — consumed by the render, a
+ * host emit, or the docs skill — rather than a maintainer's own note, so a bare, un-prefixed
+ * comment matching one of these is left alone. `<!-- note: ... -->` is the escape hatch itself:
+ * `resolveRuleIds` in `js/build/source.mjs` strips it before any render sees it, so it is
+ * already quiet by the time an agent would read it — this just stops the doctor re-flagging it.
+ */
+const ALLOWED_COMMENT_RES = [
+  /^note:[\s\S]*$/,                          // the author-note prefix itself
+  /^LEAN:(begin|else|end)$/,                 // js/build/render.mjs LEAN_BLOCK_RE
+  /^CATALOG:(begin (agents|skills)|else|end)$/, // js/build/render.mjs CATALOG_BLOCK_RE
+  /^INCLUDE:\s*\S+$/,                        // js/build/render.mjs INCLUDE_RE
+  /^invocation:\s*user$/,                    // js/hosts/native.mjs: disable-model-invocation
+  /^aliases:\s*\S.*$/,                       // js/build/source.mjs ALIASES_RE
+  /^webfetch:\s*allow$/,                     // js/hosts/* webfetch gate
+  // js/web/docs.mjs HARNESS_OPEN_RE: `harness:` then one or more of its four ids, comma-separated.
+  new RegExp(`^harness:\\s*(?:${HARNESS_IDS})(?:\\s*,\\s*(?:${HARNESS_IDS}))*$`),
+  /^bash:\s*allow$/,                         // js/hosts/native.mjs BASH_MARKER
+];
+
+/**
+ * Every bare HTML comment under `src` that is neither the `<!-- note: ... -->` author-note
+ * prefix nor a known functional marker — the half of the pair `resolveRuleIds`' strip does not
+ * cover: that function only ever sees a file once it is already being rendered, so a note
+ * someone forgot to prefix would ship verbatim rather than fail loudly. Comments inside a
+ * fenced code block or an inline code span are exempt — a skill explaining the managed-block
+ * syntax (`` `<!-- BEGIN GENESEED -->` ``) to the agent is literal text, not live markup, and
+ * `blankCodeSpans` (shared with `stripAuthorNotes`'s own fence/code-span exemption, so the two
+ * can never disagree about what counts as "shown as an example") is what tells the two apart
+ * without a full Markdown parser.
+ *
+ * A SECOND CHECK, on the SAME `note:` matches, named after the landmine `src/skills/_template.md`
+ * actually hit: a `note:` comment whose prose quotes a literal marker (`` `<!-- x -->` ``, even
+ * inside backticks) closes AT ITS OWN inner `-->`, because HTML comments do not nest — the rest
+ * of the note then leaks as live text. This is checked against the RAW slice of the match, BEFORE
+ * blanking: `blankCodeSpans` is what lets `stripAuthorNotes` run to the real closing `-->` when
+ * the inner one sits inside a fence or a span, but that same blanking would hide the inner
+ * `<!--`/`-->` from a check run on the blanked text — the raw body is the only place the nesting
+ * is still visible. `src = SRC` is a parameter, not a constant read, so a test can point it at a
+ * throwaway tree instead of planting a fault in the real one.
+ */
+export function authorNoteProblems(src = SRC) {
+  const problems = [];
+  for (const p of rglob(src)) {
+    if (!isFile(p) || !p.endsWith('.md')) continue;
+    let raw;
+    try { raw = readText(p); } catch { continue; }
+    const scan = blankCodeSpans(raw);
+    const rel = `src/${path.relative(src, p).split(path.sep).join('/')}`;
+    for (const m of scan.matchAll(/<!--([\s\S]*?)-->/g)) {
+      const body = m[1].trim();
+      const line = scan.slice(0, m.index).split('\n').length;
+      if (/^note:/.test(body)) {
+        const rawInner = raw.slice(m.index + 4, m.index + m[0].length - 3);
+        if (rawInner.includes('<!--') || rawInner.includes('-->')) {
+          problems.push(`[authoring] ${rel}:${line} note: comment contains a nested HTML `
+            + 'comment marker (<!-- or -->) — comments do not nest, so it closes early and '
+            + 'leaks the rest of the note as live text; rephrase the example without the '
+            + 'literal marker (prose instead of a quoted <!-- ... -->)');
+          continue;
+        }
+      }
+      if (ALLOWED_COMMENT_RES.some((re) => re.test(body))) continue;
+      problems.push(`[authoring] ${rel}:${line} has an HTML comment that is neither the `
+        + "'note:' author-note prefix nor a known functional marker (" + JSON.stringify(body) + ') — '
+        + "prefix it with 'note:' if it is maintainer-only, or the doctor's allow-list if the "
+        + 'agent must read it literally');
+    }
+  }
+  return problems;
+}
+
 // Moved to the two sibling modules; re-exported so callers that import the authoring group as
 // one module keep working.
 export {
@@ -115,6 +194,7 @@ export function authoringProblems() {
   problems.push(...constitutionProblems());
   problems.push(...leanBlockProblems());
   problems.push(...countTableProblems());
+  problems.push(...authorNoteProblems());
   return problems;
 }
 

package/js/inspect/checks-constitution.mjs

@@ -169,7 +169,7 @@ const DOCTRINE_TOKEN_RE = /\{\{DOCTRINE(?:\}\}|:)/;
 /**
  * The rules the hooks enforce at the tool boundary, and the address each is bound to there. The
  * hook path cannot afford to read the canon on every tool call, so its gate-ledger keys
- * (`law-1`, `law-4`, `process-1`, `process-5`, `rigor-5` in `js/hosts/hooks.mjs` and the OpenCode guard
+ * (`law-1`, `law-4`, `process-1`, `process-5`, `rigor-5`, `ops-2` in `js/hosts/hooks.mjs` and the OpenCode guard
  * plugin), `CONSENT_RULE` in `js/hosts/settings.mjs` and the console's `HOOK_GATED` stay
  * number-keyed — and this pin is what turns a renumber that moves one of these rules into a
  * doctor failure instead of a gate silently guarding its neighbour.
@@ -177,6 +177,7 @@ const DOCTRINE_TOKEN_RE = /\{\{DOCTRINE(?:\}\}|:)/;
 export const HOOK_PINNED = {
   'sealed-secrets': 'I', 'deletion-is-deliberate': 'IV',
   'persist-insight': 'process 1', 'consent-before-push': 'process 5', 'external-gate': 'rigor 5',
+  'commands-must-return': 'ops 2',
 };
 
 /**

package/js/inspect/checks-repo.mjs

@@ -10,6 +10,8 @@ import path from 'node:path';
 import {
   ALIASES_RE, PLUGIN_SRC, RETIRED_SKILL_IDS, ROOT, SRC, THEMES, WORKFLOW_SRC, aliasesOf, knownSkillIds,
 } from '../build/source.mjs';
+import { CLAUDE_STYLE, liveRecordedHooks } from '../hosts/hosts.mjs';
+import { claudeCfg, installTargets } from '../hosts/installs.mjs';
 import { VENDORED_SKILL_DIRS } from '../hosts/native.mjs';
 import { COMMAND_SET } from '../hosts/opencode.mjs';
 import { hookShimPath, shimDeadPaths } from '../hosts/shim.mjs';
@@ -165,6 +167,44 @@ export function secretProblems() {
   return problems;
 }
 
+/**
+ * Every active Claude-STYLE install (`CLAUDE_STYLE`: claude, bob, openclaude — the hosts that
+ * share this one machine-wide shim) whose LIVE, recorded hooks still name `shimPath` by exact
+ * string, keyed by its own config dir.
+ *
+ * Split out of `shimProblems` for the case `shimDeadPaths` cannot see: that function reads
+ * paths back OUT of the shim body, so it has nothing to read once the shim file is gone
+ * outright (deleted, not moved-and-regenerated) — a plain `isFile` check upstream then calls
+ * that clean, the same as a source checkout that never emitted. `liveRecordedHooks` is already
+ * "the manifest claims it AND the settings file still runs it" (`js/hosts/hosts.mjs`), so a
+ * disabled or never-wired install cannot appear here — only installs for which the missing
+ * shim is a live, standing failure.
+ *
+ * MATCHES THE EXACT PATH, not merely a command that mentions the shim's filename
+ * (`geneseed-hook`): the shim path is baked per `GENESEED_HOME`, so a machine with more than
+ * one Geneseed home (a relocated one, or a sandboxed test run beside a real install) must not
+ * let an install naming a DIFFERENT, perfectly healthy shim answer for this one.
+ *
+ * EXPORTED: `status`'s `gateSummary` (`js/inspect/status.mjs`) needs the same answer to fold
+ * into its `dead` field, the one `statusLines` already renders as a `DEAD` gates row — two
+ * readers of one fact, not two copies of the install walk.
+ *
+ * `targets` is a parameter, the same convention `hookShellProblems` uses, so a test can hand
+ * it a sandboxed `[host, scope, root]` triple instead of walking this machine's real config
+ * dirs and registry — the live default every production caller takes.
+ */
+export function installsReferencingShim(shimPath = hookShimPath(), targets = installTargets()) {
+  const out = [];
+  for (const [host, scope, root] of targets) {
+    if (!CLAUDE_STYLE.includes(host)) continue;
+    const cfg = claudeCfg(root, scope, host);
+    const live = liveRecordedHooks(cfg)
+      .some(([, h]) => typeof h.command === 'string' && h.command.includes(shimPath));
+    if (live) out.push(cfg);
+  }
+  return out;
+}
+
 /**
  * `_harness_build._shim_problems` — the hook shim exists and points at something real.
  *
@@ -176,12 +216,36 @@ export function secretProblems() {
  * every gate silently dead: the hooks still fire, the shim still runs, and the interpreter
  * reports "no such file" into a channel nobody reads.
  *
- * An ABSENT shim is not a problem: a source checkout that has never emitted has no reason to
- * own one.
+ * An ABSENT shim is not ALWAYS a problem: a source checkout that has never emitted has no
+ * reason to own one. But one deleted by hand (or by a cleanup script) out from under an
+ * install that still names it is the same dead-hooks failure as a moved checkout, newly worth
+ * catching now that the two Claude gates fail CLOSED on a dead hook instead of open
+ * (`onFailure: "block"`, Task 1) — a Bash/Write/Edit call blocked with no shim to even try
+ * running is otherwise invisible until the user notices nothing works.
+ * `installsReferencingShim` answers that half; this still returns `[]` when nothing live
+ * names the missing shim.
+ *
+ * NOT CHECKED: whether the runner (`node`) on the emitted command line can still be found.
+ * Every command this repo emits bakes an ABSOLUTE interpreter path at emit time
+ * (`hookRunnerEntry`'s `process.execPath`) — never a bare `node` resolved against the live
+ * PATH — so there is no PATH-lookup fact to check here, and confirming the absolute path
+ * still exists would mean spawning nothing (a plain `existsSync`), which `shimDeadPaths`
+ * already does for every runner path baked into a shim BODY that still exists. There is no
+ * second runner path to check in the "shim file itself is gone" branch below: the only thing
+ * the live install's settings.json names at that point is the shim's own (missing) path.
+ *
+ * `targets` is a parameter (default: the real `installTargets()`) for the same reason
+ * `installsReferencingShim` takes one: a test exercises the "missing but referenced" branch
+ * with a sandboxed install instead of this machine's.
  */
-export function shimProblems() {
+export function shimProblems(targets = installTargets()) {
   const p = hookShimPath();
-  if (!isFile(p)) return [];
+  if (!isFile(p)) {
+    return installsReferencingShim(p, targets).map((cfg) => `[shim] ${p} does not exist, but ${cfg} `
+      + 'still runs its hooks through it — every hook in that install is dead, and (since '
+      + "Task 1) Claude's git-gate/rule-gate now BLOCK instead of silently passing. Run: "
+      + 'geneseed rebuild-all');
+  }
   let body;
   try { body = readText(p); } catch (e) {
     return [`[shim] ${p} exists but cannot be read (${e.message}) — hooks may be dead`];

package/js/inspect/doctor.mjs

@@ -32,8 +32,10 @@
 import path from 'node:path';
 import { emitGlobalInto, emitProjectInto, main as driverMain } from '../build/driver.mjs';
 import { ROOT } from '../build/source.mjs';
-import { CLAUDE_STYLE, resolvePath } from '../hosts/hosts.mjs';
-import { installedDefaults, themeFiles } from '../hosts/installs.mjs';
+import { CLAUDE_STYLE, opencodeShadowedInstall, resolvePath } from '../hosts/hosts.mjs';
+import {
+  hookShellProblems, installedDefaults, openclaudeDualHarnessRoots, themeFiles,
+} from '../hosts/installs.mjs';
 import { validateIsVendored } from '../hosts/native.mjs';
 import { printOut } from '../lib/fs.mjs';
 import { authoringProblems, loopProblems } from './checks-authoring.mjs';
@@ -41,7 +43,7 @@ import {
   checkBuild, colorThemeProblems, renderedProblems, themeParityProblems,
 } from './checks-build.mjs';
 import { moduleMapProblems, scorecardProblems, shimProblems } from './checks-repo.mjs';
-import { isDoctorNote, sortedProblems, sortedUnique, stemOf, withTempDir } from './scan.mjs';
+import { NOTE, isDoctorNote, sortedProblems, sortedUnique, stemOf, withTempDir } from './scan.mjs';
 
 /**
  * `_harness_build._themes_to_check` — which themes doctor validates.
@@ -58,6 +60,18 @@ export function themesToCheck(theme, allThemes, detected, available) {
   return [...available].sort();
 }
 
+/**
+ * Host-compat I1: one `[note]`-prefixed line per root `openclaudeDualHarnessRoots` finds —
+ * extracted to its own function (rather than inlined in `doctorCollect`) so a test can pin the
+ * exact text without running a full doctor sweep.
+ */
+export function openclaudeDualHarnessNotes() {
+  return openclaudeDualHarnessRoots().map((root) => `${NOTE}[openclaude] ${root} also carries `
+    + 'a claude/bob per-repo install — OpenClaude loads its own .openclaude/CLAUDE.md AND that '
+    + 'root CLAUDE.md/AGENTS.md (every always-on doc doubles) — uninstall the one you no '
+    + 'longer use if this was not intended');
+}
+
 /**
  * `swallowStdout` and `captureBoth` below are the same operation over a different stream
  * list: replace each stream's `write` with a no-op for the duration of `fn`, then restore
@@ -219,6 +233,21 @@ export function doctorCollect({
   problems = problems.concat(ran('authoring', 'Authoring gates', authoringProblems()));
   problems = problems.concat(ran('loops', 'Loop catalogue', loopProblems()));
   problems = problems.concat(ran('shim', 'Hook shim', shimProbs));
+  // Windows: a Claude install's hooks emitted for Git Bash on a machine that no longer has it
+  // misbehave under PowerShell (Task 15) — context/learn fail open, and since Task 1 the two
+  // gates fail CLOSED instead (`onFailure: "block"`). The reverse direction is a note.
+  problems = problems.concat(ran('hook_shell', 'Hook shell', hookShellProblems()));
+  // A machine check like the shim's: OPENCODE_CONFIG_DIR adds a dir, it does not replace one.
+  const shadow = opencodeShadowedInstall();
+  problems = problems.concat(ran('opencode_dirs', 'OpenCode config dirs', shadow
+    ? [`[opencode] ${shadow} holds a Geneseed install beside $OPENCODE_CONFIG_DIR's, and OpenCode `
+      + 'loads both (every plugin runs twice) — uninstall the one you no longer use'] : []));
+  // Host-compat I1: OpenClaude's project carrier is additive, not exclusive — there is no
+  // clean exclusion, so unlike `opencode_dirs` above (an accident of an env var) this is a
+  // NOTE, not a problem: a repo that deliberately runs claude/bob AND openclaude is a legal
+  // configuration its owner chose, and doctor must not fail a legal configuration.
+  problems = problems.concat(ran('openclaude_dual', 'OpenClaude dual harness',
+    openclaudeDualHarnessNotes()));
   problems = problems.concat(ran('map', 'Module map', moduleMapProblems()));
   problems = problems.concat(ran('scorecard', 'Scorecard floor', scorecardProblems()));
   // P10c's `cli` check is GONE, and the reason is not that it stopped mattering. It hashed
@@ -259,12 +288,14 @@ export function cmdDoctor(args) {
     printOut(`${collected.length ? collected[0] : '[doctor] no themes found'}\n`);
     return 1;
   }
-  // ⚠ NOTES ARE PRINTED AND NOT COUNTED. The only producer is the pack-off citation report in
-  // `constitutionProblems`, and the state it describes is one the install's owner chose: a
-  // build that leaves body prose citing a pack it did not render. Silence there is how prose
-  // and boundary drift apart, and a non-zero exit there is doctor failing a legal
-  // configuration. Nothing in the recorded CLI corpus produces one — the checkout's own
-  // `harness.config.json` names no packs — so the byte-compared output is unmoved.
+  // ⚠ NOTES ARE PRINTED AND NOT COUNTED. Two producers: the pack-off citation report in
+  // `constitutionProblems` (a build that leaves body prose citing a pack it did not render),
+  // and `openclaudeDualHarnessRoots` above (a repo deliberately running claude/bob AND
+  // openclaude). Both describe a state the install's owner chose — silence is how prose and
+  // boundary drift apart unnoticed, or how a dual-harness repo stays a surprise, but a
+  // non-zero exit for either would be doctor failing a legal configuration. Nothing in the
+  // recorded CLI corpus produces either — the checkout's own `harness.config.json` names no
+  // packs, and it carries no dual-harness install — so the byte-compared output is unmoved.
   const notes = collected.filter(isDoctorNote);
   const problems = collected.filter((p) => !isDoctorNote(p));
   const scoped = !args.theme && !args.all && themes.length === 1;

package/js/inspect/scan.mjs

@@ -14,12 +14,15 @@ import { SRC } from '../build/source.mjs';
 import { comparePaths, within } from '../lib/paths.mjs';
 import { isDir, isFile } from '../lib/fs.mjs';
 import { has } from '../lib/json.mjs';
+import { FENCE_RE, INLINE_CODE_RE, blankCodeSpans } from '../lib/text.mjs';
 import { mkdtempSync, readdirSync, rmSync } from 'node:fs';
 
 // `isDir`/`isFile`/`has` are owned by `js/lib` now (single owner across `hosts/`, `build/`,
 // `inspect/` and `web/`) — re-exported here so this module's own existing callers keep
-// importing them from `./scan.mjs` unchanged.
-export { isDir, isFile, has };
+// importing them from `./scan.mjs` unchanged. `blankCodeSpans` is `js/lib/text.mjs`'s too, for
+// the same reason: `js/build/source.mjs`'s `stripAuthorNotes` needs the identical fence/code-span
+// answer and cannot import this module (it would cycle back through `../build/source.mjs` above).
+export { isDir, isFile, has, blankCodeSpans };
 
 // --------------------------------------------------------------------------------------
 // _harness_core's scanning primitives
@@ -32,8 +35,6 @@ export { isDir, isFile, has };
 export const TOKEN_RE = /\{\{[A-Z_][A-Z0-9_]*\}\}/g;
 export const LINK_RE = /\]\((?!https?:\/\/|#)([^)]+)\)/g;
 export const ABS_LINK_RE = /^([A-Za-z]:[\\/]|\/|~)/;
-const FENCE_RE = /```[\s\S]*?```/g;
-const INLINE_CODE_RE = /`[^`]*`/g;
 const COMMENT_RE = /<!--[\s\S]*?-->/g;
 
 /** `_harness_core.strip_code` — fenced blocks, then HTML comments, then inline code, in that order. */

package/js/inspect/status.mjs

@@ -62,17 +62,19 @@ import { THEMES, ROOT, makeCfg } from '../build/source.mjs';
 import { tuiInventory } from './inventory.mjs';
 import { readVersion, sourceFingerprint } from '../build/version.mjs';
 import {
-  claudeConfigDir, bobConfigDir, openclaudeConfigDir, opencodeConfigDir,
-  resolvePath, resolveMemoryDir, sovereignBypass, GATE_LEDGER,
+  claudeConfigDir, bobConfigDir, openclaudeConfigDir, opencodeConfigDir, opencodeShadowedInstall,
+  isHostGlobalDir, resolvePath, resolveMemoryDir, sovereignBypass, CLAUDE_STYLE, GATE_LEDGER,
 } from '../hosts/hosts.mjs';
 // P5f moved the install DETECTORS out of this file — `diff` renders its expected copy in the
 // deployed theme and footprint, and `rebuild-all` re-emits in the deployed everything, so
 // three verbs now read them.
 import {
-  defaultTheme, installedDefaults, installTargets, readJsonMaybe, readMaybe,
+  defaultTheme, hookShellProblems, installedDefaults, installTargets, legacyProcessCarrierOfDir,
+  openclaudeDualHarnessRoots, readJsonMaybe, readMaybe,
 } from '../hosts/installs.mjs';
 import { installProfile, rebuildCommand } from '../build/generate.mjs';
-import { shimDead } from '../hosts/shim.mjs';
+import { installsReferencingShim } from './checks-repo.mjs';
+import { hookShimPath, shimDead } from '../hosts/shim.mjs';
 import { printOut } from '../lib/fs.mjs';
 import { codePointLength, padEndToWidth } from '../lib/text.mjs';
 
@@ -185,7 +187,7 @@ export function accentFor(theme) {
  * do anything, and the input to the decision of whether to build more of them. Unreadable
  * ledgers and malformed lines are skipped, not reported: this is a display read.
  */
-export function gateSummary(cfgDirs) {
+export function gateSummary(cfgDirs, platform = process.platform) {
   const standingDown = [];
   const asks = {};
   let total = 0;
@@ -207,8 +209,31 @@ export function gateSummary(cfgDirs) {
     }
   }
   // `dead` is the machine shim's missing targets: every gate below is armed on paper and never
-  // runs, so it outranks `armed` in the row.
-  return { standing_down: standingDown, asks, total, dead: shimDead() };
+  // runs, so it outranks `armed` in the row. A shim that exists but names a moved checkout
+  // (`shimDead`) and a shim that is simply GONE while a live install still names it
+  // (`installsReferencingShim`, Task 1's fix round — `onFailure: "block"` makes a dead gate
+  // block instead of silently passing, so this stopped being a quiet failure) are the same
+  // row here: both mean "every hook of every install naming this shim cannot run".
+  // `fail_open` (Task 15): Claude installs whose bash-form hooks now run under PowerShell. Only
+  // present when non-empty, so every recorded `--json` panel keeps its shape.
+  // Only the dirs it was handed, and only those that are Claude's global (`isHostGlobalDir`);
+  // `platform` is injectable so a test on Linux still exercises the win32 branch.
+  const isClaude = (c) => { try { return isHostGlobalDir('claude', c); } catch { return false; } };
+  const claude = cfgDirs.filter(isClaude).map((c) => ['claude', 'global', c]);
+  const failOpen = hookShellProblems(claude, platform).filter((p) => !p.startsWith('[note] '));
+  // Same `cfgDirs`, widened to every Claude-STYLE host (`CLAUDE_STYLE`: claude, bob,
+  // openclaude — all three share this one machine-wide shim), for `installsReferencingShim`.
+  const styleTargets = cfgDirs.flatMap((c) => CLAUDE_STYLE
+    .filter((host) => { try { return isHostGlobalDir(host, c); } catch { return false; } })
+    .map((host) => [host, 'global', c]));
+  const shimPath = hookShimPath();
+  const dead = shimDead();
+  const missing = !dead.length && !existsSync(shimPath)
+    && installsReferencingShim(shimPath, styleTargets).length ? [shimPath] : dead;
+  return {
+    standing_down: standingDown, asks, total, dead: missing,
+    ...(failOpen.length ? { fail_open: failOpen } : {}),
+  };
 }
 
 /** `_harness_status._status_data`. */
@@ -263,16 +288,25 @@ export function statusData() {
     agent_md: agentMd ? String(agentMd) : null,
     agent_md_present: Boolean(agentMd && existsSync(agentMd)),
     gates: gateSummary([...(cfgDir ? [cfgDir] : []), ...otherCfg]),
+    opencode_shadow: opencodeShadowedInstall(),
+    openclaude_dual_harness: openclaudeDualHarnessRoots(),
     // EVERY install, not just the one `installedDefaults` settles on — and read through the
     // same `installProfile` `rebuild-all` uses, so the settings shown are the ones a rebuild
-    // keeps. `rebuild` is the pasteable command an agent edits one flag of. A broken install
-    // must not sink the panel, so it is reported rather than thrown. `absent` slots are
-    // filtered out here: an absent slot has no settings, so a row of defaults for it reads as
-    // an install that does not exist — noise in the panel and misinformation in `--json`.
+    // keeps. `rebuild` is the pasteable command an agent edits one flag of — EXCEPT for a
+    // pre-comms carrier, where `p.argv` already carries the under-specified read-back
+    // (`doctrinesOfDir`/`excludedRulesOfDir` no longer migrate it) and pasting it would cause
+    // the exact permanent loss `rebuild-all`/`migrate`/the web console now refuse to cause, with
+    // no guard left to stop an agent or owner from running it by hand. A broken install must not
+    // sink the panel, so it is reported rather than thrown. `absent` slots are filtered out
+    // here: an absent slot has no settings, so a row of defaults for it reads as an install that
+    // does not exist — noise in the panel and misinformation in `--json`.
     installs: installTargets().map(([host, scope, root]) => {
       try {
         const p = installProfile(host, scope, root);
-        return { ...p, rebuild: rebuildCommand(p.argv) };
+        const rebuild = legacyProcessCarrierOfDir(root, host)
+          ? "geneseed setup  # pre-comms carrier (names 'process 8') — run setup for this install, not a rebuild"
+          : rebuildCommand(p.argv);
+        return { ...p, rebuild };
       } catch (e) {
         return { host, scope, root, state: 'unreadable', error: String(e?.message ?? e) };
       }
@@ -352,6 +386,9 @@ export function statusLines(d, color = false) {
     const g = d.gates;
     const armed = g.dead?.length
       ? `DEAD — hook shim points at ${g.dead.join(', ')}; run: geneseed rebuild-all`
+      : g.fail_open?.length
+      ? `FAIL OPEN — ${g.fail_open.length} Claude install(s) emitted for Git Bash, now absent; `
+        + 'run: geneseed rebuild-all'
       : g.standing_down.length
       ? `STANDING DOWN for this cwd (excludes.json in ${g.standing_down.join(', ')})`
       : 'armed';
@@ -360,6 +397,19 @@ export function statusLines(d, color = false) {
     rows.push(['gates', `${armed}  ${DOT}  ${g.total} ask${g.total === 1 ? '' : 's'}`
       + (byRule ? ` (${byRule})` : '')]);
   }
+  // Conditional: null on every machine that has not set `OPENCODE_CONFIG_DIR` over an old install.
+  if (d.opencode_shadow) {
+    rows.push(['opencode', `ALSO LOADED: a second Geneseed install in ${d.opencode_shadow} (OpenCode `
+      + 'reads it beside OPENCODE_CONFIG_DIR, so every plugin runs twice) - uninstall one']);
+  }
+  // Conditional: empty on every machine without a claude/bob AND openclaude project install
+  // sharing one repo. There is no clean exclusion (see `openclaudeDualHarnessRoot`), so this
+  // only names the roots where it is happening.
+  for (const root of d.openclaude_dual_harness ?? []) {
+    rows.push(['openclaude', `ALSO LOADED: ${root} also carries a claude/bob per-repo install — `
+      + 'OpenClaude reads its own .openclaude/CLAUDE.md AND that root CLAUDE.md/AGENTS.md '
+      + '(every always-on doc doubles) - no clean exclusion, uninstall one']);
+  }
   // Conditional for the recording reason again: no recorded panel carries `installs`.
   for (const p of d.installs ?? []) {
     const where = p.scope === 'project' ? `  (${p.root})` : '';

package/js/lib/text.mjs

@@ -193,3 +193,26 @@ export function percentDecode(s) {
 export function relPosix(base, target) {
   return path.relative(base, target).split(path.sep).join('/');
 }
+
+/**
+ * Markdown's two ways to show syntax as a literal example rather than live markup: a fenced
+ * block (```` ``` ````) and an inline span (`` ` ``). Shared here, not duplicated in
+ * `js/inspect/scan.mjs` and `js/build/source.mjs`, because both need the SAME answer to "is this
+ * text code" and a second regex drifting from the first would silently stop agreeing on it.
+ */
+export const FENCE_RE = /```[\s\S]*?```/g;
+export const INLINE_CODE_RE = /`[^`]*`/g;
+
+/**
+ * Fenced and inline code, blanked to same-length whitespace with every newline kept — so a scan
+ * for a BARE `<!-- ... -->` (one a reader actually sees as live markup) never trips on one that
+ * is only a literal example inside a fence or a code span, while every match's INDEX still lands
+ * on the right source offset in the ORIGINAL text. Two callers: `checks-authoring.mjs`'s
+ * `authorNoteProblems` (which needs comments that survive, unlike `js/inspect/scan.mjs`'s
+ * `stripCode`, which drops them) and `js/build/source.mjs`'s `stripAuthorNotes` (which needs a
+ * `note:` comment show ONLY as a literal example left un-stripped).
+ */
+export function blankCodeSpans(text) {
+  const blank = (s) => s.replace(/[^\n]/g, ' ');
+  return text.replace(FENCE_RE, blank).replace(INLINE_CODE_RE, blank);
+}

package/js/loop/catalog.mjs

@@ -20,7 +20,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { readText, isFile, isDir } from '../lib/fs.mjs';
 import { frontmatter } from '../hosts/memory-files.mjs';
-import { SRC } from '../build/source.mjs';
+import { SRC, stripAuthorNotes } from '../build/source.mjs';
 import { checkGraph } from './graph.mjs';
 
 export function userLoopsDir() {
@@ -31,7 +31,12 @@ export function userLoopsDir() {
 const KEBAB = /^[a-z0-9][a-z0-9-]*$/;
 
 export function parseBrick(text, origin) {
-  const [fm, body] = frontmatter(text);
+  // A brick's body never goes through `renderFile` — the module header above is explicit that
+  // the loop CLI hands it to the model raw — so this is the one place that can strip a `note:`
+  // comment before it reaches the prompt, through the same `stripAuthorNotes` every other
+  // reader of `src/` text goes through (`js/build/source.mjs`).
+  const [fm, rawBody] = frontmatter(text);
+  const body = stripAuthorNotes(rawBody);
   const get = (k) => (fm.get(k) ?? '').trim();
   const name = get('name');
   const problems = [];

package/js/maintain/migrate.mjs

@@ -38,8 +38,12 @@ import path from 'node:path';
 import { main as driverMain } from '../build/driver.mjs';
 import { ROOT } from '../build/source.mjs';
 import { CLAUDE_STYLE } from '../hosts/hosts.mjs';
-import { EMIT_HOST_SCOPE, installState, installTargets, readMaybe } from '../hosts/installs.mjs';
+import {
+  claudeCfg, claudeReadManifest, EMIT_HOST_SCOPE, installState, installTargets,
+  legacyProcessCarrierOfDir, readMaybe,
+} from '../hosts/installs.mjs';
 import { installProfile } from '../build/generate.mjs';
+import { settingsFile } from './uninstall.mjs';
 import {
   autostartPaths, autostartStale, hookShimPath, migrateShape, shimHome,
 } from '../hosts/shim.mjs';
@@ -57,11 +61,23 @@ const KNOWN_EMITS = new Set(EMIT_HOST_SCOPE.keys());
  * shim nor `harness.py`), so it classifies as `none` and its whole migration is the re-emit —
  * the same re-emit, in the same change, on every host, which is what the project's
  * host-parity rule asks for.
+ *
+ * BOTH HALVES READ BACK AN EXISTING RESOLVER rather than a second hand-rolled copy
+ * (host-compat B1/B2): `claudeCfg` (`js/hosts/installs.mjs`) is the cfg dir — `root` itself
+ * for a global install, `<root>/<projectMarker>` (`.claude`/`.bob`/`.openclaude`) for a
+ * project one — and `settingsFile` (`js/maintain/uninstall.mjs`) is the file name inside it,
+ * read off the install's OWN manifest. The manifest is the authority, not a guess at the
+ * canonical name: a pre-existing `bob-global` install with no `managed.settings_file` yet
+ * recorded carries the bare, pre-nesting `settings.json` it was actually written with, not
+ * the nested `settings/settings.json` a brand new one gets — exactly the distinction
+ * `claudeWire`'s own `get(old, 'settings_file') || 'settings.json'` makes before rewiring. A
+ * literal `path.join(root, name)` here, as before, skipped the project subfolder entirely and
+ * guessed the canonical name instead of reading what the install actually has.
  */
-function hookSettingsFile(root, host, scope) {
+export function hookSettingsFile(root, host, scope) {
   if (!CLAUDE_STYLE.includes(host)) return null;
-  const name = scope === 'project' && host !== 'bob' ? 'settings.local.json' : 'settings.json';
-  return path.join(root, name);
+  const cfg = claudeCfg(root, scope, host);
+  return settingsFile(cfg, claudeReadManifest(cfg).managed);
 }
 
 /** Every hook command string in a settings file, or [] when it cannot be read or parsed. */
@@ -212,8 +228,23 @@ export function cmdMigrate(args = {}) {
   // passed the excluded rules as `null` (re-admitting every rule an owner switched off,
   // `process 5` among them) and dropped `--config-dir`, so a global found through
   // `CLAUDE_CONFIG_DIR`/`OPENCODE_CONFIG_DIR` re-emitted into the DEFAULT dir instead.
+  //
+  // A LEGACY CARRIER IS SKIPPED, NOT ROLLED BACK — the one exception to Step 4's ALL OR
+  // NOTHING, same reasoning as `rebuild-all` (`js/build/generate.mjs`): `installProfile` would
+  // read a pre-comms carrier exactly as written now (`comms` missing, `process 7`/`process 8`
+  // unaddressed) and `driverMain` would write that back PERMANENTLY — the fresh carrier carries
+  // no `process 8` text, so nothing could ever catch it again. Rolling back everything else on
+  // the machine over an install that merely needs `geneseed setup` would be a worse outcome
+  // than leaving it as it was found.
+  const skipped = [];
   for (const r of rows) {
     const label = `${r.host}:${r.scope} (${r.root})`;
+    if (legacyProcessCarrierOfDir(r.root, r.host)) {
+      skipped.push(label);
+      printOut(`[migrate] SKIPPED ${label}: pre-comms carrier (names 'process 8') — `
+        + 'run `geneseed setup` for it.\n');
+      continue;
+    }
     const { emit, theme, argv } = installProfile(r.host, r.scope, r.root,
       (n) => printErr(`[migrate] ${label}: ${n}\n`));
     printOut(`[migrate] re-emitting ${label}: theme=${theme} emit=${emit}\n`);
@@ -235,7 +266,13 @@ export function cmdMigrate(args = {}) {
     writeText(stampPath(), `${ROOT}\n`);
   } catch { /* an unwritable stamp costs a redundant re-emit next run, never correctness */ }
 
-  printOut(`[migrate] migrated ${rows.length} install(s).\n`);
+  const migrated = rows.length - skipped.length;
+  if (skipped.length) {
+    printOut(`[migrate] migrated ${migrated} install(s), skipped ${skipped.length}: `
+      + `${skipped.join(', ')}.\n`);
+  } else {
+    printOut(`[migrate] migrated ${rows.length} install(s).\n`);
+  }
 
   // Step 5 — what could NOT be fixed automatically. Reported, never rewritten: nothing in
   // this repository has ever written an autostart entry, so migrate does not own the file.