@limina-labs/momentum 0.41.1 → 0.42.0

package/bin/ecosystem.js

@@ -1834,16 +1834,11 @@ function resolveEcosystemRoot(explicitPath, subcommand) {
     }
     return abs;
   }
-  // First try parent walk-up — succeeds when CWD is inside the ecosystem root.
+  // ONE resolver (ADR-0018 R3): findRoot does up-walk -> sibling scan ->
+  // registration fallback. The local sibling+registration fallback that used to
+  // live here is gone; it existed only because findRoot walked up only.
   const found = lib.findRoot(process.cwd());
   if (found) return found;
-  // Then try sibling walk — succeeds when CWD is inside a member repo
-  // whose ecosystem root is a sibling directory. This mirrors the
-  // session-append.sh hook's discovery pattern and is what makes
-  // ENH-021 actually feel location-agnostic from inside a member repo.
-  const stateLib = require('../core/ecosystem/lib/state');
-  const reg = stateLib.findRegistration(process.cwd());
-  if (reg) return reg.rootPath;
   throw new Error(
     `${subcommand}: no ecosystem.json found in this or any parent directory, ` +
       `nor in any reachable sibling. Pass --ecosystem <path>, or cd to an ` +

package/bin/momentum.js

@@ -1226,14 +1226,21 @@ function init(targetDir, agent, opts = {}) {
     if (!_dryRun) fs.chmodSync(sessionDest, 0o755);
   }
 
-  // Phase 31b — fleet-orient helper, read by sessionstart-handoff.sh for its
-  // Fleet banner line. Shipped here for the same reason session-append.sh is:
-  // an installed project receives no copy of momentum's core/, so the script
-  // must travel with the hooks that use it. Dependency-free by construction.
+  // Phase 31c (ADR-0018 R1) — the shipped runtime. Hooks and scripts require
+  // REAL core modules from `.momentum/runtime/` instead of carrying hand-written
+  // mirrors of them, which is what produced BUG-029 and BUG-030. Verbatim
+  // copies, computed from the entry points' actual require graph.
+  console.log('→ Installing shipped runtime (.momentum/runtime/)...');
+  const runtimeFiles = require('../core/runtime/closure').install(target, { dryRun: _dryRun });
+  console.log(`  ${runtimeFiles.length} runtime module(s)`);
+
+  // TRANSITIONAL (31c G1→G3): `sessionstart-handoff.sh` and `cross-repo.js`
+  // still resolve `scripts/orient.js`. G1 is deliberately ADDITIVE — the runtime
+  // arrives before its consumers are rewired — so this copy stays until G2/G3
+  // point them at the runtime, then it is deleted.
   const orientSrc = path.join(src, 'core', 'ecosystem', 'lib', 'orient.js');
   if (fs.existsSync(orientSrc)) {
-    const orientDest = path.join(target, ...dests.scripts, 'orient.js');
-    copyFile(orientSrc, orientDest);
+    copyFile(orientSrc, path.join(target, ...dests.scripts, 'orient.js'));
   }
 
   // .githooks/ — git-lifecycle enforcement hooks (Phase 19)
@@ -1367,7 +1374,10 @@ function upgrade(targetDir, agent, opts = {}) {
     const sessionUpgradeDest = path.join(target, ...dests.scripts, 'session-append.sh');
     copyFile(sessionUpgradeSrc, sessionUpgradeDest);
   }
-  // Phase 31b — fleet-orient helper (see the install path for why it ships).
+  // Phase 31c (ADR-0018 R1) — refresh the shipped runtime so hooks always run
+  // the same core code as the installed momentum version.
+  require('../core/runtime/closure').install(target, { dryRun: _dryRun });
+  // TRANSITIONAL (31c G1→G3) — see the install path.
   const orientUpgradeSrc = path.join(src, 'core', 'ecosystem', 'lib', 'orient.js');
   if (fs.existsSync(orientUpgradeSrc)) {
     copyFile(orientUpgradeSrc, path.join(target, ...dests.scripts, 'orient.js'));

package/bin/swarm.js

@@ -81,10 +81,9 @@ function resolveEcosystemRoot(explicit) {
   if (explicit && fs.existsSync(path.join(explicit, 'ecosystem.json'))) {
     return path.resolve(explicit);
   }
+  // ONE resolver (ADR-0018 R3) — findRoot covers sibling + registration itself.
   const fromCwd = ecosystemLib.findRoot(process.cwd());
   if (fromCwd) return fromCwd;
-  const reg = findRegistration(process.cwd());
-  if (reg && reg.rootPath) return reg.rootPath;
   throw new Error(
     'swarm: cannot locate ecosystem root. Run from inside an ecosystem ' +
     'or pass --ecosystem <path>.'

package/core/ecosystem/lib/cross-repo.js

@@ -28,22 +28,36 @@ const fs = require('fs');
 const path = require('path');
 
 const EVENTS_VIEW = 'eco-events';
-const DEFAULT_WINDOW_HOURS = 24;
 
-/** Lazily locate orient.js wherever this file happens to be installed. */
-function loadOrient() {
-  const here = __dirname;
-  const candidates = [
-    path.join(here, 'orient.js'),                        // co-installed
-    path.join(here, '..', 'scripts', 'orient.js'),       // .githooks/ → scripts/
-    path.join(here, 'orient.js'),
-    path.join(here, '..', 'ecosystem', 'lib', 'orient.js'),
-    path.join(here, '..', '..', 'ecosystem', 'lib', 'orient.js'),
-  ];
-  for (const c of candidates) {
-    try {
-      if (fs.existsSync(c)) return require(c);
-    } catch (_e) { /* try next */ }
+/**
+ * Resolve a core module (ADR-0018 R2).
+ *
+ * ONE depth-independent rule rather than a per-location candidate list: walk up
+ * from this file looking for `.momentum/runtime/`, then for a `core/` that
+ * contains the module. This file executes from two different depths — as
+ * momentum's own `core/ecosystem/lib/cross-repo.js` and as the installed
+ * `.githooks/cross-repo.js` — and a fixed relative path cannot serve both.
+ *
+ * The five-entry hardcoded lookup this file used to carry (for `orient.js`) is
+ * exactly what R2 objects to: it encoded assumptions about layout per call site
+ * and broke silently when either layout moved. A bounded upward search has one
+ * rule and one failure mode.
+ */
+function resolveModule(rel) {
+  let dir = __dirname;
+  for (let i = 0; i < 8; i++) {
+    for (const base of [path.join(dir, '.momentum', 'runtime'), path.join(dir, 'core')]) {
+      const cand = path.join(base, rel);
+      try {
+        if (fs.existsSync(cand)) {
+          // eslint-disable-next-line global-require
+          return require(cand);
+        }
+      } catch (_e) { /* keep searching */ }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
   return null;
 }
@@ -56,90 +70,28 @@ function readJson(file) {
   }
 }
 
-/** Members with recorded events inside the window (mirrors detect.touchedMembers). */
-function touchedMembers(ecosystemRoot, opts) {
-  opts = opts || {};
-  const manifest = opts.manifest || readJson(path.join(ecosystemRoot, 'ecosystem.json'));
-  const cfgHours = manifest && manifest.config && manifest.config.detect_window_hours;
-  const hours = opts.hours
-    || (typeof cfgHours === 'number' && cfgHours > 0 ? cfgHours : DEFAULT_WINDOW_HOURS);
-  const now = opts.now ? new Date(opts.now).getTime() : Date.now();
-  const cutoff = now - hours * 3600 * 1000;
-
-  const seen = new Set(Array.isArray(opts.extra) ? opts.extra.filter(Boolean) : []);
-  const dir = path.join(ecosystemRoot, '.momentum', 'team', EVENTS_VIEW);
-  let names = [];
-  try { names = fs.readdirSync(dir); } catch (_e) { names = []; }
-
-  for (const n of names) {
-    if (!n.endsWith('.json')) continue;
-    const frag = readJson(path.join(dir, n));
-    if (!frag || !frag.payload || !frag.payload.member) continue;
-    if (opts.actor && frag.actor !== opts.actor) continue;
-    const ts = new Date(frag.ts).getTime();
-    if (!Number.isFinite(ts) || ts < cutoff) continue;
-    seen.add(frag.payload.member);
-  }
-  return [...seen].sort();
-}
+/** Back-compat alias — `sibling` was the 31b-era name. */
+const sibling = resolveModule;
 
-/** Member sets of every in-progress initiative (mirrors detect.openInitiatives). */
-function openInitiativeMembers(ecosystemRoot) {
-  const dir = path.join(ecosystemRoot, 'initiatives');
-  let names = [];
-  try { names = fs.readdirSync(dir); } catch (_e) { return []; }
-
-  const out = [];
-  for (const name of names.sort()) {
-    if (!/^\d{4}-.*\.md$/.test(name)) continue;
-    let body = '';
-    try { body = fs.readFileSync(path.join(dir, name), 'utf8'); } catch (_e) { continue; }
-    if (!body.startsWith('---')) continue;
-    const end = body.indexOf('\n---', 3);
-    if (end === -1) continue;
-    const fm = body.slice(3, end);
-
-    if (!/^status:\s*in-progress\s*$/m.test(fm)) continue;
-    const slug = (fm.match(/^slug:\s*"?([a-z][a-z0-9-]*)"?\s*$/m) || [])[1];
-    if (!slug) continue;
-
-    const members = new Set();
-    const repos = (fm.match(/^repos:\s*\[([^\]]*)\]/m) || [])[1];
-    if (repos) {
-      for (const r of repos.split(',')) {
-        const v = r.trim().replace(/^["']|["']$/g, '');
-        if (v) members.add(v);
-      }
-    }
-    const contrib = (fm.match(/^contributions:\s*\[([^\]]*)\]/m) || [])[1];
-    if (contrib) {
-      for (const c of contrib.split(',')) {
-        const v = c.trim().replace(/^["']|["']$/g, '');
-        const m = v.split(':')[0];
-        if (m) members.add(m);
-      }
-    }
-    out.push({ slug, members });
-  }
-  return out;
+function loadOrient() {
+  return sibling('ecosystem/lib/orient.js');
 }
 
 /**
- * The routing question. Returns
- * `{ crossRepo, covered, shouldRoute, members, initiative }`.
+ * The routing question — delegated to `core/ecosystem/lib/detect`, the authority
+ * (Phase 31c G2, ADR-0018 R1).
+ *
+ * This file used to MIRROR detect.js: its own event-stream scan, its own
+ * initiative frontmatter parser, its own coverage rule. The mirror existed only
+ * because an installed project had no `core/`; the vendored runtime removes that
+ * reason, so the mirror is gone and with it the parity fence that guarded it
+ * (R7). Returns detect's shape unchanged.
  */
 function detect(ecosystemRoot, opts) {
-  const members = touchedMembers(ecosystemRoot, opts);
-  const crossRepo = members.length >= 2;
-  if (!crossRepo) {
-    return { crossRepo: false, covered: false, shouldRoute: false, members, initiative: null };
-  }
-  for (const init of openInitiativeMembers(ecosystemRoot)) {
-    if (members.every((m) => init.members.has(m))) {
-      return { crossRepo: true, covered: true, shouldRoute: false, members, initiative: init.slug };
-    }
-  }
-  return { crossRepo: true, covered: false, shouldRoute: true, members, initiative: null };
+  const authority = sibling('ecosystem/lib/detect.js');
+  if (authority) return authority.detect(ecosystemRoot, opts);
+  // Fail-open: no runtime → nothing to route. A hook must never throw.
+  return { crossRepo: false, covered: false, shouldRoute: false, members: [], initiative: null };
 }
 
 /**
@@ -170,12 +122,15 @@ function routingMessage(ecosystemRoot, result, focus) {
   return lines;
 }
 
+// `touchedMembers` / `openInitiativeMembers` / `DEFAULT_WINDOW_HOURS` are gone:
+// they were the mirror's internals, and the mirror is deleted (ADR-0018 R1).
+// Callers wanting them should use `core/ecosystem/lib/detect` directly — there
+// is one implementation now, and this file is an ENTRY POINT over it.
 module.exports = {
   EVENTS_VIEW,
-  DEFAULT_WINDOW_HOURS,
+  resolveModule,
+  sibling,
   loadOrient,
-  touchedMembers,
-  openInitiativeMembers,
   detect,
   routingMessage,
 };

package/core/ecosystem/lib/events.js

@@ -96,47 +96,18 @@ function resolveMemberRepoRoot(cwd) {
 }
 
 /**
- * Locate the ecosystem root from a member repo — up-walk AND sibling scan.
+ * Locate the ecosystem root from a member repo.
  *
- * `lib.findRoot` walks UP ONLY, but `core/ecosystem/layout.md` documents the
- * ecosystem root as a SIBLING of its member repos, which is what `ecosystem
- * init` + `ecosystem add ../<repo>` actually produce. Every other discovery
- * path in momentum already scans siblings — `session-append.sh`,
- * `sessionstart-handoff.sh`, `core/git-hooks/eco-event.js`, and
- * `bin/ecosystem.js`'s own resolver. `findRoot` is the outlier.
+ * Phase 31b added a local sibling-scanning resolver here because `lib.findRoot`
+ * walked UP ONLY and therefore never found the sibling root that
+ * `core/ecosystem/layout.md` documents. Phase 31c (ADR-0018 R3) fixed
+ * `findRoot` itself, so this is now a thin alias kept for its callers and for
+ * back-compatibility with anything importing it.
  *
- * That inconsistency was invisible until Phase 31b called `recordEvent()` from
- * library code (the hooks had always used their own sibling-aware resolver), at
- * which point every such call silently returned "no ecosystem" in the standard
- * layout. Mirrored here rather than changing `findRoot`, whose up-only
- * semantics other callers may rely on; TD-013 tracks unifying them.
+ * There is exactly ONE discovery implementation. Do not add another.
  */
 function resolveEcosystemRootFrom(startDir) {
-  const max = (() => {
-    const raw = process.env.MOMENTUM_MAX_PARENT_WALK;
-    const n = parseInt(raw, 10);
-    return Number.isInteger(n) && n >= 0 ? n : 5;
-  })();
-
-  let current = path.resolve(startDir);
-  for (let depth = 0; depth <= max; depth++) {
-    try {
-      if (fs.statSync(path.join(current, 'ecosystem.json')).isFile()) return current;
-    } catch (_e) { /* keep walking */ }
-
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    let siblings = [];
-    try { siblings = fs.readdirSync(parent); } catch (_e) { siblings = []; }
-    for (const name of siblings) {
-      const cand = path.join(parent, name);
-      try {
-        if (fs.statSync(path.join(cand, 'ecosystem.json')).isFile()) return cand;
-      } catch (_e) { /* not it */ }
-    }
-    current = parent;
-  }
-  return null;
+  return lib.findRoot(startDir);
 }
 
 /**
@@ -202,7 +173,12 @@ function recordEvent(opts) {
     const member = resolveMemberId(ecosystemRoot, repoRoot);
     if (!member) return { recorded: false, reason: 'not a registered member' };
 
-    const actor = identity.resolveActor(repoRoot);
+    // `opts.env` lets a caller inject the environment actor resolution reads.
+    // `identity.resolveActor` has always accepted it; recordEvent simply never
+    // passed it through, so the pre-31c hook-side mirror carried a test seam
+    // core lacked. Added here rather than working around it in the test —
+    // production always uses the ambient env, so behaviour is unchanged.
+    const actor = identity.resolveActor(repoRoot, opts.env);
     const payload = {
       member,
       summary: String(opts.summary || '').split('\n')[0].slice(0, 500),

package/core/ecosystem/lib/index.js

@@ -50,6 +50,36 @@ const rootCache = new Map();
  * Memoized: repeated calls with paths under the same root return
  * instantly. Cache key is the absolute starting path.
  */
+/** True when `dir/ecosystem.json` exists and is a file. */
+function hasManifest(dir) {
+  try {
+    return fs.statSync(path.join(dir, MANIFEST_FILENAME)).isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * THE ecosystem-root resolver (ADR-0018 R3).
+ *
+ * Three strategies, in order:
+ *   1. **up-walk** — `ecosystem.json` in this dir or an ancestor
+ *   2. **sibling scan** at each level — `core/ecosystem/layout.md` documents the
+ *      ecosystem root as a SIBLING of its members, which is exactly what
+ *      `ecosystem init` + `ecosystem add ../repo` produce
+ *   3. **registration lookup** — the per-machine registry, for members whose
+ *      root is neither an ancestor nor a sibling
+ *
+ * Before Phase 31c this function did step 1 ONLY, while six other call sites
+ * each hand-rolled step 2 and the two CLIs bolted on step 3. Every ad-hoc copy
+ * encoded the documented layout; the sanctioned API contradicted it. The cost
+ * was **BUG-030**: `landing.js` had no fallback, so in the standard sibling
+ * layout `momentum lanes land` silently skipped the entire cross-repo gate and
+ * v0.41.0 shipped ENH-068 non-functional.
+ *
+ * Bounded by `MOMENTUM_MAX_PARENT_WALK` (default 5) and memoised per absolute
+ * start path.
+ */
 function findRoot(startPath) {
   if (typeof startPath !== 'string' || startPath.length === 0) {
     return null;
@@ -58,26 +88,44 @@ function findRoot(startPath) {
   if (rootCache.has(abs)) {
     return rootCache.get(abs);
   }
+
+  const remember = (val) => { rootCache.set(abs, val); return val; };
   const maxDepth = resolveMaxParentWalk();
   let current = abs;
+
   for (let i = 0; i <= maxDepth; i++) {
-    const candidate = path.join(current, MANIFEST_FILENAME);
-    let stat;
+    // 1. this directory
+    if (hasManifest(current)) return remember(current);
+
+    const parent = path.dirname(current);
+    if (parent === current) break; // filesystem root
+
+    // 2. siblings of this directory
+    let siblings = [];
     try {
-      stat = fs.statSync(candidate);
+      siblings = fs.readdirSync(parent, { withFileTypes: true })
+        .filter((e) => e.isDirectory())
+        .map((e) => path.join(parent, e.name));
     } catch (_err) {
-      stat = null;
+      siblings = []; // unreadable parent — keep walking
     }
-    if (stat && stat.isFile()) {
-      rootCache.set(abs, current);
-      return current;
+    for (const sib of siblings) {
+      if (sib !== current && hasManifest(sib)) return remember(sib);
     }
-    const parent = path.dirname(current);
-    if (parent === current) break; // reached filesystem root
+
     current = parent;
   }
-  rootCache.set(abs, null);
-  return null;
+
+  // 3. registration fallback — required lazily to avoid a module cycle
+  // (state.js reads the manifest through this module).
+  try {
+    const reg = require('./state').findRegistration(abs);
+    if (reg && reg.rootPath && hasManifest(reg.rootPath)) {
+      return remember(reg.rootPath);
+    }
+  } catch (_err) { /* registry absent or unreadable — fall through */ }
+
+  return remember(null);
 }
 
 /**

package/core/ecosystem/lib/orient.js

@@ -124,77 +124,46 @@ function openBlockers(backlogBody) {
 const IN_FLIGHT = new Set(['open', 'done']);
 
 /**
- * Resolve `<git-common-dir>/momentum/lanes` without running git.
+ * In-flight lanes for a member — delegated to `core/lanes/lib/state`, the
+ * authority (Phase 31c G2, ADR-0018 R1).
  *
- * `.git` is a directory in a normal checkout, but a FILE in a linked worktree
- * (`gitdir: /abs/path/.git/worktrees/<name>`), whose sibling `commondir` points
- * back at the shared dir. Lane state lives under the COMMON dir, so a worktree
- * that did not follow the pointer would see no lanes at all — and Rule 15 lane
- * work happens in worktrees, which is exactly where this has to be right.
- */
-function laneAnchor(repoDir) {
-  const dotGit = path.join(repoDir, '.git');
-  let stat;
-  try { stat = fs.statSync(dotGit); } catch (_e) { return null; }
-
-  if (stat.isDirectory()) return path.join(dotGit, 'momentum', 'lanes');
-
-  const pointer = readIf(dotGit);
-  if (!pointer) return null;
-  const m = pointer.match(/^gitdir:\s*(.+)$/m);
-  if (!m) return null;
-  const gitdir = path.resolve(repoDir, m[1].trim());
-  const commondir = readIf(path.join(gitdir, 'commondir'));
-  const common = commondir
-    ? path.resolve(gitdir, commondir.trim())
-    : gitdir;
-  return path.join(common, 'momentum', 'lanes');
-}
-
-/**
- * In-flight lanes for a member.
+ * This function used to re-implement lane-registry reading, because orient.js
+ * had to stay dependency-free to ship into installs. It got the format wrong:
+ * the registry holds lane ID STRINGS, not objects, so every entry became
+ * `{status: undefined}` and `undefined !== 'closed'` passed the repo's entire
+ * lane history through as open (BUG-029). The vendored runtime removes the
+ * reason for the mirror, so the mirror is gone.
  *
- * The registry stores an array of lane **id strings**; per-lane detail lives in
- * `<anchor>/<id>/manifest.json`. Reading the ids as objects was BUG-029 —
- * every entry became `{status: undefined}`, and `undefined !== 'closed'` let the
- * whole history through.
+ * `state` is resolved lazily: orient.js is also loaded from `scripts/orient.js`
+ * in installs where the sibling path differs, and a missing authority must
+ * degrade to "no lanes" rather than throw — a fleet view that dies on one bad
+ * member is useless exactly when it matters.
  */
-function openLanes(repoDir) {
-  const anchors = [laneAnchor(repoDir), path.join(repoDir, '.momentum', 'lanes')]
-    .filter(Boolean);
-
-  for (const anchor of anchors) {
-    const body = readIf(path.join(anchor, 'registry.json'));
-    if (!body) continue;
-
-    let ids;
+function laneState() {
+  for (const rel of ['../../lanes/lib/state', './lanes/lib/state', '../lanes/lib/state']) {
     try {
-      const reg = JSON.parse(body);
-      ids = Array.isArray(reg.lanes) ? reg.lanes : [];
-    } catch (_e) {
-      return [];
-    }
-
-    const out = [];
-    for (const entry of ids) {
-      // Tolerate both shapes: the id-string form momentum writes today, and an
-      // inlined object, so a future registry format change degrades instead of
-      // silently reporting garbage again.
-      const id = typeof entry === 'string' ? entry : (entry && entry.id);
-      if (!id) continue;
+      // eslint-disable-next-line global-require
+      return require(path.join(__dirname, rel));
+    } catch (_e) { /* try next */ }
+  }
+  return null;
+}
 
-      let lane = (entry && typeof entry === 'object') ? entry : null;
-      if (!lane || !lane.status) {
-        const mf = readIf(path.join(anchor, id, 'manifest.json'));
-        if (!mf) continue;
-        try { lane = JSON.parse(mf); } catch (_e) { continue; }
-      }
-      if (!IN_FLIGHT.has(lane.status)) continue;
-      out.push({ id, branch: lane.branch || null, status: lane.status });
-    }
-    return out;
+function openLanes(repoDir) {
+  const state = laneState();
+  if (!state) return [];
+  try {
+    // anchorFromRepoDir, NOT resolveAnchor: orient is contractually git-free
+    // (it runs across every member, and from the SessionStart banner's <100ms
+    // budget). state.js owns both resolvers so there is still one implementation.
+    const anchor = state.anchorFromRepoDir(repoDir);
+    if (!anchor) return [];
+    return state.listLanes(anchor)
+      .filter((l) => l && IN_FLIGHT.has(l.status))
+      .map((l) => ({ id: l.id, branch: l.branch || null, status: l.status }));
+  } catch (_e) {
+    return [];
   }
-  return [];
 }
 
 /**
@@ -289,7 +258,6 @@ function memberBrief(summary) {
 module.exports = {
   MAX_ITEMS,
   IN_FLIGHT,
-  laneAnchor,
   MAX_TITLE,
   condense,
   activePhases,

package/core/ecosystem/scripts/session-append.sh

@@ -34,71 +34,34 @@ if [ -z "$EVENT_KIND" ] || [ -z "$EVENT_SUMMARY" ]; then
   exit 0
 fi
 
-# ── Resolve ecosystem root (bounded walk-up, looking for siblings) ──────────
-# The ecosystem is a SIBLING of member repos. From a member repo we walk
-# up one level and look at each sibling for ecosystem.json.
-
-find_ecosystem_root() {
-  local start="$PWD"
-  local current="$start"
-  local depth=0
-  local max_depth="${MOMENTUM_MAX_PARENT_WALK:-5}"
-  # Guard against non-numeric / negative env value.
-  case "$max_depth" in
-    ''|*[!0-9]*) max_depth=5 ;;
-  esac
-  while [ $depth -le $max_depth ]; do
-    # Same-directory check (caller might already be in ecosystem root)
-    if [ -f "$current/ecosystem.json" ]; then
-      echo "$current"
-      return 0
-    fi
-    # Sibling check
-    local parent
-    parent=$(dirname "$current")
-    if [ "$parent" = "$current" ]; then return 1; fi
-    for sibling in "$parent"/*; do
-      if [ -d "$sibling" ] && [ -f "$sibling/ecosystem.json" ]; then
-        echo "$sibling"
-        return 0
-      fi
-    done
-    current="$parent"
-    depth=$((depth + 1))
+# ── Ecosystem discovery (Phase 31c G3, ADR-0018 R5) ────────────────────────
+# Delegates to the ONE implementation in core/ecosystem/lib/index.js via the
+# vendored runtime, instead of re-walking the tree in bash. Any future change to
+# discovery rules is then made once, not once per language — which is how the
+# seven-implementation split accumulated in the first place.
+#
+# Fail-open in every branch: no node, no runtime, no ecosystem → the caller
+# simply gets nothing and carries on. A hook must never break a commit or a
+# session start.
+momentum_discover() {
+  command -v node >/dev/null 2>&1 || return 1
+  _d=$(dirname "$(readlink -f "$0" 2>/dev/null || echo "$0")")
+  for _c in "$_d/../.momentum/runtime/discover.js" \
+            "$_d/../../.momentum/runtime/discover.js" \
+            "$_d/../../runtime/discover.js"; do
+    [ -f "$_c" ] || continue
+    node "$_c" "${1:-$PWD}" 2>/dev/null && return 0
+    return 1
   done
   return 1
 }
 
-ROOT=$(find_ecosystem_root 2>/dev/null) || exit 0
-[ -z "$ROOT" ] && exit 0
+_disc=$(momentum_discover "$PWD") || exit 0
+ROOT=$(printf '%s' "$_disc" | cut -f1)
+MEMBER_ID=$(printf '%s' "$_disc" | cut -f2)
+[ -n "$ROOT" ] || exit 0
 [ -f "$ROOT/ecosystem.json" ] || exit 0
-
-# ── Resolve member id by matching $PWD against manifest.members[].path ─────
-
-resolve_member_id() {
-  python3 - "$ROOT" "$PWD" <<'PY' 2>/dev/null || echo ""
-import sys, json, os
-root, pwd = sys.argv[1], os.path.realpath(sys.argv[2])
-try:
-    with open(os.path.join(root, "ecosystem.json")) as f:
-        m = json.load(f)
-except Exception:
-    sys.exit(0)
-for member in m.get("members", []):
-    abs_path = os.path.realpath(os.path.join(root, member.get("path", "")))
-    # Match pwd that is == abs_path or any descendant
-    try:
-        rel = os.path.relpath(pwd, abs_path)
-    except ValueError:
-        continue
-    if rel == "." or (not rel.startswith("..") and not os.path.isabs(rel)):
-        print(member.get("id", ""))
-        sys.exit(0)
-PY
-}
-
-MEMBER_ID=$(resolve_member_id)
-[ -z "$MEMBER_ID" ] && exit 0
+[ -n "$MEMBER_ID" ] || exit 0
 
 # ── Write the line ─────────────────────────────────────────────────────────