yadflow 4.3.0 → 4.5.0

package/CHANGELOG.md

@@ -1,3 +1,66 @@
+# [4.5.0](https://github.com/abdelrahmannasr/yadflow/compare/v4.4.0...v4.5.0) (2026-10-06)
+
+
+### Bug Fixes
+
+* **member:** E131 review 1 — links, twins, proof and pushes ([1179a97](https://github.com/abdelrahmannasr/yadflow/commit/1179a9731e4ff9f8d6b80f5aed82d5809bde5ed2))
+* **member:** E131 review 2 — gate-live trust, account ids, clean-ups ([74d41f6](https://github.com/abdelrahmannasr/yadflow/commit/74d41f65a585fdf06639be87688f69353eb61916))
+* **member:** E131 review 3 — trust only files the gate judged ([2f9af14](https://github.com/abdelrahmannasr/yadflow/commit/2f9af141e524ca7daacbce8c2799f56c72c6d75e))
+* **member:** E131 review 4 — trust is read from origin's default branch ([43af9c4](https://github.com/abdelrahmannasr/yadflow/commit/43af9c4565c3bbfae7042d7765df62150fa64447))
+* **member:** E131 review 5 — every change re-proves every email ([041937c](https://github.com/abdelrahmannasr/yadflow/commit/041937c936f5d9f29683ef6f9d4cc6fb93ad83bd))
+* **member:** E131 review 6 — re-runs, origin/HEAD, partial lists ([e9bad00](https://github.com/abdelrahmannasr/yadflow/commit/e9bad002eff766705d193b1515baa3d39ae0c360))
+* **standup:** E132 review 1 — gate rule, malformed ledgers, terminal safety ([a0e7d47](https://github.com/abdelrahmannasr/yadflow/commit/a0e7d4750e7b485582cded4b55dfcc212013a101))
+* **standup:** E132 review 2 — missed twins of round 1 ([ba1ce61](https://github.com/abdelrahmannasr/yadflow/commit/ba1ce61b961decbea46298b714fd33f811fb264a))
+* **standup:** E132 review 3 — paths, disputed accounts, left members ([add86cc](https://github.com/abdelrahmannasr/yadflow/commit/add86cca821ab29afa79838734a3b83621dd2330))
+* **standup:** E132 review 4 — Windows paths, a name is plain text ([435225f](https://github.com/abdelrahmannasr/yadflow/commit/435225f48a21fe8a850ba65c0c7f1315df6bbb1e))
+* **standup:** E132 review 5 — path names in square brackets ([7ac3cb2](https://github.com/abdelrahmannasr/yadflow/commit/7ac3cb265c309f0e707e6dae32076796a5e2c240))
+
+
+### Features
+
+* **join:** E131 join ends with yad member add ([3295429](https://github.com/abdelrahmannasr/yadflow/commit/3295429092b549707a03eecacddc50d15d1df77a))
+* **member:** E131 team member files, proven by the platform ([3e60bb6](https://github.com/abdelrahmannasr/yadflow/commit/3e60bb62bb2edb467be4d5f8562b9fe1bac6ca0a))
+* **standup:** yad standup — a daily status per team member (E132) ([00f32ce](https://github.com/abdelrahmannasr/yadflow/commit/00f32ce742166e8b82e796b3eef85b379edd4cee))
+
+# [4.4.0](https://github.com/abdelrahmannasr/yadflow/compare/v4.3.0...v4.4.0) (2026-10-03)
+
+
+### Bug Fixes
+
+* **skill:** E51 review 1 — read the route the epic records, never a guess ([cefdb21](https://github.com/abdelrahmannasr/yadflow/commit/cefdb216139e4608961b83a5ec61f1ca6cb318c7))
+* **skill:** E51 review 2 — say an epic's route is unknown; simplify the change-epic seed ([c5e6f0e](https://github.com/abdelrahmannasr/yadflow/commit/c5e6f0e12e56a768196088aff10d2eebd3f70293))
+* **skill:** E52 flag a pick bound in place of yadflow's skill; list prints the catalogue's age ([a0b76f3](https://github.com/abdelrahmannasr/yadflow/commit/a0b76f30fd1d9fb3123977532ab0ef055daf89bf))
+* **skill:** E52 review 1 — yadflow's skill must run last, plugin names, route view in list ([fcf675a](https://github.com/abdelrahmannasr/yadflow/commit/fcf675a6fe64788f3d0b2c12f8f7aad14eb6448c))
+* **skill:** E52 review 2 — a bare bound name never matches a plugin-qualified pick ([4199fd3](https://github.com/abdelrahmannasr/yadflow/commit/4199fd332f36eb532f9aa4bd2a4f05a77bfa6cec))
+* **skill:** E52 review 3 — a marketplace-spelled binding is the same pick ([04d7aaa](https://github.com/abdelrahmannasr/yadflow/commit/04d7aaafe640253dd0ecc48e922c993e0d7b3860))
+* **toolbox:** E87 review 1 — CRLF, unseen tools, no Product, honest Repomix fallback ([dc3bd75](https://github.com/abdelrahmannasr/yadflow/commit/dc3bd7577271c5fb71fe5522e8a6d1f2c1fff575))
+* **toolbox:** E87 review 10 — unclosed fence refused, frontmatter skipped ([577786c](https://github.com/abdelrahmannasr/yadflow/commit/577786c2ff939be1bf7565c9bc4f3b72d9569cd7))
+* **toolbox:** E87 review 11 notes — frontmatter hides nothing, exact round trip ([b8bb924](https://github.com/abdelrahmannasr/yadflow/commit/b8bb924c5320f3fdf531f03fa968f77dc970f8c8))
+* **toolbox:** E87 review 12 — a section can never cross the frontmatter ([cb1c111](https://github.com/abdelrahmannasr/yadflow/commit/cb1c11184fd2caea1e2f6b4c7082b65e5de462f3))
+* **toolbox:** E87 review 13 notes — frontmatter closes at '--- ' or '...' ([df6c644](https://github.com/abdelrahmannasr/yadflow/commit/df6c644f639eaeef04b36eb1da2116b472452f39))
+* **toolbox:** E87 review 14 — frontmatter needs a YAML key; no write leaves two copies ([20f3c75](https://github.com/abdelrahmannasr/yadflow/commit/20f3c75a231461d42566474d8be972e08edc59df))
+* **toolbox:** E87 review 15 — check names the two-copy refusal too ([88757ac](https://github.com/abdelrahmannasr/yadflow/commit/88757acf9015dc8a8b2adae7137fdf1b8a151959))
+* **toolbox:** E87 review 2 — connector-only sections, safer section finder ([00127ec](https://github.com/abdelrahmannasr/yadflow/commit/00127ecd4ae61c10cc5b34beaf32d42512d8ea05))
+* **toolbox:** E87 review 3 — a removal works, a misread is refused by content ([a42bc78](https://github.com/abdelrahmannasr/yadflow/commit/a42bc78bc5a53ba1e9c17073615f9313bab3b66e))
+* **toolbox:** E87 review 4 — one heading rule, a guard that quotes its line ([768b43a](https://github.com/abdelrahmannasr/yadflow/commit/768b43a7f8df84aeb1ca1d53818a421a1dca5ba2)), closes [#s](https://github.com/abdelrahmannasr/yadflow/issues/s)
+* **toolbox:** E87 review 5 notes — fence-aware copy count, dividers, linear heading read ([d9eb679](https://github.com/abdelrahmannasr/yadflow/commit/d9eb6793ead27dfa9f76f60bc301a45df727a832)), closes [#s](https://github.com/abdelrahmannasr/yadflow/issues/s)
+* **toolbox:** E87 review 6 — truly linear heading read, underline guard reads real headings ([83d0885](https://github.com/abdelrahmannasr/yadflow/commit/83d0885c9f8c6c216a35e740b365c6eebaca6b54)), closes [#s](https://github.com/abdelrahmannasr/yadflow/issues/s) [#hashtag](https://github.com/abdelrahmannasr/yadflow/issues/hashtag)
+* **toolbox:** E87 review 7 — no slow pattern left in the section readers ([7201076](https://github.com/abdelrahmannasr/yadflow/commit/72010765951c569ea0c0cbc52b67c13f96c9f248))
+* **toolbox:** E87 review 8 — a divider ends the block; the guard is checked against marked ([750187c](https://github.com/abdelrahmannasr/yadflow/commit/750187cecd34e8ff49c39e141424656781def287)), closes [#tag](https://github.com/abdelrahmannasr/yadflow/issues/tag)
+* **toolbox:** E88 review 1 — refuse future and impossible vetting dates; pin every Repomix line ([20048b5](https://github.com/abdelrahmannasr/yadflow/commit/20048b562129a3860a521dc8a159cc8641dc3d9a))
+* **toolbox:** E88 review 2 — install-line test fails closed; pin test covers npm install ([e955cbd](https://github.com/abdelrahmannasr/yadflow/commit/e955cbddc5d1d596c833dfb596b1536516b4d489))
+* **toolbox:** E88 review 3 — a terms page that says license is not a licence file ([34edaf8](https://github.com/abdelrahmannasr/yadflow/commit/34edaf84f0a4a3d7338de1aae61964f975c6e2e3))
+* **toolbox:** E88 review 4 — tell a licence file by where it lives, not its letter case ([4e9dbc0](https://github.com/abdelrahmannasr/yadflow/commit/4e9dbc0850ca9cba27ceba00e8b9dea777c1d1e6))
+* **toolbox:** E88 review 5 — a repository's front page is not a licence file ([3f9fe15](https://github.com/abdelrahmannasr/yadflow/commit/3f9fe15a54a259c7c784a18b4e52e69ce50a7104))
+
+
+### Features
+
+* **skill:** E51 bind a skill for one route only ([654488c](https://github.com/abdelrahmannasr/yadflow/commit/654488c7e7d876fbe29122959f2befe1122ebffe))
+* **skill:** E52 recommendation catalogue and yad skill recommend ([2b4fba0](https://github.com/abdelrahmannasr/yadflow/commit/2b4fba05a6e27af978dcaeb25fe61a0dc61c36b6))
+* **toolbox:** E88 vet every toolbox tool, and pin Repomix to the vetted version ([e4026f3](https://github.com/abdelrahmannasr/yadflow/commit/e4026f3140428a6b80c1842e410c8174f5ecb205))
+* **toolbox:** every skill that uses a tool declares its fallback (E87) ([8d4963e](https://github.com/abdelrahmannasr/yadflow/commit/8d4963e603e92be0fcbc616e98a5ea5939befbc4))
+
 # [4.3.0](https://github.com/abdelrahmannasr/yadflow/compare/v4.2.0...v4.3.0) (2026-10-01)
 
 

package/README.md

@@ -144,7 +144,7 @@ unless CI runs it), or `yad gate advance` with no platform, is the human decisio
 | --- | --- | --- |
 | Existing repositories | `yad init`, in the folder that holds them | Run the `yad-backfill` skill first. It records what already exists. |
 | One existing repository with all the code | `yad setup --brownfield --monorepo`, inside it | The same: run `yad-backfill` first. |
-| A team that already uses Yadflow | `yad join <Product clone URL>` | It clones the Product and every repository it lists. It sets up only this machine and never commits. |
+| A team that already uses Yadflow | `yad join <Product clone URL>` | It clones the Product and every repository it lists and sets up this machine. Last, it records you as a team member (`yad member add`): your accounts and verified emails, on a branch of its own with its own pull request. |
 
 **Small changes.** Not every change needs the full route:
 
@@ -256,8 +256,10 @@ The record is worth trusting because people approve what goes into it.
 - the Shape and Build steps with review gates
 - linked changes and `yad thread`
 - `yad history`, `yad next` and `yad usage`
+- `yad standup`, a daily status for each team member — what they did since the last working day, what they are on now, and what is waiting — rebuilt live from git, the ledgers and the platform, facts only
 - `yad detect`, which lists the skills, agents, MCP servers and plugins installed for each AI agent
-- `yad toolbox list`, which shows the external tools yadflow can use, which ones you have, and what happens without each; `yad toolbox add` / `remove` record the tools your team uses, and `yad toolbox check` lists the ones not ready on your machine (`yad setup`, `check`, `update` and `join` print the same list, and never install anything)
+- `yad toolbox list`, which shows the external tools yadflow can use, which ones you have, and what happens without each; `yad toolbox add` / `remove` record the tools your team uses, and `yad toolbox check` lists the ones not ready on your machine (`yad setup`, `check`, `update` and `join` print the same list, and never install anything); each skill that uses a tool reads the same answer and says what it does without it
+- `yad skill recommend`, which lists hand-picked skills from the recommended skill collections for each step, why each fits, and the command to bind one; it binds nothing, and every pick was checked against its source
 - draft saving, claims and owners
 - the CI checks
 - the Review Companion

package/bin/commands.mjs

@@ -18,7 +18,7 @@ export { gateOpen, gateSync, gateComments, gateStatus, gateCi, gateReview, gateT
 export { gateApprove, gateComment, gateAdvance } from '../cli/gate-local.mjs';
 export { isValidEpicId, productDriftError, seedableProfiles } from '../cli/epic-state.mjs';
 export { runEpicNew, runFoundationNew, runFoundationStatus } from '../cli/epic.mjs';
-export { runSkillBind, runSkillList, runSkillUnbind } from '../cli/skill.mjs';
+export { runSkillBind, runSkillList, runSkillRecommend, runSkillUnbind } from '../cli/skill.mjs';
 export { runCommit } from '../cli/commit.mjs';
 export { runOpenPr } from '../cli/openpr.mjs';
 export { reviewTrailer, reviewContext, reviewNudge, reviewReconcile, reviewWalkthrough } from '../cli/review.mjs';
@@ -29,6 +29,8 @@ export { runCapture } from '../cli/capture.mjs';
 export { runFold } from '../cli/fold.mjs';
 export { runClaims } from '../cli/claims.mjs';
 export { runAssign, runUnassign, runOwners } from '../cli/owners.mjs';
+export { runMemberAdd, runMemberList, runMemberRemove } from '../cli/members.mjs';
+export { runStandup, foreignFlags as standupForeignFlags } from '../cli/standup.mjs';
 export { runIndex } from '../cli/index-command.mjs';
 export { runHistory, HISTORY_FLAGS } from '../cli/history.mjs';
 export { runRepo } from '../cli/repo.mjs';

package/bin/yad.mjs

@@ -21,7 +21,8 @@ ${c.bold('Start a workspace')} ${c.dim('(the folder holding product/ and the cod
                        Clone the Product into [folder]/product/ (default: the URL's last name) and
                        every repo it registers; a failed repo clone is reported, never fatal. Then
                        only per-machine steps: git-ignored skill copies + the git pre-commit hook.
-                       Never commits, pushes, or changes a shared file
+                       Last, \`yad member add\` (below): your member file, on a branch with its own
+                       PR/MR — the only shared change join makes. A problem there never fails join
 
 ${c.bold('Setup & maintenance')}
   yad setup            Guided first-run setup (profile interview, install, connect & wire repos,
@@ -68,6 +69,31 @@ ${c.bold('Setup & maintenance')}
                        installs in this clone refuses a person's hand commit to the ledger.
                        YAD_HOOK_DISABLE=1 skips.
 
+${c.bold('Team members')} ${c.dim('(identity only — no roles, no reviewers, no allowlist)')}
+  yad member add [--no-push]           Prove who you are and write .sdlc/members/<platform>-<login>.json:
+                                       your account on the Product's platform (logs you in if needed),
+                                       your other GitHub/GitLab accounts and git emails that the platform
+                                       says are VERIFIED (stored hashed). One commit per email on
+                                       yad/member/<login>, pushed, with a PR/MR. Never your checkout
+  yad member list [--json]             Every member: active (committed or approved within the TTL,
+                                       default 90 days), idle (quiet, still has access), left (the
+                                       platform says no access — off the team list) or unknown
+  yad member remove [<login>] [--reason <why>]
+                                       Delete a member file — your own, or anyone's with --reason
+
+${c.bold('Daily standup')} ${c.dim('(derived live, read-only, facts only — no score, no ranking)')}
+  yad standup                          Each member on the team list: done since the last standup
+                                       (commits, approvals, comments, closed steps, ships, merged
+                                       PRs/MRs), working on now (owned steps, open claims, drafts, open
+                                       PRs/MRs) and waiting (gates on their steps, their next move, their
+                                       PRs/MRs with failing checks or no approving review). Then the
+                                       people seen who are not on the list, and who has left.
+                                       Window: from midnight of the previous working day (Monday reads
+                                       back to Friday). Asks the platform about the Product and every
+                                       registered repo; one it cannot read says "platform not read"
+                                       flags: --since <YYYY-MM-DD>|<N>h|<N>d, --tz <zone> (default UTC),
+                                       --member <login> | --me, --format md|html, --out <file>, --json
+
 ${c.bold('Team usage (EM adoption & behavior report)')}
   yad usage                            Build a per-member report (HTML) from git + the SDLC ledgers
                                        (derived, read-only — writes no tracked state)
@@ -111,12 +137,22 @@ ${c.bold('Where am I / what next')}
   yad next --all                       Every active epic's next action at once
   yad next [<epic>] --json             The same answer as a machine-readable action object (for
                                        agents/CI) — always every epic, so --all is implied
-  yad skill list [--json]              Which skill runs which step, and whether that is this
-                                       project's choice or the engine's default
-  yad skill bind <step> <skill> [<skill> ...]
-                                       Bind a step to a skill of your own. Several skills run in
-                                       the order given, one after another — each costs tokens
-  yad skill unbind <step>              Drop the binding; the step goes back to the engine's default
+  yad skill list [--profile <p> | --epic <id>] [--json]
+                                       Which skill runs which step, whether that is one route's
+                                       choice, the project's or the engine's default, and whether
+                                       each skill is installed here (--epic: that epic's route)
+  yad skill bind <step> <skill> [<skill> ...] [--profile <p>]
+                                       Bind a step to a skill of your own — for every epic, or
+                                       with --profile for epics on that route only (it wins).
+                                       Several skills run in the order given — each costs tokens.
+                                       Warns when the skill is not installed here
+  yad skill unbind <step> [--profile <p>]
+                                       Drop the binding; the step goes back to the project-wide
+                                       binding, then the engine's default
+  yad skill recommend [<step>] [--profile <p> | --epic <id>] [--json]
+                                       Hand-picked skills from the recommended pools for each step,
+                                       why each fits, whether it is installed here, and the bind
+                                       command (pool skill first, yadflow's skill last). Binds nothing
   yad toolbox list [--json] [--dir <folder>]
                                        The external tools yadflow can use — core (offered at setup),
                                        recommended pools, the design/testing/learning connectors and
@@ -339,7 +375,9 @@ ${c.bold('Environment')}
   YAD_NO_REPORT=1            Never offer to file a bug report after a failure
   YAD_PLATFORM_LOGIN=0       Name a record's author by git user.name; never ask gh/glab who is logged in`;
 
-const VALUE_FLAGS = new Set(['--dir', '--type', '--message', '--task', '--ai', '--risk', '--repo', '--platform', '--base', '--title', '--scope', '--branch', '--pr', '--epic', '--team', '--body', '--out', '--since', '--until', '--member', '--format', '--reason', '--profile', '--parent', '--inherits', '--to', '--retro-ship', '--merge-commit', '--path', '--ide-targets', '--theme', '--thread', '--by', '--count', '--engagement', '--keep', '--role', '--fallback', '--detect', '--install', '--source']);
+const STANDUP_USAGE = 'usage: yad standup [--since <YYYY-MM-DD>|<N>h|<N>d] [--tz <zone>] [--member <login>|--me] [--format md|html] [--out <file>] [--json]';
+
+const VALUE_FLAGS = new Set(['--dir', '--type', '--message', '--task', '--ai', '--risk', '--repo', '--platform', '--base', '--title', '--scope', '--branch', '--pr', '--epic', '--team', '--body', '--out', '--since', '--until', '--member', '--format', '--reason', '--profile', '--parent', '--inherits', '--to', '--retro-ship', '--merge-commit', '--path', '--ide-targets', '--theme', '--thread', '--by', '--count', '--engagement', '--keep', '--role', '--fallback', '--detect', '--install', '--source', '--tz']);
 
 function parseArgs(argv) {
   const o = { _: [], dir: process.cwd(), fix: false, force: false, scope: 'all' };
@@ -350,6 +388,7 @@ function parseArgs(argv) {
     else if (a === '--force') o.force = true;
     else if (a === '--contract-change') o.contractChange = true;
     else if (a === '--manual') o.manual = true;
+    else if (a === '--me') o.me = true;
     else if (a === '--no-push') o.noPush = true;
     else if (a === '--no-fetch') o.noFetch = true;
     else if (a === '--push') o.push = true;
@@ -425,7 +464,7 @@ let runningCmd = null;
 const ACTIONS = {
   epic: { known: ['new'] },
   foundation: { known: ['new', 'status'] },
-  skill: { known: ['list', 'bind', 'unbind'], default: 'list' },
+  skill: { known: ['list', 'bind', 'unbind', 'recommend'], default: 'list' },
   gate: { known: ['open', 'sync', 'comments', 'status', 'repair', 'review', 'walkthrough', 'trailer', 'ci', 'approve', 'comment', 'advance'] },
   review: { known: ['trailer', 'context', 'chat', 'cards', 'walkthrough', 'nudge', 'reconcile'] },
   tidy: { known: ['up'] },
@@ -437,6 +476,7 @@ const ACTIONS = {
   reconcile: { known: ['check', 'refresh', 'wire'] },
   hook: { known: ['ledger-guard'] },
   toolbox: { known: ['list', 'check', 'add', 'remove'], default: 'list' },
+  member: { known: ['add', 'list', 'remove'], default: 'list' },
 };
 // E80 — how each command finds its folder. A PRODUCT command works on the Product; a REPO command works
 // on the code repo it runs in and reads the Product beside it. The rest take their folder as given:
@@ -445,7 +485,7 @@ const PRODUCT_CMDS = new Set([
   'check', 'update', 'doctor', 'migrate', 'usage', 'sync-status', 'epic', 'foundation', 'skill', 'next',
   'skip', 'unskip', 'defer', 'undefer', 'dial', 'mode', 'kill', 'unkill', 'unblock', 'gate', 'checkpoint',
   'capture', 'claims', 'assign', 'unassign', 'owners', 'fold', 'tidy', 'index', 'history', 'repo',
-  'risk-map', 'codeowners', 'docs', 'thread', 'reconcile',
+  'risk-map', 'codeowners', 'docs', 'thread', 'reconcile', 'member', 'standup',
 ]);
 const REPO_CMDS = new Set(['commit', 'open-pr', 'ship', 'review']);
 // The Product commands that WRITE its files without first checking it is one. Run from a code repo they
@@ -458,6 +498,7 @@ function writesProduct(cmd, o) {
   if (cmd === 'epic' || cmd === 'foundation') return action === 'new';
   if (cmd === 'skill') return action === 'bind' || action === 'unbind';
   if (cmd === 'dial') return o.to !== undefined;
+  if (cmd === 'member') return o._[1] === 'add' || o._[1] === 'remove';
   // `--wire` writes a CI workflow; `--refresh` only rebuilds sites the folder already holds.
   if (cmd === 'docs') return action === 'sync' && !!o.wire;
   return false;
@@ -735,11 +776,12 @@ async function main() {
     }
     case 'skill': {
       const [, action, step, ...rest] = o._;
-      if (action === 'list' || action === undefined) { result = commands.runSkillList(o.dir, { json: o.json }); break; }
+      if (action === 'list' || action === undefined) { result = commands.runSkillList(o.dir, { json: o.json, profile: o.profile, epic: o.epic }); break; }
       if ((action === 'bind' || action === 'unbind') && noProduct()) break;
-      if (action === 'bind') { result = commands.runSkillBind(o.dir, { step, skills: rest }); break; }
-      if (action === 'unbind') { result = commands.runSkillUnbind(o.dir, { step }); break; }
-      refuse(`unknown skill action: ${action} (list, bind, unbind)`, 'usage: yad skill list [--json] | yad skill bind <step> <skill> [<skill> ...] | yad skill unbind <step>');
+      if (action === 'bind') { result = commands.runSkillBind(o.dir, { step, skills: rest, profile: o.profile }); break; }
+      if (action === 'unbind') { result = commands.runSkillUnbind(o.dir, { step, profile: o.profile }); break; }
+      if (action === 'recommend') { result = commands.runSkillRecommend(o.dir, { step: step ?? null, json: o.json, profile: o.profile, epic: o.epic }); break; }
+      refuse(`unknown skill action: ${action} (list, bind, unbind, recommend)`, 'usage: yad skill list [--profile <p> | --epic <id>] [--json] | yad skill bind <step> <skill> [<skill> ...] [--profile <p>] | yad skill unbind <step> [--profile <p>] | yad skill recommend [<step>] [--profile <p> | --epic <id>] [--json]');
       break;
     }
     case 'next': {
@@ -876,6 +918,30 @@ async function main() {
       if (o.hook) process.exitCode = 0;
       break;
     }
+    case 'member': {
+      // E131. One file per person, identity only.
+      const [, action = 'list', who, extra] = o._;
+      const usage = 'usage: yad member add [--no-push] | yad member list [--json] | yad member remove [<login>] [--reason "<why>"]';
+      if (!['add', 'list', 'remove'].includes(action)) { refuse(`unknown member action: ${action} (add, list, remove)`, usage); break; }
+      if ((action !== 'remove' && who) || extra) { refuse(`unexpected word: ${extra || who}`, usage); break; }
+      if (noProduct()) break;
+      if (action === 'add') result = await commands.runMemberAdd(o.dir, { noPush: !!o.noPush, today });
+      else if (action === 'list') result = await commands.runMemberList(o.dir, { today });
+      else result = await commands.runMemberRemove(o.dir, { login: who ?? null, reason: o.reason ?? null });
+      break;
+    }
+    case 'standup': {
+      // E132. Read-only; every flag that is not standup's own is refused, as history refuses them.
+      const foreign = commands.standupForeignFlags(process.argv.slice(2));
+      if (foreign.length) { refuse(`yad standup does not take ${foreign.join(', ')}`, STANDUP_USAGE); break; }
+      if (o._[1]) { refuse(`yad standup takes no words (got: ${o._[1]})`, STANDUP_USAGE); break; }
+      if (noProduct()) break;
+      result = await commands.runStandup(o.dir, {
+        since: o.since ?? null, tz: o.tz ?? 'UTC', member: o.member ?? null, me: !!o.me,
+        format: o.format ?? null, out: o.out ?? null, json: !!o.json,
+      });
+      break;
+    }
     case 'claims': {
       // E46. Read from the capture branches; nothing is recorded here.
       const [, epic, extra] = o._;

package/cli/claims.mjs

@@ -135,6 +135,21 @@ export function claimWarnings(root, changed, { env = process.env, now = Date.now
 }
 export const warningText = (hits, now) => `yad claims: ${hits.length === 1 ? 'this file is' : 'these files are'} also being edited by someone else — advice, not a lock; talk to them before you go further:\n${hits.map((c) => `  • ${claimLine(c, now)}`).join('\n')}`;
 
+// Fetch everyone's capture branches and the default branch: 'done' | 'failed' | 'local' (no origin). One
+// fetch, 30 seconds at most. `yad claims` and `yad standup` (E132) both read what it brings.
+export function fetchCaptures(root, env = process.env) {
+  const git = gitIn(root, env);
+  if (!git(['remote', 'get-url', 'origin']).ok) return 'local';
+  const opts = { cwd: root, encoding: 'utf8', timeout: 30_000, env: { ...env, ...pushEnv(env) } };
+  const r = spawnSync('git', fetchAllArgs({ prune: true }), opts);
+  const fetched = r.status === 0 ? 'done' : 'failed';
+  // The default branch, for the "landed" rule — on its own: a name guessed wrong (no Product default, no
+  // origin/HEAD) must not stop the capture branches from arriving. Its failure changes nothing.
+  const def = defaultRef(root, git).name;
+  if (fetched === 'done') spawnSync('git', ['-c', 'http.lowSpeedLimit=1000', '-c', 'http.lowSpeedTime=20', 'fetch', '--quiet', '--no-tags', 'origin', `+refs/heads/${def}:refs/remotes/origin/${def}`], opts);
+  return fetched;
+}
+
 // `yad claims [<epic>] [--no-fetch]`. Returns a plain object (E1 makes it the `--json` answer).
 export async function runClaims(root, { epic = null, noFetch = false, env = process.env, now = Date.now() } = {}) {
   const refuse = (msg, hint) => { fail(msg); if (hint) hand(hint); process.exitCode = 1; };
@@ -142,19 +157,7 @@ export async function runClaims(root, { epic = null, noFetch = false, env = proc
   if (!git(['rev-parse', '--show-toplevel']).ok) return refuse('not a git repository — there are no capture branches to read');
   if (!fs.existsSync(productConfigPath(root))) return refuse('not a Product (no .sdlc/hub.json or product.json here)', 'run it from the Product root, or pass --dir');
   if (epic && !/^EP-[a-z0-9-]+$/.test(epic)) return refuse(`not an epic id: ${epic}`);
-  let fetched = 'skipped';
-  if (!noFetch) {
-    if (!git(['remote', 'get-url', 'origin']).ok) fetched = 'local';
-    else {
-      const opts = { cwd: root, encoding: 'utf8', timeout: 30_000, env: { ...env, ...pushEnv(env) } };
-      const r = spawnSync('git', fetchAllArgs({ prune: true }), opts);
-      fetched = r.status === 0 ? 'done' : 'failed';
-      // The default branch, for the "landed" rule — on its own: a name guessed wrong (no Product default, no
-      // origin/HEAD) must not stop the capture branches from arriving. Its failure changes nothing.
-      const def = defaultRef(root, git).name;
-      if (fetched === 'done') spawnSync('git', ['-c', 'http.lowSpeedLimit=1000', '-c', 'http.lowSpeedTime=20', 'fetch', '--quiet', '--no-tags', 'origin', `+refs/heads/${def}:refs/remotes/origin/${def}`], opts);
-    }
-  }
+  const fetched = noFetch ? 'skipped' : fetchCaptures(root, env);
   if (fetched === 'local') info('no remote named origin — only your own captures can be read here');
   if (fetched === 'failed') warn('could not fetch the capture branches — showing what was last fetched, which may be old');
   const { claims, defaultBranch } = readClaims(root, { env, now, epics: epic ? new Set([epic]) : null });

package/cli/detect.mjs

@@ -4,8 +4,8 @@
 //   yad detect [--json] [--dir <folder>]
 //
 // Worked out fresh on every run and never saved: nothing reads it yet except a person, and a saved copy
-// would be a new file shape that goes stale the moment someone installs a skill. E51 (bind per profile)
-// and E85 (the toolbox check) are the readers this is built for.
+// would be a new file shape that goes stale the moment someone installs a skill. `yad skill list` /
+// `yad skill bind` (E51, "is this skill installed here?") and E85 (the toolbox check) read it too.
 //
 // TWO PLACES ARE LOOKED IN: the folder the command runs on (what a teammate who clones it also gets), and
 // the user's home folder (where most people install skills). Every item says which one, and which agents

package/cli/docs.mjs

@@ -2,7 +2,7 @@
 // documentation sites generated by the yad-docs / yad-docs-overview skills. The CONTENT generation
 // (reading epic/architecture/contract/ui/stories → writing src/data/*.ts and theming index.css) is
 // the AI step inside those skills; this module only does the mechanical parts: npm build (a
-// subprocess, like yad-spec shelling npx repomix), the platform Pages wiring (reusing platform.mjs),
+// subprocess, like yad-spec shelling out to Repomix), the platform Pages wiring (reusing platform.mjs),
 // and the manifest-hash staleness check (reusing the head-sha idea from repo.mjs). It NEVER touches
 // epic state, approvals, or the contract lock — docs are an output enrichment, not a gate.
 //

package/cli/doctor.mjs

@@ -10,7 +10,7 @@ import { VERSION, BACKUP_SUFFIX, MIRRORED_FILES, mirrorDrift, PROJECT_FILES, MOD
 import { mergeHookSettings, hookMatcherFires, ideTargetsFor, safeIdeTargetStateFor, hookScriptReady, miswiredGuardCommand, gitHookState, legacyModuleActions, legacyProductActions, renamedNameHits, PRODUCT_CHECK_WORKFLOWS, productProfileEffect, workflowsPassingProduct, productGateBlockers, oldProfileAdvice, gateProfileFix } from './plan.mjs';
 import { hasSiblingRepo, workspaceFileState, WORKSPACE_FILE } from './find-product.mjs';
 import { planMigration } from './migrate.mjs';
-import { ADVANCE_VALUES, isGateStep, killSwitchOn, loadAutomation, stepDef as catalogueStep, loadLedger, owedSteps, epicIds, epicRel, epicRoot, FOUNDATION_DIR, FOUNDATION_EPIC, DISCOVERY_EPIC, staleFoundationGuards, unwrittenSections, artifactBase, artifactAgrees, epicStories, laneStarted, isValidEpicId, epicLineage, isGenesisType, readFrontmatter, resolveThread, stateInvariants, contractSurfaceHash, acceptedHashes, isStaleHash, workItemType, WORK_ITEM_TYPES, themeOf, themeKey, stepPhase, stepDef, matchLifecycleProfile, lifecycleProfile, LIFECYCLE_PROFILES, SENTINELS, normalizeBindings, optionalStepsFor, isSkippableStep, recordedRouteDisagrees, isPassed, stepStatus, claimsSkipped, STEP_STATES, isStepRecord, RECORDED_STEP_STATES, productDriftPairs } from './epic-state.mjs';
+import { ADVANCE_VALUES, isGateStep, killSwitchOn, loadAutomation, stepDef as catalogueStep, loadLedger, owedSteps, epicIds, epicRel, epicRoot, FOUNDATION_DIR, FOUNDATION_EPIC, DISCOVERY_EPIC, staleFoundationGuards, unwrittenSections, artifactBase, artifactAgrees, epicStories, laneStarted, isValidEpicId, epicLineage, isGenesisType, readFrontmatter, resolveThread, stateInvariants, contractSurfaceHash, acceptedHashes, isStaleHash, workItemType, WORK_ITEM_TYPES, themeOf, themeKey, stepPhase, stepDef, matchLifecycleProfile, lifecycleProfile, LIFECYCLE_PROFILES, SENTINELS, normalizeBindings, stepsReadingBinding, optionalStepsFor, isSkippableStep, recordedRouteDisagrees, isPassed, stepStatus, claimsSkipped, STEP_STATES, isStepRecord, RECORDED_STEP_STATES, productDriftPairs } from './epic-state.mjs';
 import { loadDebt } from './thread.mjs';
 import { readShips } from './ledger.mjs';
 import { gitHead, insideWorkspace } from './setup.mjs';
@@ -25,6 +25,7 @@ import { soloTeamHint, TEAM_CMD } from './people.mjs';
 import { indexFreshness, INDEX_FILE } from './product-index.mjs';
 import { productGit, resolveDefaultBranch } from './productcommit.mjs';
 import { readOwners } from './owners.mjs';
+import { readMembers, judgedMemberFiles } from './members.mjs';
 import { loadChoices, readToolboxFile } from './toolbox.mjs';
 
 // A registered path doctor may run git in (E81): a checkout the judgement accepts — never a refused
@@ -1889,6 +1890,37 @@ export function ownerChecks(checks, root) {
     'such a file is ignored — no owner is shown and the edit-time warning is off. For a step on the chain, `yad assign <epic> <step> --force` replaces it and `yad unassign <epic> <step> --force` removes it; for any other, delete it (`git rm <path>`). `yad owners` lists them all');
 }
 
+// `members:*` (E131). A member file that cannot be used, or an account or email two files share, pairs
+// nothing — the person it was meant to join counts twice, and nobody is told anywhere else. And where no
+// CI runs (a local ledger, no platform), nothing checks a member file: say that it is its owner's statement.
+export function memberChecks(checks, root) {
+  let got;
+  try { got = readMembers(root); } catch { return; }
+  const some = (list) => `${list.slice(0, 3).join('; ')}${list.length > 3 ? ` (+${list.length - 3} more)` : ''}`;
+  if (got.errors.length) {
+    check(checks, 'members:unreadable', 'project', 'warn', `${got.errors.length} member file(s) pair nothing: ${some(got.errors.map((e) => e.error))}`,
+      'such a file joins no email to any login, so its person counts twice and is not on the team list. Its owner runs `yad member add` to write it again; otherwise delete it (`yad member remove <login> --reason …`)');
+  }
+  if (got.duplicates.length) {
+    check(checks, 'members:duplicate', 'project', 'warn', `an account or email is in two member files: ${some(got.duplicates)}`,
+      'one account and one email belong to one member. Until one file is fixed, neither file joins it. On a verified Product the member-check gate refuses the PR that adds the second');
+  }
+  // Which files the gate COUNT leaves out, and why (review 3): no live gate, or a file the gate never judged.
+  if (got.members.length && got.identity.verified && got.identity.platform === 'github') {
+    const judged = judgedMemberFiles(root, got.identity);
+    const left = got.members.filter((m) => !judged.files.has(m.rel)).map((m) => m.rel);
+    if (left.length) {
+      check(checks, 'members:untrusted', 'project', 'warn', `${left.length} member file(s) are not used by the active-people count: ${left.slice(0, 3).join('; ')}${left.length > 3 ? ` (+${left.length - 3} more)` : ''}`,
+        judged.live ? 'no gate as shipped judged them: each was last changed before the member-check gate or its workflow last changed on origin\'s default branch (every `yad update` that changes either resets this), or differs here from origin — its owner runs `yad member add` again, and that change is judged'
+          : 'the member-check gate or its workflow on origin\'s default branch is missing, edited, or from another yadflow version than this one — `yad update` installs the shipped copies, then each member runs `yad member add` again');
+    }
+  }
+  if (got.members.length && !got.identity.verified) {
+    check(checks, 'members:unchecked', 'project', 'ok', `${got.members.length} member file(s), and no CI checks them on this Product`,
+      'with a local ledger or no platform, no member-check gate runs, so each member file is its owner\'s own statement');
+  }
+}
+
 // The installed gates whose changed list must name a rename by both paths (E114), and the test for one
 // that does not. Read as bash reads it, one command at a time, so one fixed command never hides its blind
 // twin: a `#` line is prose and is dropped FIRST (a `\` at its end does not go on); then a line ending in
@@ -2099,14 +2131,86 @@ export function skillBindingChecks(checks, root) {
       `${rel} binds ${gates.join(', ')}, which no skill runs — review gates are driven by \`yad gate\``,
       'bind the author step instead (for example `architecture`, not `architecture-review`)');
   }
+  const routeBound = profileBindingChecks(checks, rel, raw.profiles);
+  if (routeBound === null) return;
   // Its OWN id, not `skills` again. A file with one good binding and one broken line fires both, and
   // two checks sharing an id put a green tick under the complaint in prose — and, worse, let a `--json`
   // consumer keying by id overwrite the warning with the tick.
-  if (bound.length) {
+  if (bound.length || routeBound) {
     const chained = bound.filter(([, list]) => list.length > 1).length;
     check(checks, 'skills:bound', 'project', 'ok',
-      `skills: ${bound.length} step(s) bound${chained ? `, ${chained} to more than one skill` : ''}`);
+      `skills: ${bound.length} step(s) bound${chained ? `, ${chained} to more than one skill` : ''}`
+        + (routeBound ? `; ${routeBound} more for one route only` : ''));
+  }
+}
+
+// `profiles.<p>.steps` (E51): the same three "your line did nothing" warnings, each naming its route,
+// plus the two only a route can have — a route this release does not carry, and a step the route never
+// walks (`architecture` on `spike`: no epic on it ever reaches that step, which is why `yad skill bind`
+// refuses the same line). Returns how many lines bind something, or null after a fail.
+function profileBindingChecks(checks, rel, profiles) {
+  if (profiles === undefined) return 0;
+  if (!isPlainObject(profiles)) {
+    check(checks, 'skills:profiles', 'project', 'fail', `${rel}: \`profiles\` must be a JSON object [YAD-STATE-002]`,
+      'expected `"profiles": { "<profile>": { "steps": { "<step-id>": "<skill>" } } }`');
+    return null;
+  }
+  const broken = Object.entries(profiles)
+    .filter(([, v]) => !isPlainObject(v) || (v.steps !== undefined && !isPlainObject(v.steps)))
+    .map(([id]) => id);
+  if (broken.length) {
+    check(checks, 'skills:profiles', 'project', 'fail',
+      `${rel}: ${broken.map((id) => `\`profiles.${id}\``).join(', ')} must hold a \`steps\` object [YAD-STATE-002]`,
+      'expected `"<profile>": { "steps": { "<step-id>": "<skill>" } }`');
+    return null;
+  }
+  const bindings = normalizeBindings({ profiles });
+  const unusable = [];
+  const unknownStep = [];
+  const gates = [];
+  const offRoute = [];
+  const unknownRoute = [];
+  let bound = 0;
+  for (const [id, entry] of Object.entries(profiles)) {
+    const kept = (Object.hasOwn(bindings.profiles, id) ? bindings.profiles[id].steps : null) || {};
+    const route = lifecycleProfile(id);
+    if (!route && Object.keys(kept).length) unknownRoute.push(id);
+    for (const step of Object.keys(entry.steps || {})) {
+      if (!Object.hasOwn(kept, step)) { unusable.push(`${id}: ${step}`); continue; }
+      bound += 1;
+      const def = stepDef(step);
+      if (!def) unknownStep.push(`${id}: ${step}`);
+      else if (!def.skill) gates.push(`${id}: ${step}`);
+      else if (route && (def.phase === 'build' ? route.level !== 'feature'
+        : !stepsReadingBinding(step).some((s) => route.rows.some((r) => r.id === s)))) offRoute.push(`${id}: ${step}`);
+    }
+  }
+  if (unusable.length) {
+    check(checks, 'skills:profile-unusable', 'project', 'warn',
+      `${rel}: ${unusable.length} route binding(s) name no skill and are ignored — ${unusable.join(', ')} [YAD-CFG-006]`,
+      'each value must be a skill name or a non-empty list of them');
+  }
+  if (unknownRoute.length) {
+    check(checks, 'skills:unknown-profile', 'project', 'warn',
+      `${rel} binds skills for ${unknownRoute.length} route(s) this yadflow does not have: ${unknownRoute.join(', ')}`,
+      `check the spelling against the routes (${LIFECYCLE_PROFILES.map((p) => p.id).join(', ')}), or upgrade yadflow if the route is from a newer release`);
+  }
+  if (unknownStep.length) {
+    check(checks, 'skills:profile-unknown-step', 'project', 'warn',
+      `${rel} binds ${unknownStep.length} route step(s) this yadflow does not run: ${unknownStep.join(', ')}`,
+      'check the spelling against `yad skill list`, or upgrade yadflow if the step is from a newer release');
+  }
+  if (gates.length) {
+    check(checks, 'skills:profile-review-step', 'project', 'warn',
+      `${rel} binds ${gates.join(', ')}, which no skill runs — review gates are driven by \`yad gate\``,
+      'bind the author step instead (for example `architecture`, not `architecture-review`)');
+  }
+  if (offRoute.length) {
+    check(checks, 'skills:off-route', 'project', 'warn',
+      `${rel} binds ${offRoute.join(', ')}, a step that route never walks — no epic on it reaches the step`,
+      'bind it for a route that has the step, or project-wide under `steps`');
   }
+  return bound;
 }
 
 // `.sdlc/toolbox.json`: which toolbox tools this Product uses or skips, and its own tools (E86). Absent is
@@ -2491,6 +2595,7 @@ export function collectDoctor(root, { headCount = null } = {}) {
   skipChecks(checks, root);
   stepStateChecks(checks, root);
   ownerChecks(checks, root);
+  memberChecks(checks, root);
   ownerGuardChecks(checks, root);
   renamedChecks(checks, root);
   productProfileChecks(checks, root);