yadflow 2.7.0 → 2.8.0

package/CHANGELOG.md

@@ -1,15 +1,9 @@
-# [2.7.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.6.0...v2.7.0) (2026-06-14)
-
-
-### Bug Fixes
-
-* drop unused today param from runDocs (lint) ([1c255f1](https://github.com/abdelrahmannasr/yadflow/commit/1c255f1c848b9571502e29b142a07366612d638c))
-* publish per-epic docs sites in CI + check shell-version staleness ([9862646](https://github.com/abdelrahmannasr/yadflow/commit/9862646fbe910de8ad8248a5f1bb586a5604b18f))
+# [2.8.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.7.0...v2.8.0) (2026-06-15)
 
 
 ### Features
 
-* add interactive documentation skills + yad docs CLI ([4bf7a25](https://github.com/abdelrahmannasr/yadflow/commit/4bf7a25c38e28ef47704a8e2f5acec2f724e4e29))
+* add `yad roster` command to manage the reviewer roster any time ([#64](https://github.com/abdelrahmannasr/yadflow/issues/64)) ([4d78225](https://github.com/abdelrahmannasr/yadflow/commit/4d78225ec25579b50d24d917f217212f4820728f))
 
 # [2.2.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.1.0...v2.2.0) (2026-06-14)
 

package/README.md

@@ -90,6 +90,7 @@ with `npx` from your **product hub** repo — no clone needed.
 | `npx yadflow check --fix` | Reconcile: fill what is missing **and** update what changed — touches nothing already correct. |
 | `npx yadflow update` | Apply drift only (alias for `check --fix --scope=changed`). Also migrates a pre-2.0 install in place: `sdlc-*` skill copies and marker-owned `sdlc-*.yml` CI files are replaced by their `yad-*` names (a same-named file *you* authored is never touched). |
 | `npx yadflow doctor [--json]` | Environment + state health: tools on PATH and platform auth, config files parse and point at real repos, every epic ledger loads. Exit 1 on any failure; `--json` for CI and bug reports. |
+| `yad roster list` / `yad roster add <login>` | Manage the reviewer roster + per-repo roles **any time** (not just at setup). `add` upserts a member then walks each connected repo asking for their role; `grant`/`revoke <name> <repo> <role>` and `remove <login>` round it out. A `domain-owner` grant keeps `repos.json` `domain_owners` in sync. |
 | `yad gate open <epic> <artifact>` | Open the front-half **review PR/MR** for an artifact and mark the step `in_review`. |
 | `yad gate sync <epic> [artifact]` | Pull the PR/MR's reviews + comment threads into the file ledger; **auto-advance** the step when approvals are satisfied, all threads are resolved, and the PR is merged. |
 | `yad gate comments <epic> [artifact]` | Fetch the unresolved review comments to address (then reply on the PR; reviewers resolve their threads). |
@@ -136,6 +137,7 @@ simultaneous advancements can be lost; the next event or scheduled sweep re-sync
 2. **Install the module** — copy all 29 `yad-*` skills into the IDE skill dirs you pick
    (`.claude/`, `.agents/`, `.zencoder/`, `.opencode/`) and register `_bmad/sdlc/`.
 3. **Hub platform & roster** — detect GitHub/GitLab from the remote; record reviewers → `.sdlc/hub.json`.
+   Edit the roster any time afterwards with `yad roster` (no need to re-run the whole wizard).
 4. **Connect a design tool** — record the design tool (Figma / pencil / none) → `.sdlc/design.json` so
    the UI step can materialize the design; the MCP itself is confirmed later by `yad-connect-design`.
 5. **Connect a testing tool** — record the testing tool (Playwright / cypress / pytest / none) →
@@ -234,7 +236,8 @@ directly. Each skill stops at a gate and never auto-advances unless a step has *
   contract lock. `generate` / `refresh` / `deploy`.
 - **`yad-docs-overview`** — Generates the project **SDLC-overview site** (`docs/sdlc-site/`) — every
   stage from setup → ship as flow paths / system components / stakeholder roles, reusing the same shell —
-  superseding the hand-maintained `docs/index.html`.
+  superseding the hand-maintained `docs/index.html` (folded into the site as `public/report.html`, linked
+  from the nav).
 - **`yad-docs-sync`** — Keeps the sites fresh: detects staleness (a content hash of the authored
   artifacts + the connected repos' HEAD shas vs each site's build manifest), regenerates + redeploys, and
   can wire a CI job that rebuilds on push. Generalizes the rule that feature work must hand-update the
@@ -387,9 +390,10 @@ detailed sections below expand every phase. Invoke a skill by name in your agent
    `testing.json`, lets `yad-test-cases` implement automation), `yad-connect-learning action: connect`
    (DeepTutor-first → `learning.json`, powers the cross-cutting learning layer).
 7. **(Optional) Put the hub on a platform** so the front-half review runs through real PRs:
-   `yad-connect-repos action: detect-hub`, then `action: roster` once per reviewer (login → SDLC
-   name + role), and `yad-pr-template repo:hub action: wire` / `yad-review-comments repo:hub action:
-   wire` / `yad-checks repo:hub action: wire`. With no hub platform the front gate just runs file-only.
+   `yad-connect-repos action: detect-hub`, then `yad roster add <login>` once per reviewer (login →
+   SDLC name + per-repo roles — the `add` walk asks for each connected repo's role; `yad roster grant`
+   sets one directly), and `yad-pr-template repo:hub action: wire` / `yad-review-comments repo:hub
+   action: wire` / `yad-checks repo:hub action: wire`. With no hub platform the front gate runs file-only.
 8. **Conventions:** commits and PR/MR titles follow Conventional Commits (lowercase after the type), the
    human author owns each commit with an optional per-commit `Co-Authored-By` AI trailer — see
    [`CONTRIBUTING.md`](CONTRIBUTING.md).

package/bin/yad.mjs

@@ -10,6 +10,7 @@ import { runCommit } from '../cli/commit.mjs';
 import { runOpenPr } from '../cli/openpr.mjs';
 import { runShip } from '../cli/ship.mjs';
 import { runRepo } from '../cli/repo.mjs';
+import { runRoster } from '../cli/roster.mjs';
 import { runDocs } from '../cli/docs.mjs';
 import { runDoctor } from '../cli/doctor.mjs';
 
@@ -24,6 +25,14 @@ ${c.bold('Setup & maintenance')}
   yad doctor [--json]  Environment + state health: tools/auth, config files,
                        repo paths, epic ledgers (exit 1 on any failure)
 
+${c.bold('Reviewer roster')}
+  yad roster list                      Show every member + their roles per scope (hub + each repo)
+  yad roster add <login>               Add/edit a member, then walk the connected repos for their roles
+                                       (--name, --email, --roles "hub=owner,reviewer backend=domain-owner")
+  yad roster grant <name> <repo> <role...>   Grant role(s) for a connected repo (domain-owner|reviewer|owner)
+  yad roster revoke <name> <repo> <role...>  Remove role(s) for a repo
+  yad roster remove <login>            Delete a member from the roster
+
 ${c.bold('Review gate (front half)')}
   yad gate open <epic> <artifact>      Open the review PR/MR; mark the step in_review
   yad gate sync <epic> [artifact]      Pull PR state -> ledger; advance on approved+resolved+merged
@@ -66,7 +75,7 @@ ${c.bold('Options')}
   -h, --help            Show this help
   -v, --version         Print version`;
 
-const VALUE_FLAGS = new Set(['--dir', '--type', '--message', '--task', '--ai', '--risk', '--repo', '--platform', '--base', '--title', '--scope', '--branch', '--pr', '--epic']);
+const VALUE_FLAGS = new Set(['--dir', '--type', '--message', '--task', '--ai', '--risk', '--repo', '--platform', '--base', '--title', '--scope', '--branch', '--pr', '--epic', '--name', '--email', '--roles']);
 
 function parseArgs(argv) {
   const o = { _: [], dir: process.cwd(), fix: false, force: false, scope: 'all' };
@@ -147,6 +156,11 @@ async function main() {
       await runRepo(o.dir, { action: action || 'list', name, today });
       break;
     }
+    case 'roster': {
+      const [, action, ...rest] = o._;
+      await runRoster(o.dir, { action: action || 'list', args: rest, name: o.name, email: o.email, roles: o.roles, today });
+      break;
+    }
     case 'docs': {
       const [, action] = o._;
       if (o.epic && !isValidEpicId(o.epic)) { log(c.red(`invalid epic id: ${o.epic} (expected EP-<slug>, [a-z0-9-] only)`)); process.exitCode = 1; break; }

package/cli/roster.mjs

@@ -0,0 +1,164 @@
+// `yad roster` — manage the reviewer roster (.sdlc/hub.json) and per-repo roles at any time.
+// The roster maps a platform login -> SDLC name + a per-scope roles map; it is the only thing that lets
+// the review gate attribute approvals and route per-repo domain-owner reviewers. This is the standalone
+// counterpart of the `yad setup` roster step and the `yad-connect-repos action: roster` skill action.
+// Repo-driven: `add`/`edit` walks the connected repos from repos.json so roles are assigned against what
+// is actually connected, not against repo names the user has to remember. Granting/revoking a
+// `domain-owner` keeps repos.json `domain_owners` in sync so the gate never drifts from the roster.
+import path from 'node:path';
+import { c, log, ok, info, warn, hand, fail, ask, askYesNo, readJSON, writeJSON } from './lib.mjs';
+import { PROJECT_FILES } from './manifest.mjs';
+import { rolesForScope } from './platform.mjs';
+import { parseRolesSpec, upsertRosterEntry, addRepoRoles, removeRepoRole, setRepoDomainOwners, reconcileRepoRoles } from './setup.mjs';
+
+const ROLES = ['owner', 'reviewer', 'domain-owner'];
+
+const loadHub = (root) => readJSON(path.join(root, PROJECT_FILES.hubConfig), null);
+const loadRepos = (root) => readJSON(path.join(root, PROJECT_FILES.reposRegistry), { repos: [] }).repos || [];
+const ownersOf = (repo) => (Array.isArray(repo.domain_owners) ? repo.domain_owners : (repo.domain_owner ? [repo.domain_owner] : []));
+
+// `list` — every member with their per-scope roles, plus a drift check between hub.json roles and
+// repos.json domain_owners (the two should agree; the sync on grant/revoke keeps them aligned).
+function rosterList(root) {
+  const hub = loadHub(root);
+  if (!hub || !Array.isArray(hub.roster) || !hub.roster.length) {
+    warn('no roster yet (.sdlc/hub.json) — add one with `yad roster add <login>` or `yad setup`');
+    return { members: 0 };
+  }
+  const repos = loadRepos(root);
+  log(c.bold('\nreviewer roster'));
+  for (const e of hub.roster) {
+    const flag = e.unverified ? c.yellow(' (unverified)') : '';
+    log(`  ${c.bold(e.name || e.login)} ${c.dim(`@${e.login}`)}${e.email ? c.dim(` <${e.email}>`) : ''}${flag}`);
+    const hubRoles = rolesForScope(e, 'hub');
+    log(`    hub: ${hubRoles.length ? hubRoles.join(', ') : c.dim('—')}`);
+    for (const r of repos) {
+      const rr = rolesForScope(e, r.name);
+      if (rr.length) log(`    ${r.name}: ${rr.join(', ')}`);
+    }
+  }
+  const drift = [];
+  for (const r of repos) {
+    const owners = ownersOf(r);
+    for (const nm of owners) {
+      const e = hub.roster.find((x) => x.name === nm);
+      if (!e || !rolesForScope(e, r.name).includes('domain-owner')) {
+        drift.push(`${nm} owns ${r.name} in repos.json but has no domain-owner role in hub.json`);
+      }
+    }
+    for (const e of hub.roster) {
+      if (rolesForScope(e, r.name).includes('domain-owner') && !owners.includes(e.name)) {
+        drift.push(`${e.name} has domain-owner for ${r.name} in hub.json but is missing from repos.json domain_owners`);
+      }
+    }
+  }
+  if (drift.length) { log(''); for (const d of drift) warn(d); }
+  return { members: hub.roster.length, repos: repos.length, drift: drift.length };
+}
+
+// The repo-driven walk: for each connected repo show the member's current role and offer to set it.
+async function repoWalk(root, entry) {
+  const repos = loadRepos(root);
+  if (!repos.length) { info('no connected repos to assign roles for (.sdlc/repos.json) — connect one with `yad setup`'); return; }
+  for (const r of repos) {
+    const cur = rolesForScope(entry, r.name);
+    if (!(await askYesNo(`  set ${entry.name}'s role on ${r.name}? (current: ${cur.length ? cur.join(', ') : 'none'})`, false))) continue;
+    const input = await ask('    roles (domain-owner/reviewer/owner, space-separated; blank = clear)', cur.join(' '));
+    const want = input.split(/\s+/).map((x) => x.trim()).filter(Boolean);
+    const invalid = want.filter((x) => !ROLES.includes(x));
+    if (invalid.length) warn(`ignoring unknown role(s): ${invalid.join(', ')} (allowed: ${ROLES.join(', ')})`);
+    reconcileRepoRoles(root, entry.name, r.name, cur, want.filter((x) => ROLES.includes(x)));
+  }
+}
+
+// Mirror any domain-owner scopes from a non-interactive `--roles` upsert into repos.json.
+function syncDomainOwners(root, entry) {
+  for (const [scope, list] of Object.entries(entry.roles || {})) {
+    if (scope !== 'hub' && Array.isArray(list) && list.includes('domain-owner')) setRepoDomainOwners(root, scope, entry.name, { add: true });
+  }
+}
+
+// `add`/`edit <login>` — upsert by login (from flags or interactive prompts), then either apply a
+// `--roles` spec directly (scriptable) or run the repo-driven walk (interactive default).
+async function rosterAdd(root, login, { name, email, roles } = {}) {
+  if (!login) { fail('usage: yad roster add <login> [--name N] [--email E] [--roles "hub=owner,reviewer backend=domain-owner"]'); process.exitCode = 1; return {}; }
+  const hub = loadHub(root);
+  const platform = hub ? hub.platform : null;
+  const existing = hub && Array.isArray(hub.roster) ? hub.roster.find((e) => e.login === login) : null;
+  const scripted = !!roles;
+  let nm = name;
+  let em = email;
+  let rolesMap;
+  if (scripted) {
+    rolesMap = parseRolesSpec(roles);
+  } else {
+    nm = nm || await ask('  yad name', (existing && existing.name) || login);
+    em = em || await ask('  commit email (blank to skip)', (existing && existing.email) || '');
+    const def = rolesForScope(existing, 'hub').join(' ') || 'reviewer';
+    const hubRoles = (await ask('  hub roles (owner/reviewer, space-separated)', def)).split(/\s+/).filter(Boolean);
+    rolesMap = hubRoles.length ? { hub: hubRoles } : {};
+  }
+  const { entry, created } = upsertRosterEntry(root, { login, name: nm, email: em || undefined, roles: rolesMap, platform });
+  if (!entry) return {};
+  ok(`${created ? 'added' : 'updated'} ${entry.name} (@${login})`);
+  if (scripted) syncDomainOwners(root, entry);
+  else await repoWalk(root, entry);
+  return { entry: entry.name, created };
+}
+
+// `grant <name> <repo> <role...>` — scriptable per-repo grant (member must already be in the roster).
+function rosterGrant(root, [name, repo, ...roles]) {
+  if (!name || !repo || !roles.length) { fail('usage: yad roster grant <name> <repo> <role...>'); process.exitCode = 1; return {}; }
+  const invalid = roles.filter((r) => !ROLES.includes(r));
+  if (invalid.length) { fail(`unknown role(s): ${invalid.join(', ')} (allowed: ${ROLES.join(', ')})`); process.exitCode = 1; return {}; }
+  const hub = loadHub(root);
+  if (!hub || !Array.isArray(hub.roster) || !hub.roster.some((e) => e.name === name)) {
+    fail(`'${name}' is not in the roster — add them first with \`yad roster add <login>\``); process.exitCode = 1; return {};
+  }
+  if (!loadRepos(root).some((r) => r.name === repo)) warn(`repo '${repo}' is not registered — the role is recorded and applies once it is connected`);
+  addRepoRoles(root, repo, Object.fromEntries(roles.map((r) => [r, [name]])));
+  if (roles.includes('domain-owner')) setRepoDomainOwners(root, repo, name, { add: true });
+  ok(`granted ${name} ${roles.join(', ')} on ${repo}`);
+  return { name, repo, roles };
+}
+
+// `revoke <name> <repo> <role...>` — scriptable per-repo revoke.
+function rosterRevoke(root, [name, repo, ...roles]) {
+  if (!name || !repo || !roles.length) { fail('usage: yad roster revoke <name> <repo> <role...>'); process.exitCode = 1; return {}; }
+  removeRepoRole(root, name, repo, roles);
+  if (roles.includes('domain-owner')) setRepoDomainOwners(root, repo, name, { add: false });
+  ok(`revoked ${name} ${roles.join(', ')} on ${repo}`);
+  return { name, repo, roles };
+}
+
+// `remove <login>` — delete a member; warn (do not cascade) if still a domain owner in repos.json.
+function rosterRemove(root, login) {
+  if (!login) { fail('usage: yad roster remove <login>'); process.exitCode = 1; return {}; }
+  const hubPath = path.join(root, PROJECT_FILES.hubConfig);
+  const hub = readJSON(hubPath, null);
+  if (!hub || !Array.isArray(hub.roster)) { warn('no roster to remove from (.sdlc/hub.json)'); return { removed: 0 }; }
+  const idx = hub.roster.findIndex((e) => e.login === login);
+  if (idx < 0) { warn(`no roster member with login '${login}'`); return { removed: 0 }; }
+  const [removed] = hub.roster.splice(idx, 1);
+  writeJSON(hubPath, hub);
+  ok(`removed ${removed.name} (@${login})`);
+  const refs = loadRepos(root).filter((r) => ownersOf(r).includes(removed.name)).map((r) => r.name);
+  if (refs.length) hand(`'${removed.name}' is still a domain owner in repos.json for: ${refs.join(', ')} — revoke with \`yad roster revoke ${removed.name} <repo> domain-owner\``);
+  return { removed: 1 };
+}
+
+export async function runRoster(root, { action = 'list', args = [], name, email, roles } = {}) {
+  switch (action) {
+    case 'list': return rosterList(root);
+    case 'add':
+    case 'edit': return rosterAdd(root, args[0], { name, email, roles });
+    case 'grant': return rosterGrant(root, args);
+    case 'revoke': return rosterRevoke(root, args);
+    case 'remove':
+    case 'rm': return rosterRemove(root, args[0]);
+    default:
+      fail(`unknown roster action: ${action} (list | add | edit | grant | revoke | remove)`);
+      process.exitCode = 1;
+      return {};
+  }
+}

package/cli/setup.mjs

@@ -11,13 +11,29 @@ import {
   moduleActions, repoActions, hubActions, authorsActions,
   legacyModuleActions, legacyRepoActions, legacyHubActions,
 } from './plan.mjs';
-import { validateLogin } from './platform.mjs';
+import { validateLogin, rolesForScope } from './platform.mjs';
 
 // Parse a comma/space separated list into a clean, deduped array of trimmed tokens.
-function parseList(s) {
+export function parseList(s) {
   return [...new Set((s || '').split(/[,\s]+/).map((x) => x.trim()).filter(Boolean))];
 }
 
+// Parse a per-scope roles spec — `"hub=owner,reviewer backend=domain-owner"` — into the roster's
+// per-scope map `{ hub: ['owner','reviewer'], backend: ['domain-owner'] }`. Tokens are whitespace
+// separated; each is `scope=role[,role...]`. Malformed tokens (no `=`, empty scope/roles) are skipped.
+export function parseRolesSpec(s) {
+  const out = {};
+  for (const tok of (s || '').split(/\s+/).map((x) => x.trim()).filter(Boolean)) {
+    const eq = tok.indexOf('=');
+    if (eq < 0) continue;
+    const scope = tok.slice(0, eq).trim();
+    const roles = parseList(tok.slice(eq + 1));
+    if (!scope || !roles.length) continue;
+    out[scope] = [...new Set([...(out[scope] || []), ...roles])];
+  }
+  return out;
+}
+
 const ALL_IDES = [...IDE_FOLDER_TARGETS, '.opencode'];
 
 export function detectPlatform(remoteUrl = '') {
@@ -68,6 +84,98 @@ export function addRepoRoles(root, repo, grants = {}) {
   if (touched) writeJSON(hubPath, hub);
 }
 
+// Normalize a roster entry's roles in place to the per-scope map, migrating the two legacy shapes
+// (a flat array, or a single `role` string) into `roles.hub` so nothing is lost. Mirrors the
+// migration addRepoRoles does; pulled out so upsert/remove share it.
+function normalizeRoles(entry) {
+  if (!entry.roles || typeof entry.roles !== 'object' || Array.isArray(entry.roles)) {
+    const hub = Array.isArray(entry.roles) ? entry.roles : (entry.role ? [entry.role] : []);
+    entry.roles = hub.length ? { hub } : {};
+    delete entry.role;
+  }
+  return entry.roles;
+}
+
+// Upsert one roster member into hub.json, keyed by `login`. Deep-merges the per-scope `roles` map so
+// scopes the caller did not name are preserved; sets `name`/`email` when given; validates the login
+// against the hub (warn-only — a miss flags `unverified`, `checked:false` skips silently). Creates the
+// hub.json shell if absent. Returns { entry, created }.
+export function upsertRosterEntry(root, { login, name, email, roles = {}, platform } = {}) {
+  if (!login) { warn('roster upsert needs a login — skipped'); return { entry: null, created: false }; }
+  const hubPath = path.join(root, PROJECT_FILES.hubConfig);
+  const hub = readJSON(hubPath, null) || { platform: platform && platform !== 'none' ? platform : null, bridge_enabled: false, bridge: false, default_branch: 'main', roster: [] };
+  if (!Array.isArray(hub.roster)) hub.roster = [];
+  let entry = hub.roster.find((e) => e.login === login);
+  const created = !entry;
+  if (!entry) { entry = { login, name: name || login, roles: {} }; hub.roster.push(entry); }
+  if (name) entry.name = name;
+  if (email) entry.email = email;
+  normalizeRoles(entry);
+  for (const [scope, list] of Object.entries(roles || {})) {
+    const cur = Array.isArray(entry.roles[scope]) ? entry.roles[scope] : [];
+    entry.roles[scope] = [...new Set([...cur, ...list])];
+  }
+  if (email && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) warn(`'${email}' does not look like an email address`);
+  const plat = platform || hub.platform;
+  if (plat && plat !== 'none') {
+    const v = validateLogin(plat, login);
+    if (v.checked && !v.exists) { warn(`'${login}' not found on ${plat} — saved as unverified`); entry.unverified = true; }
+    else if (v.checked && v.exists) { ok(`verified ${login} on ${plat}`); delete entry.unverified; }
+  }
+  writeJSON(hubPath, hub);
+  return { entry, created };
+}
+
+// Inverse of addRepoRoles: drop the named role(s) from a member's `roles[<repo>]` scope, removing the
+// scope key when it empties. Member is found by yad `name` (matching addRepoRoles). Idempotent.
+export function removeRepoRole(root, name, repo, roles = []) {
+  const hubPath = path.join(root, PROJECT_FILES.hubConfig);
+  const hub = readJSON(hubPath, null);
+  if (!hub || !Array.isArray(hub.roster)) return;
+  const entry = hub.roster.find((e) => e.name === name);
+  if (!entry) { warn(`'${name}' is not in the roster — nothing to revoke for ${repo}`); return; }
+  normalizeRoles(entry);
+  const cur = Array.isArray(entry.roles[repo]) ? entry.roles[repo] : [];
+  const next = cur.filter((r) => !roles.includes(r));
+  if (next.length === cur.length) return; // nothing removed
+  if (next.length) entry.roles[repo] = next; else delete entry.roles[repo];
+  writeJSON(hubPath, hub);
+}
+
+// Keep repos.json `domain_owners` in sync when a domain-owner role is granted/revoked via the roster,
+// so the gate's per-repo reviewer-routing and the derivation fallback never drift from hub.json. Adds
+// or removes the yad `name` and mirrors `domain_owner = domain_owners[0]`. No-op + warn if the repo is
+// not registered. Returns true when the registry was written.
+export function setRepoDomainOwners(root, repo, name, { add = true } = {}) {
+  const regPath = path.join(root, PROJECT_FILES.reposRegistry);
+  const registry = readJSON(regPath, { repos: [] });
+  const entry = (registry.repos || []).find((r) => r.name === repo);
+  if (!entry) { warn(`repo '${repo}' is not registered (.sdlc/repos.json) — domain_owners not synced`); return false; }
+  const owners = Array.isArray(entry.domain_owners) ? [...entry.domain_owners] : (entry.domain_owner ? [entry.domain_owner] : []);
+  const has = owners.includes(name);
+  let next;
+  if (add) { if (has) return false; next = [...owners, name]; }
+  else { if (!has) return false; next = owners.filter((o) => o !== name); }
+  entry.domain_owners = next;
+  entry.domain_owner = next[0] || '';
+  writeJSON(regPath, registry);
+  return true;
+}
+
+// Reconcile one repo's roles for a member to exactly `want`: grant what is new, revoke what is gone,
+// and mirror domain-owner changes into repos.json. `current` is the member's existing roles for the
+// repo. Shared by the `yad roster` walk and the `yad setup` per-repo role step. Idempotent.
+export function reconcileRepoRoles(root, name, repo, current = [], want = []) {
+  const toAdd = want.filter((r) => !current.includes(r));
+  const toRemove = current.filter((r) => !want.includes(r));
+  if (!toAdd.length && !toRemove.length) { info(`    ${repo}: unchanged`); return; }
+  if (toAdd.length) addRepoRoles(root, repo, Object.fromEntries(toAdd.map((r) => [r, [name]])));
+  if (toRemove.length) removeRepoRole(root, name, repo, toRemove);
+  if (toAdd.includes('domain-owner')) setRepoDomainOwners(root, repo, name, { add: true });
+  if (toRemove.includes('domain-owner')) setRepoDomainOwners(root, repo, name, { add: false });
+  ok(`    ${repo}: ${want.length ? want.join(', ') : 'cleared'}`);
+}
+
 export function registerRepo(root, registry, { name, rpath, platform, domain_owner = '', domain_owners = null, default_branch = 'main', today = null }) {
   if (!insideRoot(root, rpath)) {
     warn(`${rpath} resolves outside the project root — skipped`);
@@ -370,6 +478,24 @@ export async function runSetup(root, opts = {}) {
     }
   }
 
+  // 7b. Assign/update roles for ALREADY-connected repos. The connect loop above only prompts for the
+  // repos you add now; this closes the gap so a member's domain-owner/reviewer/owner role on a repo
+  // connected in an earlier run can be set without reconnecting. Mirrors `yad roster` (repo-driven).
+  const hub7 = readJSON(hubPath, null);
+  if (registry.repos.length && hub7 && Array.isArray(hub7.roster) && hub7.roster.length
+      && await askYesNo('Assign/update roles for connected repos?', false)) {
+    for (const member of hub7.roster) {
+      if (!(await askYesNo(`  edit ${member.name}'s repo roles?`, false))) continue;
+      for (const repo of registry.repos) {
+        const cur = rolesForScope(member, repo.name);
+        if (!(await askYesNo(`    set ${member.name}'s role on ${repo.name}? (current: ${cur.length ? cur.join(', ') : 'none'})`, false))) continue;
+        const input = await ask('      roles (domain-owner/reviewer/owner, space-separated; blank = clear)', cur.join(' '));
+        const want = parseList(input).filter((x) => ['owner', 'reviewer', 'domain-owner'].includes(x));
+        reconcileRepoRoles(root, member.name, repo.name, cur, want);
+      }
+    }
+  }
+
   // 8. Wire each connected repo + the hub itself
   step(8, total, 'Wire connected repos + the hub (CI gates, PR template, comment scaffold, gate-sync)');
   if (registry.repos.length === 0) info('no repos to wire');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yadflow",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Yadflow — the gated, team, multi-repo SDLC: author → review → build with a PR-driven review gate and a zero-dependency `yad` CLI (setup, gate, commit, open-pr, ship, repo). A BMAD module + 29 yad-* skills.",
   "type": "module",
   "author": "AbdelRahman Nasr",
@@ -22,7 +22,6 @@
     "!cli/test.mjs",
     "!cli/test-checks.mjs",
     "skills/",
-    "docs/index.html",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -55,7 +54,7 @@
     "deeptutor"
   ],
   "devDependencies": {
-    "@eslint/js": "^9.39.4",
+    "@eslint/js": "^10.0.1",
     "@semantic-release/changelog": "^6.0.3",
     "eslint": "^9.39.4",
     "semantic-release": "^25.0.3"

package/skills/sdlc/module-help.csv

@@ -26,5 +26,5 @@ SDLC Workflow,yad-run,Run (Automation),RN,"Phase 4 orchestrator: drive a story's
 SDLC Workflow,yad-status,SDLC Status,SS,"Read-only: print the full front-state chain, per-step dials, contract lock, story repo tags, and pending approvals at the active gate. For stories in the build half, also print each back-half step's automation dial and status, the trust record (runs / % approved-unchanged / earned vs gathering evidence), and the system-wide kill-switch state.",,{epic: EP-<slug>},1-front,,,false,,
 SDLC Workflow,yad-connect-docs,Connect Docs Target,DX,"Setup/maintenance: connect a docs/Pages publishing target so the interactive-docs steps can deploy the generated site (not just commit its source). Auto-detects the platform from .sdlc/hub.json (github->github-pages, gitlab->gitlab-pages, null->build-only), resolves the Vite base path, and records the target in .sdlc/docs.json (local-user auth, no stored tokens). Degrades to build-only when gh/glab is absent. Idempotent and refreshable; one connection per project. Not a gated state — never touches epic state or approvals.",,{action: connect|refresh|list|disconnect} {target: github-pages|gitlab-pages|none} {scope: hub|<repo>|dedicated} {base_path: <override>},0-setup,,yad-docs,false,.sdlc/,docs.json
 SDLC Workflow,yad-docs,Author Docs Site,DS,"Generate the per-epic interactive documentation SPA (animated flow canvas + role-based stakeholder doc pages) from the epic's approved artifacts (epic, architecture, locked contract, ui-design, stories, code-context, test-cases), themed by the connected design system, into epics/EP-<slug>/docs-site/. Copies the vendored React/Vite/Tailwind shell verbatim and generates src/data/*.ts deterministically; drives the yad docs build/deploy CLI to publish to Pages (or build-only). An OUTPUT ENRICHMENT — never a gate; never mutates state.json, approvals, or the contract lock.",,{epic: EP-<slug>} {action: generate|refresh|deploy} {login_gate: true|false},,yad-review-gate,,false,epics/EP-<slug>/docs-site/,docs-site/ docs-build.json
-SDLC Workflow,yad-docs-overview,Docs Overview Site,DO,"Generate the project SDLC-overview interactive site (docs/sdlc-site/) — every stage from setup to ship modeled as flow paths, system components, and stakeholder roles — reusing the same vendored shell, themed with yadflow's brand palette. Reads config.yaml + module-help.csv + the overview diagram as the pipeline source. Supersedes the hand-maintained docs/index.html (left as a thin redirect for one release). Not a gate — a project-level enrichment that regenerates whenever the skill set / pipeline changes.",,{action: generate|deploy},,,,false,docs/sdlc-site/,sdlc-site/ .docs-build.json
+SDLC Workflow,yad-docs-overview,Docs Overview Site,DO,"Generate the project SDLC-overview interactive site (docs/sdlc-site/) — every stage from setup to ship modeled as flow paths, system components, and stakeholder roles — reusing the same vendored shell, themed with yadflow's brand palette. Reads config.yaml + module-help.csv + the overview diagram as the pipeline source. Folds the hand-maintained docs/index.html report into the site as report.html (linked from the nav). Not a gate — a project-level enrichment that regenerates whenever the skill set / pipeline changes.",,{action: generate|deploy},,,,false,docs/sdlc-site/,sdlc-site/ .docs-build.json
 SDLC Workflow,yad-docs-sync,Docs Sync,DY,"Maintenance/CI: keep the generated doc sites fresh. Detect staleness (a content hash of the approved artifacts + the connected repos' HEAD shas + the doc-shell version vs each site's build manifest), report which sites drifted and why, regenerate + redeploy the stale ones, and wire a CI job that rebuilds on push (carrying [skip ci] + a concurrency group to prevent deploy loops). Generalizes the rule that feature work must hand-update docs/index.html + diagrams + skill counts. Refresh is always a human/CI decision; never a gate.",,{action: check|refresh|wire} {epic: EP-<slug>},,,,false,epics/EP-<slug>/.sdlc/,docs-build.json yad-docs.yml

package/skills/yad-connect-repos/SKILL.md

@@ -133,6 +133,10 @@ write only `{project-root}/.sdlc/hub.json` (`config.yaml` `hub.config`) — neve
   `roles[<repo>]` (and still **derived** as a fallback when a roster `name` equals a repo's
   `domain_owner`/`domain_owners` in `repos.json` — see `references/hub-config.md`). An unmapped login
   degrades to a plain `reviewer`, never auto-promoted to owner/domain-owner.
+  **The deterministic half is the `yad roster` CLI command** — runnable any time, not just at setup:
+  `yad roster list`; `yad roster add <login>` (upsert, then a repo-driven walk that asks for each
+  connected repo's role); `yad roster grant|revoke <name> <repo> <role>`; `yad roster remove <login>`.
+  A `domain-owner` grant/revoke keeps `repos.json` `domain_owners` in sync so the gate never drifts.
 
 If the hub has no remote (`platform: null`) or the bridge is disabled, the front-half gate runs
 file-only with no error — the bridge is purely additive.

package/skills/yad-connect-repos/references/hub-config.md

@@ -33,7 +33,9 @@ login to an SDLC name + role. It is a single object for the hub itself — the s
 
 The roster is how a platform identity (a GitHub/GitLab **login**) becomes an SDLC **name + role(s)** in
 the file ledger (`approvals.json` / `comments.json`). Roles are the same three the gate uses:
-`owner | reviewer | domain-owner`.
+`owner | reviewer | domain-owner`. Populate and edit it any time with the **`yad roster`** CLI command
+(`list` / `add` / `grant` / `revoke` / `remove`) — `add` walks the connected repos asking for each
+one's role, and a `domain-owner` grant keeps `repos.json` `domain_owners` in sync.
 
 - **`login`** — the platform username whose PR review / approval is being mapped.
 - **`name`** — the SDLC name written into the ledger (the same names used across `approvals.json`,

package/skills/yad-docs-overview/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yad-docs-overview
-description: 'Generates the project-level SDLC-overview interactive site — the same React/Vite/Tailwind shell as the per-epic docs — showing every yadflow stage from setup → ship: the pipeline as a flow canvas, each skill/gate as a flow step, the durable .sdlc state objects as system components, and the lenses as stakeholder roles. Themed with yadflow''s own brand palette for continuity, built from config.yaml + module-help.csv + the overview diagram. Supersedes docs/index.html with a thin redirect and deploys via `yad docs deploy --overview`. This is project documentation, not a gated state — it never touches any epic''s state or approvals. Use when the user says "generate the overview site", "build the SDLC overview docs", or after the pipeline (module-help.csv / config.yaml / skill count) changes.'
+description: 'Generates the project-level SDLC-overview interactive site — the same React/Vite/Tailwind shell as the per-epic docs — showing every yadflow stage from setup → ship: the pipeline as a flow canvas, each skill/gate as a flow step, the durable .sdlc state objects as system components, and the lenses as stakeholder roles. Themed with yadflow''s own brand palette for continuity, built from config.yaml + module-help.csv + the overview diagram. Folds the legacy hand-maintained docs/index.html report into the site as report.html (linked from the nav) and deploys via `yad docs deploy --overview`. This is project documentation, not a gated state — it never touches any epic''s state or approvals. Use when the user says "generate the overview site", "build the SDLC overview docs", or after the pipeline (module-help.csv / config.yaml / skill count) changes.'
 ---
 
 # SDLC — Author the Overview Site (project-level, the pipeline as a living map)
@@ -9,7 +9,7 @@ description: 'Generates the project-level SDLC-overview interactive site — the
 reusing the same shell as the per-epic docs (`skills/yad-docs/templates/app/`). Where `yad-docs`
 animates one epic's flows, this animates the **workflow itself**: the front gates, the build half, the
 automation dial, the setup connectors. It is the regenerable successor to the hand-maintained
-`docs/index.html` overview.
+overview report, which is folded into this site as `public/report.html`.
 
 This is **project documentation, not a gated state** — there is no epic, no `state.json`, no approvals.
 It only reads the pipeline definition and writes a project-level site. When a docs target is connected
@@ -22,7 +22,7 @@ It only reads the pipeline definition and writes a project-level site. When a do
   the generated **source is committed**. The overview build manifest is `docs/sdlc-site/.docs-build.json`.
 - The shell template is `skills/yad-docs/templates/app/` — copied **verbatim**, themed only in the
   `:root` of `index.css`. Generated data satisfies `src/data/types.ts`.
-- Theme: **yadflow's own brand palette** (the `:root` of `docs/index.html`) — for visual continuity with
+- Theme: **yadflow's own brand palette** (the `:root` of the legacy report, now `docs/sdlc-site/public/report.html`) — for visual continuity with
   the existing overview, not an epic's design tokens.
 - Speak in the configured `communication_language`; write documents in `document_output_language`.
 
@@ -68,7 +68,7 @@ Map the pipeline onto the same data structures `yad-docs` uses (concrete mapping
 Copy the shell from `templates/app/` **verbatim**, generate `src/data/*.ts` deterministically (same
 determinism rules as `yad-docs`: stable-ID sort by skill pipeline order / phase, fixed key order, no
 timestamps in the data files), theme the `:root` of `index.css` from **yadflow's brand palette** — the
-`docs/index.html` `:root`: `--accent: #2471a3` and the node colors (`--artifact-*`, `--gate-*`,
+the legacy report's `:root`: `--accent: #2471a3` and the node colors (`--artifact-*`, `--gate-*`,
 `--earns-*`, `--locked-*`, `--sentinel-*`) — and substitute the Vite base from `.sdlc/docs.json`
 `basePath` (the overview sits at the base root, e.g. `/<repo>/`).
 
@@ -91,11 +91,13 @@ doc-shell upgrade triggers a rebuild). `skillCount` rides along in the manifest
 — it is **not** a separate hash input, since `module-help.csv` already moves whenever the skill set does.
 Not per-epic artifacts/repo heads.
 
-### Step 5 — Supersede `docs/index.html` (one release)
-Turn `docs/index.html` into a **thin redirect** to `docs/sdlc-site/` (e.g. a `<meta http-equiv="refresh">`
-+ a one-line link), and **note in the report** that the hand-maintained overview is superseded by the
-generated site for this release. This generalizes the standing rule that feature work hand-updates
-`docs/index.html`: the overview site now **regenerates** instead.
+### Step 5 — Fold the legacy report into the site
+Relocate the hand-maintained static report into the generated site as `docs/sdlc-site/public/report.html`
+(Vite copies `public/` verbatim into `dist/`, so it publishes alongside the app at `<base>/report.html`),
+and link it from the app nav (a "Full report" link in `TopNavBar`). The interactive overview becomes the
+primary documentation and the legacy report rides along as its detailed companion — no orphaned
+`docs/index.html` at the repo root. This generalizes the standing rule that feature work hand-updates the
+report: the overview site now **regenerates** instead.
 
 ### Step 6 — Build / deploy (`action`)
 - `action: generate` (default) — generate source + manifest; stop.
@@ -104,8 +106,8 @@ generated site for this release. This generalizes the standing rule that feature
 
 ### Step 7 — Stop. Report (no gate, no epic)
 Report: the site path (`docs/sdlc-site/`), the data files produced, that the theme is the yadflow brand
-palette, the deploy URL or "build-only", the staleness baseline, and that `docs/index.html` now
-redirects to the generated site. Never touches any epic state.
+palette, the deploy URL or "build-only", the staleness baseline, and that the legacy report is folded in
+at `public/report.html` (linked from the nav). Never touches any epic state.
 
 ## Hard rules
 

package/skills/yad-docs-overview/references/pipeline-model.md

@@ -97,6 +97,6 @@ The eight yadflow lenses, each to its relevant phase sections + paths:
 ## Determinism + theme
 Same discipline as `yad-docs`: stable-sort steps by phase then pipeline order, fixed key order, **no
 timestamps** in `src/data/*.ts` (build time lives only in `.docs-build.json`). Theme the `:root` from
-**yadflow's brand palette** (`docs/index.html` `:root`): `--accent: #2471a3`, and carry the node-class
+**yadflow's brand palette** (the legacy report's `:root`): `--accent: #2471a3`, and carry the node-class
 colors through to step/path colors — `--artifact-* #b7950b`, `--gate-* #ca6f1e`, `--earns-* #2471a3`,
 `--locked-* #566573`, `--sentinel-* #1e8449` — so the canvas reads like the existing diagram.

package/skills/yad-hub-bridge/references/login-roster.md

@@ -3,6 +3,7 @@
 The roster lives in `.sdlc/hub.json` (`roster: [...]`) and is the only thing that turns a platform
 **login** into an SDLC **name + role** for the ledger. Schema and the no-tokens rule are documented once
 in `../../yad-connect-repos/references/hub-config.md`; this file covers how the bridge *uses* it.
+It is populated/edited any time with the `yad roster` CLI command (see that reference).
 
 ## Entry