@limina-labs/momentum 0.35.0 → 0.37.0

package/adapters/antigravity/instructions/AGENTS.md

@@ -176,6 +176,10 @@ lives in this AGENTS.md primary-instruction text as a belt-and-braces
 fallback: if a `.momentum/inbox/handoff-NNN.md` file exists at session
 start, read it and acknowledge before continuing.
 
+## In-Session Task Tool
+
+When a rule mentions tracking in-session progress (Rule 2), Antigravity's task tool is the native **task list** artifact (task.md) — in-session only; the durable record is `specs/phases/<phase>/tasks.md`.
+
 ## Autonomous Behaviors (Always-On Rules)
 
 ### Rule 1: Always Orient First
@@ -197,7 +201,7 @@ After completing ANY meaningful work, automatically update:
 2. **`specs/status.md`** — if phase progress, blockers, or P0 items changed (touch only your own lane's row — Rule 15)
 3. **`specs/changelog/YYYY-MM.md`** — log what changed (one line per change, append-only)
 
-Use the native **task list** artifact (task.md) to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
+Use your in-session task-tracking tool (named in the "In-Session Task Tool" note above) to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
 
 #### Why
 Tracking debt compounds invisibly. A task list one day stale is recoverable; one week stale is fiction. Status drift is how phases silently lose direction.
@@ -215,7 +219,7 @@ Tracking debt compounds invisibly. A task list one day stale is recoverable; one
 #### Anti-Rationalization Counters
 
 - "It's faster to do the work first and track at the end" — wrong: reconstruction takes 2-3× longer than real-time logging.
-- "The task-list artifact is enough" — The task-list artifact is in-session only; `tasks.md` is the durable record.
+- "Your in-session task-tracking tool is enough" — it is in-session only; `tasks.md` is the durable record.
 - "Mid-task tracking interrupts flow" — a one-line update costs <30s; reconstructing a day later costs 30 minutes.
 
 ### Rule 3: Auto-Track Discoveries

package/adapters/antigravity/instructions/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "antigravity",
+  "displayName": "Antigravity",
+  "surface": "agents-md",
+  "taskTool": "the native **task list** artifact (task.md)",
+  "taskToolName": "The task-list artifact",
+  "hasSurfaceDelta": true
+}

package/adapters/claude-code/instructions/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "claude-code",
+  "displayName": "Claude Code",
+  "surface": "claude-md",
+  "taskTool": "the built-in **TodoWrite** tool",
+  "taskToolName": "TodoWrite",
+  "hasSurfaceDelta": false
+}

package/adapters/codex/instructions/AGENTS.md

@@ -230,6 +230,10 @@ This is the documented escalation point referenced in Phase 18 G1
 plan.md; if the MCP shim is widely broken, momentum will ship a
 minimal `core/swarm/mcp-cwd-server.js` in a follow-up.
 
+## In-Session Task Tool
+
+When a rule mentions tracking in-session progress (Rule 2), Codex's task tool is the built-in **plan** tool — in-session only; the durable record is `specs/phases/<phase>/tasks.md`.
+
 ## Autonomous Behaviors (Always-On Rules)
 
 ### Rule 1: Always Orient First
@@ -251,7 +255,7 @@ After completing ANY meaningful work, automatically update:
 2. **`specs/status.md`** — if phase progress, blockers, or P0 items changed (touch only your own lane's row — Rule 15)
 3. **`specs/changelog/YYYY-MM.md`** — log what changed (one line per change, append-only)
 
-Use the built-in **plan** tool to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
+Use your in-session task-tracking tool (named in the "In-Session Task Tool" note above) to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
 
 #### Why
 Tracking debt compounds invisibly. A task list one day stale is recoverable; one week stale is fiction. Status drift is how phases silently lose direction.
@@ -269,7 +273,7 @@ Tracking debt compounds invisibly. A task list one day stale is recoverable; one
 #### Anti-Rationalization Counters
 
 - "It's faster to do the work first and track at the end" — wrong: reconstruction takes 2-3× longer than real-time logging.
-- "The plan tool is enough" — The plan tool is in-session only; `tasks.md` is the durable record.
+- "Your in-session task-tracking tool is enough" — it is in-session only; `tasks.md` is the durable record.
 - "Mid-task tracking interrupts flow" — a one-line update costs <30s; reconstructing a day later costs 30 minutes.
 
 ### Rule 3: Auto-Track Discoveries

package/adapters/codex/instructions/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "codex",
+  "displayName": "Codex",
+  "surface": "agents-md",
+  "taskTool": "the built-in **plan** tool",
+  "taskToolName": "The plan tool",
+  "hasSurfaceDelta": true
+}

package/adapters/opencode/instructions/AGENTS.md

@@ -143,6 +143,10 @@ skill paths (`.claude/skills/`, `.agents/skills/`); momentum's opencode
 surfaces live under `.opencode/` so multi-adapter installs stay
 side-by-side without collisions.
 
+## In-Session Task Tool
+
+When a rule mentions tracking in-session progress (Rule 2), opencode's task tool is the built-in **task** tool (subagent fan-out) — in-session only; the durable record is `specs/phases/<phase>/tasks.md`.
+
 ## Autonomous Behaviors (Always-On Rules)
 
 ### Rule 1: Always Orient First
@@ -164,7 +168,7 @@ After completing ANY meaningful work, automatically update:
 2. **`specs/status.md`** — if phase progress, blockers, or P0 items changed (touch only your own lane's row — Rule 15)
 3. **`specs/changelog/YYYY-MM.md`** — log what changed (one line per change, append-only)
 
-Use the built-in **task** tool (subagent fan-out) to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
+Use your in-session task-tracking tool (named in the "In-Session Task Tool" note above) to track in-session task progress. Do NOT wait for the user to ask you to update tracking.
 
 #### Why
 Tracking debt compounds invisibly. A task list one day stale is recoverable; one week stale is fiction. Status drift is how phases silently lose direction.
@@ -182,7 +186,7 @@ Tracking debt compounds invisibly. A task list one day stale is recoverable; one
 #### Anti-Rationalization Counters
 
 - "It's faster to do the work first and track at the end" — wrong: reconstruction takes 2-3× longer than real-time logging.
-- "The task tool is enough" — The task tool is in-session only; `tasks.md` is the durable record.
+- "Your in-session task-tracking tool is enough" — it is in-session only; `tasks.md` is the durable record.
 - "Mid-task tracking interrupts flow" — a one-line update costs <30s; reconstructing a day later costs 30 minutes.
 
 ### Rule 3: Auto-Track Discoveries

package/adapters/opencode/instructions/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "opencode",
+  "displayName": "opencode",
+  "surface": "agents-md",
+  "taskTool": "the built-in **task** tool (subagent fan-out)",
+  "taskToolName": "The task tool",
+  "hasSurfaceDelta": true
+}

package/bin/ecosystem.js

@@ -777,9 +777,18 @@ function detectMemberAgent(repoPath) {
     const m = JSON.parse(
       fs.readFileSync(path.join(repoPath, '.momentum', 'installed.json'), 'utf8'),
     );
-    if (m && m.agent) return m.agent;
+    // ADR-0007: the lock is `{ agents: { <id>: … } }`; the pre-0007 lock was
+    // `{ agent }`. Read the map first (else every AGENTS.md agent — opencode,
+    // Antigravity, Codex — falls through to the `AGENTS.md ⇒ codex` heuristic
+    // below and is misidentified). ADR-0011.
+    if (m && m.agents && typeof m.agents === 'object') {
+      const ids = Object.keys(m.agents);
+      if (ids.length) return ids.includes('claude-code') ? 'claude-code' : ids.sort()[0];
+    }
+    if (m && m.agent) return m.agent; // legacy single-agent lock
   } catch (_e) { /* fall through to heuristic */ }
   if (fs.existsSync(path.join(repoPath, '.codex'))) return 'codex';
+  if (fs.existsSync(path.join(repoPath, '.opencode'))) return 'opencode';
   if (fs.existsSync(path.join(repoPath, '.claude'))) return 'claude-code';
   if (
     fs.existsSync(path.join(repoPath, '.agents', 'hooks.json')) ||
@@ -1297,6 +1306,7 @@ module.exports = {
   ensurePointerInjected,
   stripPointer,
   findPrimaryInstructionFile,
+  detectMemberAgent,
   sanitizeId,
   POINTER_BEGIN,
   POINTER_END,

package/bin/momentum.js

@@ -719,7 +719,46 @@ function resolveAdapterSource(srcRoot, adapterDir, fileSpec) {
   return path.join(base, ...fileSpec.source);
 }
 
-function installPrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstruction) {
+/**
+ * ADR-0011 — the raw primary-instruction template content for `agent`.
+ * A claude-md agent (and a lone installed agents-md agent) gets the static
+ * committed template. When MORE THAN ONE agents-md agent is installed, AGENTS.md
+ * is COMPOSED — the neutral spine once + one integration section per installed
+ * AGENTS.md agent — so switching or running several agents never drops an
+ * integration (fixes the same-path collision). Project name is not yet rendered.
+ */
+function resolvePrimaryInstructionContent(srcRoot, targetDir, agent, srcPath) {
+  const readStatic = () => fs.readFileSync(srcPath, 'utf8');
+  let compose;
+  try {
+    compose = require('../core/lib/instruction-compose');
+  } catch (_e) {
+    return readStatic();
+  }
+  let manifest;
+  try {
+    manifest = compose.readManifest(srcRoot, agent);
+  } catch (_e) {
+    return readStatic(); // unknown / manifest-less agent → static template
+  }
+  if (manifest.surface !== 'agents-md') return readStatic(); // claude-md → static
+
+  // The set of installed AGENTS.md agents ∪ the one being (re)installed.
+  const valid = new Set(compose.discoverAgents(srcRoot));
+  const ids = new Set(valid.has(agent) ? [agent] : []);
+  const state = loadInstalledState(targetDir);
+  for (const id of Object.keys(state.agents || {})) {
+    if (!valid.has(id)) continue;
+    try {
+      if (compose.readManifest(srcRoot, id).surface === 'agents-md') ids.add(id);
+    } catch (_e) { /* skip an agent we can't read */ }
+  }
+  const sorted = [...ids].sort();
+  if (sorted.length <= 1) return readStatic(); // N=1 → static committed template
+  return compose.composeInstruction(srcRoot, sorted); // N>1 → composed
+}
+
+function installPrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstruction, agent) {
   if (!primaryInstruction) return null;
   const srcPath = resolveAdapterSource(srcRoot, adapterDir, primaryInstruction);
   const destPath = path.join(targetDir, ...primaryInstruction.destination);
@@ -733,7 +772,7 @@ function installPrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstru
       return 'added';
     }
     const rendered = renderProjectName(
-      fs.readFileSync(srcPath, 'utf8'),
+      resolvePrimaryInstructionContent(srcRoot, targetDir, agent, srcPath),
       getProjectName(targetDir)
     );
     fs.mkdirSync(path.dirname(destPath), { recursive: true });
@@ -745,7 +784,7 @@ function installPrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstru
   return 'skipped';
 }
 
-function upgradePrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstruction) {
+function upgradePrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstruction, agent) {
   if (!primaryInstruction) return null;
   const srcPath = resolveAdapterSource(srcRoot, adapterDir, primaryInstruction);
   const destPath = path.join(targetDir, ...primaryInstruction.destination);
@@ -753,12 +792,15 @@ function upgradePrimaryInstruction(srcRoot, targetDir, adapterDir, primaryInstru
   const projectName = getProjectName(targetDir);
   recordManaged(destPath); // managed (marker-owned)
 
+  // ADR-0011: compose AGENTS.md across all installed AGENTS.md agents.
+  const rawContent = resolvePrimaryInstructionContent(srcRoot, targetDir, agent, srcPath);
+
   console.log(`→ Upgrading ${label}...`);
   if (primaryInstruction.markerAware) {
-    return upgradeMarkedFile(srcPath, destPath, label, targetDir, projectName);
+    return upgradeMarkedFile(srcPath, destPath, label, targetDir, projectName, rawContent);
   }
 
-  const srcContent = renderProjectName(fs.readFileSync(srcPath, 'utf8'), projectName);
+  const srcContent = renderProjectName(rawContent, projectName);
   const relDest = path.relative(targetDir, destPath);
   if (!fileExists(destPath)) {
     if (_dryRun) {
@@ -895,11 +937,14 @@ function partitionByMarker(content) {
  *
  * Returns one of: 'added', 'updated', 'unchanged', 'migrated'.
  */
-function upgradeMarkedFile(srcPath, destPath, label, root, projectName) {
+function upgradeMarkedFile(srcPath, destPath, label, root, projectName, srcContentRaw) {
   const rel = path.relative(root || process.cwd(), destPath);
   recordManaged(destPath); // managed (marker-owned) in all branches
   const render = (content) =>
     projectName ? renderProjectName(content, projectName) : content;
+  // ADR-0011: callers may pass composed content (multi-agent AGENTS.md); else
+  // read the static committed template.
+  const rawSrc = srcContentRaw != null ? srcContentRaw : fs.readFileSync(srcPath, 'utf8');
 
   if (!fileExists(destPath)) {
     if (_dryRun) {
@@ -907,12 +952,12 @@ function upgradeMarkedFile(srcPath, destPath, label, root, projectName) {
       return 'added';
     }
     fs.mkdirSync(path.dirname(destPath), { recursive: true });
-    fs.writeFileSync(destPath, render(fs.readFileSync(srcPath, 'utf8')));
+    fs.writeFileSync(destPath, render(rawSrc));
     console.log(`  + added:    ${rel}`);
     return 'added';
   }
 
-  const srcContent = render(fs.readFileSync(srcPath, 'utf8'));
+  const srcContent = render(rawSrc);
   const destContent = fs.readFileSync(destPath, 'utf8');
   const destParts = partitionByMarker(destContent);
 
@@ -1215,7 +1260,7 @@ function init(targetDir, agent, opts = {}) {
   console.log('→ Inferring project config...');
   installConfig(target, { dryRun: _dryRun });
 
-  installPrimaryInstruction(src, target, adapterDir, adapter.primaryInstruction);
+  installPrimaryInstruction(src, target, adapterDir, adapter.primaryInstruction, agent);
 
   // Adapter overlay — per-agent commands/agent-rules/scripts (additive)
   applyOverlay(adapterDir, target, dests, { backup: true, root: target });
@@ -1381,7 +1426,8 @@ function upgrade(targetDir, agent, opts = {}) {
     src,
     target,
     adapterDir,
-    adapter.primaryInstruction
+    adapter.primaryInstruction,
+    agent
   );
 
   if (hadPointerBlock && !_dryRun) {
@@ -2152,6 +2198,22 @@ async function main() {
       console.error(`\nError: ${err.message}`);
       exitCode = 1;
     }
+  } else if (args[0] === 'claim') {
+    try {
+      const { runClaim } = require('./team');
+      exitCode = runClaim(args.slice(1));
+    } catch (err) {
+      console.error(`\nError: ${err.message}`);
+      exitCode = 1;
+    }
+  } else if (args[0] === 'team') {
+    try {
+      const { runTeam } = require('./team');
+      exitCode = runTeam(args.slice(1));
+    } catch (err) {
+      console.error(`\nError: ${err.message}`);
+      exitCode = 1;
+    }
   } else {
     console.error(`Unknown command: ${args[0]}`);
     console.error('Run "momentum --help" for usage.');

package/bin/team.js

@@ -0,0 +1,223 @@
+'use strict';
+
+/**
+ * `momentum team` + `momentum claim` — git-native team coordination (Phase 30a
+ * Team-Walk, ADR-0012). No daemon; every command computes from git + files.
+ *
+ *   momentum claim <namespace> <key>   atomic cross-machine allocation (ref-CAS)
+ *   momentum team whoami               show the resolved durable actor
+ *   momentum team sync                 fetch coordination refs + recompile views
+ */
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MOMENTUM_ROOT = path.resolve(__dirname, '..');
+const claimLib = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'claim'));
+const refcas = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'refcas'));
+const compile = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'compile'));
+const presenceLib = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'presence'));
+const approvalsLib = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'approvals'));
+const queueLib = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'queue'));
+const leaseLib = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'lib', 'lease'));
+const { createRelay } = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'relay', 'server'));
+const { CONTRACT } = require(path.join(MOMENTUM_ROOT, 'core', 'team', 'contract'));
+const identity = require(path.join(MOMENTUM_ROOT, 'core', 'identity'));
+
+function repoRoot(cwd) {
+  const r = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--json') flags.json = true;
+    else if (a.startsWith('--')) flags[a.slice(2)] = argv[++i];
+    else positional.push(a);
+  }
+  return { flags, positional };
+}
+
+function insideRepo(cwd) {
+  return spawnSync('git', ['rev-parse', '--git-dir'], { cwd, encoding: 'utf8' }).status === 0;
+}
+
+// ─── momentum claim ────────────────────────────────────────────────────────
+
+function runClaim(argv) {
+  const { flags, positional } = parseFlags(argv);
+  const [namespace, key] = positional;
+  if (!namespace || !key) {
+    console.error('usage: momentum claim <namespace> <key> [--remote origin] [--actor id]');
+    console.error('  e.g. momentum claim phase 30a  |  momentum claim version 0.37.0  |  momentum claim id BUG-028');
+    return 1;
+  }
+  const cwd = process.cwd();
+  if (!insideRepo(cwd)) { console.error('✗ not inside a git repository'); return 1; }
+  const actor = flags.actor || identity.resolveActor(cwd).id;
+  let res;
+  try {
+    res = claimLib.claimKey(cwd, namespace, key, { remote: flags.remote, actor });
+  } catch (err) {
+    console.error(`✗ claim failed: ${err.message}`);
+    return 1;
+  }
+  if (res.won) {
+    console.log(`✓ claimed ${namespace}/${key} as '${actor}'  (${res.ref})`);
+    return 0;
+  }
+  const who = res.winner && res.winner.actor ? res.winner.actor : 'someone else';
+  console.error(`✗ ${namespace}/${key} already claimed by '${who}' — pick another`);
+  return 2; // distinct from usage(1) so recipes can gate on "lost"
+}
+
+// ─── momentum team ─────────────────────────────────────────────────────────
+
+function runTeam(argv) {
+  const sub = argv[0];
+  const cwd = process.cwd();
+  if (sub === 'whoami') {
+    const a = identity.resolveActor(cwd);
+    console.log(`${a.id}  (source: ${a.source}${a.email ? `, ${a.email}` : ''})`);
+    return 0;
+  }
+  if (sub === 'sync') {
+    if (!insideRepo(cwd)) { console.error('✗ not inside a git repository'); return 1; }
+    const remote = argv[1] && !argv[1].startsWith('--') ? argv[1] : 'origin';
+    const ok = refcas.fetchAll(cwd, remote);
+    const root = repoRoot(cwd);
+    const rec = root ? compile.compileStatusFile(root) : { changed: false };
+    console.log(ok
+      ? `✓ synced coordination refs from ${remote} (refs/momentum/*). Fragments arrive via branch integration.`
+      : `⚠ could not fetch from ${remote} — working offline; coordination is eventually consistent`);
+    if (rec.changed) console.log('✓ recompiled the Active-Phase table in specs/status.md');
+    return 0;
+  }
+  if (sub === 'compile') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const rec = compile.compileStatusFile(root);
+    console.log(rec.path
+      ? (rec.changed ? '✓ recompiled Active-Phase table in specs/status.md' : '✓ specs/status.md already current')
+      : 'ℹ no specs/status.md to compile into');
+    return 0;
+  }
+  if (sub === 'board') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    console.log(compile.compileActivePhase(root));
+    return 0;
+  }
+  if (sub === 'record') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const { flags } = parseFlags(argv.slice(1));
+    if (!flags.branch) { console.error('usage: momentum team record --branch B [--phase P] [--status S] [--progress "..."]'); return 1; }
+    const actor = flags.actor || identity.resolveActor(root).id;
+    compile.recordActivePhase(root, actor, {
+      branch: flags.branch, phase: flags.phase || '', status: flags.status || '', progress: flags.progress || '',
+    });
+    console.log(`✓ recorded active-phase row for '${flags.branch}' as '${actor}'`);
+    return 0;
+  }
+  if (sub === 'heartbeat') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const { flags } = parseFlags(argv.slice(1));
+    const actor = flags.actor || identity.resolveActor(root).id;
+    presenceLib.heartbeat(root, actor, { branch: flags.branch, lane: flags.lane, activity: flags.activity });
+    console.log(`✓ heartbeat for '${actor}'`);
+    return 0;
+  }
+  if (sub === 'presence') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const now = Date.now();
+    const list = presenceLib.presence(root, now);
+    if (!list.length) { console.log('(no presence recorded)'); return 0; }
+    for (const p of list) {
+      console.log(`${p.liveness === 'active' ? '●' : p.liveness === 'idle' ? '◐' : '○'} ${p.actor}  ${p.liveness}  ${p.branch || ''}${p.activity ? '  — ' + p.activity : ''}`);
+    }
+    return 0;
+  }
+  if (sub === 'approve') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const { flags, positional } = parseFlags(argv.slice(1));
+    const change = positional[0];
+    if (!change) { console.error('usage: momentum team approve <change> [--verdict approve|reject]'); return 1; }
+    const actor = flags.actor || identity.resolveActor(root).id;
+    approvalsLib.approve(root, actor, change, { verdict: flags.verdict || 'approve' });
+    console.log(`✓ ${flags.verdict === 'reject' ? 'rejected' : 'approved'} '${change}' as '${actor}'`);
+    return 0;
+  }
+  if (sub === 'check') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const { flags, positional } = parseFlags(argv.slice(1));
+    const change = positional[0];
+    if (!change || !flags.author) { console.error('usage: momentum team check <change> --author <a> [--threshold N] [--allow-self]'); return 1; }
+    const threshold = flags.threshold ? parseInt(flags.threshold, 10) : 1;
+    const allowSelf = argv.includes('--allow-self');
+    const approvers = approvalsLib.approversFor(root, change, flags.author, allowSelf);
+    if (approvers.length >= threshold) {
+      console.log(`✓ '${change}' satisfied — ${approvers.length}/${threshold} approval(s): ${approvers.join(', ')}`);
+      return 0;
+    }
+    console.error(`✗ '${change}' not satisfied — ${approvers.length}/${threshold} peer approval(s)${allowSelf ? '' : ' (author self-approval does not count)'}`);
+    return 2;
+  }
+  if (sub === 'turn') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const action = argv[1];
+    const runway = argv[2] || 'main';
+    const actor = identity.resolveActor(root).id;
+    if (action === 'take') {
+      const r = queueLib.takeTurn(root, runway, actor);
+      if (r.held) { console.log(`✓ took the '${runway}' landing turn as '${actor}'`); return 0; }
+      console.error(`✗ '${runway}' turn held by '${r.holder}' — wait or coordinate`); return 2;
+    }
+    if (action === 'release') { queueLib.releaseTurn(root, runway); console.log(`✓ released the '${runway}' turn`); return 0; }
+    if (action === 'holder') { const h = queueLib.turnHolder(root, runway); console.log(h ? `${runway}: held by '${h}'` : `${runway}: free`); return 0; }
+    console.error('usage: momentum team turn <take|release|holder> [runway]');
+    return 1;
+  }
+  if (sub === 'lease') {
+    const root = repoRoot(cwd);
+    if (!root) { console.error('✗ not inside a git repository'); return 1; }
+    const action = argv[1];
+    const resource = argv[2];
+    if (!action || !resource) { console.error('usage: momentum team lease <acquire|release|owner> <resource>'); return 1; }
+    const actor = identity.resolveActor(root).id;
+    if (action === 'acquire') {
+      const r = leaseLib.acquireLease(root, resource, actor);
+      if (r.held) { console.log(`✓ leased '${resource}' as '${actor}'`); return 0; }
+      console.error(`✗ '${resource}' leased by '${r.owner}'`); return 2;
+    }
+    if (action === 'release') { leaseLib.releaseLease(root, resource); console.log(`✓ released lease '${resource}'`); return 0; }
+    if (action === 'owner') { const o = leaseLib.leaseOwner(root, resource); console.log(o ? `${resource}: owned by '${o}'` : `${resource}: free`); return 0; }
+    console.error('usage: momentum team lease <acquire|release|owner> <resource>');
+    return 1;
+  }
+  if (sub === 'contract') {
+    console.log(JSON.stringify(CONTRACT, null, 2));
+    return 0;
+  }
+  if (sub === 'relay') {
+    const { flags } = parseFlags(argv.slice(1));
+    const relay = createRelay({ port: flags.port ? parseInt(flags.port, 10) : 0 });
+    relay.listen((port) => {
+      console.log(`✓ momentum coordination relay (authority-free) on http://127.0.0.1:${port}`);
+      console.log(`  set relay_url=http://127.0.0.1:${port} for teammates; Ctrl-C to stop.`);
+    });
+    return 0; // server keeps the process alive
+  }
+  console.error('usage: momentum team <whoami|sync|board|record|compile|heartbeat|presence|approve|check|turn|lease|contract|relay>');
+  return 1;
+}
+
+module.exports = { runTeam, runClaim };

package/core/identity/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Actor identity (Phase 30a Team-Walk, ADR-0012).
+ *
+ * momentum was identity-blind — "actors" were random per-process UUIDs
+ * (bin/swarm.js) and branch names (core/lanes/lib/signals.js). Team mode needs
+ * a DURABLE actor so coordination writes, claims, and approvals can say WHO.
+ *
+ * The zero-config source is git's own identity (`git config user.email` /
+ * `user.name`), overridable by $MOMENTUM_ACTOR, with a deterministic fallback
+ * (stable per repo+user) when git identity is unset. No accounts, no server.
+ *
+ * Zero dependencies — node builtins only.
+ */
+
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+function git(cwd, ...args) {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  if (res.status !== 0) return null;
+  return res.stdout.trim();
+}
+
+/** Slugify an email/name into a stable, path-safe actor id. */
+function slug(s) {
+  const out = String(s)
+    .toLowerCase()
+    .trim()
+    .replace(/@.*$/, '') // email local-part
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+  return out || 'anon';
+}
+
+/**
+ * Resolve the durable actor for `cwd`.
+ * Precedence: $MOMENTUM_ACTOR → git config user.email → deterministic fallback.
+ * `env` is injectable for testing (defaults to process.env).
+ * Returns { id, name, email, source }.
+ */
+function resolveActor(cwd, env) {
+  env = env || process.env;
+  const dir = cwd || process.cwd();
+
+  const override = env.MOMENTUM_ACTOR && env.MOMENTUM_ACTOR.trim();
+  if (override) {
+    return { id: slug(override), name: override, email: null, source: 'env' };
+  }
+
+  const email = git(dir, 'config', 'user.email');
+  const name = git(dir, 'config', 'user.name');
+  if (email) {
+    return { id: slug(email), name: name || email, email, source: 'git' };
+  }
+
+  // Deterministic fallback — stable per repo+user without a git identity.
+  const root = git(dir, 'rev-parse', '--show-toplevel') || dir;
+  const user = env.USER || env.USERNAME || 'unknown';
+  const h = crypto.createHash('sha256').update(`${user}::${root}`).digest('hex').slice(0, 8);
+  return { id: `anon-${h}`, name: `anon-${h}`, email: null, source: 'fallback' };
+}
+
+module.exports = { resolveActor, slug };