@limina-labs/momentum 0.40.0 → 0.41.0

package/adapters/antigravity/hooks.json

@@ -35,5 +35,19 @@
         "timeout": 15
       }
     ]
+  },
+  "momentum-cross-repo-gate": {
+    "PreToolUse": [
+      {
+        "matcher": "write_to_file|.*write.*|.*edit.*|.*replace.*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ../scripts/cross-repo-gate.sh",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
   }
 }

package/adapters/claude-code/settings.json

@@ -9,6 +9,15 @@
             "command": "bash scripts/brainstorm-gate.sh"
           }
         ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash scripts/cross-repo-gate.sh"
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/adapters/codex/hooks.json

@@ -9,6 +9,15 @@
             "command": "bash scripts/brainstorm-gate.sh"
           }
         ]
+      },
+      {
+        "matcher": "apply_patch|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash scripts/cross-repo-gate.sh"
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/bin/ecosystem.js

@@ -82,7 +82,7 @@ Usage:
   momentum ecosystem init [name]
   momentum ecosystem add <repo-path> [--role <role>] [--id <id>] [--ecosystem <path>]
   momentum ecosystem remove <member-id> [--ecosystem <path>]
-  momentum ecosystem status [--no-git] [--ecosystem <path>]
+  momentum ecosystem status [--no-git] [--brief] [--ecosystem <path>]
   momentum ecosystem upgrade [--dry-run] [--force|--autostash] [--agent <name>] [--ecosystem <path>]
   momentum ecosystem initiative create <slug> [--why "<text>"] [--repos r1,r2] [--owner <name>] [--ecosystem <path>]
   momentum ecosystem initiative start <slug> [--contribute <member>:<kind>:<ref>]... [--edge <from>:<to>:<kind>]...
@@ -778,11 +778,21 @@ function cmdRemove(args) {
 function cmdStatus(args) {
   const opts = parseFlags(args, {
     'no-git': 'boolean',
+    brief: 'boolean',
     ecosystem: 'string',
   });
   const root = resolveEcosystemRoot(opts.ecosystem, 'status');
   const manifest = lib.loadManifest(root);
 
+  // Fleet orient (Phase 31b, ENH-067). `--brief` preserves the pre-31b output
+  // for scripts that parse this. Read once up front so the per-member loop can
+  // render each summary inline.
+  const orientLib = require('../core/ecosystem/lib/orient');
+  const orient = opts.brief ? null : (() => {
+    try { return new Map(orientLib.orientFleet(root, manifest).map((s) => [s.id, s])); }
+    catch (_e) { return null; }   // orient is additive — never fail status on it
+  })();
+
   // Auto-heartbeat (ADR-0015 G2): mark this actor present when the ecosystem is
   // team-active (a .momentum/team/ dir exists). Best-effort, gated so solo
   // ecosystems stay quiet — mirrors bin/team.js.
@@ -818,6 +828,28 @@ function cmdStatus(args) {
       // path was declared but the checkout is absent on this machine.
       console.log(`  ${m.id}  [${m.role}]  ${loc.path || '(no path)'}  (MISSING)`);
     }
+
+    // Fleet orient (ENH-067) — each member's own tracking state, so a session
+    // reaching into a sibling sees its phase and open P0/P1 BEFORE editing it.
+    const s = orient && orient.get(m.id);
+    if (s && s.reachable && s.managed) {
+      for (const p of s.phases) {
+        console.log(`    phase: ${p.phase} — ${p.status} (${p.branch})`);
+      }
+      for (const b of s.blockers.slice(0, 5)) {
+        console.log(`    ${b.priority}: ${b.id} — ${b.title}`);
+      }
+      const extra = s.blockers.length - 5;
+      if (extra > 0) console.log(`    …+${extra} more open P0/P1`);
+      if (s.lanes.length) {
+        console.log(`    lanes: ${s.lanes.map((l) => `${l.id} (${l.status})`).join(', ')}`);
+      }
+      if (!s.phases.length && !s.blockers.length && !s.lanes.length) {
+        console.log('    (no active phase, no open P0/P1, no lanes)');
+      }
+    } else if (s && s.reachable && s.managed === false) {
+      console.log('    (not momentum-managed — no specs/)');
+    }
   }
 
   // Active initiative — shared, attributed fragment (ADR-0015 G2) with a

package/bin/momentum.js

@@ -1226,6 +1226,16 @@ 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.
+  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);
+  }
+
   // .githooks/ — git-lifecycle enforcement hooks (Phase 19)
   console.log('→ Installing git-lifecycle hooks...');
   installGitHooks(src, target);
@@ -1357,6 +1367,11 @@ 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).
+  const orientUpgradeSrc = path.join(src, 'core', 'ecosystem', 'lib', 'orient.js');
+  if (fs.existsSync(orientUpgradeSrc)) {
+    copyFile(orientUpgradeSrc, path.join(target, ...dests.scripts, 'orient.js'));
+  }
   // Re-apply executable bit to all .sh scripts
   const scriptsDir = path.join(target, ...dests.scripts);
   if (!_dryRun && fs.existsSync(scriptsDir)) {

package/core/commands/sync-docs.md

@@ -39,11 +39,40 @@ Present to user:
   - [list of files]
   Proceed? (yes/no)"
 
-**If any cross-repo entries were partitioned out in Step 2:** also show them
-under a "Cross-repo impact (NOT touching — sync the other repo manually)"
-heading, listing each `Affects-specs: ../...` path. Tell the user which repo
-they need to edit and which entries pointed there. Do NOT prompt for approval
-on cross-repo paths — they're informational only.
+**If any cross-repo entries were partitioned out in Step 2:** show them under a
+"Cross-repo impact" heading, listing each `Affects-specs: ../...` path and which
+member repo owns it.
+
+**Then DELIVER them, don't just mention them (Phase 31b, ADR-0017 E6).** A chat
+message dies with the session — that is why one reviewed multi-repo session's
+glossary propagation never happened *despite this rule working exactly as
+designed*. For each target member repo, write a structured handoff into its
+inbox:
+
+```js
+const orchestration = require('<momentum-root>/core/orchestration');
+await orchestration.handoff.handoff({
+  fromRepo: '<this repo absolute path>',
+  toRepo: '<target member absolute path>',
+  summary: 'Doc sync needed: <N> entries from <this repo> phase <phase> affect your specs',
+  decisions: [/* the history entries that pointed here, verbatim */],
+  filesTouched: [/* the ../ paths, rewritten relative to the TARGET repo */],
+  verificationCommands: [],
+  openQuestions: ['Do these entries still apply after your latest changes?'],
+  ecosystem: { rootPath: '<ecosystem root>', memberId: '<this repo member id>' },
+});
+```
+
+The receiving session surfaces it at SessionStart and picks it up with
+`/continue`.
+
+**The ownership rule is unchanged and absolute:** you still NEVER edit a file in
+another repo. You are handing the target repo's own agent a note; that agent
+decides what to change. Delivery is not ownership.
+
+Do NOT prompt for approval on cross-repo paths — writing a handoff into an
+inbox is additive and reversible, and the receiving session gates the actual
+edits.
 
 If user says no → stop.
 
@@ -76,6 +105,6 @@ Ready to run /complete-phase."
 ## Safeguards
 - NEVER update files not in the targeted list
 - NEVER update `specs/architecture/` (monorepo only — constitution is read-only)
-- NEVER update files in another repo (paths starting with `../`) — you only own this repo's docs. Flag cross-repo entries to the user instead.
+- NEVER update files in another repo (paths starting with `../`) — you only own this repo's docs. **Deliver** cross-repo entries as a handoff into the target member's inbox (ADR-0017 E6); the receiving repo's own agent decides what to change. Delivery is not ownership.
 - ALWAYS show the plan (Step 3) before making any edits
 - History entries are NEVER modified — only read

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

@@ -0,0 +1,181 @@
+'use strict';
+
+/**
+ * momentum git-hook helper — cross-repo routing detection (Phase 31b G2, ADR-0017).
+ *
+ * Produces the routing message shown by BOTH enforcement layers (E1):
+ *   - the `post-commit` banner (git-native, agent-independent)
+ *   - the `cross-repo-gate.sh` PreToolUse nudge (fires before the edit)
+ *
+ * WHY THIS IS ANOTHER SELF-CONTAINED FILE
+ * ---------------------------------------
+ * Third time in this arc, so worth stating plainly rather than rediscovering:
+ * an installed project receives NO copy of momentum's `core/`. Anything a hook
+ * needs must travel with the hook. `core/git-hooks/eco-event.js` (31a) and
+ * `core/ecosystem/lib/orient.js` (31b G1) hit the same wall.
+ *
+ * This file is therefore node-builtins-only, ships into `.githooks/` beside
+ * `eco-event.js`, and resolves `orient.js` LAZILY through a candidate list so
+ * it degrades to a detail-free message rather than throwing when orient is not
+ * installed. TD-012 tracks consolidating this shipped-runtime story.
+ *
+ * The coverage logic here is a deliberate minimal mirror of
+ * `core/ecosystem/lib/detect.js`, fenced by a parity test — the same discipline
+ * applied to the eco-event.js/fragments duplication in 31a.
+ */
+
+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 */ }
+  }
+  return null;
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+/** 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();
+}
+
+/** 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;
+}
+
+/**
+ * The routing question. Returns
+ * `{ crossRepo, covered, shouldRoute, members, initiative }`.
+ */
+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 };
+}
+
+/**
+ * The routing message. `focus` is the member being entered right now (the
+ * PreToolUse case) — its open P0/P1 items are surfaced, which is what turns
+ * "this is cross-repo work" into something worth reading (AC-4).
+ */
+function routingMessage(ecosystemRoot, result, focus) {
+  const lines = [];
+  lines.push(`⚠ Cross-repo work with no initiative: ${result.members.join(' + ')}`);
+
+  if (focus) {
+    const orient = loadOrient();
+    if (orient) {
+      try {
+        const manifest = readJson(path.join(ecosystemRoot, 'ecosystem.json')) || {};
+        const member = (manifest.members || []).find((m) => m && m.id === focus);
+        if (member) {
+          const summary = orient.orientMember(ecosystemRoot, member);
+          for (const l of orient.memberBrief(summary)) lines.push(`  ${l}`);
+        }
+      } catch (_e) { /* detail is a bonus, never a requirement */ }
+    }
+  }
+
+  lines.push('  → Run /brainstorm-initiative to open one before going further.');
+  lines.push('    (Cross-repo work belongs to an initiative — see ADR-0016.)');
+  return lines;
+}
+
+module.exports = {
+  EVENTS_VIEW,
+  DEFAULT_WINDOW_HOURS,
+  loadOrient,
+  touchedMembers,
+  openInitiativeMembers,
+  detect,
+  routingMessage,
+};

package/core/ecosystem/lib/detect.js

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * Cross-repo coverage detection (Phase 31b G0, ADR-0017 E2).
+ *
+ * Answers one question: **is this actor doing cross-repo work that no initiative
+ * covers?**
+ *
+ * WHY THIS IS A QUERY AND NOT A TRACKER
+ * -------------------------------------
+ * The obvious implementation is a per-session record of "members touched so
+ * far". That is unnecessary — ADR-0016's write path already records
+ * `{actor, ts, member}` for every commit, so the answer is a query over data
+ * momentum already collects. A parallel tracker would be a second source of
+ * truth to keep honest, which is the exact failure mode this arc exists to
+ * close (BUG-007/BUG-028, and the hook-side writer's parity fence).
+ *
+ * Two properties follow from that choice, and both are load-bearing:
+ *
+ *   1. **No git calls.** Everything here is file reads over the fragment stream
+ *      and `initiatives/`. That is what makes it cheap enough to run from a
+ *      PreToolUse hook on every edit.
+ *   2. **A CLOSED initiative covers nothing.** Coverage is a question about live
+ *      state, not history. An initiative that shipped last month does not
+ *      license today's untracked cross-repo work.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const events = require('./events');
+const initiativeLib = require('./initiative');
+
+/** Default lookback for "is this the same stretch of work". */
+const DEFAULT_WINDOW_HOURS = 24;
+
+/**
+ * Resolve the detection window from ecosystem config, falling back to the
+ * default. Invalid values fall back rather than throwing — this runs inside
+ * hooks, where an exception is worse than an imperfect window.
+ */
+function windowHours(manifest) {
+  const cfg = (manifest && manifest.config) || {};
+  const raw = cfg.detect_window_hours;
+  const n = typeof raw === 'number' ? raw : parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_WINDOW_HOURS;
+}
+
+/**
+ * Members this actor has recorded events in, within the window.
+ *
+ * `opts.actor`  — restrict to one actor (omit for all actors)
+ * `opts.hours`  — lookback (defaults to config / 24)
+ * `opts.now`    — injectable clock for tests
+ * `opts.extra`  — additional member ids to fold in (used by the PreToolUse
+ *                 nudge, where the member being edited RIGHT NOW has no event
+ *                 yet — the whole point is to fire before the commit).
+ */
+function touchedMembers(ecosystemRoot, opts) {
+  opts = opts || {};
+  const hours = opts.hours || 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) : []);
+  let stream = [];
+  try {
+    stream = events.listEvents(ecosystemRoot);
+  } catch (_e) {
+    stream = [];
+  }
+
+  for (const f of stream) {
+    if (!f || !f.payload || !f.payload.member) continue;
+    if (opts.actor && f.actor !== opts.actor) continue;
+    const ts = new Date(f.ts).getTime();
+    if (!Number.isFinite(ts) || ts < cutoff) continue;
+    seen.add(f.payload.member);
+  }
+  return [...seen].sort();
+}
+
+/** Every in-progress initiative, parsed. Closed/abandoned are excluded (E2). */
+function openInitiatives(ecosystemRoot) {
+  const dir = path.join(ecosystemRoot, initiativeLib.INITIATIVES_DIR);
+  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 raw = '';
+    try {
+      raw = fs.readFileSync(path.join(dir, name), 'utf8');
+    } catch (_e) {
+      continue;
+    }
+    const { frontmatter } = initiativeLib.parseFrontmatter(raw);
+    if (!frontmatter || frontmatter.status !== 'in-progress') continue;
+
+    const repos = new Set(Array.isArray(frontmatter.repos) ? frontmatter.repos : []);
+    for (const entry of (frontmatter.contributions || [])) {
+      const parsed = initiativeLib.parseContribution(entry);
+      if (parsed) repos.add(parsed.member);
+    }
+    out.push({ slug: frontmatter.slug, file: name, members: repos });
+  }
+  return out;
+}
+
+/**
+ * Which in-progress initiative covers `members`, if any.
+ *
+ * "Covers" means every member in the set appears in that initiative's `repos[]`
+ * or `contributions[]`. A partial match does NOT cover: an initiative spanning
+ * backend+frontend does not license work that also touches infra, because the
+ * infra work is precisely the part nobody planned.
+ *
+ * Returns { initiative, uncovered } — `initiative` is the covering slug or null,
+ * and `uncovered` lists the members no open initiative accounts for.
+ */
+function coverage(ecosystemRoot, members) {
+  const set = [...new Set(members || [])].sort();
+  if (set.length === 0) return { initiative: null, uncovered: [] };
+
+  const open = openInitiatives(ecosystemRoot);
+  for (const init of open) {
+    if (set.every((m) => init.members.has(m))) {
+      return { initiative: init.slug, uncovered: [] };
+    }
+  }
+
+  // Nothing covers the whole set. Report which members no OPEN initiative
+  // mentions at all — those are the ones a new initiative must account for.
+  const mentioned = new Set();
+  for (const init of open) for (const m of init.members) mentioned.add(m);
+  return { initiative: null, uncovered: set.filter((m) => !mentioned.has(m)) };
+}
+
+/**
+ * The detection question, answered.
+ *
+ * Returns:
+ *   {
+ *     crossRepo: boolean,   // ≥2 members touched in the window
+ *     covered:   boolean,   // an open initiative covers the whole set
+ *     members:   string[],  // everything touched
+ *     initiative: string|null,
+ *     uncovered: string[],  // members no open initiative mentions
+ *   }
+ *
+ * `shouldRoute` (crossRepo && !covered) is the condition the nudge and the
+ * commit banner both fire on.
+ */
+function detect(ecosystemRoot, opts) {
+  opts = opts || {};
+  let manifest = null;
+  try {
+    manifest = require('./index').loadManifest(ecosystemRoot);
+  } catch (_e) {
+    manifest = null;
+  }
+
+  const members = touchedMembers(ecosystemRoot, {
+    actor: opts.actor,
+    hours: opts.hours || windowHours(manifest),
+    now: opts.now,
+    extra: opts.extra,
+  });
+
+  const crossRepo = members.length >= 2;
+  const { initiative, uncovered } = coverage(ecosystemRoot, members);
+
+  return {
+    crossRepo,
+    covered: crossRepo && initiative !== null,
+    members,
+    initiative,
+    uncovered,
+    shouldRoute: crossRepo && initiative === null,
+  };
+}
+
+module.exports = {
+  DEFAULT_WINDOW_HOURS,
+  windowHours,
+  touchedMembers,
+  openInitiatives,
+  coverage,
+  detect,
+};

package/core/ecosystem/lib/events.js

@@ -46,8 +46,16 @@ const teamState = require('./team-state');
 /** Fragment view holding ecosystem activity events. */
 const EVENTS_VIEW = 'eco-events';
 
-/** Event kinds the git hooks emit. */
-const EVENT_KINDS = ['commit', 'merge', 'tag'];
+/**
+ * Event kinds recorded on the stream.
+ *
+ * `land` (Phase 31b, ADR-0017 E5) is written by `momentum lanes land --execute`
+ * on success. It exists because "has member X landed its contribution?" must be
+ * answerable from a RECORD rather than inferred from branch or merge state —
+ * the asking machine may not have member X checked out at all, the same reason
+ * the 31a completion gate blocks on absent members rather than skipping them.
+ */
+const EVENT_KINDS = ['commit', 'merge', 'tag', 'land'];
 
 function git(dir, ...args) {
   try {
@@ -87,6 +95,50 @@ function resolveMemberRepoRoot(cwd) {
   return top ? path.resolve(top) : null;
 }
 
+/**
+ * Locate the ecosystem root from a member repo — up-walk AND sibling scan.
+ *
+ * `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.
+ *
+ * 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.
+ */
+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;
+}
+
 /**
  * Match a member repo root against the ecosystem manifest.
  * Returns the member id, or null when this repo is not a registered member.
@@ -144,7 +196,7 @@ function recordEvent(opts) {
     const repoRoot = resolveMemberRepoRoot(cwd);
     if (!repoRoot) return { recorded: false, reason: 'not a git repo' };
 
-    const ecosystemRoot = lib.findRoot(repoRoot);
+    const ecosystemRoot = opts.ecosystemRoot || resolveEcosystemRootFrom(repoRoot);
     if (!ecosystemRoot) return { recorded: false, reason: 'no ecosystem' };
 
     const member = resolveMemberId(ecosystemRoot, repoRoot);
@@ -156,6 +208,12 @@ function recordEvent(opts) {
       summary: String(opts.summary || '').split('\n')[0].slice(0, 500),
       context: opts.context ? String(opts.context).slice(0, 200) : '',
     };
+    // `land` events carry which initiative they belong to and whether the
+    // landing order was overridden (Phase 31b, ADR-0017 E5). Recorded on the
+    // event rather than inferred later, so a forced land stays visible in the
+    // stream instead of vanishing the way a `--no-verify` bypass would.
+    if (opts.initiative) payload.initiative = String(opts.initiative).slice(0, 64);
+    if (opts.forced) payload.forced = true;
 
     const frag = fragments.writeFragment(
       ecosystemRoot, EVENTS_VIEW, actor, kind, payload,
@@ -235,6 +293,7 @@ function writeSessionLog(ecosystemRoot, date) {
 module.exports = {
   EVENTS_VIEW,
   EVENT_KINDS,
+  resolveEcosystemRootFrom,
   resolveMemberRepoRoot,
   resolveMemberId,
   recordEvent,