npm - yadflow - Versions diffs - 2.15.0 → 2.16.1 - Mend

yadflow 2.15.0 → 2.16.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/CHANGELOG.md +3 -3
package/README.md +2 -2
package/bin/yad.mjs +5 -3
package/cli/commit.mjs +9 -2
package/cli/gate.mjs +8 -3
package/cli/openpr.mjs +78 -6
package/package.json +1 -1
package/skills/yad-checks/references/check-gates.md +25 -7
package/skills/yad-checks/templates/github/yad-hub-checks.yml +27 -6
package/skills/yad-checks/templates/gitlab/yad-hub-checks.gitlab-ci.yml +11 -5
package/skills/yad-commit/SKILL.md +2 -1
package/skills/yad-open-pr/SKILL.md +8 -0
package/skills/yad-pr-template/templates/checks/pr-template.sh +53 -10
package/skills/yad-pr-template/templates/checks/pr-title.sh +55 -18
package/skills/yad-ship/SKILL.md +4 -0

package/CHANGELOG.md CHANGED Viewed

@@ -1,9 +1,9 @@
-# [2.15.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.14.0...v2.15.0) (2026-06-24)
+## [2.16.1](https://github.com/abdelrahmannasr/yadflow/compare/v2.16.0...v2.16.1) (2026-06-25)
-### Features
+### Bug Fixes
-* merge-driven review gate (Path B) — CI never pushes the review branch ([#78](https://github.com/abdelrahmannasr/yadflow/issues/78)) ([d4d983a](https://github.com/abdelrahmannasr/yadflow/commit/d4d983ab4efddb4e6ec259bb940b393e9237f9cf)), closes [#76](https://github.com/abdelrahmannasr/yadflow/issues/76)
+* **open-pr:** make build helpers stage-aware on the hub (closes [#80](https://github.com/abdelrahmannasr/yadflow/issues/80)) ([#81](https://github.com/abdelrahmannasr/yadflow/issues/81)) ([8d74e3d](https://github.com/abdelrahmannasr/yadflow/commit/8d74e3d267d4c056992d3bc6f5a2a7a15a66b431))
 # [2.2.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.1.0...v2.2.0) (2026-06-14)

package/README.md CHANGED Viewed

@@ -98,8 +98,8 @@ with `npx` from your **product hub** repo — no clone needed.
 | `yad gate status <epic>` | Show each review step and its recorded approvals. |
 | `yad gate ci [--branch <head>] [--pr <n>]` | The CI entry the hub workflow calls on review/merge events: derive the epic/artifact from the `review/EP-*` branch, run the same sync, and commit **only the ledger** to the hub default branch (sweep every open review PR when no `--branch`). |
 | `yad commit --type <t> -m <subject>` | Commit by the SDLC convention — Conventional subject, `Task`/`Contract-Change`/`Co-Authored-By` trailers, atomic-file guard. |
-| `yad open-pr [--repo <name>]` | Open a code-repo **task** PR/MR from the repo's platform template (build half). |
-| `yad ship --type <t> -m <subject>` | Commit **and** open the task PR/MR in one step (`yad commit` then `yad open-pr`). |
+| `yad open-pr [--repo <name>]` | Open a **task** PR/MR from the platform template (build half). **Stage-aware on the hub:** a `review/EP-*` branch opens the front-half artifact-review PR (delegates to `yad gate open`); any other hub branch uses the code-task template (so hub tooling PRs pass the `pr-template` gate). |
+| `yad ship --type <t> -m <subject>` | Commit **and** open the task PR/MR in one step (`yad commit` then `yad open-pr`) — stage-aware, same as `open-pr`. |
 | `yad repo list` / `yad repo refresh [name]` | List connected repos as **fresh / stale**, and re-pack a stale one — staleness is now an explicit human decision, never an automatic skill side-effect. |
 | `yad repo sync [name]` | Switch every connected repo to its **default branch** and fast-forward it from origin (one or all). Dirty repos are skipped, never overwritten; fast-forward only. |
 | `npx yadflow --version` | Print the installed CLI version. |

package/bin/yad.mjs CHANGED Viewed

@@ -56,8 +56,10 @@ ${c.bold('Review gate (front half)')}
 ${c.bold('Build helpers')}
   yad commit --type <t> -m <subject>   Commit by convention (trailers, atomic guard)
-  yad open-pr [--repo <name>]          Open a code-repo task PR/MR from the template
-  yad ship --type <t> -m <subject>     Commit AND open the task PR/MR in one step
+  yad open-pr [--repo <name>]          Open a task PR/MR — stage-aware on the hub: a review/EP-*
+                                       branch opens the front-half artifact-review PR (delegates to
+                                       gate open), any other hub branch uses the code-task template
+  yad ship --type <t> -m <subject>     Commit AND open the task PR/MR in one step (stage-aware)
   yad repo list                        Show connected repos (fresh / stale)
   yad repo refresh [name]              Re-pack a stale repo (a human decision)
@@ -181,7 +183,7 @@ async function main() {
       // In bridge mode CI is the sole ledger writer: `open` only opens the PR, and local `sync` is
       // advisory (reads the platform, prints status, writes nothing). The artifact status flip is
       // CI's job at merge — never wired into the local gate. File-only mode keeps local writes.
-      if (action === 'open') await gateOpen(o.dir, { epic, artifact, today });
+      if (action === 'open') await gateOpen(o.dir, { epic, artifact });
       else if (action === 'sync') await gateSync(o.dir, { epic, artifact, today, local: true });
       else if (action === 'comments') await gateComments(o.dir, { epic, artifact, today });
       else if (action === 'status') await gateStatus(o.dir, { epic });

package/cli/commit.mjs CHANGED Viewed

@@ -7,7 +7,7 @@ import fs from 'node:fs';
 import { c, log, ok, info, warn, fail, run, exists } from './lib.mjs';
 import {
   COMMIT_TYPES, AI_COAUTHORS, ATOMIC_FILE_LIMIT,
-  TASK_TRAILER, CONTRACT_CHANGE_TRAILER, COAUTHOR_TRAILER,
+  TASK_TRAILER, CONTRACT_CHANGE_TRAILER, COAUTHOR_TRAILER, PROJECT_FILES,
 } from './manifest.mjs';
 // PURE — unit tested directly. Build the full commit message text.
@@ -51,7 +51,14 @@ export async function runCommit(root, opts = {}) {
   const branch = run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root }).stdout;
   const task = opts.task || taskFromBranch(branch);
-  if (!task) warn('no Task trailer (none given and branch has no -S0N-T0N) — spec-link gate will fail on a code repo');
+  if (!task) {
+    // spec-link is a code-repo gate (REPO_WIRING.common), not a hub gate — so a missing Task trailer
+    // is expected on a hub PR (front-half artifact review or hub tooling) and only matters on a repo.
+    const onHub = exists(path.join(root, PROJECT_FILES.hubConfig));
+    warn(onHub
+      ? 'no Task trailer (none given and branch has no -S0N-T0N) — fine for a hub PR; required on code-repo tasks (spec-link gate)'
+      : 'no Task trailer (none given and branch has no -S0N-T0N) — spec-link gate will fail on a code repo');
+  }
   let message;
   try {

package/cli/gate.mjs CHANGED Viewed

@@ -449,7 +449,11 @@ export async function gateStatus(root, { epic } = {}) {
   }
 }
-export async function gateOpen(root, { epic, artifact } = {}) {
+// `head` overrides the review branch the PR is opened against — `open-pr` delegates here after pushing
+// the user's checked-out branch, which for a per-story review (review/EP-*/stories-S01) does NOT equal
+// the branch this would otherwise recompute (artifactFromBase collapses stories-S01 → stories/). Pass
+// the real pushed head so the PR targets a branch that exists. `creator` is injected in tests.
+export async function gateOpen(root, { epic, artifact, head, creator = createPr } = {}) {
   const { hub } = loadHub(root);
   const epicDir = epicRoot(root, epic);
   const ledger = loadLedger(epicDir);
@@ -458,7 +462,7 @@ export async function gateOpen(root, { epic, artifact } = {}) {
   const step = findReviewStep(ledger.state, artifact);
   if (!step) { fail(`no review step for ${artifact}`); process.exitCode = 1; return; }
   const b = base(artifact);
-  const branch = `review/${epic}/${b}`;
+  const branch = head || `review/${epic}/${b}`;
   const domains = touchedDomains(epicDir, step);
   warnUnlockedContract(epicDir, artifact);
@@ -487,7 +491,7 @@ export async function gateOpen(root, { epic, artifact } = {}) {
   const assignees = committer ? [committer] : [];
   const labels = isEscalated(step) ? domains.map((d) => `domain:${d}`) : [];
   info(`opening review ${hub.platform === 'gitlab' ? 'MR' : 'PR'} on branch ${branch} …`);
-  const r = createPr(hub.platform, { title: `review: ${artifact} (${epic})`, body, base: hub.default_branch || 'main', head: branch, reviewers, assignees, labels, cwd: root });
+  const r = creator(hub.platform, { title: `review: ${artifact} (${epic})`, body, base: hub.default_branch || 'main', head: branch, reviewers, assignees, labels, cwd: root });
   if (!r.ok) { warn(`could not open PR (${r.reason || 'unknown'})${bridge ? ' — open it manually; CI records the gate on merge' : '; step is in_review file-only'}`); return; }
   if (!bridge) {
@@ -498,6 +502,7 @@ export async function gateOpen(root, { epic, artifact } = {}) {
   hand(bridge
     ? 'reviewers approve/comment there; CI advances the gate on the default branch when it is merged'
     : `reviewers approve/comment there; then run \`yad gate sync ${epic} ${artifact}\``);
+  return { url: r.url };
 }
 // ---- helpers ------------------------------------------------------------------------------------

package/cli/openpr.mjs CHANGED Viewed

@@ -8,6 +8,8 @@ import { c, log, ok, info, hand, fail, run, exists, readJSON } from './lib.mjs';
 import { PROJECT_FILES } from './manifest.mjs';
 import { detectPlatform, createPr, reviewersForScopes, resolveCommitterLogin } from './platform.mjs';
 import { taskFromBranch } from './commit.mjs';
+import { parseReviewBranch, artifactFromBase } from './epic-state.mjs';
+import { gateOpen } from './gate.mjs';
 // Resolve the target code repo: --repo <name> from the registry, else --dir, else cwd.
 function resolveRepo(root, { repo, dir }) {
@@ -19,11 +21,59 @@ function resolveRepo(root, { repo, dir }) {
   return { repoRoot: path.resolve(root, dir || '.'), meta: null };
 }
-function templateBody(repoRoot, platform, { task, risk, contract, domains }) {
-  const tplPath = platform === 'gitlab'
-    ? path.join(repoRoot, '.gitlab/merge_request_templates/Default.md')
-    : path.join(repoRoot, '.github/pull_request_template.md');
-  const base = exists(tplPath) ? fs.readFileSync(tplPath, 'utf8') : '## Summary\n\n## Impact & Risk\n';
+// Which SDLC stage is this PR? The hub serves two vehicles; a code repo only one. Mirrors the
+// `--head` split the hub pattern gates (pr-title.sh/pr-template.sh) already apply:
+//   code-repo    — NOT the product hub (a registry repo via --repo, or root is not a hub).
+//   hub-front    — the hub itself AND head is a review/EP-* branch (artifact-review PR).
+//   hub-tooling  — the hub itself AND head is anything else (a tooling/CI change to the hub).
+// `meta` (truthy when resolved from the repos registry via --repo) is a connected code repo, so it is
+// never the hub regardless of its path. Otherwise "is the hub" = repoRoot resolves to root AND root
+// carries .sdlc/hub.json. path.resolve normalises `--dir .` / trailing slashes.
+export function detectStage(root, repoRoot, head, meta) {
+  if (meta) return 'code-repo';
+  const isHub = path.resolve(repoRoot) === path.resolve(root)
+    && exists(path.join(root, PROJECT_FILES.hubConfig));
+  if (!isHub) return 'code-repo';
+  return /^review\/EP-[a-z0-9-]+\//.test(head || '') ? 'hub-front' : 'hub-tooling';
+}
+// The bundled code-task template — the same file `REPO_WIRING` installs into code repos, resolved
+// from the package (mirrors how manifest.mjs reads ../package.json). Used for a hub-tooling PR, whose
+// `.github/pull_request_template.md` is the ARTIFACT-REVIEW template (wrong shape for the code-task
+// hub gate). Falls back to a minimal body that still carries every section the gate requires.
+function codeTaskTemplate(platform) {
+  const rel = platform === 'gitlab'
+    ? '../skills/yad-pr-template/templates/gitlab/merge_request_templates/Default.md'
+    : '../skills/yad-pr-template/templates/github/pull_request_template.md';
+  try {
+    return fs.readFileSync(new URL(rel, import.meta.url), 'utf8');
+  } catch {
+    return [
+      '## Summary', '',
+      '## Impact & Risk',
+      '- **Domains / repos touched:** <repo>',
+      '- **Contract surface touched:** no',
+      '- **Risk level:** low',
+      '',
+      '## Checklist',
+      '- [ ] Lint, build, and tests pass (build/test/lint gate)',
+      '',
+    ].join('\n');
+  }
+}
+export function templateBody(repoRoot, platform, { task, risk, contract, domains, stage }) {
+  // hub-tooling: the hub's own template is artifact-review — use the bundled code-task template so the
+  // body matches the shape the hub `pr-template` gate demands for a non-review head.
+  let base;
+  if (stage === 'hub-tooling') {
+    base = codeTaskTemplate(platform);
+  } else {
+    const tplPath = platform === 'gitlab'
+      ? path.join(repoRoot, '.gitlab/merge_request_templates/Default.md')
+      : path.join(repoRoot, '.github/pull_request_template.md');
+    base = exists(tplPath) ? fs.readFileSync(tplPath, 'utf8') : codeTaskTemplate(platform);
+  }
   // Fill the obvious fields; leave the rest of the committed template intact for the author.
   return base
     .replace(/EP-<slug>-S0N-T0N/g, task || 'EP-<slug>-S0N-T0N')
@@ -45,6 +95,28 @@ export async function runOpenPr(root, opts = {}) {
   const baseBranch = opts.base || meta?.default_branch || 'main';
   if (branch === baseBranch) { fail(`on ${baseBranch} — switch to your task branch first`); process.exitCode = 1; return; }
+  const stage = detectStage(root, repoRoot, branch, meta);
+  // hub-front: this is a front-half artifact-review PR (review/EP-*/<artifact> head on the hub). The
+  // artifact-review title, body, and ledger bookkeeping all live in `yad gate open` — delegate to it
+  // rather than emit the code-task shape (which the hub gate would reject). Push first (gateOpen does
+  // not push), then hand off; any --title/--message is dropped (gateOpen sets `review: …`).
+  if (stage === 'hub-front') {
+    const parsed = parseReviewBranch(branch);
+    if (!parsed) { fail(`could not parse review branch '${branch}' (expected review/EP-<slug>/<artifact>)`); process.exitCode = 1; return; }
+    info(`pushing ${branch} …`);
+    const fpush = run('git', ['push', '-u', 'origin', branch], { cwd: repoRoot });
+    if (!fpush.ok) { fail(`git push failed — ${fpush.stderr.split('\n')[0] || 'unknown'}`); process.exitCode = 1; return; }
+    // Pass the branch we just pushed as the head so gateOpen opens the PR against it (its own
+    // recompute would collapse a per-story base). gateOpen signals failure by returning no url —
+    // mirror open-pr's own error contract so `ship` sees the non-zero exit and never reports success.
+    // (On a platform-less hub gateOpen marks the step in_review file-only and returns no url; open-pr's
+    // job is to open a PR, so "no PR opened" is a non-zero outcome here, unlike `yad gate open`.)
+    const res = await gateOpen(root, { epic: parsed.epic, artifact: artifactFromBase(parsed.base), head: branch });
+    if (!res?.url) process.exitCode = 1;
+    return res;
+  }
   // Push the branch (sets upstream) using the user's own auth. Abort on failure — creating a PR for a
   // branch that is not on the remote just fails with a more confusing error.
   info(`pushing ${branch} …`);
@@ -54,7 +126,7 @@ export async function runOpenPr(root, opts = {}) {
   const task = opts.task || taskFromBranch(branch);
   const title = opts.title || run('git', ['log', '-1', '--format=%s'], { cwd: repoRoot }).stdout || `task ${task || branch}`;
   const body = templateBody(repoRoot, platform, {
-    task, risk: opts.risk || 'low', contract: !!opts.contractChange, domains: meta?.name,
+    task, risk: opts.risk || 'low', contract: !!opts.contractChange, domains: meta?.name, stage,
   });
   // Auto-assign from the hub roster, scoped to this repo: assignee = the committer (resolved from

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "yadflow",
-  "version": "2.15.0",
+  "version": "2.16.1",
   "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 + 30 yad-* skills.",
   "type": "module",
   "author": "AbdelRahman Nasr",

package/skills/yad-checks/references/check-gates.md CHANGED Viewed

@@ -121,8 +121,17 @@ from the event payload):
 - `--profile code` (default) → a Conventional-Commits subject `<type>: <description>`, no trailing
   period (`config.yaml build.pr_title_style: same_as_commit_subject` — one task = one PR, the title is
   the squash-merge subject).
-- `--profile hub` → a front-half artifact-review title `review: <artifact> (EP-<slug>)`, the shape
-  `yad gate open` creates.
+- `--profile hub` → splits by the PR/MR **head branch** (passed via `--head`, injected by CI):
+  - `review/EP-*` head (or no `--head` — stays strict) → a front-half artifact-review title
+    `review: <artifact> (EP-<slug>)`, the shape `yad gate open` creates.
+  - any other head → a tooling/code change to the hub itself, so it follows the `code` convention (a
+    Conventional-Commits subject). This is what lets a PR that changes the hub's own workflows/checks
+    pass — it has no EP artifact to review.
+  - **Anti-bypass guard.** The branch name alone is not trusted: a non-review head that actually
+    changes front-half artifacts (any path under `epics/**`) **FAILS** — those changes must go through
+    a `review/EP-*` PR and the artifact-review workflow. CI passes the PR's changed paths via
+    `--changed <file>` (computed from the diff against the base ref); without that list (a direct
+    by-hand caller) the guard is inert and the branch split alone applies.
 ## 7. pr-template (`templates/checks/pr-template.sh`)
@@ -131,8 +140,14 @@ catches a free-form description that bypassed it:
 - `--profile code` (default) → requires `## Summary`, `## Impact & Risk`, `## Checklist`, and a filled
   `Risk level:` (`low|medium|high`).
-- `--profile hub` → requires `## Artifact under review`, `## Impact & Risk (front-half)`, `## Checklist`,
-  and a `Risk tags:` line.
+- `--profile hub` → splits by the PR/MR **head branch** (passed via `--head`, injected by CI):
+  - `review/EP-*` head (or no `--head`) → requires the artifact-review template: `## Artifact under
+    review`, `## Impact & Risk (front-half)`, `## Checklist`, and a `Risk tags:` line.
+  - any other head → a hub tooling PR, so it requires the `code` task template (`## Summary`,
+    `## Impact & Risk`, `## Checklist`, filled `Risk level:`).
+  - **Anti-bypass guard** (same as pr-title): a non-review head that changes front-half artifacts
+    (`epics/**`, detected from the CI-supplied `--changed <file>` list) **FAILS** — artifact changes
+    must go through a `review/EP-*` PR.
 ## CI wiring (both platforms)
@@ -202,9 +217,12 @@ its one include line) whenever `.sdlc/hub.json` has a platform with the bridge e
 front-half review PRs are held to the same rule as code-repo PRs: signed, known authors only.
 The hub **also** runs the three pattern gates (`commit-message`, `pr-title`, `pr-template`) with
-`--profile hub`, so the front-half review PRs follow the hub conventions — Conventional-Commits commit
-subjects, a `review: <artifact> (EP-<slug>)` title, and a body that uses the hub artifact-review
-template. `yad check --fix` installs the same `checks/*.sh` scripts plus a standalone hub workflow
+`--profile hub`. The pattern gates split by the PR/MR **head branch** (passed via `--head`): a
+`review/EP-*` head is a front-half review PR — Conventional-Commits commit subjects, a
+`review: <artifact> (EP-<slug>)` title, and the hub artifact-review template body; **any other head is
+a tooling/code change to the hub itself** and follows the `code` convention (a Conventional-Commits
+title + the code task template), so a PR that changes the hub's own workflows/checks can pass.
+`yad check --fix` installs the same `checks/*.sh` scripts plus a standalone hub workflow
 (`templates/github/yad-hub-checks.yml` → `.github/workflows/yad-hub-checks.yml`, or the GitLab fragment
 `templates/gitlab/yad-hub-checks.gitlab-ci.yml` → `.gitlab/ci/yad-hub-checks.yml` + its one include
 line). Code repos run the same three with `--profile code` inside the main `yad-checks` workflow.

package/skills/yad-checks/templates/github/yad-hub-checks.yml CHANGED Viewed

@@ -1,43 +1,64 @@
 # yad-managed: yad-checks
-# Pattern gates for the PRODUCT HUB: every PR (including the front-half review/EP-* PRs) must follow
-# the hub conventions — Conventional-Commits commit subjects, a `review: <artifact> (EP-<slug>)` PR
-# title, and a PR body that uses the hub artifact-review template. They run with `--profile hub`.
-# Standalone workflow so it never collides with the code-repo yad-checks workflow.
+# Pattern gates for the PRODUCT HUB. They run with `--profile hub` and split by head branch:
+#   review/EP-* PRs are front-half artifact-review vehicles — a `review: <artifact> (EP-<slug>)` title
+#     and the hub artifact-review template body.
+#   every other PR is a tooling/code change to the hub itself — a Conventional-Commits title and the
+#     code task template body (same convention the code repos use).
+# The head ref is passed via --head so the gate can tell the two apart. Commit subjects are always
+# Conventional-Commits. Standalone workflow so it never collides with the code-repo yad-checks workflow.
 name: yad-hub-checks
 on:
   pull_request:
+    # `edited` (beyond the opened/synchronize/reopened defaults) so a PR title/body correction
+    # re-runs the pattern gates without a close/reopen — e.g. fixing a body the pr-template gate held.
+    types: [opened, synchronize, reopened, edited]
     branches: ["**"]
 jobs:
+  # commit-message + ledger-guard read the commit range, not the PR title/body — skip them on a bare
+  # `edited` event (only pr-title/pr-template need to re-check a title/body fix).
   commit-message:
     runs-on: ubuntu-latest
+    if: github.event.action != 'edited'
     steps:
       - uses: actions/checkout@v4
         with: { fetch-depth: 0 }
       - run: bash checks/commit-message.sh --profile hub "origin/${{ github.base_ref }}"
   # Pass the title via env (never interpolate untrusted ${{ }} into a run line — injection-safe).
+  # fetch-depth: 0 + the base ref give us the PR's changed paths, so the gate can reject an artifact
+  # change (epics/**) riding a non-review head past the front-half review with a plain code title.
   pr-title:
     runs-on: ubuntu-latest
     env:
       PR_TITLE: ${{ github.event.pull_request.title }}
+      PR_HEAD: ${{ github.event.pull_request.head.ref }}
+      BASE_REF: ${{ github.base_ref }}
     steps:
       - uses: actions/checkout@v4
-      - run: bash checks/pr-title.sh --profile hub "$PR_TITLE"
+        with: { fetch-depth: 0 }
+      - run: |
+          changed="$(mktemp)"; git diff --name-only "origin/${BASE_REF}...HEAD" > "$changed"
+          bash checks/pr-title.sh --profile hub --head "$PR_HEAD" --changed "$changed" "$PR_TITLE"
   pr-template:
     runs-on: ubuntu-latest
     env:
       PR_BODY: ${{ github.event.pull_request.body }}
+      PR_HEAD: ${{ github.event.pull_request.head.ref }}
+      BASE_REF: ${{ github.base_ref }}
     steps:
       - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
       - run: |
+          changed="$(mktemp)"; git diff --name-only "origin/${BASE_REF}...HEAD" > "$changed"
           body="$(mktemp)"; printf '%s' "$PR_BODY" > "$body"
-          bash checks/pr-template.sh --profile hub "$body"
+          bash checks/pr-template.sh --profile hub --head "$PR_HEAD" --changed "$changed" "$body"
   # The gate ledger is CI-owned: reject non-bot commits to .sdlc/*.json or reviews/*.md.
   ledger-guard:
     runs-on: ubuntu-latest
+    if: github.event.action != 'edited'
     steps:
       - uses: actions/checkout@v4
         with: { fetch-depth: 0 }

package/skills/yad-checks/templates/gitlab/yad-hub-checks.gitlab-ci.yml CHANGED Viewed

@@ -3,9 +3,11 @@
 # .gitlab-ci.yml via:
 #   include:
 #     - local: '.gitlab/ci/yad-hub-checks.yml'
-# Every MR (including the front-half review/EP-* MRs) must follow the hub conventions — a
-# Conventional-Commits commit subject, a `review: <artifact> (EP-<slug>)` MR title, and an MR body
-# that uses the hub artifact-review template. They run with `--profile hub`.
+# MRs run with `--profile hub` and split by source branch: review/EP-* MRs are front-half artifact-
+# review vehicles (a `review: <artifact> (EP-<slug>)` title + the hub artifact-review template body);
+# every other MR is a tooling/code change to the hub itself and follows the code convention (a
+# Conventional-Commits title + the code task template body). The source branch is passed via --head so
+# the gate can tell the two apart. Commit subjects are always Conventional-Commits.
 # Job names are yad-hub-prefixed so they coexist with any code-repo fragment in one pipeline; jobs use
 # `needs: []` and no `stage:` so a foreign `stages:` list can neither break nor reorder them.
 default:
@@ -25,18 +27,22 @@ yad-hub-commit-message:
   script:
     - bash checks/commit-message.sh --profile hub "origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME"
+# GIT_DEPTH: 0 (above) gives the changed paths, so the gate can reject an artifact change (epics/**)
+# riding a non-review source branch past the front-half review with a plain code title/template.
 yad-hub-pr-title:
   extends: .yad_hub_mr_only
   needs: []
   script:
-    - bash checks/pr-title.sh --profile hub "$CI_MERGE_REQUEST_TITLE"
+    - changed="$(mktemp)"; git diff --name-only "origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME...HEAD" > "$changed"
+    - bash checks/pr-title.sh --profile hub --head "$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME" --changed "$changed" "$CI_MERGE_REQUEST_TITLE"
 yad-hub-pr-template:
   extends: .yad_hub_mr_only
   needs: []
   script:
+    - changed="$(mktemp)"; git diff --name-only "origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME...HEAD" > "$changed"
     - body="$(mktemp)"; printf '%s' "$CI_MERGE_REQUEST_DESCRIPTION" > "$body"
-    - bash checks/pr-template.sh --profile hub "$body"
+    - bash checks/pr-template.sh --profile hub --head "$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME" --changed "$changed" "$body"
 # The gate ledger is CI-owned: reject non-bot commits to .sdlc/*.json or reviews/*.md.
 yad-hub-ledger-guard:

package/skills/yad-commit/SKILL.md CHANGED Viewed

@@ -21,7 +21,8 @@ and `yad-ship` use. It **never auto-advances**; it just commits.
   `feat|fix|docs|refactor|test|perf|build|ci|chore|revert`; proper nouns/acronyms keep their case.
 - **Task trailer** — required on a code repo (anchors the `spec-link` + `commit-message` gates). Given
   with `--task`, else derived from the branch (`feat/<story>-<task>-…`). Hub commits are not
-  task-scoped, so the trailer is optional there.
+  task-scoped, so the trailer is optional there — a missing-Task warning is informational on the hub
+  (`spec-link` is a code-repo gate) and only flags a real gate failure in a code repo.
 - **Contract-Change trailer** — `--contract-change` only when the diff touches the locked contract
   surface; it routes the change back to the architecture gate.
 - **AI co-author footer — OFF by default.** No `Co-Authored-By` trailer is written unless `--ai <id>`

package/skills/yad-open-pr/SKILL.md CHANGED Viewed

@@ -22,6 +22,14 @@ the product hub.
   `.gitlab/merge_request_templates/Default.md`) with `Task:`, `Risk level:`, `Contract surface
   touched:`, and `Domains` prefilled; the rest is left for the author. This satisfies the `pr-template`
   gate.
+- **Stage-aware on the product hub** — `open-pr` mirrors the `--head` split the hub gates apply:
+  - a **`review/EP-*/<artifact>`** branch is a front-half artifact-review PR → it **delegates to
+    `yad gate open`** (artifact-review title `review: <artifact> (EP-<slug>)`, the hub artifact-review
+    body, and the gate ledger bookkeeping all in one place). Any `--title`/`-m` is ignored here.
+  - any **other hub branch** is a tooling/CI change → it uses the bundled **code-task** template
+    (`## Summary` / `Risk level:` / `## Checklist`) instead of the hub's artifact-review
+    `pull_request_template.md`, so the hub `pr-template` gate passes.
+  In a code repo nothing changes — it reads the repo's own committed code-task template.
 - **Auto-assign** — from the hub roster scoped to this repo: assignee = the committer (resolved from
   the local git identity), reviewers = the repo's `reviewer`/`domain-owner` logins minus the committer.
   Degrades cleanly when there is no roster.

package/skills/yad-pr-template/templates/checks/pr-template.sh CHANGED Viewed

@@ -7,21 +7,38 @@
 #     requires `## Summary`, `## Impact & Risk`, `## Checklist`, and a filled `Risk level:` (low|medium|high).
 #   --profile hub — the front-half artifact-review template (templates/hub/<platform>/):
 #     requires `## Artifact under review`, `## Impact & Risk (front-half)`, `## Checklist`, and a `Risk tags:` line.
+#     BUT only for review/EP-* head branches. Every other hub PR is a tooling/code change to the hub
+#     itself and uses the code task template instead; pass the head ref via --head so the gate knows
+#     which template to require. With no --head, the hub profile stays strict (artifact-review template).
+#     Branch name is not enough on its own: a non-review head that actually changes front-half
+#     artifacts (epics/**) would otherwise slip past the review workflow with only the code template.
+#     Pass the PR's changed paths via --changed <file> (one path per line); when they touch epics/**
+#     on a non-review head the gate FAILS — artifact changes must go through a review/EP-* PR.
 # The body is passed as a FILE path (single positional arg); CI writes the event body to a temp file
 # (GitHub: github.event.pull_request.body; GitLab: $CI_MERGE_REQUEST_DESCRIPTION).
 set -euo pipefail
 PROFILE=code
+HEADREF=""
+CHANGED=""
 ARGS=()
 while [ $# -gt 0 ]; do
   case "$1" in
     --profile) PROFILE="${2:-code}"; shift 2 ;;
     --profile=*) PROFILE="${1#*=}"; shift ;;
+    --head) HEADREF="${2:-}"; shift 2 ;;
+    --head=*) HEADREF="${1#*=}"; shift ;;
+    --changed) CHANGED="${2:-}"; shift 2 ;;
+    --changed=*) CHANGED="${1#*=}"; shift ;;
     *) ARGS+=("$1"); shift ;;
   esac
 done
 case "$PROFILE" in code|hub) ;; *) echo "FAIL [pr-template]: unknown --profile '$PROFILE' (code|hub)."; exit 1 ;; esac
+# True when the PR changes a front-half artifact (anything under epics/**). Reads the --changed list
+# of paths CI computed from the PR diff; with no list (direct caller / test) it reports false.
+artifact_changed() { [ -n "$CHANGED" ] && [ -f "$CHANGED" ] && grep -qE '^epics/' "$CHANGED"; }
 BODY="${ARGS[0]:-}"
 if [ -z "$BODY" ] || [ ! -f "$BODY" ]; then
   echo "FAIL [pr-template]: body file not found — pass the PR/MR description as a file path."
@@ -36,19 +53,14 @@ require_heading() {
   fi
 }
-if [ "$PROFILE" = hub ]; then
-  require_heading '## Artifact under review' '## Artifact under review'
-  require_heading '## Impact & Risk \(front-half\)' '## Impact & Risk (front-half)'
-  require_heading '## Checklist' '## Checklist'
-  if ! grep -qiE '(\*\*)?Risk tags:' "$BODY"; then
-    echo "FAIL [pr-template]: missing 'Risk tags:' line (front-half Impact & Risk)."
-    rc=1
-  fi
-else
+# The code task template: `## Summary`, `## Impact & Risk`, `## Checklist`, and a filled `Risk level:`.
+# Used by the code profile and by hub tooling PRs (any head branch that is not review/EP-*).
+check_code_body() {
   require_heading '## Summary' '## Summary'
   require_heading '## Impact & Risk' '## Impact & Risk'
   require_heading '## Checklist' '## Checklist'
   # Risk level must be present AND filled with a real value (not the <placeholder>).
+  local rl
   rl="$(grep -iE '(\*\*)?Risk level:' "$BODY" | head -1 \
         | sed -E 's/<!--.*$//; s/^[^:]*://; s/[*`]//g; s/^[[:space:]]*//; s/[[:space:]]*$//' || true)"
   rl="$(printf '%s' "$rl" | tr 'A-Z' 'a-z' | grep -oE 'low|medium|high' | head -1 || true)"
@@ -56,7 +68,38 @@ else
     echo "FAIL [pr-template]: 'Risk level:' missing or not set to low|medium|high."
     rc=1
   fi
+}
+# The front-half artifact-review template.
+check_hub_body() {
+  require_heading '## Artifact under review' '## Artifact under review'
+  require_heading '## Impact & Risk \(front-half\)' '## Impact & Risk (front-half)'
+  require_heading '## Checklist' '## Checklist'
+  if ! grep -qiE '(\*\*)?Risk tags:' "$BODY"; then
+    echo "FAIL [pr-template]: missing 'Risk tags:' line (front-half Impact & Risk)."
+    rc=1
+  fi
+}
+KIND="$PROFILE"
+if [ "$PROFILE" = hub ]; then
+  case "$HEADREF" in
+    review/EP-*|"") check_hub_body ;;            # artifact-review PR (or unknown head — stay strict)
+    *)
+      # tooling/code change to the hub itself — UNLESS it changes front-half artifacts (epics/**),
+      # which must go through a review/EP-* PR. Without this guard a non-review head could carry an
+      # artifact change past the front-half review with only the code template.
+      if artifact_changed; then
+        echo "FAIL [pr-template]: head '${HEADREF}' changes front-half artifacts (epics/**) but is not a review/EP-* branch — artifact changes must go through a review PR."
+        rc=1
+      else
+        check_code_body; KIND="hub-tooling"
+      fi
+      ;;
+  esac
+else
+  check_code_body
 fi
-[ "$rc" = 0 ] && echo "PASS [pr-template]: body uses the ${PROFILE} template (required sections present)."
+[ "$rc" = 0 ] && echo "PASS [pr-template]: body uses the ${KIND} template (required sections present)."
 exit "$rc"

package/skills/yad-pr-template/templates/checks/pr-title.sh CHANGED Viewed

@@ -5,22 +5,39 @@
 #     period (config.yaml build.pr_title_style: same_as_commit_subject; one task = one PR, the title is
 #     the squash-merge subject). Keep <type> in sync with cli/manifest.mjs COMMIT_TYPES.
 #   --profile hub — a front-half artifact-review title "review: <artifact> (EP-<slug>)", the shape
-#     `yad gate open` creates (cli/gate.mjs).
+#     `yad gate open` creates (cli/gate.mjs) — BUT only for review/EP-* head branches. Every other
+#     hub PR is a tooling/code change to the hub itself and follows the code convention; pass the
+#     head ref via --head so the gate can tell the two apart (a tooling PR has no EP artifact to
+#     review). With no --head, the hub profile stays strict (requires the review shape).
+#     Branch name is not enough on its own: a non-review head that actually changes front-half
+#     artifacts (epics/**) would otherwise slip past the review workflow with a plain code title.
+#     Pass the PR's changed paths via --changed <file> (one path per line); when they touch epics/**
+#     on a non-review head the gate FAILS — artifact changes must go through a review/EP-* PR.
 # The title is passed as the (single) positional arg; CI injects it from the event payload
 # (GitHub: github.event.pull_request.title; GitLab: $CI_MERGE_REQUEST_TITLE).
 set -euo pipefail
 PROFILE=code
+HEADREF=""
+CHANGED=""
 ARGS=()
 while [ $# -gt 0 ]; do
   case "$1" in
     --profile) PROFILE="${2:-code}"; shift 2 ;;
     --profile=*) PROFILE="${1#*=}"; shift ;;
+    --head) HEADREF="${2:-}"; shift 2 ;;
+    --head=*) HEADREF="${1#*=}"; shift ;;
+    --changed) CHANGED="${2:-}"; shift 2 ;;
+    --changed=*) CHANGED="${1#*=}"; shift ;;
     *) ARGS+=("$1"); shift ;;
   esac
 done
 case "$PROFILE" in code|hub) ;; *) echo "FAIL [pr-title]: unknown --profile '$PROFILE' (code|hub)."; exit 1 ;; esac
+# True when the PR changes a front-half artifact (anything under epics/**). Reads the --changed list
+# of paths CI computed from the PR diff; with no list (direct caller / test) it reports false.
+artifact_changed() { [ -n "$CHANGED" ] && [ -f "$CHANGED" ] && grep -qE '^epics/' "$CHANGED"; }
 TITLE="${ARGS[0]:-}"
 if [ -z "$TITLE" ]; then
   echo "FAIL [pr-title]: empty title — pass the PR/MR title as the argument."
@@ -29,23 +46,43 @@ fi
 TYPES='feat|fix|docs|refactor|test|perf|build|ci|chore|revert'
-if [ "$PROFILE" = hub ]; then
-  # review: <artifact> (EP-<slug>)
-  if printf '%s' "$TITLE" | grep -qE '^review: .+ \(EP-[a-z0-9-]+\)$'; then
-    echo "PASS [pr-title]: '${TITLE}' (profile: hub)"
-    exit 0
+# Conventional-Commits subject (optional scope + breaking `!`), no trailing period. Used by the code
+# profile and by hub tooling PRs (any head branch that is not review/EP-*).
+check_code_title() {
+  if ! printf '%s' "$TITLE" | grep -qE "^(${TYPES})(\([a-z0-9._-]+\))?!?: .+"; then
+    echo "FAIL [pr-title]: '${TITLE}' is not '<type>(<scope>)?!?: <description>' (type one of: ${TYPES//|/, })."
+    exit 1
   fi
-  echo "FAIL [pr-title]: '${TITLE}' is not a hub review title 'review: <artifact> (EP-<slug>)'."
-  exit 1
-fi
+  if printf '%s' "$TITLE" | grep -qE '\.$'; then
+    echo "FAIL [pr-title]: '${TITLE}' must not end with a period."
+    exit 1
+  fi
+  echo "PASS [pr-title]: '${TITLE}' (profile: ${PROFILE}, tooling/code)"
+  exit 0
+}
-# code profile — Conventional-Commits subject (optional scope + breaking `!`), no trailing period.
-if ! printf '%s' "$TITLE" | grep -qE "^(${TYPES})(\([a-z0-9._-]+\))?!?: .+"; then
-  echo "FAIL [pr-title]: '${TITLE}' is not '<type>(<scope>)?!?: <description>' (type one of: ${TYPES//|/, })."
-  exit 1
-fi
-if printf '%s' "$TITLE" | grep -qE '\.$'; then
-  echo "FAIL [pr-title]: '${TITLE}' must not end with a period."
-  exit 1
+if [ "$PROFILE" = hub ]; then
+  # review/EP-* head branch (or unknown head ref) => front-half artifact-review PR: 'review: <artifact> (EP-<slug>)'.
+  case "$HEADREF" in
+    review/EP-*|"")
+      if printf '%s' "$TITLE" | grep -qE '^review: .+ \(EP-[a-z0-9-]+\)$'; then
+        echo "PASS [pr-title]: '${TITLE}' (profile: hub, artifact-review)"
+        exit 0
+      fi
+      echo "FAIL [pr-title]: '${TITLE}' is not a hub review title 'review: <artifact> (EP-<slug>)'."
+      exit 1
+      ;;
+    *)
+      # Any other hub PR is a tooling/code change to the hub itself — UNLESS it changes front-half
+      # artifacts (epics/**), which must go through a review/EP-* PR. Without this guard a non-review
+      # head could carry an artifact change past the front-half review with only a code title.
+      if artifact_changed; then
+        echo "FAIL [pr-title]: head '${HEADREF}' changes front-half artifacts (epics/**) but is not a review/EP-* branch — artifact changes must go through a review PR."
+        exit 1
+      fi
+      # tooling only — fall through to the code convention.
+      ;;
+  esac
 fi
-echo "PASS [pr-title]: '${TITLE}' (profile: code)"
+check_code_title

package/skills/yad-ship/SKILL.md CHANGED Viewed

@@ -22,6 +22,10 @@ its own and **never merges**. The engineer review + merge are Step E (`yad-engin
     roster auto-assign, risk routing (`../yad-open-pr/SKILL.md`).
 - **Order matters:** the PR/MR is opened **only if the commit lands**. A failed commit, a tripped
   atomic guard, or `--dry-run` stops the step before anything is pushed.
+- **Stage-aware on the product hub** (via `yad-open-pr`): on a `review/EP-*` branch `ship` opens the
+  front-half **artifact-review** PR (delegating to `yad gate open` — `--title` is ignored); on any
+  other hub branch it opens the **code-task** PR from the bundled code-task template. In a code repo
+  it is unchanged.
 ## Inputs